diff --git a/Cargo.toml b/Cargo.toml index e1a6f19..342f317 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "winrt" -version = "0.5.0" +version = "0.5.1" authors = ["Patrick Reisert", "Max Strini"] description = "Automatically generated, (mostly) safe bindings for the Windows Runtime APIs" repository = "https://github.com/contextfree/winrt-rust" @@ -18,6 +18,7 @@ winapi = { version = "0.3", features = ["winnt", "combaseapi", "oleauto", "roapi [features] nightly = [] lang-compat = [] +windows-ai = [] windows-applicationmodel = [] windows-data = [] windows-devices = [] @@ -35,7 +36,7 @@ windows-system = [] windows-ui = [] windows-ui-xaml = ["windows-ui"] windows-web = [] -all = ["windows-applicationmodel", "windows-data", "windows-devices", "windows-gaming", +all = ["windows-ai", "windows-applicationmodel", "windows-data", "windows-devices", "windows-gaming", "windows-globalization", "windows-graphics", "windows-management", "windows-media", "windows-networking", "windows-perception", "windows-security", "windows-services", "windows-storage", "windows-system", "windows-ui", "windows-ui-xaml", "windows-web"] diff --git a/src/rt/gen/windows/ai.rs b/src/rt/gen/windows/ai.rs new file mode 100644 index 0000000..9613983 --- /dev/null +++ b/src/rt/gen/windows/ai.rs @@ -0,0 +1,363 @@ +pub mod machinelearning { // Windows.AI.MachineLearning +pub mod preview { // Windows.AI.MachineLearning.Preview +use ::prelude::*; +RT_ENUM! { enum FeatureElementKindPreview: i32 { + Undefined (FeatureElementKindPreview_Undefined) = 0, Float (FeatureElementKindPreview_Float) = 1, UInt8 (FeatureElementKindPreview_UInt8) = 2, Int8 (FeatureElementKindPreview_Int8) = 3, UInt16 (FeatureElementKindPreview_UInt16) = 4, Int16 (FeatureElementKindPreview_Int16) = 5, Int32 (FeatureElementKindPreview_Int32) = 6, Int64 (FeatureElementKindPreview_Int64) = 7, String (FeatureElementKindPreview_String) = 8, Boolean (FeatureElementKindPreview_Boolean) = 9, Float16 (FeatureElementKindPreview_Float16) = 10, Double (FeatureElementKindPreview_Double) = 11, UInt32 (FeatureElementKindPreview_UInt32) = 12, UInt64 (FeatureElementKindPreview_UInt64) = 13, Complex64 (FeatureElementKindPreview_Complex64) = 14, Complex128 (FeatureElementKindPreview_Complex128) = 15, +}} +DEFINE_IID!(IID_IImageVariableDescriptorPreview, 2061630066, 670, 19909, 162, 248, 95, 183, 99, 21, 65, 80); +RT_INTERFACE!{interface IImageVariableDescriptorPreview(IImageVariableDescriptorPreviewVtbl): IInspectable(IInspectableVtbl) [IID_IImageVariableDescriptorPreview] { + #[cfg(not(feature="windows-graphics"))] fn __Dummy0(&self) -> (), + #[cfg(feature="windows-graphics")] fn get_BitmapPixelFormat(&self, out: *mut ::rt::gen::windows::graphics::imaging::BitmapPixelFormat) -> HRESULT, + fn get_Width(&self, out: *mut u32) -> HRESULT, + fn get_Height(&self, out: *mut u32) -> HRESULT +}} +impl IImageVariableDescriptorPreview { + #[cfg(feature="windows-graphics")] #[inline] pub fn get_bitmap_pixel_format(&self) -> Result<::rt::gen::windows::graphics::imaging::BitmapPixelFormat> { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_BitmapPixelFormat)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_width(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Width)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_height(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Height)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} +RT_CLASS!{class ImageVariableDescriptorPreview: IImageVariableDescriptorPreview} +DEFINE_IID!(IID_IInferencingOptionsPreview, 1203536389, 19766, 18345, 143, 104, 255, 203, 51, 157, 208, 252); +RT_INTERFACE!{interface IInferencingOptionsPreview(IInferencingOptionsPreviewVtbl): IInspectable(IInspectableVtbl) [IID_IInferencingOptionsPreview] { + fn get_PreferredDeviceKind(&self, out: *mut LearningModelDeviceKindPreview) -> HRESULT, + fn put_PreferredDeviceKind(&self, value: LearningModelDeviceKindPreview) -> HRESULT, + fn get_IsTracingEnabled(&self, out: *mut bool) -> HRESULT, + fn put_IsTracingEnabled(&self, value: bool) -> HRESULT, + fn get_MaxBatchSize(&self, out: *mut i32) -> HRESULT, + fn put_MaxBatchSize(&self, value: i32) -> HRESULT, + fn get_MinimizeMemoryAllocation(&self, out: *mut bool) -> HRESULT, + fn put_MinimizeMemoryAllocation(&self, value: bool) -> HRESULT, + fn get_ReclaimMemoryAfterEvaluation(&self, out: *mut bool) -> HRESULT, + fn put_ReclaimMemoryAfterEvaluation(&self, value: bool) -> HRESULT +}} +impl IInferencingOptionsPreview { + #[inline] pub fn get_preferred_device_kind(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_PreferredDeviceKind)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_preferred_device_kind(&self, value: LearningModelDeviceKindPreview) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_PreferredDeviceKind)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_is_tracing_enabled(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_IsTracingEnabled)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_is_tracing_enabled(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_IsTracingEnabled)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_max_batch_size(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_MaxBatchSize)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_max_batch_size(&self, value: i32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_MaxBatchSize)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_minimize_memory_allocation(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_MinimizeMemoryAllocation)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_minimize_memory_allocation(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_MinimizeMemoryAllocation)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_reclaim_memory_after_evaluation(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_ReclaimMemoryAfterEvaluation)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_reclaim_memory_after_evaluation(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_ReclaimMemoryAfterEvaluation)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class InferencingOptionsPreview: IInferencingOptionsPreview} +DEFINE_IID!(IID_ILearningModelBindingPreview, 2479423976, 27768, 19279, 174, 193, 166, 187, 158, 105, 22, 36); +RT_INTERFACE!{interface ILearningModelBindingPreview(ILearningModelBindingPreviewVtbl): IInspectable(IInspectableVtbl) [IID_ILearningModelBindingPreview] { + fn Bind(&self, name: HSTRING, value: *mut IInspectable) -> HRESULT, + fn BindWithProperties(&self, name: HSTRING, value: *mut IInspectable, metadata: *mut foundation::collections::IPropertySet) -> HRESULT, + fn Clear(&self) -> HRESULT +}} +impl ILearningModelBindingPreview { + #[inline] pub fn bind(&self, name: &HStringArg, value: &IInspectable) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).Bind)(self as *const _ as *mut _, name.get(), value as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn bind_with_properties(&self, name: &HStringArg, value: &IInspectable, metadata: &foundation::collections::IPropertySet) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).BindWithProperties)(self as *const _ as *mut _, name.get(), value as *const _ as *mut _, metadata as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn clear(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).Clear)(self as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class LearningModelBindingPreview: ILearningModelBindingPreview} +impl RtActivatable for LearningModelBindingPreview {} +impl LearningModelBindingPreview { + #[inline] pub fn create_from_model(model: &LearningModelPreview) -> Result> { + >::get_activation_factory().create_from_model(model) + } +} +DEFINE_CLSID!(LearningModelBindingPreview(&[87,105,110,100,111,119,115,46,65,73,46,77,97,99,104,105,110,101,76,101,97,114,110,105,110,103,46,80,114,101,118,105,101,119,46,76,101,97,114,110,105,110,103,77,111,100,101,108,66,105,110,100,105,110,103,80,114,101,118,105,101,119,0]) [CLSID_LearningModelBindingPreview]); +DEFINE_IID!(IID_ILearningModelBindingPreviewFactory, 1220026783, 7761, 19831, 174, 80, 62, 193, 100, 173, 52, 128); +RT_INTERFACE!{static interface ILearningModelBindingPreviewFactory(ILearningModelBindingPreviewFactoryVtbl): IInspectable(IInspectableVtbl) [IID_ILearningModelBindingPreviewFactory] { + fn CreateFromModel(&self, model: *mut LearningModelPreview, out: *mut *mut LearningModelBindingPreview) -> HRESULT +}} +impl ILearningModelBindingPreviewFactory { + #[inline] pub fn create_from_model(&self, model: &LearningModelPreview) -> Result> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreateFromModel)(self as *const _ as *mut _, model as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} +} +DEFINE_IID!(IID_ILearningModelDescriptionPreview, 4113304006, 34321, 16557, 142, 89, 222, 63, 215, 3, 10, 64); +RT_INTERFACE!{interface ILearningModelDescriptionPreview(ILearningModelDescriptionPreviewVtbl): IInspectable(IInspectableVtbl) [IID_ILearningModelDescriptionPreview] { + fn get_Author(&self, out: *mut HSTRING) -> HRESULT, + fn get_Name(&self, out: *mut HSTRING) -> HRESULT, + fn get_Domain(&self, out: *mut HSTRING) -> HRESULT, + fn get_Description(&self, out: *mut HSTRING) -> HRESULT, + fn get_Version(&self, out: *mut i64) -> HRESULT, + fn get_Metadata(&self, out: *mut *mut foundation::collections::IMapView) -> HRESULT, + fn get_InputFeatures(&self, out: *mut *mut foundation::collections::IIterable) -> HRESULT, + fn get_OutputFeatures(&self, out: *mut *mut foundation::collections::IIterable) -> HRESULT +}} +impl ILearningModelDescriptionPreview { + #[inline] pub fn get_author(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Author)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_name(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Name)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_domain(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Domain)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_description(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Description)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_version(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Version)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_metadata(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Metadata)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_input_features(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_InputFeatures)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_output_features(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_OutputFeatures)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +RT_CLASS!{class LearningModelDescriptionPreview: ILearningModelDescriptionPreview} +RT_ENUM! { enum LearningModelDeviceKindPreview: i32 { + LearningDeviceAny (LearningModelDeviceKindPreview_LearningDeviceAny) = 0, LearningDeviceCpu (LearningModelDeviceKindPreview_LearningDeviceCpu) = 1, LearningDeviceGpu (LearningModelDeviceKindPreview_LearningDeviceGpu) = 2, LearningDeviceNpu (LearningModelDeviceKindPreview_LearningDeviceNpu) = 3, LearningDeviceDsp (LearningModelDeviceKindPreview_LearningDeviceDsp) = 4, LearningDeviceFpga (LearningModelDeviceKindPreview_LearningDeviceFpga) = 5, +}} +DEFINE_IID!(IID_ILearningModelEvaluationResultPreview, 3743804063, 39011, 16520, 132, 152, 135, 161, 244, 104, 111, 146); +RT_INTERFACE!{interface ILearningModelEvaluationResultPreview(ILearningModelEvaluationResultPreviewVtbl): IInspectable(IInspectableVtbl) [IID_ILearningModelEvaluationResultPreview] { + fn get_CorrelationId(&self, out: *mut HSTRING) -> HRESULT, + fn get_Outputs(&self, out: *mut *mut foundation::collections::IMapView) -> HRESULT +}} +impl ILearningModelEvaluationResultPreview { + #[inline] pub fn get_correlation_id(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_CorrelationId)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_outputs(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Outputs)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +RT_CLASS!{class LearningModelEvaluationResultPreview: ILearningModelEvaluationResultPreview} +RT_ENUM! { enum LearningModelFeatureKindPreview: i32 { + Undefined (LearningModelFeatureKindPreview_Undefined) = 0, Tensor (LearningModelFeatureKindPreview_Tensor) = 1, Sequence (LearningModelFeatureKindPreview_Sequence) = 2, Map (LearningModelFeatureKindPreview_Map) = 3, Image (LearningModelFeatureKindPreview_Image) = 4, +}} +DEFINE_IID!(IID_ILearningModelPreview, 77342314, 37812, 18316, 174, 184, 112, 21, 123, 240, 255, 148); +RT_INTERFACE!{interface ILearningModelPreview(ILearningModelPreviewVtbl): IInspectable(IInspectableVtbl) [IID_ILearningModelPreview] { + fn EvaluateAsync(&self, binding: *mut LearningModelBindingPreview, correlationId: HSTRING, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn EvaluateFeaturesAsync(&self, features: *mut foundation::collections::IMap, correlationId: HSTRING, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn get_Description(&self, out: *mut *mut LearningModelDescriptionPreview) -> HRESULT, + fn get_InferencingOptions(&self, out: *mut *mut InferencingOptionsPreview) -> HRESULT, + fn put_InferencingOptions(&self, value: *mut InferencingOptionsPreview) -> HRESULT +}} +impl ILearningModelPreview { + #[inline] pub fn evaluate_async(&self, binding: &LearningModelBindingPreview, correlationId: &HStringArg) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).EvaluateAsync)(self as *const _ as *mut _, binding as *const _ as *mut _, correlationId.get(), &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn evaluate_features_async(&self, features: &foundation::collections::IMap, correlationId: &HStringArg) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).EvaluateFeaturesAsync)(self as *const _ as *mut _, features as *const _ as *mut _, correlationId.get(), &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_description(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Description)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_inferencing_options(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_InferencingOptions)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn set_inferencing_options(&self, value: &InferencingOptionsPreview) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_InferencingOptions)(self as *const _ as *mut _, value as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class LearningModelPreview: ILearningModelPreview} +impl RtActivatable for LearningModelPreview {} +impl LearningModelPreview { + #[cfg(feature="windows-storage")] #[inline] pub fn load_model_from_storage_file_async(modelFile: &::rt::gen::windows::storage::IStorageFile) -> Result>> { + >::get_activation_factory().load_model_from_storage_file_async(modelFile) + } + #[cfg(feature="windows-storage")] #[inline] pub fn load_model_from_stream_async(modelStream: &::rt::gen::windows::storage::streams::IRandomAccessStreamReference) -> Result>> { + >::get_activation_factory().load_model_from_stream_async(modelStream) + } +} +DEFINE_CLSID!(LearningModelPreview(&[87,105,110,100,111,119,115,46,65,73,46,77,97,99,104,105,110,101,76,101,97,114,110,105,110,103,46,80,114,101,118,105,101,119,46,76,101,97,114,110,105,110,103,77,111,100,101,108,80,114,101,118,105,101,119,0]) [CLSID_LearningModelPreview]); +DEFINE_IID!(IID_ILearningModelPreviewStatics, 374061920, 33893, 18310, 139, 147, 44, 22, 168, 146, 137, 215); +RT_INTERFACE!{static interface ILearningModelPreviewStatics(ILearningModelPreviewStaticsVtbl): IInspectable(IInspectableVtbl) [IID_ILearningModelPreviewStatics] { + #[cfg(feature="windows-storage")] fn LoadModelFromStorageFileAsync(&self, modelFile: *mut ::rt::gen::windows::storage::IStorageFile, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + #[cfg(feature="windows-storage")] fn LoadModelFromStreamAsync(&self, modelStream: *mut ::rt::gen::windows::storage::streams::IRandomAccessStreamReference, out: *mut *mut foundation::IAsyncOperation) -> HRESULT +}} +impl ILearningModelPreviewStatics { + #[cfg(feature="windows-storage")] #[inline] pub fn load_model_from_storage_file_async(&self, modelFile: &::rt::gen::windows::storage::IStorageFile) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).LoadModelFromStorageFileAsync)(self as *const _ as *mut _, modelFile as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[cfg(feature="windows-storage")] #[inline] pub fn load_model_from_stream_async(&self, modelStream: &::rt::gen::windows::storage::streams::IRandomAccessStreamReference) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).LoadModelFromStreamAsync)(self as *const _ as *mut _, modelStream as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} +} +DEFINE_IID!(IID_ILearningModelVariableDescriptorPreview, 2973628034, 64560, 18731, 142, 160, 237, 31, 83, 192, 176, 56); +RT_INTERFACE!{interface ILearningModelVariableDescriptorPreview(ILearningModelVariableDescriptorPreviewVtbl): IInspectable(IInspectableVtbl) [IID_ILearningModelVariableDescriptorPreview] { + fn get_Name(&self, out: *mut HSTRING) -> HRESULT, + fn get_Description(&self, out: *mut HSTRING) -> HRESULT, + fn get_ModelFeatureKind(&self, out: *mut LearningModelFeatureKindPreview) -> HRESULT, + fn get_IsRequired(&self, out: *mut bool) -> HRESULT +}} +impl ILearningModelVariableDescriptorPreview { + #[inline] pub fn get_name(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Name)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_description(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Description)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_model_feature_kind(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_ModelFeatureKind)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_is_required(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_IsRequired)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} +RT_CLASS!{class LearningModelVariableDescriptorPreview: ILearningModelVariableDescriptorPreview} +DEFINE_IID!(IID_IMapVariableDescriptorPreview, 1018397552, 49195, 16950, 179, 232, 107, 220, 164, 156, 49, 41); +RT_INTERFACE!{interface IMapVariableDescriptorPreview(IMapVariableDescriptorPreviewVtbl): IInspectable(IInspectableVtbl) [IID_IMapVariableDescriptorPreview] { + fn get_KeyKind(&self, out: *mut FeatureElementKindPreview) -> HRESULT, + fn get_ValidStringKeys(&self, out: *mut *mut foundation::collections::IIterable) -> HRESULT, + fn get_ValidIntegerKeys(&self, out: *mut *mut foundation::collections::IIterable) -> HRESULT, + fn get_Fields(&self, out: *mut *mut ILearningModelVariableDescriptorPreview) -> HRESULT +}} +impl IMapVariableDescriptorPreview { + #[inline] pub fn get_key_kind(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_KeyKind)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_valid_string_keys(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ValidStringKeys)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_valid_integer_keys(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ValidIntegerKeys)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_fields(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Fields)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +RT_CLASS!{class MapVariableDescriptorPreview: IMapVariableDescriptorPreview} +DEFINE_IID!(IID_ISequenceVariableDescriptorPreview, 2631463570, 39090, 17712, 161, 182, 45, 237, 95, 236, 188, 38); +RT_INTERFACE!{interface ISequenceVariableDescriptorPreview(ISequenceVariableDescriptorPreviewVtbl): IInspectable(IInspectableVtbl) [IID_ISequenceVariableDescriptorPreview] { + fn get_ElementType(&self, out: *mut *mut ILearningModelVariableDescriptorPreview) -> HRESULT +}} +impl ISequenceVariableDescriptorPreview { + #[inline] pub fn get_element_type(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ElementType)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +RT_CLASS!{class SequenceVariableDescriptorPreview: ISequenceVariableDescriptorPreview} +DEFINE_IID!(IID_ITensorVariableDescriptorPreview, 2819575834, 39596, 16947, 151, 132, 172, 234, 249, 37, 16, 181); +RT_INTERFACE!{interface ITensorVariableDescriptorPreview(ITensorVariableDescriptorPreviewVtbl): IInspectable(IInspectableVtbl) [IID_ITensorVariableDescriptorPreview] { + fn get_DataType(&self, out: *mut FeatureElementKindPreview) -> HRESULT, + fn get_Shape(&self, out: *mut *mut foundation::collections::IIterable) -> HRESULT +}} +impl ITensorVariableDescriptorPreview { + #[inline] pub fn get_data_type(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_DataType)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_shape(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Shape)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +RT_CLASS!{class TensorVariableDescriptorPreview: ITensorVariableDescriptorPreview} +} // Windows.AI.MachineLearning.Preview +} // Windows.AI.MachineLearning diff --git a/src/rt/gen/windows/applicationmodel.rs b/src/rt/gen/windows/applicationmodel.rs index a0d4f01..6f8bc81 100644 --- a/src/rt/gen/windows/applicationmodel.rs +++ b/src/rt/gen/windows/applicationmodel.rs @@ -1,4 +1,7 @@ use ::prelude::*; +RT_ENUM! { enum AddResourcePackageOptions: u32 { + None (AddResourcePackageOptions_None) = 0, ForceTargetAppShutdown (AddResourcePackageOptions_ForceTargetAppShutdown) = 1, ApplyUpdateIfAvailable (AddResourcePackageOptions_ApplyUpdateIfAvailable) = 2, +}} DEFINE_IID!(IID_IAppDisplayInfo, 451612931, 58580, 16810, 164, 246, 196, 162, 118, 231, 158, 172); RT_INTERFACE!{interface IAppDisplayInfo(IAppDisplayInfoVtbl): IInspectable(IInspectableVtbl) [IID_IAppDisplayInfo] { fn get_DisplayName(&self, out: *mut HSTRING) -> HRESULT, @@ -53,6 +56,82 @@ impl IAppInfo { }} } RT_CLASS!{class AppInfo: IAppInfo} +DEFINE_IID!(IID_IAppInstance, 1734290247, 62047, 17714, 159, 214, 54, 51, 224, 99, 77, 1); +RT_INTERFACE!{interface IAppInstance(IAppInstanceVtbl): IInspectable(IInspectableVtbl) [IID_IAppInstance] { + fn get_Key(&self, out: *mut HSTRING) -> HRESULT, + fn get_IsCurrentInstance(&self, out: *mut bool) -> HRESULT, + fn RedirectActivationTo(&self) -> HRESULT +}} +impl IAppInstance { + #[inline] pub fn get_key(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Key)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_is_current_instance(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_IsCurrentInstance)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn redirect_activation_to(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).RedirectActivationTo)(self as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class AppInstance: IAppInstance} +impl RtActivatable for AppInstance {} +impl AppInstance { + #[inline] pub fn get_recommended_instance() -> Result>> { + >::get_activation_factory().get_recommended_instance() + } + #[inline] pub fn get_activated_event_args() -> Result>> { + >::get_activation_factory().get_activated_event_args() + } + #[inline] pub fn find_or_register_instance_for_key(key: &HStringArg) -> Result>> { + >::get_activation_factory().find_or_register_instance_for_key(key) + } + #[inline] pub fn unregister() -> Result<()> { + >::get_activation_factory().unregister() + } + #[inline] pub fn get_instances() -> Result>>> { + >::get_activation_factory().get_instances() + } +} +DEFINE_CLSID!(AppInstance(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,65,112,112,73,110,115,116,97,110,99,101,0]) [CLSID_AppInstance]); +DEFINE_IID!(IID_IAppInstanceStatics, 2635196287, 40614, 18351, 166, 236, 70, 120, 76, 91, 162, 84); +RT_INTERFACE!{static interface IAppInstanceStatics(IAppInstanceStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IAppInstanceStatics] { + fn get_RecommendedInstance(&self, out: *mut *mut AppInstance) -> HRESULT, + fn GetActivatedEventArgs(&self, out: *mut *mut activation::IActivatedEventArgs) -> HRESULT, + fn FindOrRegisterInstanceForKey(&self, key: HSTRING, out: *mut *mut AppInstance) -> HRESULT, + fn Unregister(&self) -> HRESULT, + fn GetInstances(&self, out: *mut *mut foundation::collections::IVector) -> HRESULT +}} +impl IAppInstanceStatics { + #[inline] pub fn get_recommended_instance(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_RecommendedInstance)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_activated_event_args(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetActivatedEventArgs)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn find_or_register_instance_for_key(&self, key: &HStringArg) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).FindOrRegisterInstanceForKey)(self as *const _ as *mut _, key.get(), &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn unregister(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).Unregister)(self as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_instances(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetInstances)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} RT_CLASS!{static class DesignMode} impl RtActivatable for DesignMode {} impl RtActivatable for DesignMode {} @@ -427,6 +506,23 @@ impl IPackageCatalog3 { if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IPackageCatalog4, 3279698331, 17612, 19323, 139, 175, 121, 108, 4, 234, 211, 185); +RT_INTERFACE!{interface IPackageCatalog4(IPackageCatalog4Vtbl): IInspectable(IInspectableVtbl) [IID_IPackageCatalog4] { + fn AddResourcePackageAsync(&self, resourcePackageFamilyName: HSTRING, resourceID: HSTRING, options: AddResourcePackageOptions, out: *mut *mut foundation::IAsyncOperationWithProgress) -> HRESULT, + fn RemoveResourcePackagesAsync(&self, resourcePackages: *mut foundation::collections::IIterable, out: *mut *mut foundation::IAsyncOperation) -> HRESULT +}} +impl IPackageCatalog4 { + #[inline] pub fn add_resource_package_async(&self, resourcePackageFamilyName: &HStringArg, resourceID: &HStringArg, options: AddResourcePackageOptions) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).AddResourcePackageAsync)(self as *const _ as *mut _, resourcePackageFamilyName.get(), resourceID.get(), options, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn remove_resource_packages_async(&self, resourcePackages: &foundation::collections::IIterable) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).RemoveResourcePackagesAsync)(self as *const _ as *mut _, resourcePackages as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IPackageCatalogAddOptionalPackageResult, 1005653204, 46303, 18355, 169, 99, 226, 250, 131, 47, 125, 211); RT_INTERFACE!{interface IPackageCatalogAddOptionalPackageResult(IPackageCatalogAddOptionalPackageResultVtbl): IInspectable(IInspectableVtbl) [IID_IPackageCatalogAddOptionalPackageResult] { fn get_Package(&self, out: *mut *mut Package) -> HRESULT, @@ -445,6 +541,30 @@ impl IPackageCatalogAddOptionalPackageResult { }} } RT_CLASS!{class PackageCatalogAddOptionalPackageResult: IPackageCatalogAddOptionalPackageResult} +DEFINE_IID!(IID_IPackageCatalogAddResourcePackageResult, 2520174093, 15895, 18751, 170, 8, 204, 236, 111, 222, 246, 153); +RT_INTERFACE!{interface IPackageCatalogAddResourcePackageResult(IPackageCatalogAddResourcePackageResultVtbl): IInspectable(IInspectableVtbl) [IID_IPackageCatalogAddResourcePackageResult] { + fn get_Package(&self, out: *mut *mut Package) -> HRESULT, + fn get_IsComplete(&self, out: *mut bool) -> HRESULT, + fn get_ExtendedError(&self, out: *mut foundation::HResult) -> HRESULT +}} +impl IPackageCatalogAddResourcePackageResult { + #[inline] pub fn get_package(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Package)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_is_complete(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_IsComplete)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_extended_error(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_ExtendedError)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} +RT_CLASS!{class PackageCatalogAddResourcePackageResult: IPackageCatalogAddResourcePackageResult} DEFINE_IID!(IID_IPackageCatalogRemoveOptionalPackagesResult, 701692283, 55668, 20068, 147, 89, 34, 202, 223, 215, 152, 40); RT_INTERFACE!{interface IPackageCatalogRemoveOptionalPackagesResult(IPackageCatalogRemoveOptionalPackagesResultVtbl): IInspectable(IInspectableVtbl) [IID_IPackageCatalogRemoveOptionalPackagesResult] { fn get_PackagesRemoved(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT, @@ -463,6 +583,24 @@ impl IPackageCatalogRemoveOptionalPackagesResult { }} } RT_CLASS!{class PackageCatalogRemoveOptionalPackagesResult: IPackageCatalogRemoveOptionalPackagesResult} +DEFINE_IID!(IID_IPackageCatalogRemoveResourcePackagesResult, 2926679817, 6738, 17185, 135, 179, 229, 161, 161, 121, 129, 167); +RT_INTERFACE!{interface IPackageCatalogRemoveResourcePackagesResult(IPackageCatalogRemoveResourcePackagesResultVtbl): IInspectable(IInspectableVtbl) [IID_IPackageCatalogRemoveResourcePackagesResult] { + fn get_PackagesRemoved(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT, + fn get_ExtendedError(&self, out: *mut foundation::HResult) -> HRESULT +}} +impl IPackageCatalogRemoveResourcePackagesResult { + #[inline] pub fn get_packages_removed(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_PackagesRemoved)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_extended_error(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_ExtendedError)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} +RT_CLASS!{class PackageCatalogRemoveResourcePackagesResult: IPackageCatalogRemoveResourcePackagesResult} DEFINE_IID!(IID_IPackageCatalogStatics, 2710345366, 58971, 17972, 186, 33, 94, 99, 235, 114, 68, 167); RT_INTERFACE!{static interface IPackageCatalogStatics(IPackageCatalogStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IPackageCatalogStatics] { fn OpenForCurrentPackage(&self, out: *mut *mut PackageCatalog) -> HRESULT, @@ -687,6 +825,9 @@ impl IPackageInstallingEventArgs { }} } RT_CLASS!{class PackageInstallingEventArgs: IPackageInstallingEventArgs} +RT_STRUCT! { struct PackageInstallProgress { + PercentComplete: u32, +}} RT_ENUM! { enum PackageSignatureKind: i32 { None (PackageSignatureKind_None) = 0, Developer (PackageSignatureKind_Developer) = 1, Enterprise (PackageSignatureKind_Enterprise) = 2, Store (PackageSignatureKind_Store) = 3, System (PackageSignatureKind_System) = 4, }} @@ -981,7 +1122,7 @@ impl StartupTask { } DEFINE_CLSID!(StartupTask(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,83,116,97,114,116,117,112,84,97,115,107,0]) [CLSID_StartupTask]); RT_ENUM! { enum StartupTaskState: i32 { - Disabled (StartupTaskState_Disabled) = 0, DisabledByUser (StartupTaskState_DisabledByUser) = 1, Enabled (StartupTaskState_Enabled) = 2, DisabledByPolicy (StartupTaskState_DisabledByPolicy) = 3, + Disabled (StartupTaskState_Disabled) = 0, DisabledByUser (StartupTaskState_DisabledByUser) = 1, Enabled (StartupTaskState_Enabled) = 2, DisabledByPolicy (StartupTaskState_DisabledByPolicy) = 3, EnabledByPolicy (StartupTaskState_EnabledByPolicy) = 4, }} DEFINE_IID!(IID_IStartupTaskStatics, 3998965949, 41288, 16807, 178, 110, 232, 184, 138, 30, 98, 248); RT_INTERFACE!{static interface IStartupTaskStatics(IStartupTaskStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IStartupTaskStatics] { @@ -1041,3871 +1182,3983 @@ impl ISuspendingOperation { }} } RT_CLASS!{class SuspendingOperation: ISuspendingOperation} -pub mod calls { // Windows.ApplicationModel.Calls +pub mod background { // Windows.ApplicationModel.Background use ::prelude::*; -DEFINE_IID!(IID_ICallAnswerEventArgs, 4252538391, 11735, 19596, 178, 189, 149, 209, 122, 91, 183, 51); -RT_INTERFACE!{interface ICallAnswerEventArgs(ICallAnswerEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_ICallAnswerEventArgs] { - fn get_AcceptedMedia(&self, out: *mut VoipPhoneCallMedia) -> HRESULT +DEFINE_IID!(IID_IActivitySensorTrigger, 3504161602, 58235, 18467, 165, 254, 107, 49, 223, 239, 222, 176); +RT_INTERFACE!{interface IActivitySensorTrigger(IActivitySensorTriggerVtbl): IInspectable(IInspectableVtbl) [IID_IActivitySensorTrigger] { + #[cfg(not(feature="windows-devices"))] fn __Dummy0(&self) -> (), + #[cfg(feature="windows-devices")] fn get_SubscribedActivities(&self, out: *mut *mut foundation::collections::IVector) -> HRESULT, + fn get_ReportInterval(&self, out: *mut u32) -> HRESULT, + #[cfg(not(feature="windows-devices"))] fn __Dummy2(&self) -> (), + #[cfg(feature="windows-devices")] fn get_SupportedActivities(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT, + fn get_MinimumReportInterval(&self, out: *mut u32) -> HRESULT }} -impl ICallAnswerEventArgs { - #[inline] pub fn get_accepted_media(&self) -> Result { unsafe { +impl IActivitySensorTrigger { + #[cfg(feature="windows-devices")] #[inline] pub fn get_subscribed_activities(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_SubscribedActivities)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_report_interval(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_AcceptedMedia)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_ReportInterval)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} -} -RT_CLASS!{class CallAnswerEventArgs: ICallAnswerEventArgs} -DEFINE_IID!(IID_ICallRejectEventArgs, 3662150359, 5076, 19858, 161, 194, 183, 120, 17, 238, 55, 236); -RT_INTERFACE!{interface ICallRejectEventArgs(ICallRejectEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_ICallRejectEventArgs] { - fn get_RejectReason(&self, out: *mut VoipPhoneCallRejectReason) -> HRESULT -}} -impl ICallRejectEventArgs { - #[inline] pub fn get_reject_reason(&self) -> Result { unsafe { + #[cfg(feature="windows-devices")] #[inline] pub fn get_supported_activities(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_SupportedActivities)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_minimum_report_interval(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_RejectReason)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_MinimumReportInterval)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} } -RT_CLASS!{class CallRejectEventArgs: ICallRejectEventArgs} -DEFINE_IID!(IID_ICallStateChangeEventArgs, 3937547422, 26357, 18425, 159, 181, 69, 156, 81, 152, 199, 32); -RT_INTERFACE!{interface ICallStateChangeEventArgs(ICallStateChangeEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_ICallStateChangeEventArgs] { - fn get_State(&self, out: *mut VoipPhoneCallState) -> HRESULT +RT_CLASS!{class ActivitySensorTrigger: IActivitySensorTrigger} +impl RtActivatable for ActivitySensorTrigger {} +impl ActivitySensorTrigger { + #[inline] pub fn create(reportIntervalInMilliseconds: u32) -> Result> { + >::get_activation_factory().create(reportIntervalInMilliseconds) + } +} +DEFINE_CLSID!(ActivitySensorTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,65,99,116,105,118,105,116,121,83,101,110,115,111,114,84,114,105,103,103,101,114,0]) [CLSID_ActivitySensorTrigger]); +DEFINE_IID!(IID_IActivitySensorTriggerFactory, 2804322755, 14391, 17655, 131, 27, 1, 50, 204, 135, 43, 195); +RT_INTERFACE!{static interface IActivitySensorTriggerFactory(IActivitySensorTriggerFactoryVtbl): IInspectable(IInspectableVtbl) [IID_IActivitySensorTriggerFactory] { + fn Create(&self, reportIntervalInMilliseconds: u32, out: *mut *mut ActivitySensorTrigger) -> HRESULT }} -impl ICallStateChangeEventArgs { - #[inline] pub fn get_state(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_State)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } +impl IActivitySensorTriggerFactory { + #[inline] pub fn create(&self, reportIntervalInMilliseconds: u32) -> Result> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, reportIntervalInMilliseconds, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } -RT_CLASS!{class CallStateChangeEventArgs: ICallStateChangeEventArgs} -DEFINE_IID!(IID_ILockScreenCallEndCallDeferral, 769125645, 39149, 16449, 150, 50, 80, 255, 129, 43, 119, 63); -RT_INTERFACE!{interface ILockScreenCallEndCallDeferral(ILockScreenCallEndCallDeferralVtbl): IInspectable(IInspectableVtbl) [IID_ILockScreenCallEndCallDeferral] { - fn Complete(&self) -> HRESULT +RT_ENUM! { enum AlarmAccessStatus: i32 { + Unspecified (AlarmAccessStatus_Unspecified) = 0, AllowedWithWakeupCapability (AlarmAccessStatus_AllowedWithWakeupCapability) = 1, AllowedWithoutWakeupCapability (AlarmAccessStatus_AllowedWithoutWakeupCapability) = 2, Denied (AlarmAccessStatus_Denied) = 3, }} -impl ILockScreenCallEndCallDeferral { - #[inline] pub fn complete(&self) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).Complete)(self as *const _ as *mut _); - if hr == S_OK { Ok(()) } else { err(hr) } - }} +RT_CLASS!{static class AlarmApplicationManager} +impl RtActivatable for AlarmApplicationManager {} +impl AlarmApplicationManager { + #[inline] pub fn request_access_async() -> Result>> { + >::get_activation_factory().request_access_async() + } + #[inline] pub fn get_access_status() -> Result { + >::get_activation_factory().get_access_status() + } } -RT_CLASS!{class LockScreenCallEndCallDeferral: ILockScreenCallEndCallDeferral} -DEFINE_IID!(IID_ILockScreenCallEndRequestedEventArgs, 2173739875, 28455, 18153, 174, 182, 192, 174, 131, 228, 125, 199); -RT_INTERFACE!{interface ILockScreenCallEndRequestedEventArgs(ILockScreenCallEndRequestedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_ILockScreenCallEndRequestedEventArgs] { - fn GetDeferral(&self, out: *mut *mut LockScreenCallEndCallDeferral) -> HRESULT, - fn get_Deadline(&self, out: *mut foundation::DateTime) -> HRESULT +DEFINE_CLSID!(AlarmApplicationManager(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,65,108,97,114,109,65,112,112,108,105,99,97,116,105,111,110,77,97,110,97,103,101,114,0]) [CLSID_AlarmApplicationManager]); +DEFINE_IID!(IID_IAlarmApplicationManagerStatics, 3389258299, 52454, 19938, 176, 155, 150, 40, 189, 51, 187, 190); +RT_INTERFACE!{static interface IAlarmApplicationManagerStatics(IAlarmApplicationManagerStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IAlarmApplicationManagerStatics] { + fn RequestAccessAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn GetAccessStatus(&self, out: *mut AlarmAccessStatus) -> HRESULT }} -impl ILockScreenCallEndRequestedEventArgs { - #[inline] pub fn get_deferral(&self) -> Result>> { unsafe { +impl IAlarmApplicationManagerStatics { + #[inline] pub fn request_access_async(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetDeferral)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).RequestAccessAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_deadline(&self) -> Result { unsafe { + #[inline] pub fn get_access_status(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_Deadline)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).GetAccessStatus)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} } -RT_CLASS!{class LockScreenCallEndRequestedEventArgs: ILockScreenCallEndRequestedEventArgs} -DEFINE_IID!(IID_ILockScreenCallUI, 3315006861, 29641, 18964, 176, 33, 236, 28, 80, 163, 183, 39); -RT_INTERFACE!{interface ILockScreenCallUI(ILockScreenCallUIVtbl): IInspectable(IInspectableVtbl) [IID_ILockScreenCallUI] { - fn Dismiss(&self) -> HRESULT, - fn add_EndRequested(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, - fn remove_EndRequested(&self, token: foundation::EventRegistrationToken) -> HRESULT, - fn add_Closed(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, - fn remove_Closed(&self, token: foundation::EventRegistrationToken) -> HRESULT, - fn get_CallTitle(&self, out: *mut HSTRING) -> HRESULT, - fn put_CallTitle(&self, value: HSTRING) -> HRESULT +DEFINE_IID!(IID_IAppBroadcastTrigger, 1960113302, 36151, 17644, 148, 129, 42, 11, 152, 84, 235, 72); +RT_INTERFACE!{interface IAppBroadcastTrigger(IAppBroadcastTriggerVtbl): IInspectable(IInspectableVtbl) [IID_IAppBroadcastTrigger] { + fn put_ProviderInfo(&self, value: *mut AppBroadcastTriggerProviderInfo) -> HRESULT, + fn get_ProviderInfo(&self, out: *mut *mut AppBroadcastTriggerProviderInfo) -> HRESULT }} -impl ILockScreenCallUI { - #[inline] pub fn dismiss(&self) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).Dismiss)(self as *const _ as *mut _); - if hr == S_OK { Ok(()) } else { err(hr) } - }} - #[inline] pub fn add_end_requested(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).add_EndRequested)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } - }} - #[inline] pub fn remove_end_requested(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).remove_EndRequested)(self as *const _ as *mut _, token); - if hr == S_OK { Ok(()) } else { err(hr) } - }} - #[inline] pub fn add_closed(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).add_Closed)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } - }} - #[inline] pub fn remove_closed(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).remove_Closed)(self as *const _ as *mut _, token); +impl IAppBroadcastTrigger { + #[inline] pub fn set_provider_info(&self, value: &AppBroadcastTriggerProviderInfo) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_ProviderInfo)(self as *const _ as *mut _, value as *const _ as *mut _); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_call_title(&self) -> Result { unsafe { + #[inline] pub fn get_provider_info(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_CallTitle)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } - }} - #[inline] pub fn set_call_title(&self, value: &HStringArg) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_CallTitle)(self as *const _ as *mut _, value.get()); - if hr == S_OK { Ok(()) } else { err(hr) } + let hr = ((*self.lpVtbl).get_ProviderInfo)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } -RT_CLASS!{class LockScreenCallUI: ILockScreenCallUI} -DEFINE_IID!(IID_IMuteChangeEventArgs, 2240143705, 3137, 17196, 129, 77, 197, 241, 253, 245, 48, 190); -RT_INTERFACE!{interface IMuteChangeEventArgs(IMuteChangeEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IMuteChangeEventArgs] { - fn get_Muted(&self, out: *mut bool) -> HRESULT +RT_CLASS!{class AppBroadcastTrigger: IAppBroadcastTrigger} +impl RtActivatable for AppBroadcastTrigger {} +impl AppBroadcastTrigger { + #[inline] pub fn create_app_broadcast_trigger(providerKey: &HStringArg) -> Result> { + >::get_activation_factory().create_app_broadcast_trigger(providerKey) + } +} +DEFINE_CLSID!(AppBroadcastTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,65,112,112,66,114,111,97,100,99,97,115,116,84,114,105,103,103,101,114,0]) [CLSID_AppBroadcastTrigger]); +DEFINE_IID!(IID_IAppBroadcastTriggerFactory, 671850308, 8948, 17944, 160, 46, 231, 228, 17, 235, 114, 56); +RT_INTERFACE!{static interface IAppBroadcastTriggerFactory(IAppBroadcastTriggerFactoryVtbl): IInspectable(IInspectableVtbl) [IID_IAppBroadcastTriggerFactory] { + fn CreateAppBroadcastTrigger(&self, providerKey: HSTRING, out: *mut *mut AppBroadcastTrigger) -> HRESULT }} -impl IMuteChangeEventArgs { - #[inline] pub fn get_muted(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_Muted)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } +impl IAppBroadcastTriggerFactory { + #[inline] pub fn create_app_broadcast_trigger(&self, providerKey: &HStringArg) -> Result> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreateAppBroadcastTrigger)(self as *const _ as *mut _, providerKey.get(), &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } -RT_CLASS!{class MuteChangeEventArgs: IMuteChangeEventArgs} -DEFINE_IID!(IID_IPhoneCallHistoryEntry, 4205895977, 12964, 19333, 131, 209, 249, 13, 140, 35, 168, 87); -RT_INTERFACE!{interface IPhoneCallHistoryEntry(IPhoneCallHistoryEntryVtbl): IInspectable(IInspectableVtbl) [IID_IPhoneCallHistoryEntry] { - fn get_Id(&self, out: *mut HSTRING) -> HRESULT, - fn get_Address(&self, out: *mut *mut PhoneCallHistoryEntryAddress) -> HRESULT, - fn put_Address(&self, value: *mut PhoneCallHistoryEntryAddress) -> HRESULT, - fn get_Duration(&self, out: *mut *mut foundation::IReference) -> HRESULT, - fn put_Duration(&self, value: *mut foundation::IReference) -> HRESULT, - fn get_IsCallerIdBlocked(&self, out: *mut bool) -> HRESULT, - fn put_IsCallerIdBlocked(&self, value: bool) -> HRESULT, - fn get_IsEmergency(&self, out: *mut bool) -> HRESULT, - fn put_IsEmergency(&self, value: bool) -> HRESULT, - fn get_IsIncoming(&self, out: *mut bool) -> HRESULT, - fn put_IsIncoming(&self, value: bool) -> HRESULT, - fn get_IsMissed(&self, out: *mut bool) -> HRESULT, - fn put_IsMissed(&self, value: bool) -> HRESULT, - fn get_IsRinging(&self, out: *mut bool) -> HRESULT, - fn put_IsRinging(&self, value: bool) -> HRESULT, - fn get_IsSeen(&self, out: *mut bool) -> HRESULT, - fn put_IsSeen(&self, value: bool) -> HRESULT, - fn get_IsSuppressed(&self, out: *mut bool) -> HRESULT, - fn put_IsSuppressed(&self, value: bool) -> HRESULT, - fn get_IsVoicemail(&self, out: *mut bool) -> HRESULT, - fn put_IsVoicemail(&self, value: bool) -> HRESULT, - fn get_Media(&self, out: *mut PhoneCallHistoryEntryMedia) -> HRESULT, - fn put_Media(&self, value: PhoneCallHistoryEntryMedia) -> HRESULT, - fn get_OtherAppReadAccess(&self, out: *mut PhoneCallHistoryEntryOtherAppReadAccess) -> HRESULT, - fn put_OtherAppReadAccess(&self, value: PhoneCallHistoryEntryOtherAppReadAccess) -> HRESULT, - fn get_RemoteId(&self, out: *mut HSTRING) -> HRESULT, - fn put_RemoteId(&self, value: HSTRING) -> HRESULT, - fn get_SourceDisplayName(&self, out: *mut HSTRING) -> HRESULT, - fn get_SourceId(&self, out: *mut HSTRING) -> HRESULT, - fn put_SourceId(&self, value: HSTRING) -> HRESULT, - fn get_SourceIdKind(&self, out: *mut PhoneCallHistorySourceIdKind) -> HRESULT, - fn put_SourceIdKind(&self, value: PhoneCallHistorySourceIdKind) -> HRESULT, - fn get_StartTime(&self, out: *mut foundation::DateTime) -> HRESULT, - fn put_StartTime(&self, value: foundation::DateTime) -> HRESULT +DEFINE_IID!(IID_IAppBroadcastTriggerProviderInfo, 4061738285, 40424, 17440, 156, 226, 94, 255, 143, 23, 55, 107); +RT_INTERFACE!{interface IAppBroadcastTriggerProviderInfo(IAppBroadcastTriggerProviderInfoVtbl): IInspectable(IInspectableVtbl) [IID_IAppBroadcastTriggerProviderInfo] { + fn put_DisplayNameResource(&self, value: HSTRING) -> HRESULT, + fn get_DisplayNameResource(&self, out: *mut HSTRING) -> HRESULT, + fn put_LogoResource(&self, value: HSTRING) -> HRESULT, + fn get_LogoResource(&self, out: *mut HSTRING) -> HRESULT, + fn put_VideoKeyFrameInterval(&self, value: foundation::TimeSpan) -> HRESULT, + fn get_VideoKeyFrameInterval(&self, out: *mut foundation::TimeSpan) -> HRESULT, + fn put_MaxVideoBitrate(&self, value: u32) -> HRESULT, + fn get_MaxVideoBitrate(&self, out: *mut u32) -> HRESULT, + fn put_MaxVideoWidth(&self, value: u32) -> HRESULT, + fn get_MaxVideoWidth(&self, out: *mut u32) -> HRESULT, + fn put_MaxVideoHeight(&self, value: u32) -> HRESULT, + fn get_MaxVideoHeight(&self, out: *mut u32) -> HRESULT }} -impl IPhoneCallHistoryEntry { - #[inline] pub fn get_id(&self) -> Result { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Id)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } +impl IAppBroadcastTriggerProviderInfo { + #[inline] pub fn set_display_name_resource(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_DisplayNameResource)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_address(&self) -> Result>> { unsafe { + #[inline] pub fn get_display_name_resource(&self) -> Result { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Address)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).get_DisplayNameResource)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} - #[inline] pub fn set_address(&self, value: &PhoneCallHistoryEntryAddress) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_Address)(self as *const _ as *mut _, value as *const _ as *mut _); + #[inline] pub fn set_logo_resource(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_LogoResource)(self as *const _ as *mut _, value.get()); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_duration(&self) -> Result>>> { unsafe { + #[inline] pub fn get_logo_resource(&self) -> Result { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Duration)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).get_LogoResource)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} - #[inline] pub fn set_duration(&self, value: &foundation::IReference) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_Duration)(self as *const _ as *mut _, value as *const _ as *mut _); + #[inline] pub fn set_video_key_frame_interval(&self, value: foundation::TimeSpan) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_VideoKeyFrameInterval)(self as *const _ as *mut _, value); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_is_caller_id_blocked(&self) -> Result { unsafe { + #[inline] pub fn get_video_key_frame_interval(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_IsCallerIdBlocked)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_VideoKeyFrameInterval)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn set_is_caller_id_blocked(&self, value: bool) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_IsCallerIdBlocked)(self as *const _ as *mut _, value); + #[inline] pub fn set_max_video_bitrate(&self, value: u32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_MaxVideoBitrate)(self as *const _ as *mut _, value); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_is_emergency(&self) -> Result { unsafe { + #[inline] pub fn get_max_video_bitrate(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_IsEmergency)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_MaxVideoBitrate)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn set_is_emergency(&self, value: bool) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_IsEmergency)(self as *const _ as *mut _, value); + #[inline] pub fn set_max_video_width(&self, value: u32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_MaxVideoWidth)(self as *const _ as *mut _, value); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_is_incoming(&self) -> Result { unsafe { + #[inline] pub fn get_max_video_width(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_IsIncoming)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_MaxVideoWidth)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn set_is_incoming(&self, value: bool) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_IsIncoming)(self as *const _ as *mut _, value); + #[inline] pub fn set_max_video_height(&self, value: u32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_MaxVideoHeight)(self as *const _ as *mut _, value); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_is_missed(&self) -> Result { unsafe { + #[inline] pub fn get_max_video_height(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_IsMissed)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_MaxVideoHeight)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn set_is_missed(&self, value: bool) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_IsMissed)(self as *const _ as *mut _, value); - if hr == S_OK { Ok(()) } else { err(hr) } - }} - #[inline] pub fn get_is_ringing(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_IsRinging)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } +} +RT_CLASS!{class AppBroadcastTriggerProviderInfo: IAppBroadcastTriggerProviderInfo} +DEFINE_IID!(IID_IApplicationTrigger, 189171248, 38260, 18732, 158, 147, 26, 58, 230, 51, 95, 233); +RT_INTERFACE!{interface IApplicationTrigger(IApplicationTriggerVtbl): IInspectable(IInspectableVtbl) [IID_IApplicationTrigger] { + fn RequestAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn RequestAsyncWithArguments(&self, arguments: *mut foundation::collections::ValueSet, out: *mut *mut foundation::IAsyncOperation) -> HRESULT +}} +impl IApplicationTrigger { + #[inline] pub fn request_async(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).RequestAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn set_is_ringing(&self, value: bool) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_IsRinging)(self as *const _ as *mut _, value); - if hr == S_OK { Ok(()) } else { err(hr) } + #[inline] pub fn request_async_with_arguments(&self, arguments: &foundation::collections::ValueSet) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).RequestAsyncWithArguments)(self as *const _ as *mut _, arguments as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_is_seen(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_IsSeen)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } +} +RT_CLASS!{class ApplicationTrigger: IApplicationTrigger} +impl RtActivatable for ApplicationTrigger {} +DEFINE_CLSID!(ApplicationTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,65,112,112,108,105,99,97,116,105,111,110,84,114,105,103,103,101,114,0]) [CLSID_ApplicationTrigger]); +DEFINE_IID!(IID_IApplicationTriggerDetails, 2547804850, 8729, 19102, 156, 94, 65, 208, 71, 247, 110, 130); +RT_INTERFACE!{interface IApplicationTriggerDetails(IApplicationTriggerDetailsVtbl): IInspectable(IInspectableVtbl) [IID_IApplicationTriggerDetails] { + fn get_Arguments(&self, out: *mut *mut foundation::collections::ValueSet) -> HRESULT +}} +impl IApplicationTriggerDetails { + #[inline] pub fn get_arguments(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Arguments)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn set_is_seen(&self, value: bool) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_IsSeen)(self as *const _ as *mut _, value); - if hr == S_OK { Ok(()) } else { err(hr) } +} +RT_CLASS!{class ApplicationTriggerDetails: IApplicationTriggerDetails} +RT_ENUM! { enum ApplicationTriggerResult: i32 { + Allowed (ApplicationTriggerResult_Allowed) = 0, CurrentlyRunning (ApplicationTriggerResult_CurrentlyRunning) = 1, DisabledByPolicy (ApplicationTriggerResult_DisabledByPolicy) = 2, UnknownError (ApplicationTriggerResult_UnknownError) = 3, +}} +DEFINE_IID!(IID_IAppointmentStoreNotificationTrigger, 1691616268, 49665, 17069, 170, 42, 226, 27, 163, 66, 91, 109); +RT_INTERFACE!{interface IAppointmentStoreNotificationTrigger(IAppointmentStoreNotificationTriggerVtbl): IInspectable(IInspectableVtbl) [IID_IAppointmentStoreNotificationTrigger] { + +}} +RT_CLASS!{class AppointmentStoreNotificationTrigger: IAppointmentStoreNotificationTrigger} +impl RtActivatable for AppointmentStoreNotificationTrigger {} +DEFINE_CLSID!(AppointmentStoreNotificationTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,65,112,112,111,105,110,116,109,101,110,116,83,116,111,114,101,78,111,116,105,102,105,99,97,116,105,111,110,84,114,105,103,103,101,114,0]) [CLSID_AppointmentStoreNotificationTrigger]); +RT_ENUM! { enum BackgroundAccessRequestKind: i32 { + AlwaysAllowed (BackgroundAccessRequestKind_AlwaysAllowed) = 0, AllowedSubjectToSystemPolicy (BackgroundAccessRequestKind_AllowedSubjectToSystemPolicy) = 1, +}} +RT_ENUM! { enum BackgroundAccessStatus: i32 { + Unspecified (BackgroundAccessStatus_Unspecified) = 0, AllowedWithAlwaysOnRealTimeConnectivity (BackgroundAccessStatus_AllowedWithAlwaysOnRealTimeConnectivity) = 1, AllowedMayUseActiveRealTimeConnectivity (BackgroundAccessStatus_AllowedMayUseActiveRealTimeConnectivity) = 2, Denied (BackgroundAccessStatus_Denied) = 3, AlwaysAllowed (BackgroundAccessStatus_AlwaysAllowed) = 4, AllowedSubjectToSystemPolicy (BackgroundAccessStatus_AllowedSubjectToSystemPolicy) = 5, DeniedBySystemPolicy (BackgroundAccessStatus_DeniedBySystemPolicy) = 6, DeniedByUser (BackgroundAccessStatus_DeniedByUser) = 7, +}} +DEFINE_IID!(IID_IBackgroundCondition, 2923995630, 35153, 16394, 131, 2, 156, 156, 154, 42, 58, 59); +RT_INTERFACE!{interface IBackgroundCondition(IBackgroundConditionVtbl): IInspectable(IInspectableVtbl) [IID_IBackgroundCondition] { + +}} +RT_CLASS!{static class BackgroundExecutionManager} +impl RtActivatable for BackgroundExecutionManager {} +impl RtActivatable for BackgroundExecutionManager {} +impl BackgroundExecutionManager { + #[inline] pub fn request_access_async() -> Result>> { + >::get_activation_factory().request_access_async() + } + #[inline] pub fn request_access_for_application_async(applicationId: &HStringArg) -> Result>> { + >::get_activation_factory().request_access_for_application_async(applicationId) + } + #[inline] pub fn remove_access() -> Result<()> { + >::get_activation_factory().remove_access() + } + #[inline] pub fn remove_access_for_application(applicationId: &HStringArg) -> Result<()> { + >::get_activation_factory().remove_access_for_application(applicationId) + } + #[inline] pub fn get_access_status() -> Result { + >::get_activation_factory().get_access_status() + } + #[inline] pub fn get_access_status_for_application(applicationId: &HStringArg) -> Result { + >::get_activation_factory().get_access_status_for_application(applicationId) + } + #[inline] pub fn request_access_kind_async(requestedAccess: BackgroundAccessRequestKind, reason: &HStringArg) -> Result>> { + >::get_activation_factory().request_access_kind_async(requestedAccess, reason) + } +} +DEFINE_CLSID!(BackgroundExecutionManager(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,66,97,99,107,103,114,111,117,110,100,69,120,101,99,117,116,105,111,110,77,97,110,97,103,101,114,0]) [CLSID_BackgroundExecutionManager]); +DEFINE_IID!(IID_IBackgroundExecutionManagerStatics, 3894864472, 26281, 19777, 131, 212, 180, 193, 140, 135, 184, 70); +RT_INTERFACE!{static interface IBackgroundExecutionManagerStatics(IBackgroundExecutionManagerStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IBackgroundExecutionManagerStatics] { + fn RequestAccessAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn RequestAccessForApplicationAsync(&self, applicationId: HSTRING, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn RemoveAccess(&self) -> HRESULT, + fn RemoveAccessForApplication(&self, applicationId: HSTRING) -> HRESULT, + fn GetAccessStatus(&self, out: *mut BackgroundAccessStatus) -> HRESULT, + fn GetAccessStatusForApplication(&self, applicationId: HSTRING, out: *mut BackgroundAccessStatus) -> HRESULT +}} +impl IBackgroundExecutionManagerStatics { + #[inline] pub fn request_access_async(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).RequestAccessAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_is_suppressed(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_IsSuppressed)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } + #[inline] pub fn request_access_for_application_async(&self, applicationId: &HStringArg) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).RequestAccessForApplicationAsync)(self as *const _ as *mut _, applicationId.get(), &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn set_is_suppressed(&self, value: bool) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_IsSuppressed)(self as *const _ as *mut _, value); + #[inline] pub fn remove_access(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).RemoveAccess)(self as *const _ as *mut _); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_is_voicemail(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_IsVoicemail)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } - }} - #[inline] pub fn set_is_voicemail(&self, value: bool) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_IsVoicemail)(self as *const _ as *mut _, value); + #[inline] pub fn remove_access_for_application(&self, applicationId: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).RemoveAccessForApplication)(self as *const _ as *mut _, applicationId.get()); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_media(&self) -> Result { unsafe { + #[inline] pub fn get_access_status(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_Media)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).GetAccessStatus)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn set_media(&self, value: PhoneCallHistoryEntryMedia) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_Media)(self as *const _ as *mut _, value); - if hr == S_OK { Ok(()) } else { err(hr) } - }} - #[inline] pub fn get_other_app_read_access(&self) -> Result { unsafe { + #[inline] pub fn get_access_status_for_application(&self, applicationId: &HStringArg) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_OtherAppReadAccess)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).GetAccessStatusForApplication)(self as *const _ as *mut _, applicationId.get(), &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn set_other_app_read_access(&self, value: PhoneCallHistoryEntryOtherAppReadAccess) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_OtherAppReadAccess)(self as *const _ as *mut _, value); - if hr == S_OK { Ok(()) } else { err(hr) } - }} - #[inline] pub fn get_remote_id(&self) -> Result { unsafe { +} +DEFINE_IID!(IID_IBackgroundExecutionManagerStatics2, 1184572655, 39867, 19992, 153, 154, 253, 101, 18, 147, 27, 233); +RT_INTERFACE!{static interface IBackgroundExecutionManagerStatics2(IBackgroundExecutionManagerStatics2Vtbl): IInspectable(IInspectableVtbl) [IID_IBackgroundExecutionManagerStatics2] { + fn RequestAccessKindAsync(&self, requestedAccess: BackgroundAccessRequestKind, reason: HSTRING, out: *mut *mut foundation::IAsyncOperation) -> HRESULT +}} +impl IBackgroundExecutionManagerStatics2 { + #[inline] pub fn request_access_kind_async(&self, requestedAccess: BackgroundAccessRequestKind, reason: &HStringArg) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_RemoteId)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).RequestAccessKindAsync)(self as *const _ as *mut _, requestedAccess, reason.get(), &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn set_remote_id(&self, value: &HStringArg) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_RemoteId)(self as *const _ as *mut _, value.get()); +} +DEFINE_IID!(IID_IBackgroundTask, 2098451764, 64786, 17358, 140, 34, 234, 31, 241, 60, 6, 223); +RT_INTERFACE!{interface IBackgroundTask(IBackgroundTaskVtbl): IInspectable(IInspectableVtbl) [IID_IBackgroundTask] { + fn Run(&self, taskInstance: *mut IBackgroundTaskInstance) -> HRESULT +}} +impl IBackgroundTask { + #[inline] pub fn run(&self, taskInstance: &IBackgroundTaskInstance) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).Run)(self as *const _ as *mut _, taskInstance as *const _ as *mut _); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_source_display_name(&self) -> Result { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_SourceDisplayName)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } +} +DEFINE_IID!(IID_IBackgroundTaskBuilder, 55661838, 15972, 17778, 169, 58, 132, 7, 90, 55, 201, 23); +RT_INTERFACE!{interface IBackgroundTaskBuilder(IBackgroundTaskBuilderVtbl): IInspectable(IInspectableVtbl) [IID_IBackgroundTaskBuilder] { + fn put_TaskEntryPoint(&self, value: HSTRING) -> HRESULT, + fn get_TaskEntryPoint(&self, out: *mut HSTRING) -> HRESULT, + fn SetTrigger(&self, trigger: *mut IBackgroundTrigger) -> HRESULT, + fn AddCondition(&self, condition: *mut IBackgroundCondition) -> HRESULT, + fn put_Name(&self, value: HSTRING) -> HRESULT, + fn get_Name(&self, out: *mut HSTRING) -> HRESULT, + fn Register(&self, out: *mut *mut BackgroundTaskRegistration) -> HRESULT +}} +impl IBackgroundTaskBuilder { + #[inline] pub fn set_task_entry_point(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_TaskEntryPoint)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_source_id(&self) -> Result { unsafe { + #[inline] pub fn get_task_entry_point(&self) -> Result { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_SourceId)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_TaskEntryPoint)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} - #[inline] pub fn set_source_id(&self, value: &HStringArg) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_SourceId)(self as *const _ as *mut _, value.get()); + #[inline] pub fn set_trigger(&self, trigger: &IBackgroundTrigger) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).SetTrigger)(self as *const _ as *mut _, trigger as *const _ as *mut _); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_source_id_kind(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_SourceIdKind)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } - }} - #[inline] pub fn set_source_id_kind(&self, value: PhoneCallHistorySourceIdKind) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_SourceIdKind)(self as *const _ as *mut _, value); + #[inline] pub fn add_condition(&self, condition: &IBackgroundCondition) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).AddCondition)(self as *const _ as *mut _, condition as *const _ as *mut _); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_start_time(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_StartTime)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } - }} - #[inline] pub fn set_start_time(&self, value: foundation::DateTime) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_StartTime)(self as *const _ as *mut _, value); + #[inline] pub fn set_name(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Name)(self as *const _ as *mut _, value.get()); if hr == S_OK { Ok(()) } else { err(hr) } }} -} -RT_CLASS!{class PhoneCallHistoryEntry: IPhoneCallHistoryEntry} -impl RtActivatable for PhoneCallHistoryEntry {} -DEFINE_CLSID!(PhoneCallHistoryEntry(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,67,97,108,108,115,46,80,104,111,110,101,67,97,108,108,72,105,115,116,111,114,121,69,110,116,114,121,0]) [CLSID_PhoneCallHistoryEntry]); -DEFINE_IID!(IID_IPhoneCallHistoryEntryAddress, 821123546, 14677, 16450, 132, 230, 102, 238, 191, 130, 230, 127); -RT_INTERFACE!{interface IPhoneCallHistoryEntryAddress(IPhoneCallHistoryEntryAddressVtbl): IInspectable(IInspectableVtbl) [IID_IPhoneCallHistoryEntryAddress] { - fn get_ContactId(&self, out: *mut HSTRING) -> HRESULT, - fn put_ContactId(&self, value: HSTRING) -> HRESULT, - fn get_DisplayName(&self, out: *mut HSTRING) -> HRESULT, - fn put_DisplayName(&self, value: HSTRING) -> HRESULT, - fn get_RawAddress(&self, out: *mut HSTRING) -> HRESULT, - fn put_RawAddress(&self, value: HSTRING) -> HRESULT, - fn get_RawAddressKind(&self, out: *mut PhoneCallHistoryEntryRawAddressKind) -> HRESULT, - fn put_RawAddressKind(&self, value: PhoneCallHistoryEntryRawAddressKind) -> HRESULT -}} -impl IPhoneCallHistoryEntryAddress { - #[inline] pub fn get_contact_id(&self) -> Result { unsafe { + #[inline] pub fn get_name(&self) -> Result { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_ContactId)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_Name)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} - #[inline] pub fn set_contact_id(&self, value: &HStringArg) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_ContactId)(self as *const _ as *mut _, value.get()); - if hr == S_OK { Ok(()) } else { err(hr) } - }} - #[inline] pub fn get_display_name(&self) -> Result { unsafe { + #[inline] pub fn register(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_DisplayName)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).Register)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn set_display_name(&self, value: &HStringArg) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_DisplayName)(self as *const _ as *mut _, value.get()); +} +RT_CLASS!{class BackgroundTaskBuilder: IBackgroundTaskBuilder} +impl RtActivatable for BackgroundTaskBuilder {} +DEFINE_CLSID!(BackgroundTaskBuilder(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,66,97,99,107,103,114,111,117,110,100,84,97,115,107,66,117,105,108,100,101,114,0]) [CLSID_BackgroundTaskBuilder]); +DEFINE_IID!(IID_IBackgroundTaskBuilder2, 1793576881, 4175, 16493, 141, 182, 132, 74, 87, 15, 66, 187); +RT_INTERFACE!{interface IBackgroundTaskBuilder2(IBackgroundTaskBuilder2Vtbl): IInspectable(IInspectableVtbl) [IID_IBackgroundTaskBuilder2] { + fn put_CancelOnConditionLoss(&self, value: bool) -> HRESULT, + fn get_CancelOnConditionLoss(&self, out: *mut bool) -> HRESULT +}} +impl IBackgroundTaskBuilder2 { + #[inline] pub fn set_cancel_on_condition_loss(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_CancelOnConditionLoss)(self as *const _ as *mut _, value); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_raw_address(&self) -> Result { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_RawAddress)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + #[inline] pub fn get_cancel_on_condition_loss(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_CancelOnConditionLoss)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn set_raw_address(&self, value: &HStringArg) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_RawAddress)(self as *const _ as *mut _, value.get()); +} +DEFINE_IID!(IID_IBackgroundTaskBuilder3, 684150602, 35753, 19465, 162, 79, 25, 104, 62, 44, 146, 76); +RT_INTERFACE!{interface IBackgroundTaskBuilder3(IBackgroundTaskBuilder3Vtbl): IInspectable(IInspectableVtbl) [IID_IBackgroundTaskBuilder3] { + fn put_IsNetworkRequested(&self, value: bool) -> HRESULT, + fn get_IsNetworkRequested(&self, out: *mut bool) -> HRESULT +}} +impl IBackgroundTaskBuilder3 { + #[inline] pub fn set_is_network_requested(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_IsNetworkRequested)(self as *const _ as *mut _, value); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_raw_address_kind(&self) -> Result { unsafe { + #[inline] pub fn get_is_network_requested(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_RawAddressKind)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_IsNetworkRequested)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn set_raw_address_kind(&self, value: PhoneCallHistoryEntryRawAddressKind) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_RawAddressKind)(self as *const _ as *mut _, value); - if hr == S_OK { Ok(()) } else { err(hr) } - }} -} -RT_CLASS!{class PhoneCallHistoryEntryAddress: IPhoneCallHistoryEntryAddress} -impl RtActivatable for PhoneCallHistoryEntryAddress {} -impl RtActivatable for PhoneCallHistoryEntryAddress {} -impl PhoneCallHistoryEntryAddress { - #[inline] pub fn create(rawAddress: &HStringArg, rawAddressKind: PhoneCallHistoryEntryRawAddressKind) -> Result> { - >::get_activation_factory().create(rawAddress, rawAddressKind) - } } -DEFINE_CLSID!(PhoneCallHistoryEntryAddress(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,67,97,108,108,115,46,80,104,111,110,101,67,97,108,108,72,105,115,116,111,114,121,69,110,116,114,121,65,100,100,114,101,115,115,0]) [CLSID_PhoneCallHistoryEntryAddress]); -DEFINE_IID!(IID_IPhoneCallHistoryEntryAddressFactory, 4212108730, 51184, 19382, 159, 107, 186, 93, 115, 32, 154, 202); -RT_INTERFACE!{static interface IPhoneCallHistoryEntryAddressFactory(IPhoneCallHistoryEntryAddressFactoryVtbl): IInspectable(IInspectableVtbl) [IID_IPhoneCallHistoryEntryAddressFactory] { - fn Create(&self, rawAddress: HSTRING, rawAddressKind: PhoneCallHistoryEntryRawAddressKind, out: *mut *mut PhoneCallHistoryEntryAddress) -> HRESULT +DEFINE_IID!(IID_IBackgroundTaskBuilder4, 1196811554, 52130, 20021, 189, 22, 166, 218, 127, 28, 25, 170); +RT_INTERFACE!{interface IBackgroundTaskBuilder4(IBackgroundTaskBuilder4Vtbl): IInspectable(IInspectableVtbl) [IID_IBackgroundTaskBuilder4] { + fn get_TaskGroup(&self, out: *mut *mut BackgroundTaskRegistrationGroup) -> HRESULT, + fn put_TaskGroup(&self, value: *mut BackgroundTaskRegistrationGroup) -> HRESULT }} -impl IPhoneCallHistoryEntryAddressFactory { - #[inline] pub fn create(&self, rawAddress: &HStringArg, rawAddressKind: PhoneCallHistoryEntryRawAddressKind) -> Result> { unsafe { +impl IBackgroundTaskBuilder4 { + #[inline] pub fn get_task_group(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, rawAddress.get(), rawAddressKind, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).get_TaskGroup)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn set_task_group(&self, value: &BackgroundTaskRegistrationGroup) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_TaskGroup)(self as *const _ as *mut _, value as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } }} } -RT_ENUM! { enum PhoneCallHistoryEntryMedia: i32 { - Audio (PhoneCallHistoryEntryMedia_Audio) = 0, Video (PhoneCallHistoryEntryMedia_Video) = 1, -}} -RT_ENUM! { enum PhoneCallHistoryEntryOtherAppReadAccess: i32 { - Full (PhoneCallHistoryEntryOtherAppReadAccess_Full) = 0, SystemOnly (PhoneCallHistoryEntryOtherAppReadAccess_SystemOnly) = 1, +DEFINE_IID!(IID_BackgroundTaskCanceledEventHandler, 2797910720, 20984, 19543, 172, 63, 21, 109, 209, 104, 12, 79); +RT_DELEGATE!{delegate BackgroundTaskCanceledEventHandler(BackgroundTaskCanceledEventHandlerVtbl, BackgroundTaskCanceledEventHandlerImpl) [IID_BackgroundTaskCanceledEventHandler] { + fn Invoke(&self, sender: *mut IBackgroundTaskInstance, reason: BackgroundTaskCancellationReason) -> HRESULT }} -RT_ENUM! { enum PhoneCallHistoryEntryQueryDesiredMedia: u32 { - None (PhoneCallHistoryEntryQueryDesiredMedia_None) = 0, Audio (PhoneCallHistoryEntryQueryDesiredMedia_Audio) = 1, Video (PhoneCallHistoryEntryQueryDesiredMedia_Video) = 2, All (PhoneCallHistoryEntryQueryDesiredMedia_All) = 4294967295, +impl BackgroundTaskCanceledEventHandler { + #[inline] pub fn invoke(&self, sender: &IBackgroundTaskInstance, reason: BackgroundTaskCancellationReason) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).Invoke)(self as *const _ as *mut _, sender as *const _ as *mut _, reason); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_ENUM! { enum BackgroundTaskCancellationReason: i32 { + Abort (BackgroundTaskCancellationReason_Abort) = 0, Terminating (BackgroundTaskCancellationReason_Terminating) = 1, LoggingOff (BackgroundTaskCancellationReason_LoggingOff) = 2, ServicingUpdate (BackgroundTaskCancellationReason_ServicingUpdate) = 3, IdleTask (BackgroundTaskCancellationReason_IdleTask) = 4, Uninstall (BackgroundTaskCancellationReason_Uninstall) = 5, ConditionLoss (BackgroundTaskCancellationReason_ConditionLoss) = 6, SystemPolicy (BackgroundTaskCancellationReason_SystemPolicy) = 7, QuietHoursEntered (BackgroundTaskCancellationReason_QuietHoursEntered) = 8, ExecutionTimeExceeded (BackgroundTaskCancellationReason_ExecutionTimeExceeded) = 9, ResourceRevocation (BackgroundTaskCancellationReason_ResourceRevocation) = 10, EnergySaver (BackgroundTaskCancellationReason_EnergySaver) = 11, }} -DEFINE_IID!(IID_IPhoneCallHistoryEntryQueryOptions, 2623529308, 35821, 16586, 176, 110, 196, 202, 142, 174, 92, 135); -RT_INTERFACE!{interface IPhoneCallHistoryEntryQueryOptions(IPhoneCallHistoryEntryQueryOptionsVtbl): IInspectable(IInspectableVtbl) [IID_IPhoneCallHistoryEntryQueryOptions] { - fn get_DesiredMedia(&self, out: *mut PhoneCallHistoryEntryQueryDesiredMedia) -> HRESULT, - fn put_DesiredMedia(&self, value: PhoneCallHistoryEntryQueryDesiredMedia) -> HRESULT, - fn get_SourceIds(&self, out: *mut *mut foundation::collections::IVector) -> HRESULT +DEFINE_IID!(IID_IBackgroundTaskCompletedEventArgs, 1448945103, 61961, 18676, 153, 103, 43, 24, 79, 123, 251, 240); +RT_INTERFACE!{interface IBackgroundTaskCompletedEventArgs(IBackgroundTaskCompletedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IBackgroundTaskCompletedEventArgs] { + fn get_InstanceId(&self, out: *mut Guid) -> HRESULT, + fn CheckResult(&self) -> HRESULT }} -impl IPhoneCallHistoryEntryQueryOptions { - #[inline] pub fn get_desired_media(&self) -> Result { unsafe { +impl IBackgroundTaskCompletedEventArgs { + #[inline] pub fn get_instance_id(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_DesiredMedia)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_InstanceId)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn set_desired_media(&self, value: PhoneCallHistoryEntryQueryDesiredMedia) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_DesiredMedia)(self as *const _ as *mut _, value); + #[inline] pub fn check_result(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).CheckResult)(self as *const _ as *mut _); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_source_ids(&self) -> Result>>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_SourceIds)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } - }} } -RT_CLASS!{class PhoneCallHistoryEntryQueryOptions: IPhoneCallHistoryEntryQueryOptions} -impl RtActivatable for PhoneCallHistoryEntryQueryOptions {} -DEFINE_CLSID!(PhoneCallHistoryEntryQueryOptions(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,67,97,108,108,115,46,80,104,111,110,101,67,97,108,108,72,105,115,116,111,114,121,69,110,116,114,121,81,117,101,114,121,79,112,116,105,111,110,115,0]) [CLSID_PhoneCallHistoryEntryQueryOptions]); -RT_ENUM! { enum PhoneCallHistoryEntryRawAddressKind: i32 { - PhoneNumber (PhoneCallHistoryEntryRawAddressKind_PhoneNumber) = 0, Custom (PhoneCallHistoryEntryRawAddressKind_Custom) = 1, -}} -DEFINE_IID!(IID_IPhoneCallHistoryEntryReader, 1642915006, 36230, 18335, 132, 4, 169, 132, 105, 32, 254, 230); -RT_INTERFACE!{interface IPhoneCallHistoryEntryReader(IPhoneCallHistoryEntryReaderVtbl): IInspectable(IInspectableVtbl) [IID_IPhoneCallHistoryEntryReader] { - fn ReadBatchAsync(&self, out: *mut *mut foundation::IAsyncOperation>) -> HRESULT +RT_CLASS!{class BackgroundTaskCompletedEventArgs: IBackgroundTaskCompletedEventArgs} +DEFINE_IID!(IID_BackgroundTaskCompletedEventHandler, 1530456361, 41094, 18087, 166, 120, 67, 145, 53, 130, 43, 207); +RT_DELEGATE!{delegate BackgroundTaskCompletedEventHandler(BackgroundTaskCompletedEventHandlerVtbl, BackgroundTaskCompletedEventHandlerImpl) [IID_BackgroundTaskCompletedEventHandler] { + fn Invoke(&self, sender: *mut BackgroundTaskRegistration, args: *mut BackgroundTaskCompletedEventArgs) -> HRESULT }} -impl IPhoneCallHistoryEntryReader { - #[inline] pub fn read_batch_async(&self) -> Result>>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).ReadBatchAsync)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } +impl BackgroundTaskCompletedEventHandler { + #[inline] pub fn invoke(&self, sender: &BackgroundTaskRegistration, args: &BackgroundTaskCompletedEventArgs) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).Invoke)(self as *const _ as *mut _, sender as *const _ as *mut _, args as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } }} } -RT_CLASS!{class PhoneCallHistoryEntryReader: IPhoneCallHistoryEntryReader} -RT_CLASS!{static class PhoneCallHistoryManager} -impl RtActivatable for PhoneCallHistoryManager {} -impl RtActivatable for PhoneCallHistoryManager {} -impl PhoneCallHistoryManager { - #[inline] pub fn request_store_async(accessType: PhoneCallHistoryStoreAccessType) -> Result>> { - >::get_activation_factory().request_store_async(accessType) - } - #[cfg(feature="windows-system")] #[inline] pub fn get_for_user(user: &super::super::system::User) -> Result>> { - >::get_activation_factory().get_for_user(user) - } -} -DEFINE_CLSID!(PhoneCallHistoryManager(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,67,97,108,108,115,46,80,104,111,110,101,67,97,108,108,72,105,115,116,111,114,121,77,97,110,97,103,101,114,0]) [CLSID_PhoneCallHistoryManager]); -DEFINE_IID!(IID_IPhoneCallHistoryManagerForUser, 3643131171, 62815, 17235, 157, 180, 2, 5, 165, 38, 90, 85); -RT_INTERFACE!{interface IPhoneCallHistoryManagerForUser(IPhoneCallHistoryManagerForUserVtbl): IInspectable(IInspectableVtbl) [IID_IPhoneCallHistoryManagerForUser] { - fn RequestStoreAsync(&self, accessType: PhoneCallHistoryStoreAccessType, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, - #[cfg(feature="windows-system")] fn get_User(&self, out: *mut *mut super::super::system::User) -> HRESULT +DEFINE_IID!(IID_IBackgroundTaskDeferral, 2479625581, 44839, 19923, 132, 110, 36, 238, 64, 202, 221, 37); +RT_INTERFACE!{interface IBackgroundTaskDeferral(IBackgroundTaskDeferralVtbl): IInspectable(IInspectableVtbl) [IID_IBackgroundTaskDeferral] { + fn Complete(&self) -> HRESULT }} -impl IPhoneCallHistoryManagerForUser { - #[inline] pub fn request_store_async(&self, accessType: PhoneCallHistoryStoreAccessType) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).RequestStoreAsync)(self as *const _ as *mut _, accessType, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } - }} - #[cfg(feature="windows-system")] #[inline] pub fn get_user(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_User)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } +impl IBackgroundTaskDeferral { + #[inline] pub fn complete(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).Complete)(self as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } }} } -RT_CLASS!{class PhoneCallHistoryManagerForUser: IPhoneCallHistoryManagerForUser} -DEFINE_IID!(IID_IPhoneCallHistoryManagerStatics, 4121352761, 45855, 20293, 172, 142, 27, 8, 137, 60, 27, 80); -RT_INTERFACE!{static interface IPhoneCallHistoryManagerStatics(IPhoneCallHistoryManagerStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IPhoneCallHistoryManagerStatics] { - fn RequestStoreAsync(&self, accessType: PhoneCallHistoryStoreAccessType, out: *mut *mut foundation::IAsyncOperation) -> HRESULT +RT_CLASS!{class BackgroundTaskDeferral: IBackgroundTaskDeferral} +DEFINE_IID!(IID_IBackgroundTaskInstance, 2254166650, 8664, 17779, 143, 50, 146, 138, 27, 6, 65, 246); +RT_INTERFACE!{interface IBackgroundTaskInstance(IBackgroundTaskInstanceVtbl): IInspectable(IInspectableVtbl) [IID_IBackgroundTaskInstance] { + fn get_InstanceId(&self, out: *mut Guid) -> HRESULT, + fn get_Task(&self, out: *mut *mut BackgroundTaskRegistration) -> HRESULT, + fn get_Progress(&self, out: *mut u32) -> HRESULT, + fn put_Progress(&self, value: u32) -> HRESULT, + fn get_TriggerDetails(&self, out: *mut *mut IInspectable) -> HRESULT, + fn add_Canceled(&self, cancelHandler: *mut BackgroundTaskCanceledEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_Canceled(&self, cookie: foundation::EventRegistrationToken) -> HRESULT, + fn get_SuspendedCount(&self, out: *mut u32) -> HRESULT, + fn GetDeferral(&self, out: *mut *mut BackgroundTaskDeferral) -> HRESULT }} -impl IPhoneCallHistoryManagerStatics { - #[inline] pub fn request_store_async(&self, accessType: PhoneCallHistoryStoreAccessType) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).RequestStoreAsync)(self as *const _ as *mut _, accessType, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } +impl IBackgroundTaskInstance { + #[inline] pub fn get_instance_id(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_InstanceId)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} -} -DEFINE_IID!(IID_IPhoneCallHistoryManagerStatics2, 4023678192, 41691, 16776, 158, 146, 188, 60, 250, 104, 19, 207); -RT_INTERFACE!{static interface IPhoneCallHistoryManagerStatics2(IPhoneCallHistoryManagerStatics2Vtbl): IInspectable(IInspectableVtbl) [IID_IPhoneCallHistoryManagerStatics2] { - #[cfg(feature="windows-system")] fn GetForUser(&self, user: *mut super::super::system::User, out: *mut *mut PhoneCallHistoryManagerForUser) -> HRESULT -}} -impl IPhoneCallHistoryManagerStatics2 { - #[cfg(feature="windows-system")] #[inline] pub fn get_for_user(&self, user: &super::super::system::User) -> Result>> { unsafe { + #[inline] pub fn get_task(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetForUser)(self as *const _ as *mut _, user as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_Task)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} -} -RT_ENUM! { enum PhoneCallHistorySourceIdKind: i32 { - CellularPhoneLineId (PhoneCallHistorySourceIdKind_CellularPhoneLineId) = 0, PackageFamilyName (PhoneCallHistorySourceIdKind_PackageFamilyName) = 1, -}} -DEFINE_IID!(IID_IPhoneCallHistoryStore, 797998520, 46094, 16939, 133, 69, 203, 25, 16, 166, 28, 82); -RT_INTERFACE!{interface IPhoneCallHistoryStore(IPhoneCallHistoryStoreVtbl): IInspectable(IInspectableVtbl) [IID_IPhoneCallHistoryStore] { - fn GetEntryAsync(&self, callHistoryEntryId: HSTRING, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, - fn GetEntryReader(&self, out: *mut *mut PhoneCallHistoryEntryReader) -> HRESULT, - fn GetEntryReaderWithOptions(&self, queryOptions: *mut PhoneCallHistoryEntryQueryOptions, out: *mut *mut PhoneCallHistoryEntryReader) -> HRESULT, - fn SaveEntryAsync(&self, callHistoryEntry: *mut PhoneCallHistoryEntry, out: *mut *mut foundation::IAsyncAction) -> HRESULT, - fn DeleteEntryAsync(&self, callHistoryEntry: *mut PhoneCallHistoryEntry, out: *mut *mut foundation::IAsyncAction) -> HRESULT, - fn DeleteEntriesAsync(&self, callHistoryEntries: *mut foundation::collections::IIterable, out: *mut *mut foundation::IAsyncAction) -> HRESULT, - fn MarkEntryAsSeenAsync(&self, callHistoryEntry: *mut PhoneCallHistoryEntry, out: *mut *mut foundation::IAsyncAction) -> HRESULT, - fn MarkEntriesAsSeenAsync(&self, callHistoryEntries: *mut foundation::collections::IIterable, out: *mut *mut foundation::IAsyncAction) -> HRESULT, - fn GetUnseenCountAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, - fn MarkAllAsSeenAsync(&self, out: *mut *mut foundation::IAsyncAction) -> HRESULT, - fn GetSourcesUnseenCountAsync(&self, sourceIds: *mut foundation::collections::IIterable, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, - fn MarkSourcesAsSeenAsync(&self, sourceIds: *mut foundation::collections::IIterable, out: *mut *mut foundation::IAsyncAction) -> HRESULT -}} -impl IPhoneCallHistoryStore { - #[inline] pub fn get_entry_async(&self, callHistoryEntryId: &HStringArg) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetEntryAsync)(self as *const _ as *mut _, callHistoryEntryId.get(), &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + #[inline] pub fn get_progress(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Progress)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_entry_reader(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetEntryReader)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + #[inline] pub fn set_progress(&self, value: u32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Progress)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_entry_reader_with_options(&self, queryOptions: &PhoneCallHistoryEntryQueryOptions) -> Result>> { unsafe { + #[inline] pub fn get_trigger_details(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetEntryReaderWithOptions)(self as *const _ as *mut _, queryOptions as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_TriggerDetails)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn save_entry_async(&self, callHistoryEntry: &PhoneCallHistoryEntry) -> Result> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).SaveEntryAsync)(self as *const _ as *mut _, callHistoryEntry as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } - }} - #[inline] pub fn delete_entry_async(&self, callHistoryEntry: &PhoneCallHistoryEntry) -> Result> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).DeleteEntryAsync)(self as *const _ as *mut _, callHistoryEntry as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } - }} - #[inline] pub fn delete_entries_async(&self, callHistoryEntries: &foundation::collections::IIterable) -> Result> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).DeleteEntriesAsync)(self as *const _ as *mut _, callHistoryEntries as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } - }} - #[inline] pub fn mark_entry_as_seen_async(&self, callHistoryEntry: &PhoneCallHistoryEntry) -> Result> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).MarkEntryAsSeenAsync)(self as *const _ as *mut _, callHistoryEntry as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + #[inline] pub fn add_canceled(&self, cancelHandler: &BackgroundTaskCanceledEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_Canceled)(self as *const _ as *mut _, cancelHandler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn mark_entries_as_seen_async(&self, callHistoryEntries: &foundation::collections::IIterable) -> Result> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).MarkEntriesAsSeenAsync)(self as *const _ as *mut _, callHistoryEntries as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + #[inline] pub fn remove_canceled(&self, cookie: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_Canceled)(self as *const _ as *mut _, cookie); + if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_unseen_count_async(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetUnseenCountAsync)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + #[inline] pub fn get_suspended_count(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_SuspendedCount)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn mark_all_as_seen_async(&self) -> Result> { unsafe { + #[inline] pub fn get_deferral(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).MarkAllAsSeenAsync)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).GetDeferral)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn get_sources_unseen_count_async(&self, sourceIds: &foundation::collections::IIterable) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetSourcesUnseenCountAsync)(self as *const _ as *mut _, sourceIds as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } +} +DEFINE_IID!(IID_IBackgroundTaskInstance2, 1333592438, 3190, 20404, 137, 109, 93, 225, 134, 65, 34, 246); +RT_INTERFACE!{interface IBackgroundTaskInstance2(IBackgroundTaskInstance2Vtbl): IInspectable(IInspectableVtbl) [IID_IBackgroundTaskInstance2] { + fn GetThrottleCount(&self, counter: BackgroundTaskThrottleCounter, out: *mut u32) -> HRESULT +}} +impl IBackgroundTaskInstance2 { + #[inline] pub fn get_throttle_count(&self, counter: BackgroundTaskThrottleCounter) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).GetThrottleCount)(self as *const _ as *mut _, counter, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn mark_sources_as_seen_async(&self, sourceIds: &foundation::collections::IIterable) -> Result> { unsafe { +} +DEFINE_IID!(IID_IBackgroundTaskInstance4, 2133455420, 43524, 19208, 151, 176, 6, 216, 116, 205, 171, 245); +RT_INTERFACE!{interface IBackgroundTaskInstance4(IBackgroundTaskInstance4Vtbl): IInspectable(IInspectableVtbl) [IID_IBackgroundTaskInstance4] { + #[cfg(feature="windows-system")] fn get_User(&self, out: *mut *mut super::super::system::User) -> HRESULT +}} +impl IBackgroundTaskInstance4 { + #[cfg(feature="windows-system")] #[inline] pub fn get_user(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).MarkSourcesAsSeenAsync)(self as *const _ as *mut _, sourceIds as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).get_User)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } -RT_CLASS!{class PhoneCallHistoryStore: IPhoneCallHistoryStore} -RT_ENUM! { enum PhoneCallHistoryStoreAccessType: i32 { - AppEntriesReadWrite (PhoneCallHistoryStoreAccessType_AppEntriesReadWrite) = 0, AllEntriesLimitedReadWrite (PhoneCallHistoryStoreAccessType_AllEntriesLimitedReadWrite) = 1, AllEntriesReadWrite (PhoneCallHistoryStoreAccessType_AllEntriesReadWrite) = 2, -}} -DEFINE_IID!(IID_IVoipCallCoordinator, 1326549967, 59631, 17460, 156, 95, 168, 216, 147, 250, 254, 121); -RT_INTERFACE!{interface IVoipCallCoordinator(IVoipCallCoordinatorVtbl): IInspectable(IInspectableVtbl) [IID_IVoipCallCoordinator] { - fn ReserveCallResourcesAsync(&self, taskEntryPoint: HSTRING, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, - fn add_MuteStateChanged(&self, muteChangeHandler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, - fn remove_MuteStateChanged(&self, token: foundation::EventRegistrationToken) -> HRESULT, - fn RequestNewIncomingCall(&self, context: HSTRING, contactName: HSTRING, contactNumber: HSTRING, contactImage: *mut foundation::Uri, serviceName: HSTRING, brandingImage: *mut foundation::Uri, callDetails: HSTRING, ringtone: *mut foundation::Uri, media: VoipPhoneCallMedia, ringTimeout: foundation::TimeSpan, out: *mut *mut VoipPhoneCall) -> HRESULT, - fn RequestNewOutgoingCall(&self, context: HSTRING, contactName: HSTRING, serviceName: HSTRING, media: VoipPhoneCallMedia, out: *mut *mut VoipPhoneCall) -> HRESULT, - fn NotifyMuted(&self) -> HRESULT, - fn NotifyUnmuted(&self) -> HRESULT, - fn RequestOutgoingUpgradeToVideoCall(&self, callUpgradeGuid: Guid, context: HSTRING, contactName: HSTRING, serviceName: HSTRING, out: *mut *mut VoipPhoneCall) -> HRESULT, - fn RequestIncomingUpgradeToVideoCall(&self, context: HSTRING, contactName: HSTRING, contactNumber: HSTRING, contactImage: *mut foundation::Uri, serviceName: HSTRING, brandingImage: *mut foundation::Uri, callDetails: HSTRING, ringtone: *mut foundation::Uri, ringTimeout: foundation::TimeSpan, out: *mut *mut VoipPhoneCall) -> HRESULT, - fn TerminateCellularCall(&self, callUpgradeGuid: Guid) -> HRESULT, - fn CancelUpgrade(&self, callUpgradeGuid: Guid) -> HRESULT +DEFINE_IID!(IID_IBackgroundTaskProgressEventArgs, 4212418732, 33586, 19722, 149, 50, 3, 234, 230, 132, 218, 49); +RT_INTERFACE!{interface IBackgroundTaskProgressEventArgs(IBackgroundTaskProgressEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IBackgroundTaskProgressEventArgs] { + fn get_InstanceId(&self, out: *mut Guid) -> HRESULT, + fn get_Progress(&self, out: *mut u32) -> HRESULT }} -impl IVoipCallCoordinator { - #[inline] pub fn reserve_call_resources_async(&self, taskEntryPoint: &HStringArg) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).ReserveCallResourcesAsync)(self as *const _ as *mut _, taskEntryPoint.get(), &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } +impl IBackgroundTaskProgressEventArgs { + #[inline] pub fn get_instance_id(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_InstanceId)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn add_mute_state_changed(&self, muteChangeHandler: &foundation::TypedEventHandler) -> Result { unsafe { + #[inline] pub fn get_progress(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).add_MuteStateChanged)(self as *const _ as *mut _, muteChangeHandler as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_Progress)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn remove_mute_state_changed(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).remove_MuteStateChanged)(self as *const _ as *mut _, token); +} +RT_CLASS!{class BackgroundTaskProgressEventArgs: IBackgroundTaskProgressEventArgs} +DEFINE_IID!(IID_BackgroundTaskProgressEventHandler, 1189111868, 35464, 19609, 128, 76, 118, 137, 127, 98, 119, 166); +RT_DELEGATE!{delegate BackgroundTaskProgressEventHandler(BackgroundTaskProgressEventHandlerVtbl, BackgroundTaskProgressEventHandlerImpl) [IID_BackgroundTaskProgressEventHandler] { + fn Invoke(&self, sender: *mut BackgroundTaskRegistration, args: *mut BackgroundTaskProgressEventArgs) -> HRESULT +}} +impl BackgroundTaskProgressEventHandler { + #[inline] pub fn invoke(&self, sender: &BackgroundTaskRegistration, args: &BackgroundTaskProgressEventArgs) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).Invoke)(self as *const _ as *mut _, sender as *const _ as *mut _, args as *const _ as *mut _); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn request_new_incoming_call(&self, context: &HStringArg, contactName: &HStringArg, contactNumber: &HStringArg, contactImage: &foundation::Uri, serviceName: &HStringArg, brandingImage: &foundation::Uri, callDetails: &HStringArg, ringtone: &foundation::Uri, media: VoipPhoneCallMedia, ringTimeout: foundation::TimeSpan) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).RequestNewIncomingCall)(self as *const _ as *mut _, context.get(), contactName.get(), contactNumber.get(), contactImage as *const _ as *mut _, serviceName.get(), brandingImage as *const _ as *mut _, callDetails.get(), ringtone as *const _ as *mut _, media, ringTimeout, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } +} +DEFINE_IID!(IID_IBackgroundTaskRegistration, 275074242, 41582, 17343, 140, 18, 31, 180, 13, 191, 191, 160); +RT_INTERFACE!{interface IBackgroundTaskRegistration(IBackgroundTaskRegistrationVtbl): IInspectable(IInspectableVtbl) [IID_IBackgroundTaskRegistration] { + fn get_TaskId(&self, out: *mut Guid) -> HRESULT, + fn get_Name(&self, out: *mut HSTRING) -> HRESULT, + fn add_Progress(&self, handler: *mut BackgroundTaskProgressEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_Progress(&self, cookie: foundation::EventRegistrationToken) -> HRESULT, + fn add_Completed(&self, handler: *mut BackgroundTaskCompletedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_Completed(&self, cookie: foundation::EventRegistrationToken) -> HRESULT, + fn Unregister(&self, cancelTask: bool) -> HRESULT +}} +impl IBackgroundTaskRegistration { + #[inline] pub fn get_task_id(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_TaskId)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn request_new_outgoing_call(&self, context: &HStringArg, contactName: &HStringArg, serviceName: &HStringArg, media: VoipPhoneCallMedia) -> Result>> { unsafe { + #[inline] pub fn get_name(&self) -> Result { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).RequestNewOutgoingCall)(self as *const _ as *mut _, context.get(), contactName.get(), serviceName.get(), media, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).get_Name)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} - #[inline] pub fn notify_muted(&self) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).NotifyMuted)(self as *const _ as *mut _); - if hr == S_OK { Ok(()) } else { err(hr) } + #[inline] pub fn add_progress(&self, handler: &BackgroundTaskProgressEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_Progress)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn notify_unmuted(&self) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).NotifyUnmuted)(self as *const _ as *mut _); + #[inline] pub fn remove_progress(&self, cookie: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_Progress)(self as *const _ as *mut _, cookie); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn request_outgoing_upgrade_to_video_call(&self, callUpgradeGuid: Guid, context: &HStringArg, contactName: &HStringArg, serviceName: &HStringArg) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).RequestOutgoingUpgradeToVideoCall)(self as *const _ as *mut _, callUpgradeGuid, context.get(), contactName.get(), serviceName.get(), &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } - }} - #[inline] pub fn request_incoming_upgrade_to_video_call(&self, context: &HStringArg, contactName: &HStringArg, contactNumber: &HStringArg, contactImage: &foundation::Uri, serviceName: &HStringArg, brandingImage: &foundation::Uri, callDetails: &HStringArg, ringtone: &foundation::Uri, ringTimeout: foundation::TimeSpan) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).RequestIncomingUpgradeToVideoCall)(self as *const _ as *mut _, context.get(), contactName.get(), contactNumber.get(), contactImage as *const _ as *mut _, serviceName.get(), brandingImage as *const _ as *mut _, callDetails.get(), ringtone as *const _ as *mut _, ringTimeout, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + #[inline] pub fn add_completed(&self, handler: &BackgroundTaskCompletedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_Completed)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn terminate_cellular_call(&self, callUpgradeGuid: Guid) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).TerminateCellularCall)(self as *const _ as *mut _, callUpgradeGuid); + #[inline] pub fn remove_completed(&self, cookie: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_Completed)(self as *const _ as *mut _, cookie); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn cancel_upgrade(&self, callUpgradeGuid: Guid) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).CancelUpgrade)(self as *const _ as *mut _, callUpgradeGuid); + #[inline] pub fn unregister(&self, cancelTask: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).Unregister)(self as *const _ as *mut _, cancelTask); if hr == S_OK { Ok(()) } else { err(hr) } }} } -RT_CLASS!{class VoipCallCoordinator: IVoipCallCoordinator} -impl RtActivatable for VoipCallCoordinator {} -impl VoipCallCoordinator { - #[inline] pub fn get_default() -> Result>> { - >::get_activation_factory().get_default() +RT_CLASS!{class BackgroundTaskRegistration: IBackgroundTaskRegistration} +impl RtActivatable for BackgroundTaskRegistration {} +impl RtActivatable for BackgroundTaskRegistration {} +impl BackgroundTaskRegistration { + #[inline] pub fn get_all_tasks() -> Result>>> { + >::get_activation_factory().get_all_tasks() + } + #[inline] pub fn get_all_task_groups() -> Result>>> { + >::get_activation_factory().get_all_task_groups() + } + #[inline] pub fn get_task_group(groupId: &HStringArg) -> Result>> { + >::get_activation_factory().get_task_group(groupId) } } -DEFINE_CLSID!(VoipCallCoordinator(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,67,97,108,108,115,46,86,111,105,112,67,97,108,108,67,111,111,114,100,105,110,97,116,111,114,0]) [CLSID_VoipCallCoordinator]); -DEFINE_IID!(IID_IVoipCallCoordinator2, 3199511027, 50948, 16948, 137, 206, 232, 140, 192, 210, 143, 190); -RT_INTERFACE!{interface IVoipCallCoordinator2(IVoipCallCoordinator2Vtbl): IInspectable(IInspectableVtbl) [IID_IVoipCallCoordinator2] { - fn SetupNewAcceptedCall(&self, context: HSTRING, contactName: HSTRING, contactNumber: HSTRING, serviceName: HSTRING, media: VoipPhoneCallMedia, out: *mut *mut VoipPhoneCall) -> HRESULT +DEFINE_CLSID!(BackgroundTaskRegistration(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,66,97,99,107,103,114,111,117,110,100,84,97,115,107,82,101,103,105,115,116,114,97,116,105,111,110,0]) [CLSID_BackgroundTaskRegistration]); +DEFINE_IID!(IID_IBackgroundTaskRegistration2, 1631110915, 48006, 16658, 175, 195, 127, 147, 155, 22, 110, 59); +RT_INTERFACE!{interface IBackgroundTaskRegistration2(IBackgroundTaskRegistration2Vtbl): IInspectable(IInspectableVtbl) [IID_IBackgroundTaskRegistration2] { + fn get_Trigger(&self, out: *mut *mut IBackgroundTrigger) -> HRESULT }} -impl IVoipCallCoordinator2 { - #[inline] pub fn setup_new_accepted_call(&self, context: &HStringArg, contactName: &HStringArg, contactNumber: &HStringArg, serviceName: &HStringArg, media: VoipPhoneCallMedia) -> Result>> { unsafe { +impl IBackgroundTaskRegistration2 { + #[inline] pub fn get_trigger(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).SetupNewAcceptedCall)(self as *const _ as *mut _, context.get(), contactName.get(), contactNumber.get(), serviceName.get(), media, &mut out); + let hr = ((*self.lpVtbl).get_Trigger)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } -DEFINE_IID!(IID_IVoipCallCoordinatorStatics, 2136809259, 57418, 19728, 179, 26, 165, 92, 146, 44, 194, 251); -RT_INTERFACE!{static interface IVoipCallCoordinatorStatics(IVoipCallCoordinatorStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IVoipCallCoordinatorStatics] { - fn GetDefault(&self, out: *mut *mut VoipCallCoordinator) -> HRESULT +DEFINE_IID!(IID_IBackgroundTaskRegistration3, 4264788373, 37923, 19851, 131, 13, 177, 221, 44, 123, 173, 213); +RT_INTERFACE!{interface IBackgroundTaskRegistration3(IBackgroundTaskRegistration3Vtbl): IInspectable(IInspectableVtbl) [IID_IBackgroundTaskRegistration3] { + fn get_TaskGroup(&self, out: *mut *mut BackgroundTaskRegistrationGroup) -> HRESULT }} -impl IVoipCallCoordinatorStatics { - #[inline] pub fn get_default(&self) -> Result>> { unsafe { +impl IBackgroundTaskRegistration3 { + #[inline] pub fn get_task_group(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetDefault)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_TaskGroup)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } -DEFINE_IID!(IID_IVoipPhoneCall, 1827795354, 30612, 19034, 140, 104, 174, 135, 148, 122, 105, 144); -RT_INTERFACE!{interface IVoipPhoneCall(IVoipPhoneCallVtbl): IInspectable(IInspectableVtbl) [IID_IVoipPhoneCall] { - fn add_EndRequested(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, - fn remove_EndRequested(&self, token: foundation::EventRegistrationToken) -> HRESULT, - fn add_HoldRequested(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, - fn remove_HoldRequested(&self, token: foundation::EventRegistrationToken) -> HRESULT, - fn add_ResumeRequested(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, - fn remove_ResumeRequested(&self, token: foundation::EventRegistrationToken) -> HRESULT, - fn add_AnswerRequested(&self, acceptHandler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, - fn remove_AnswerRequested(&self, token: foundation::EventRegistrationToken) -> HRESULT, - fn add_RejectRequested(&self, rejectHandler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, - fn remove_RejectRequested(&self, token: foundation::EventRegistrationToken) -> HRESULT, - fn NotifyCallHeld(&self) -> HRESULT, - fn NotifyCallActive(&self) -> HRESULT, - fn NotifyCallEnded(&self) -> HRESULT, - fn get_ContactName(&self, out: *mut HSTRING) -> HRESULT, - fn put_ContactName(&self, value: HSTRING) -> HRESULT, - fn get_StartTime(&self, out: *mut foundation::DateTime) -> HRESULT, - fn put_StartTime(&self, value: foundation::DateTime) -> HRESULT, - fn get_CallMedia(&self, out: *mut VoipPhoneCallMedia) -> HRESULT, - fn put_CallMedia(&self, value: VoipPhoneCallMedia) -> HRESULT, - fn NotifyCallReady(&self) -> HRESULT +DEFINE_IID!(IID_IBackgroundTaskRegistrationGroup, 716280218, 34587, 16743, 138, 118, 5, 92, 214, 123, 91, 35); +RT_INTERFACE!{interface IBackgroundTaskRegistrationGroup(IBackgroundTaskRegistrationGroupVtbl): IInspectable(IInspectableVtbl) [IID_IBackgroundTaskRegistrationGroup] { + fn get_Id(&self, out: *mut HSTRING) -> HRESULT, + fn get_Name(&self, out: *mut HSTRING) -> HRESULT, + fn add_BackgroundActivated(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_BackgroundActivated(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn get_AllTasks(&self, out: *mut *mut foundation::collections::IMapView) -> HRESULT }} -impl IVoipPhoneCall { - #[inline] pub fn add_end_requested(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).add_EndRequested)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } +impl IBackgroundTaskRegistrationGroup { + #[inline] pub fn get_id(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Id)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} - #[inline] pub fn remove_end_requested(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).remove_EndRequested)(self as *const _ as *mut _, token); - if hr == S_OK { Ok(()) } else { err(hr) } + #[inline] pub fn get_name(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Name)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} - #[inline] pub fn add_hold_requested(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + #[inline] pub fn add_background_activated(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).add_HoldRequested)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).add_BackgroundActivated)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn remove_hold_requested(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).remove_HoldRequested)(self as *const _ as *mut _, token); + #[inline] pub fn remove_background_activated(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_BackgroundActivated)(self as *const _ as *mut _, token); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn add_resume_requested(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + #[inline] pub fn get_all_tasks(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_AllTasks)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +RT_CLASS!{class BackgroundTaskRegistrationGroup: IBackgroundTaskRegistrationGroup} +impl RtActivatable for BackgroundTaskRegistrationGroup {} +impl BackgroundTaskRegistrationGroup { + #[inline] pub fn create(id: &HStringArg) -> Result> { + >::get_activation_factory().create(id) + } + #[inline] pub fn create_with_name(id: &HStringArg, name: &HStringArg) -> Result> { + >::get_activation_factory().create_with_name(id, name) + } +} +DEFINE_CLSID!(BackgroundTaskRegistrationGroup(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,66,97,99,107,103,114,111,117,110,100,84,97,115,107,82,101,103,105,115,116,114,97,116,105,111,110,71,114,111,117,112,0]) [CLSID_BackgroundTaskRegistrationGroup]); +DEFINE_IID!(IID_IBackgroundTaskRegistrationGroupFactory, 2212047721, 17615, 17969, 151, 64, 3, 199, 216, 116, 27, 197); +RT_INTERFACE!{static interface IBackgroundTaskRegistrationGroupFactory(IBackgroundTaskRegistrationGroupFactoryVtbl): IInspectable(IInspectableVtbl) [IID_IBackgroundTaskRegistrationGroupFactory] { + fn Create(&self, id: HSTRING, out: *mut *mut BackgroundTaskRegistrationGroup) -> HRESULT, + fn CreateWithName(&self, id: HSTRING, name: HSTRING, out: *mut *mut BackgroundTaskRegistrationGroup) -> HRESULT +}} +impl IBackgroundTaskRegistrationGroupFactory { + #[inline] pub fn create(&self, id: &HStringArg) -> Result> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, id.get(), &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn create_with_name(&self, id: &HStringArg, name: &HStringArg) -> Result> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreateWithName)(self as *const _ as *mut _, id.get(), name.get(), &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} +} +DEFINE_IID!(IID_IBackgroundTaskRegistrationStatics, 1280585577, 45056, 17082, 160, 147, 106, 86, 60, 101, 227, 248); +RT_INTERFACE!{static interface IBackgroundTaskRegistrationStatics(IBackgroundTaskRegistrationStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IBackgroundTaskRegistrationStatics] { + fn get_AllTasks(&self, out: *mut *mut foundation::collections::IMapView) -> HRESULT +}} +impl IBackgroundTaskRegistrationStatics { + #[inline] pub fn get_all_tasks(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_AllTasks)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +DEFINE_IID!(IID_IBackgroundTaskRegistrationStatics2, 390817566, 45581, 20393, 173, 154, 233, 58, 214, 199, 30, 1); +RT_INTERFACE!{static interface IBackgroundTaskRegistrationStatics2(IBackgroundTaskRegistrationStatics2Vtbl): IInspectable(IInspectableVtbl) [IID_IBackgroundTaskRegistrationStatics2] { + fn get_AllTaskGroups(&self, out: *mut *mut foundation::collections::IMapView) -> HRESULT, + fn GetTaskGroup(&self, groupId: HSTRING, out: *mut *mut BackgroundTaskRegistrationGroup) -> HRESULT +}} +impl IBackgroundTaskRegistrationStatics2 { + #[inline] pub fn get_all_task_groups(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_AllTaskGroups)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_task_group(&self, groupId: &HStringArg) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetTaskGroup)(self as *const _ as *mut _, groupId.get(), &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +RT_ENUM! { enum BackgroundTaskThrottleCounter: i32 { + All (BackgroundTaskThrottleCounter_All) = 0, Cpu (BackgroundTaskThrottleCounter_Cpu) = 1, Network (BackgroundTaskThrottleCounter_Network) = 2, +}} +DEFINE_IID!(IID_IBackgroundTrigger, 2226364504, 24615, 19335, 151, 144, 189, 243, 247, 87, 219, 215); +RT_INTERFACE!{interface IBackgroundTrigger(IBackgroundTriggerVtbl): IInspectable(IInspectableVtbl) [IID_IBackgroundTrigger] { + +}} +RT_CLASS!{static class BackgroundWorkCost} +impl RtActivatable for BackgroundWorkCost {} +impl BackgroundWorkCost { + #[inline] pub fn get_current_background_work_cost() -> Result { + >::get_activation_factory().get_current_background_work_cost() + } +} +DEFINE_CLSID!(BackgroundWorkCost(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,66,97,99,107,103,114,111,117,110,100,87,111,114,107,67,111,115,116,0]) [CLSID_BackgroundWorkCost]); +DEFINE_IID!(IID_IBackgroundWorkCostStatics, 3342902882, 49936, 19330, 179, 227, 59, 207, 185, 228, 199, 125); +RT_INTERFACE!{static interface IBackgroundWorkCostStatics(IBackgroundWorkCostStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IBackgroundWorkCostStatics] { + fn get_CurrentBackgroundWorkCost(&self, out: *mut BackgroundWorkCostValue) -> HRESULT +}} +impl IBackgroundWorkCostStatics { + #[inline] pub fn get_current_background_work_cost(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).add_ResumeRequested)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_CurrentBackgroundWorkCost)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn remove_resume_requested(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).remove_ResumeRequested)(self as *const _ as *mut _, token); - if hr == S_OK { Ok(()) } else { err(hr) } +} +RT_ENUM! { enum BackgroundWorkCostValue: i32 { + Low (BackgroundWorkCostValue_Low) = 0, Medium (BackgroundWorkCostValue_Medium) = 1, High (BackgroundWorkCostValue_High) = 2, +}} +DEFINE_IID!(IID_IBluetoothLEAdvertisementPublisherTrigger, 2872976914, 9683, 18606, 135, 36, 216, 24, 119, 174, 97, 41); +RT_INTERFACE!{interface IBluetoothLEAdvertisementPublisherTrigger(IBluetoothLEAdvertisementPublisherTriggerVtbl): IInspectable(IInspectableVtbl) [IID_IBluetoothLEAdvertisementPublisherTrigger] { + #[cfg(feature="windows-devices")] fn get_Advertisement(&self, out: *mut *mut super::super::devices::bluetooth::advertisement::BluetoothLEAdvertisement) -> HRESULT +}} +impl IBluetoothLEAdvertisementPublisherTrigger { + #[cfg(feature="windows-devices")] #[inline] pub fn get_advertisement(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Advertisement)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn add_answer_requested(&self, acceptHandler: &foundation::TypedEventHandler) -> Result { unsafe { +} +RT_CLASS!{class BluetoothLEAdvertisementPublisherTrigger: IBluetoothLEAdvertisementPublisherTrigger} +impl RtActivatable for BluetoothLEAdvertisementPublisherTrigger {} +DEFINE_CLSID!(BluetoothLEAdvertisementPublisherTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,66,108,117,101,116,111,111,116,104,76,69,65,100,118,101,114,116,105,115,101,109,101,110,116,80,117,98,108,105,115,104,101,114,84,114,105,103,103,101,114,0]) [CLSID_BluetoothLEAdvertisementPublisherTrigger]); +DEFINE_IID!(IID_IBluetoothLEAdvertisementWatcherTrigger, 447420441, 48353, 18667, 168, 39, 89, 251, 124, 238, 82, 166); +RT_INTERFACE!{interface IBluetoothLEAdvertisementWatcherTrigger(IBluetoothLEAdvertisementWatcherTriggerVtbl): IInspectable(IInspectableVtbl) [IID_IBluetoothLEAdvertisementWatcherTrigger] { + fn get_MinSamplingInterval(&self, out: *mut foundation::TimeSpan) -> HRESULT, + fn get_MaxSamplingInterval(&self, out: *mut foundation::TimeSpan) -> HRESULT, + fn get_MinOutOfRangeTimeout(&self, out: *mut foundation::TimeSpan) -> HRESULT, + fn get_MaxOutOfRangeTimeout(&self, out: *mut foundation::TimeSpan) -> HRESULT, + #[cfg(feature="windows-devices")] fn get_SignalStrengthFilter(&self, out: *mut *mut super::super::devices::bluetooth::BluetoothSignalStrengthFilter) -> HRESULT, + #[cfg(feature="windows-devices")] fn put_SignalStrengthFilter(&self, value: *mut super::super::devices::bluetooth::BluetoothSignalStrengthFilter) -> HRESULT, + #[cfg(feature="windows-devices")] fn get_AdvertisementFilter(&self, out: *mut *mut super::super::devices::bluetooth::advertisement::BluetoothLEAdvertisementFilter) -> HRESULT, + #[cfg(feature="windows-devices")] fn put_AdvertisementFilter(&self, value: *mut super::super::devices::bluetooth::advertisement::BluetoothLEAdvertisementFilter) -> HRESULT +}} +impl IBluetoothLEAdvertisementWatcherTrigger { + #[inline] pub fn get_min_sampling_interval(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).add_AnswerRequested)(self as *const _ as *mut _, acceptHandler as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_MinSamplingInterval)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn remove_answer_requested(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).remove_AnswerRequested)(self as *const _ as *mut _, token); - if hr == S_OK { Ok(()) } else { err(hr) } - }} - #[inline] pub fn add_reject_requested(&self, rejectHandler: &foundation::TypedEventHandler) -> Result { unsafe { + #[inline] pub fn get_max_sampling_interval(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).add_RejectRequested)(self as *const _ as *mut _, rejectHandler as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_MaxSamplingInterval)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn remove_reject_requested(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).remove_RejectRequested)(self as *const _ as *mut _, token); - if hr == S_OK { Ok(()) } else { err(hr) } + #[inline] pub fn get_min_out_of_range_timeout(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_MinOutOfRangeTimeout)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn notify_call_held(&self) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).NotifyCallHeld)(self as *const _ as *mut _); - if hr == S_OK { Ok(()) } else { err(hr) } + #[inline] pub fn get_max_out_of_range_timeout(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_MaxOutOfRangeTimeout)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn notify_call_active(&self) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).NotifyCallActive)(self as *const _ as *mut _); - if hr == S_OK { Ok(()) } else { err(hr) } + #[cfg(feature="windows-devices")] #[inline] pub fn get_signal_strength_filter(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_SignalStrengthFilter)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn notify_call_ended(&self) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).NotifyCallEnded)(self as *const _ as *mut _); + #[cfg(feature="windows-devices")] #[inline] pub fn set_signal_strength_filter(&self, value: &super::super::devices::bluetooth::BluetoothSignalStrengthFilter) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_SignalStrengthFilter)(self as *const _ as *mut _, value as *const _ as *mut _); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_contact_name(&self) -> Result { unsafe { + #[cfg(feature="windows-devices")] #[inline] pub fn get_advertisement_filter(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_ContactName)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).get_AdvertisementFilter)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn set_contact_name(&self, value: &HStringArg) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_ContactName)(self as *const _ as *mut _, value.get()); + #[cfg(feature="windows-devices")] #[inline] pub fn set_advertisement_filter(&self, value: &super::super::devices::bluetooth::advertisement::BluetoothLEAdvertisementFilter) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_AdvertisementFilter)(self as *const _ as *mut _, value as *const _ as *mut _); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_start_time(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_StartTime)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } - }} - #[inline] pub fn set_start_time(&self, value: foundation::DateTime) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_StartTime)(self as *const _ as *mut _, value); - if hr == S_OK { Ok(()) } else { err(hr) } - }} - #[inline] pub fn get_call_media(&self) -> Result { unsafe { +} +RT_CLASS!{class BluetoothLEAdvertisementWatcherTrigger: IBluetoothLEAdvertisementWatcherTrigger} +impl RtActivatable for BluetoothLEAdvertisementWatcherTrigger {} +DEFINE_CLSID!(BluetoothLEAdvertisementWatcherTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,66,108,117,101,116,111,111,116,104,76,69,65,100,118,101,114,116,105,115,101,109,101,110,116,87,97,116,99,104,101,114,84,114,105,103,103,101,114,0]) [CLSID_BluetoothLEAdvertisementWatcherTrigger]); +DEFINE_IID!(IID_ICachedFileUpdaterTrigger, 3793530603, 13042, 19761, 181, 83, 185, 224, 27, 222, 55, 224); +RT_INTERFACE!{interface ICachedFileUpdaterTrigger(ICachedFileUpdaterTriggerVtbl): IInspectable(IInspectableVtbl) [IID_ICachedFileUpdaterTrigger] { + +}} +RT_CLASS!{class CachedFileUpdaterTrigger: ICachedFileUpdaterTrigger} +impl RtActivatable for CachedFileUpdaterTrigger {} +DEFINE_CLSID!(CachedFileUpdaterTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,67,97,99,104,101,100,70,105,108,101,85,112,100,97,116,101,114,84,114,105,103,103,101,114,0]) [CLSID_CachedFileUpdaterTrigger]); +DEFINE_IID!(IID_ICachedFileUpdaterTriggerDetails, 1904446483, 4884, 18356, 149, 151, 220, 126, 36, 140, 23, 204); +RT_INTERFACE!{interface ICachedFileUpdaterTriggerDetails(ICachedFileUpdaterTriggerDetailsVtbl): IInspectable(IInspectableVtbl) [IID_ICachedFileUpdaterTriggerDetails] { + #[cfg(not(feature="windows-storage"))] fn __Dummy0(&self) -> (), + #[cfg(feature="windows-storage")] fn get_UpdateTarget(&self, out: *mut super::super::storage::provider::CachedFileTarget) -> HRESULT, + #[cfg(not(feature="windows-storage"))] fn __Dummy1(&self) -> (), + #[cfg(feature="windows-storage")] fn get_UpdateRequest(&self, out: *mut *mut super::super::storage::provider::FileUpdateRequest) -> HRESULT, + fn get_CanRequestUserInput(&self, out: *mut bool) -> HRESULT +}} +impl ICachedFileUpdaterTriggerDetails { + #[cfg(feature="windows-storage")] #[inline] pub fn get_update_target(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_CallMedia)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_UpdateTarget)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn set_call_media(&self, value: VoipPhoneCallMedia) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_CallMedia)(self as *const _ as *mut _, value); - if hr == S_OK { Ok(()) } else { err(hr) } - }} - #[inline] pub fn notify_call_ready(&self) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).NotifyCallReady)(self as *const _ as *mut _); - if hr == S_OK { Ok(()) } else { err(hr) } + #[cfg(feature="windows-storage")] #[inline] pub fn get_update_request(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_UpdateRequest)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} -} -RT_CLASS!{class VoipPhoneCall: IVoipPhoneCall} -DEFINE_IID!(IID_IVoipPhoneCall2, 1947944673, 9311, 16883, 147, 153, 49, 65, 210, 91, 82, 227); -RT_INTERFACE!{interface IVoipPhoneCall2(IVoipPhoneCall2Vtbl): IInspectable(IInspectableVtbl) [IID_IVoipPhoneCall2] { - fn TryShowAppUI(&self) -> HRESULT -}} -impl IVoipPhoneCall2 { - #[inline] pub fn try_show_app_ui(&self) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).TryShowAppUI)(self as *const _ as *mut _); - if hr == S_OK { Ok(()) } else { err(hr) } + #[inline] pub fn get_can_request_user_input(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_CanRequestUserInput)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} } -RT_ENUM! { enum VoipPhoneCallMedia: u32 { - None (VoipPhoneCallMedia_None) = 0, Audio (VoipPhoneCallMedia_Audio) = 1, Video (VoipPhoneCallMedia_Video) = 2, +RT_CLASS!{class CachedFileUpdaterTriggerDetails: ICachedFileUpdaterTriggerDetails} +DEFINE_IID!(IID_IChatMessageNotificationTrigger, 1362838463, 7488, 23645, 120, 245, 201, 35, 254, 227, 115, 158); +RT_INTERFACE!{interface IChatMessageNotificationTrigger(IChatMessageNotificationTriggerVtbl): IInspectable(IInspectableVtbl) [IID_IChatMessageNotificationTrigger] { + }} -RT_ENUM! { enum VoipPhoneCallRejectReason: i32 { - UserIgnored (VoipPhoneCallRejectReason_UserIgnored) = 0, TimedOut (VoipPhoneCallRejectReason_TimedOut) = 1, OtherIncomingCall (VoipPhoneCallRejectReason_OtherIncomingCall) = 2, EmergencyCallExists (VoipPhoneCallRejectReason_EmergencyCallExists) = 3, InvalidCallState (VoipPhoneCallRejectReason_InvalidCallState) = 4, +RT_CLASS!{class ChatMessageNotificationTrigger: IChatMessageNotificationTrigger} +impl RtActivatable for ChatMessageNotificationTrigger {} +DEFINE_CLSID!(ChatMessageNotificationTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,67,104,97,116,77,101,115,115,97,103,101,78,111,116,105,102,105,99,97,116,105,111,110,84,114,105,103,103,101,114,0]) [CLSID_ChatMessageNotificationTrigger]); +DEFINE_IID!(IID_IChatMessageReceivedNotificationTrigger, 1050899982, 47861, 16503, 136, 233, 6, 12, 246, 240, 198, 213); +RT_INTERFACE!{interface IChatMessageReceivedNotificationTrigger(IChatMessageReceivedNotificationTriggerVtbl): IInspectable(IInspectableVtbl) [IID_IChatMessageReceivedNotificationTrigger] { + }} -RT_ENUM! { enum VoipPhoneCallResourceReservationStatus: i32 { - Success (VoipPhoneCallResourceReservationStatus_Success) = 0, ResourcesNotAvailable (VoipPhoneCallResourceReservationStatus_ResourcesNotAvailable) = 1, +RT_CLASS!{class ChatMessageReceivedNotificationTrigger: IChatMessageReceivedNotificationTrigger} +impl RtActivatable for ChatMessageReceivedNotificationTrigger {} +DEFINE_CLSID!(ChatMessageReceivedNotificationTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,67,104,97,116,77,101,115,115,97,103,101,82,101,99,101,105,118,101,100,78,111,116,105,102,105,99,97,116,105,111,110,84,114,105,103,103,101,114,0]) [CLSID_ChatMessageReceivedNotificationTrigger]); +DEFINE_IID!(IID_IContactStoreNotificationTrigger, 3358802331, 18181, 17777, 154, 22, 6, 185, 151, 191, 156, 150); +RT_INTERFACE!{interface IContactStoreNotificationTrigger(IContactStoreNotificationTriggerVtbl): IInspectable(IInspectableVtbl) [IID_IContactStoreNotificationTrigger] { + }} -RT_ENUM! { enum VoipPhoneCallState: i32 { - Ended (VoipPhoneCallState_Ended) = 0, Held (VoipPhoneCallState_Held) = 1, Active (VoipPhoneCallState_Active) = 2, Incoming (VoipPhoneCallState_Incoming) = 3, Outgoing (VoipPhoneCallState_Outgoing) = 4, +RT_CLASS!{class ContactStoreNotificationTrigger: IContactStoreNotificationTrigger} +impl RtActivatable for ContactStoreNotificationTrigger {} +DEFINE_CLSID!(ContactStoreNotificationTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,67,111,110,116,97,99,116,83,116,111,114,101,78,111,116,105,102,105,99,97,116,105,111,110,84,114,105,103,103,101,114,0]) [CLSID_ContactStoreNotificationTrigger]); +DEFINE_IID!(IID_IContentPrefetchTrigger, 1896228846, 1274, 17419, 128, 192, 23, 50, 2, 25, 158, 93); +RT_INTERFACE!{interface IContentPrefetchTrigger(IContentPrefetchTriggerVtbl): IInspectable(IInspectableVtbl) [IID_IContentPrefetchTrigger] { + fn get_WaitInterval(&self, out: *mut foundation::TimeSpan) -> HRESULT }} -pub mod background { // Windows.ApplicationModel.Calls.Background -use ::prelude::*; -RT_ENUM! { enum PhoneCallBlockedReason: i32 { - InCallBlockingList (PhoneCallBlockedReason_InCallBlockingList) = 0, PrivateNumber (PhoneCallBlockedReason_PrivateNumber) = 1, UnknownNumber (PhoneCallBlockedReason_UnknownNumber) = 2, +impl IContentPrefetchTrigger { + #[inline] pub fn get_wait_interval(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_WaitInterval)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} +RT_CLASS!{class ContentPrefetchTrigger: IContentPrefetchTrigger} +impl RtActivatable for ContentPrefetchTrigger {} +impl RtActivatable for ContentPrefetchTrigger {} +impl ContentPrefetchTrigger { + #[inline] pub fn create(waitInterval: foundation::TimeSpan) -> Result> { + >::get_activation_factory().create(waitInterval) + } +} +DEFINE_CLSID!(ContentPrefetchTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,67,111,110,116,101,110,116,80,114,101,102,101,116,99,104,84,114,105,103,103,101,114,0]) [CLSID_ContentPrefetchTrigger]); +DEFINE_IID!(IID_IContentPrefetchTriggerFactory, 3261349594, 35331, 16542, 184, 196, 136, 129, 76, 40, 204, 182); +RT_INTERFACE!{static interface IContentPrefetchTriggerFactory(IContentPrefetchTriggerFactoryVtbl): IInspectable(IInspectableVtbl) [IID_IContentPrefetchTriggerFactory] { + fn Create(&self, waitInterval: foundation::TimeSpan, out: *mut *mut ContentPrefetchTrigger) -> HRESULT }} -DEFINE_IID!(IID_IPhoneCallBlockedTriggerDetails, 2762379426, 58561, 17023, 134, 78, 228, 112, 71, 125, 219, 103); -RT_INTERFACE!{interface IPhoneCallBlockedTriggerDetails(IPhoneCallBlockedTriggerDetailsVtbl): IInspectable(IInspectableVtbl) [IID_IPhoneCallBlockedTriggerDetails] { - fn get_PhoneNumber(&self, out: *mut HSTRING) -> HRESULT, - fn get_LineId(&self, out: *mut Guid) -> HRESULT, - fn get_CallBlockedReason(&self, out: *mut PhoneCallBlockedReason) -> HRESULT +impl IContentPrefetchTriggerFactory { + #[inline] pub fn create(&self, waitInterval: foundation::TimeSpan) -> Result> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, waitInterval, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} +} +DEFINE_IID!(IID_ICustomSystemEventTrigger, 4082722712, 53099, 20212, 160, 202, 41, 207, 74, 39, 140, 135); +RT_INTERFACE!{interface ICustomSystemEventTrigger(ICustomSystemEventTriggerVtbl): IInspectable(IInspectableVtbl) [IID_ICustomSystemEventTrigger] { + fn get_TriggerId(&self, out: *mut HSTRING) -> HRESULT, + fn get_Recurrence(&self, out: *mut CustomSystemEventTriggerRecurrence) -> HRESULT }} -impl IPhoneCallBlockedTriggerDetails { - #[inline] pub fn get_phone_number(&self) -> Result { unsafe { +impl ICustomSystemEventTrigger { + #[inline] pub fn get_trigger_id(&self) -> Result { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_PhoneNumber)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_TriggerId)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_line_id(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_LineId)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } - }} - #[inline] pub fn get_call_blocked_reason(&self) -> Result { unsafe { + #[inline] pub fn get_recurrence(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_CallBlockedReason)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_Recurrence)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} } -RT_CLASS!{class PhoneCallBlockedTriggerDetails: IPhoneCallBlockedTriggerDetails} -DEFINE_IID!(IID_IPhoneCallOriginDataRequestTriggerDetails, 1855675199, 50507, 20098, 76, 201, 227, 41, 164, 24, 69, 146); -RT_INTERFACE!{interface IPhoneCallOriginDataRequestTriggerDetails(IPhoneCallOriginDataRequestTriggerDetailsVtbl): IInspectable(IInspectableVtbl) [IID_IPhoneCallOriginDataRequestTriggerDetails] { - fn get_RequestId(&self, out: *mut Guid) -> HRESULT, - fn get_PhoneNumber(&self, out: *mut HSTRING) -> HRESULT +RT_CLASS!{class CustomSystemEventTrigger: ICustomSystemEventTrigger} +impl RtActivatable for CustomSystemEventTrigger {} +impl CustomSystemEventTrigger { + #[inline] pub fn create(triggerId: &HStringArg, recurrence: CustomSystemEventTriggerRecurrence) -> Result> { + >::get_activation_factory().create(triggerId, recurrence) + } +} +DEFINE_CLSID!(CustomSystemEventTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,67,117,115,116,111,109,83,121,115,116,101,109,69,118,101,110,116,84,114,105,103,103,101,114,0]) [CLSID_CustomSystemEventTrigger]); +DEFINE_IID!(IID_ICustomSystemEventTriggerFactory, 1808471749, 62172, 16818, 158, 253, 185, 107, 220, 209, 60, 237); +RT_INTERFACE!{static interface ICustomSystemEventTriggerFactory(ICustomSystemEventTriggerFactoryVtbl): IInspectable(IInspectableVtbl) [IID_ICustomSystemEventTriggerFactory] { + fn Create(&self, triggerId: HSTRING, recurrence: CustomSystemEventTriggerRecurrence, out: *mut *mut CustomSystemEventTrigger) -> HRESULT }} -impl IPhoneCallOriginDataRequestTriggerDetails { - #[inline] pub fn get_request_id(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_RequestId)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } - }} - #[inline] pub fn get_phone_number(&self) -> Result { unsafe { +impl ICustomSystemEventTriggerFactory { + #[inline] pub fn create(&self, triggerId: &HStringArg, recurrence: CustomSystemEventTriggerRecurrence) -> Result> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_PhoneNumber)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, triggerId.get(), recurrence, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } -RT_CLASS!{class PhoneCallOriginDataRequestTriggerDetails: IPhoneCallOriginDataRequestTriggerDetails} -DEFINE_IID!(IID_IPhoneLineChangedTriggerDetails, 3335725543, 53533, 16600, 178, 183, 228, 10, 1, 214, 98, 73); -RT_INTERFACE!{interface IPhoneLineChangedTriggerDetails(IPhoneLineChangedTriggerDetailsVtbl): IInspectable(IInspectableVtbl) [IID_IPhoneLineChangedTriggerDetails] { - fn get_LineId(&self, out: *mut Guid) -> HRESULT, - fn get_ChangeType(&self, out: *mut PhoneLineChangeKind) -> HRESULT, - fn HasLinePropertyChanged(&self, lineProperty: PhoneLineProperties, out: *mut bool) -> HRESULT +RT_ENUM! { enum CustomSystemEventTriggerRecurrence: i32 { + Once (CustomSystemEventTriggerRecurrence_Once) = 0, Always (CustomSystemEventTriggerRecurrence_Always) = 1, }} -impl IPhoneLineChangedTriggerDetails { - #[inline] pub fn get_line_id(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_LineId)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } +DEFINE_IID!(IID_IDeviceConnectionChangeTrigger, 2424790628, 15581, 20219, 171, 28, 91, 59, 106, 96, 206, 52); +RT_INTERFACE!{interface IDeviceConnectionChangeTrigger(IDeviceConnectionChangeTriggerVtbl): IInspectable(IInspectableVtbl) [IID_IDeviceConnectionChangeTrigger] { + fn get_DeviceId(&self, out: *mut HSTRING) -> HRESULT, + fn get_CanMaintainConnection(&self, out: *mut bool) -> HRESULT, + fn get_MaintainConnection(&self, out: *mut bool) -> HRESULT, + fn put_MaintainConnection(&self, value: bool) -> HRESULT +}} +impl IDeviceConnectionChangeTrigger { + #[inline] pub fn get_device_id(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_DeviceId)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_change_type(&self) -> Result { unsafe { + #[inline] pub fn get_can_maintain_connection(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_ChangeType)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_CanMaintainConnection)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn has_line_property_changed(&self, lineProperty: PhoneLineProperties) -> Result { unsafe { + #[inline] pub fn get_maintain_connection(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).HasLinePropertyChanged)(self as *const _ as *mut _, lineProperty, &mut out); + let hr = ((*self.lpVtbl).get_MaintainConnection)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} + #[inline] pub fn set_maintain_connection(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_MaintainConnection)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} } -RT_CLASS!{class PhoneLineChangedTriggerDetails: IPhoneLineChangedTriggerDetails} -RT_ENUM! { enum PhoneLineChangeKind: i32 { - Added (PhoneLineChangeKind_Added) = 0, Removed (PhoneLineChangeKind_Removed) = 1, PropertiesChanged (PhoneLineChangeKind_PropertiesChanged) = 2, -}} -RT_ENUM! { enum PhoneLineProperties: u32 { - None (PhoneLineProperties_None) = 0, BrandingOptions (PhoneLineProperties_BrandingOptions) = 1, CanDial (PhoneLineProperties_CanDial) = 2, CellularDetails (PhoneLineProperties_CellularDetails) = 4, DisplayColor (PhoneLineProperties_DisplayColor) = 8, DisplayName (PhoneLineProperties_DisplayName) = 16, NetworkName (PhoneLineProperties_NetworkName) = 32, NetworkState (PhoneLineProperties_NetworkState) = 64, Transport (PhoneLineProperties_Transport) = 128, Voicemail (PhoneLineProperties_Voicemail) = 256, +RT_CLASS!{class DeviceConnectionChangeTrigger: IDeviceConnectionChangeTrigger} +impl RtActivatable for DeviceConnectionChangeTrigger {} +impl DeviceConnectionChangeTrigger { + #[inline] pub fn from_id_async(deviceId: &HStringArg) -> Result>> { + >::get_activation_factory().from_id_async(deviceId) + } +} +DEFINE_CLSID!(DeviceConnectionChangeTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,68,101,118,105,99,101,67,111,110,110,101,99,116,105,111,110,67,104,97,110,103,101,84,114,105,103,103,101,114,0]) [CLSID_DeviceConnectionChangeTrigger]); +DEFINE_IID!(IID_IDeviceConnectionChangeTriggerStatics, 3286901866, 20221, 17560, 170, 96, 164, 228, 227, 177, 122, 185); +RT_INTERFACE!{static interface IDeviceConnectionChangeTriggerStatics(IDeviceConnectionChangeTriggerStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IDeviceConnectionChangeTriggerStatics] { + fn FromIdAsync(&self, deviceId: HSTRING, out: *mut *mut foundation::IAsyncOperation) -> HRESULT }} -DEFINE_IID!(IID_IPhoneNewVoicemailMessageTriggerDetails, 329826331, 47153, 18643, 139, 169, 141, 34, 166, 88, 13, 207); -RT_INTERFACE!{interface IPhoneNewVoicemailMessageTriggerDetails(IPhoneNewVoicemailMessageTriggerDetailsVtbl): IInspectable(IInspectableVtbl) [IID_IPhoneNewVoicemailMessageTriggerDetails] { - fn get_LineId(&self, out: *mut Guid) -> HRESULT, - fn get_VoicemailCount(&self, out: *mut i32) -> HRESULT, - fn get_OperatorMessage(&self, out: *mut HSTRING) -> HRESULT +impl IDeviceConnectionChangeTriggerStatics { + #[inline] pub fn from_id_async(&self, deviceId: &HStringArg) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).FromIdAsync)(self as *const _ as *mut _, deviceId.get(), &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} +} +DEFINE_IID!(IID_IDeviceManufacturerNotificationTrigger, 2166852277, 16811, 5850, 134, 194, 127, 123, 240, 145, 47, 91); +RT_INTERFACE!{interface IDeviceManufacturerNotificationTrigger(IDeviceManufacturerNotificationTriggerVtbl): IInspectable(IInspectableVtbl) [IID_IDeviceManufacturerNotificationTrigger] { + fn get_TriggerQualifier(&self, out: *mut HSTRING) -> HRESULT, + fn get_OneShot(&self, out: *mut bool) -> HRESULT }} -impl IPhoneNewVoicemailMessageTriggerDetails { - #[inline] pub fn get_line_id(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_LineId)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } +impl IDeviceManufacturerNotificationTrigger { + #[inline] pub fn get_trigger_qualifier(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_TriggerQualifier)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_voicemail_count(&self) -> Result { unsafe { + #[inline] pub fn get_one_shot(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_VoicemailCount)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_OneShot)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_operator_message(&self) -> Result { unsafe { +} +RT_CLASS!{class DeviceManufacturerNotificationTrigger: IDeviceManufacturerNotificationTrigger} +impl RtActivatable for DeviceManufacturerNotificationTrigger {} +impl DeviceManufacturerNotificationTrigger { + #[inline] pub fn create(triggerQualifier: &HStringArg, oneShot: bool) -> Result> { + >::get_activation_factory().create(triggerQualifier, oneShot) + } +} +DEFINE_CLSID!(DeviceManufacturerNotificationTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,68,101,118,105,99,101,77,97,110,117,102,97,99,116,117,114,101,114,78,111,116,105,102,105,99,97,116,105,111,110,84,114,105,103,103,101,114,0]) [CLSID_DeviceManufacturerNotificationTrigger]); +DEFINE_IID!(IID_IDeviceManufacturerNotificationTriggerFactory, 2035670645, 9659, 16723, 161, 162, 48, 41, 252, 171, 182, 82); +RT_INTERFACE!{static interface IDeviceManufacturerNotificationTriggerFactory(IDeviceManufacturerNotificationTriggerFactoryVtbl): IInspectable(IInspectableVtbl) [IID_IDeviceManufacturerNotificationTriggerFactory] { + fn Create(&self, triggerQualifier: HSTRING, oneShot: bool, out: *mut *mut DeviceManufacturerNotificationTrigger) -> HRESULT +}} +impl IDeviceManufacturerNotificationTriggerFactory { + #[inline] pub fn create(&self, triggerQualifier: &HStringArg, oneShot: bool) -> Result> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_OperatorMessage)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, triggerQualifier.get(), oneShot, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } -RT_CLASS!{class PhoneNewVoicemailMessageTriggerDetails: IPhoneNewVoicemailMessageTriggerDetails} -RT_ENUM! { enum PhoneTriggerType: i32 { - NewVoicemailMessage (PhoneTriggerType_NewVoicemailMessage) = 0, CallHistoryChanged (PhoneTriggerType_CallHistoryChanged) = 1, LineChanged (PhoneTriggerType_LineChanged) = 2, AirplaneModeDisabledForEmergencyCall (PhoneTriggerType_AirplaneModeDisabledForEmergencyCall) = 3, CallOriginDataRequest (PhoneTriggerType_CallOriginDataRequest) = 4, CallBlocked (PhoneTriggerType_CallBlocked) = 5, -}} -} // Windows.ApplicationModel.Calls.Background -} // Windows.ApplicationModel.Calls -pub mod socialinfo { // Windows.ApplicationModel.SocialInfo -use ::prelude::*; -DEFINE_IID!(IID_ISocialFeedChildItem, 191535194, 54685, 16574, 152, 12, 72, 138, 42, 179, 10, 131); -RT_INTERFACE!{interface ISocialFeedChildItem(ISocialFeedChildItemVtbl): IInspectable(IInspectableVtbl) [IID_ISocialFeedChildItem] { - fn get_Author(&self, out: *mut *mut SocialUserInfo) -> HRESULT, - fn get_PrimaryContent(&self, out: *mut *mut SocialFeedContent) -> HRESULT, - fn get_SecondaryContent(&self, out: *mut *mut SocialFeedContent) -> HRESULT, - fn get_Timestamp(&self, out: *mut foundation::DateTime) -> HRESULT, - fn put_Timestamp(&self, value: foundation::DateTime) -> HRESULT, - fn get_TargetUri(&self, out: *mut *mut foundation::Uri) -> HRESULT, - fn put_TargetUri(&self, value: *mut foundation::Uri) -> HRESULT, - fn get_Thumbnails(&self, out: *mut *mut foundation::collections::IVector) -> HRESULT, - fn get_SharedItem(&self, out: *mut *mut SocialFeedSharedItem) -> HRESULT, - fn put_SharedItem(&self, value: *mut SocialFeedSharedItem) -> HRESULT +DEFINE_IID!(IID_IDeviceServicingTrigger, 447879085, 28212, 18899, 158, 111, 23, 241, 182, 223, 168, 129); +RT_INTERFACE!{interface IDeviceServicingTrigger(IDeviceServicingTriggerVtbl): IInspectable(IInspectableVtbl) [IID_IDeviceServicingTrigger] { + fn RequestAsyncSimple(&self, deviceId: HSTRING, expectedDuration: foundation::TimeSpan, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn RequestAsyncWithArguments(&self, deviceId: HSTRING, expectedDuration: foundation::TimeSpan, arguments: HSTRING, out: *mut *mut foundation::IAsyncOperation) -> HRESULT }} -impl ISocialFeedChildItem { - #[inline] pub fn get_author(&self) -> Result>> { unsafe { +impl IDeviceServicingTrigger { + #[inline] pub fn request_async_simple(&self, deviceId: &HStringArg, expectedDuration: foundation::TimeSpan) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Author)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).RequestAsyncSimple)(self as *const _ as *mut _, deviceId.get(), expectedDuration, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_primary_content(&self) -> Result>> { unsafe { + #[inline] pub fn request_async_with_arguments(&self, deviceId: &HStringArg, expectedDuration: foundation::TimeSpan, arguments: &HStringArg) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_PrimaryContent)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).RequestAsyncWithArguments)(self as *const _ as *mut _, deviceId.get(), expectedDuration, arguments.get(), &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_secondary_content(&self) -> Result>> { unsafe { +} +RT_CLASS!{class DeviceServicingTrigger: IDeviceServicingTrigger} +impl RtActivatable for DeviceServicingTrigger {} +DEFINE_CLSID!(DeviceServicingTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,68,101,118,105,99,101,83,101,114,118,105,99,105,110,103,84,114,105,103,103,101,114,0]) [CLSID_DeviceServicingTrigger]); +RT_ENUM! { enum DeviceTriggerResult: i32 { + Allowed (DeviceTriggerResult_Allowed) = 0, DeniedByUser (DeviceTriggerResult_DeniedByUser) = 1, DeniedBySystem (DeviceTriggerResult_DeniedBySystem) = 2, LowBattery (DeviceTriggerResult_LowBattery) = 3, +}} +DEFINE_IID!(IID_IDeviceUseTrigger, 229015569, 13135, 19799, 182, 236, 109, 202, 100, 180, 18, 228); +RT_INTERFACE!{interface IDeviceUseTrigger(IDeviceUseTriggerVtbl): IInspectable(IInspectableVtbl) [IID_IDeviceUseTrigger] { + fn RequestAsyncSimple(&self, deviceId: HSTRING, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn RequestAsyncWithArguments(&self, deviceId: HSTRING, arguments: HSTRING, out: *mut *mut foundation::IAsyncOperation) -> HRESULT +}} +impl IDeviceUseTrigger { + #[inline] pub fn request_async_simple(&self, deviceId: &HStringArg) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_SecondaryContent)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } - }} - #[inline] pub fn get_timestamp(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_Timestamp)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } + let hr = ((*self.lpVtbl).RequestAsyncSimple)(self as *const _ as *mut _, deviceId.get(), &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn set_timestamp(&self, value: foundation::DateTime) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_Timestamp)(self as *const _ as *mut _, value); - if hr == S_OK { Ok(()) } else { err(hr) } + #[inline] pub fn request_async_with_arguments(&self, deviceId: &HStringArg, arguments: &HStringArg) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).RequestAsyncWithArguments)(self as *const _ as *mut _, deviceId.get(), arguments.get(), &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_target_uri(&self) -> Result>> { unsafe { +} +RT_CLASS!{class DeviceUseTrigger: IDeviceUseTrigger} +impl RtActivatable for DeviceUseTrigger {} +DEFINE_CLSID!(DeviceUseTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,68,101,118,105,99,101,85,115,101,84,114,105,103,103,101,114,0]) [CLSID_DeviceUseTrigger]); +DEFINE_IID!(IID_IDeviceWatcherTrigger, 2757853149, 34163, 16992, 190, 252, 91, 236, 137, 203, 105, 61); +RT_INTERFACE!{interface IDeviceWatcherTrigger(IDeviceWatcherTriggerVtbl): IInspectable(IInspectableVtbl) [IID_IDeviceWatcherTrigger] { + +}} +RT_CLASS!{class DeviceWatcherTrigger: IDeviceWatcherTrigger} +DEFINE_IID!(IID_IEmailStoreNotificationTrigger, 2557282010, 18411, 17000, 164, 242, 243, 247, 113, 136, 56, 138); +RT_INTERFACE!{interface IEmailStoreNotificationTrigger(IEmailStoreNotificationTriggerVtbl): IInspectable(IInspectableVtbl) [IID_IEmailStoreNotificationTrigger] { + +}} +RT_CLASS!{class EmailStoreNotificationTrigger: IEmailStoreNotificationTrigger} +impl RtActivatable for EmailStoreNotificationTrigger {} +DEFINE_CLSID!(EmailStoreNotificationTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,69,109,97,105,108,83,116,111,114,101,78,111,116,105,102,105,99,97,116,105,111,110,84,114,105,103,103,101,114,0]) [CLSID_EmailStoreNotificationTrigger]); +DEFINE_IID!(IID_IGattCharacteristicNotificationTrigger, 3797913544, 1686, 18255, 167, 50, 242, 146, 176, 206, 188, 93); +RT_INTERFACE!{interface IGattCharacteristicNotificationTrigger(IGattCharacteristicNotificationTriggerVtbl): IInspectable(IInspectableVtbl) [IID_IGattCharacteristicNotificationTrigger] { + #[cfg(feature="windows-devices")] fn get_Characteristic(&self, out: *mut *mut super::super::devices::bluetooth::genericattributeprofile::GattCharacteristic) -> HRESULT +}} +impl IGattCharacteristicNotificationTrigger { + #[cfg(feature="windows-devices")] #[inline] pub fn get_characteristic(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_TargetUri)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_Characteristic)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn set_target_uri(&self, value: &foundation::Uri) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_TargetUri)(self as *const _ as *mut _, value as *const _ as *mut _); - if hr == S_OK { Ok(()) } else { err(hr) } +} +RT_CLASS!{class GattCharacteristicNotificationTrigger: IGattCharacteristicNotificationTrigger} +impl RtActivatable for GattCharacteristicNotificationTrigger {} +impl RtActivatable for GattCharacteristicNotificationTrigger {} +impl GattCharacteristicNotificationTrigger { + #[cfg(feature="windows-devices")] #[inline] pub fn create(characteristic: &super::super::devices::bluetooth::genericattributeprofile::GattCharacteristic) -> Result> { + >::get_activation_factory().create(characteristic) + } + #[cfg(feature="windows-devices")] #[inline] pub fn create_with_event_triggering_mode(characteristic: &super::super::devices::bluetooth::genericattributeprofile::GattCharacteristic, eventTriggeringMode: super::super::devices::bluetooth::background::BluetoothEventTriggeringMode) -> Result> { + >::get_activation_factory().create_with_event_triggering_mode(characteristic, eventTriggeringMode) + } +} +DEFINE_CLSID!(GattCharacteristicNotificationTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,71,97,116,116,67,104,97,114,97,99,116,101,114,105,115,116,105,99,78,111,116,105,102,105,99,97,116,105,111,110,84,114,105,103,103,101,114,0]) [CLSID_GattCharacteristicNotificationTrigger]); +DEFINE_IID!(IID_IGattCharacteristicNotificationTrigger2, 2468520644, 44558, 17138, 178, 140, 245, 19, 114, 230, 146, 69); +RT_INTERFACE!{interface IGattCharacteristicNotificationTrigger2(IGattCharacteristicNotificationTrigger2Vtbl): IInspectable(IInspectableVtbl) [IID_IGattCharacteristicNotificationTrigger2] { + #[cfg(feature="windows-devices")] fn get_EventTriggeringMode(&self, out: *mut super::super::devices::bluetooth::background::BluetoothEventTriggeringMode) -> HRESULT +}} +impl IGattCharacteristicNotificationTrigger2 { + #[cfg(feature="windows-devices")] #[inline] pub fn get_event_triggering_mode(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_EventTriggeringMode)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_thumbnails(&self) -> Result>>> { unsafe { +} +DEFINE_IID!(IID_IGattCharacteristicNotificationTriggerFactory, 1471814037, 45379, 17781, 159, 107, 253, 89, 217, 58, 206, 26); +RT_INTERFACE!{static interface IGattCharacteristicNotificationTriggerFactory(IGattCharacteristicNotificationTriggerFactoryVtbl): IInspectable(IInspectableVtbl) [IID_IGattCharacteristicNotificationTriggerFactory] { + #[cfg(feature="windows-devices")] fn Create(&self, characteristic: *mut super::super::devices::bluetooth::genericattributeprofile::GattCharacteristic, out: *mut *mut GattCharacteristicNotificationTrigger) -> HRESULT +}} +impl IGattCharacteristicNotificationTriggerFactory { + #[cfg(feature="windows-devices")] #[inline] pub fn create(&self, characteristic: &super::super::devices::bluetooth::genericattributeprofile::GattCharacteristic) -> Result> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Thumbnails)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, characteristic as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_shared_item(&self) -> Result>> { unsafe { +} +DEFINE_IID!(IID_IGattCharacteristicNotificationTriggerFactory2, 1503193375, 35411, 20127, 163, 44, 35, 205, 51, 102, 76, 238); +RT_INTERFACE!{static interface IGattCharacteristicNotificationTriggerFactory2(IGattCharacteristicNotificationTriggerFactory2Vtbl): IInspectable(IInspectableVtbl) [IID_IGattCharacteristicNotificationTriggerFactory2] { + #[cfg(feature="windows-devices")] fn CreateWithEventTriggeringMode(&self, characteristic: *mut super::super::devices::bluetooth::genericattributeprofile::GattCharacteristic, eventTriggeringMode: super::super::devices::bluetooth::background::BluetoothEventTriggeringMode, out: *mut *mut GattCharacteristicNotificationTrigger) -> HRESULT +}} +impl IGattCharacteristicNotificationTriggerFactory2 { + #[cfg(feature="windows-devices")] #[inline] pub fn create_with_event_triggering_mode(&self, characteristic: &super::super::devices::bluetooth::genericattributeprofile::GattCharacteristic, eventTriggeringMode: super::super::devices::bluetooth::background::BluetoothEventTriggeringMode) -> Result> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_SharedItem)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } - }} - #[inline] pub fn set_shared_item(&self, value: &SocialFeedSharedItem) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_SharedItem)(self as *const _ as *mut _, value as *const _ as *mut _); - if hr == S_OK { Ok(()) } else { err(hr) } + let hr = ((*self.lpVtbl).CreateWithEventTriggeringMode)(self as *const _ as *mut _, characteristic as *const _ as *mut _, eventTriggeringMode, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } -RT_CLASS!{class SocialFeedChildItem: ISocialFeedChildItem} -impl RtActivatable for SocialFeedChildItem {} -DEFINE_CLSID!(SocialFeedChildItem(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,83,111,99,105,97,108,73,110,102,111,46,83,111,99,105,97,108,70,101,101,100,67,104,105,108,100,73,116,101,109,0]) [CLSID_SocialFeedChildItem]); -DEFINE_IID!(IID_ISocialFeedContent, 2721375273, 15929, 18765, 163, 124, 244, 98, 162, 73, 69, 20); -RT_INTERFACE!{interface ISocialFeedContent(ISocialFeedContentVtbl): IInspectable(IInspectableVtbl) [IID_ISocialFeedContent] { - fn get_Title(&self, out: *mut HSTRING) -> HRESULT, - fn put_Title(&self, value: HSTRING) -> HRESULT, - fn get_Message(&self, out: *mut HSTRING) -> HRESULT, - fn put_Message(&self, value: HSTRING) -> HRESULT, - fn get_TargetUri(&self, out: *mut *mut foundation::Uri) -> HRESULT, - fn put_TargetUri(&self, value: *mut foundation::Uri) -> HRESULT +DEFINE_IID!(IID_IGattServiceProviderTrigger, 3720782825, 5463, 19416, 133, 66, 70, 138, 160, 198, 150, 246); +RT_INTERFACE!{interface IGattServiceProviderTrigger(IGattServiceProviderTriggerVtbl): IInspectable(IInspectableVtbl) [IID_IGattServiceProviderTrigger] { + fn get_TriggerId(&self, out: *mut HSTRING) -> HRESULT, + #[cfg(feature="windows-devices")] fn get_Service(&self, out: *mut *mut super::super::devices::bluetooth::genericattributeprofile::GattLocalService) -> HRESULT, + #[cfg(feature="windows-devices")] fn put_AdvertisingParameters(&self, value: *mut super::super::devices::bluetooth::genericattributeprofile::GattServiceProviderAdvertisingParameters) -> HRESULT, + #[cfg(feature="windows-devices")] fn get_AdvertisingParameters(&self, out: *mut *mut super::super::devices::bluetooth::genericattributeprofile::GattServiceProviderAdvertisingParameters) -> HRESULT }} -impl ISocialFeedContent { - #[inline] pub fn get_title(&self) -> Result { unsafe { +impl IGattServiceProviderTrigger { + #[inline] pub fn get_trigger_id(&self) -> Result { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Title)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_TriggerId)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} - #[inline] pub fn set_title(&self, value: &HStringArg) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_Title)(self as *const _ as *mut _, value.get()); - if hr == S_OK { Ok(()) } else { err(hr) } - }} - #[inline] pub fn get_message(&self) -> Result { unsafe { + #[cfg(feature="windows-devices")] #[inline] pub fn get_service(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Message)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).get_Service)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn set_message(&self, value: &HStringArg) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_Message)(self as *const _ as *mut _, value.get()); + #[cfg(feature="windows-devices")] #[inline] pub fn set_advertising_parameters(&self, value: &super::super::devices::bluetooth::genericattributeprofile::GattServiceProviderAdvertisingParameters) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_AdvertisingParameters)(self as *const _ as *mut _, value as *const _ as *mut _); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_target_uri(&self) -> Result>> { unsafe { + #[cfg(feature="windows-devices")] #[inline] pub fn get_advertising_parameters(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_TargetUri)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_AdvertisingParameters)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn set_target_uri(&self, value: &foundation::Uri) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_TargetUri)(self as *const _ as *mut _, value as *const _ as *mut _); - if hr == S_OK { Ok(()) } else { err(hr) } - }} } -RT_CLASS!{class SocialFeedContent: ISocialFeedContent} -DEFINE_IID!(IID_ISocialFeedItem, 1326682795, 8050, 19763, 182, 149, 222, 62, 29, 182, 3, 23); -RT_INTERFACE!{interface ISocialFeedItem(ISocialFeedItemVtbl): IInspectable(IInspectableVtbl) [IID_ISocialFeedItem] { - fn get_Author(&self, out: *mut *mut SocialUserInfo) -> HRESULT, - fn get_PrimaryContent(&self, out: *mut *mut SocialFeedContent) -> HRESULT, - fn get_SecondaryContent(&self, out: *mut *mut SocialFeedContent) -> HRESULT, - fn get_Timestamp(&self, out: *mut foundation::DateTime) -> HRESULT, - fn put_Timestamp(&self, value: foundation::DateTime) -> HRESULT, - fn get_TargetUri(&self, out: *mut *mut foundation::Uri) -> HRESULT, - fn put_TargetUri(&self, value: *mut foundation::Uri) -> HRESULT, - fn get_Thumbnails(&self, out: *mut *mut foundation::collections::IVector) -> HRESULT, - fn get_SharedItem(&self, out: *mut *mut SocialFeedSharedItem) -> HRESULT, - fn put_SharedItem(&self, value: *mut SocialFeedSharedItem) -> HRESULT, - fn get_BadgeStyle(&self, out: *mut SocialItemBadgeStyle) -> HRESULT, - fn put_BadgeStyle(&self, value: SocialItemBadgeStyle) -> HRESULT, - fn get_BadgeCountValue(&self, out: *mut i32) -> HRESULT, - fn put_BadgeCountValue(&self, value: i32) -> HRESULT, - fn get_RemoteId(&self, out: *mut HSTRING) -> HRESULT, - fn put_RemoteId(&self, value: HSTRING) -> HRESULT, - fn get_ChildItem(&self, out: *mut *mut SocialFeedChildItem) -> HRESULT, - fn put_ChildItem(&self, value: *mut SocialFeedChildItem) -> HRESULT, - fn get_Style(&self, out: *mut SocialFeedItemStyle) -> HRESULT, - fn put_Style(&self, value: SocialFeedItemStyle) -> HRESULT +RT_CLASS!{class GattServiceProviderTrigger: IGattServiceProviderTrigger} +impl RtActivatable for GattServiceProviderTrigger {} +impl GattServiceProviderTrigger { + #[inline] pub fn create_async(triggerId: &HStringArg, serviceUuid: Guid) -> Result>> { + >::get_activation_factory().create_async(triggerId, serviceUuid) + } +} +DEFINE_CLSID!(GattServiceProviderTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,71,97,116,116,83,101,114,118,105,99,101,80,114,111,118,105,100,101,114,84,114,105,103,103,101,114,0]) [CLSID_GattServiceProviderTrigger]); +DEFINE_IID!(IID_IGattServiceProviderTriggerResult, 1011257777, 45464, 20100, 186, 212, 207, 74, 210, 153, 237, 58); +RT_INTERFACE!{interface IGattServiceProviderTriggerResult(IGattServiceProviderTriggerResultVtbl): IInspectable(IInspectableVtbl) [IID_IGattServiceProviderTriggerResult] { + fn get_Trigger(&self, out: *mut *mut GattServiceProviderTrigger) -> HRESULT, + #[cfg(feature="windows-devices")] fn get_Error(&self, out: *mut super::super::devices::bluetooth::BluetoothError) -> HRESULT }} -impl ISocialFeedItem { - #[inline] pub fn get_author(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Author)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } - }} - #[inline] pub fn get_primary_content(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_PrimaryContent)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } - }} - #[inline] pub fn get_secondary_content(&self) -> Result>> { unsafe { +impl IGattServiceProviderTriggerResult { + #[inline] pub fn get_trigger(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_SecondaryContent)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_Trigger)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn get_timestamp(&self) -> Result { unsafe { + #[cfg(feature="windows-devices")] #[inline] pub fn get_error(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_Timestamp)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_Error)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn set_timestamp(&self, value: foundation::DateTime) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_Timestamp)(self as *const _ as *mut _, value); - if hr == S_OK { Ok(()) } else { err(hr) } - }} - #[inline] pub fn get_target_uri(&self) -> Result>> { unsafe { +} +RT_CLASS!{class GattServiceProviderTriggerResult: IGattServiceProviderTriggerResult} +DEFINE_IID!(IID_IGattServiceProviderTriggerStatics, 3021185898, 58004, 17809, 165, 166, 100, 137, 26, 130, 129, 83); +RT_INTERFACE!{static interface IGattServiceProviderTriggerStatics(IGattServiceProviderTriggerStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IGattServiceProviderTriggerStatics] { + fn CreateAsync(&self, triggerId: HSTRING, serviceUuid: Guid, out: *mut *mut foundation::IAsyncOperation) -> HRESULT +}} +impl IGattServiceProviderTriggerStatics { + #[inline] pub fn create_async(&self, triggerId: &HStringArg, serviceUuid: Guid) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_TargetUri)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } - }} - #[inline] pub fn set_target_uri(&self, value: &foundation::Uri) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_TargetUri)(self as *const _ as *mut _, value as *const _ as *mut _); - if hr == S_OK { Ok(()) } else { err(hr) } - }} - #[inline] pub fn get_thumbnails(&self) -> Result>>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Thumbnails)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).CreateAsync)(self as *const _ as *mut _, triggerId.get(), serviceUuid, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_shared_item(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_SharedItem)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } +} +DEFINE_IID!(IID_IGeovisitTrigger, 1209593258, 1249, 16679, 154, 76, 25, 53, 27, 138, 128, 164); +RT_INTERFACE!{interface IGeovisitTrigger(IGeovisitTriggerVtbl): IInspectable(IInspectableVtbl) [IID_IGeovisitTrigger] { + #[cfg(feature="windows-devices")] fn get_MonitoringScope(&self, out: *mut super::super::devices::geolocation::VisitMonitoringScope) -> HRESULT, + #[cfg(feature="windows-devices")] fn put_MonitoringScope(&self, value: super::super::devices::geolocation::VisitMonitoringScope) -> HRESULT +}} +impl IGeovisitTrigger { + #[cfg(feature="windows-devices")] #[inline] pub fn get_monitoring_scope(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_MonitoringScope)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn set_shared_item(&self, value: &SocialFeedSharedItem) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_SharedItem)(self as *const _ as *mut _, value as *const _ as *mut _); + #[cfg(feature="windows-devices")] #[inline] pub fn set_monitoring_scope(&self, value: super::super::devices::geolocation::VisitMonitoringScope) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_MonitoringScope)(self as *const _ as *mut _, value); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_badge_style(&self) -> Result { unsafe { +} +RT_CLASS!{class GeovisitTrigger: IGeovisitTrigger} +impl RtActivatable for GeovisitTrigger {} +DEFINE_CLSID!(GeovisitTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,71,101,111,118,105,115,105,116,84,114,105,103,103,101,114,0]) [CLSID_GeovisitTrigger]); +DEFINE_IID!(IID_ILocationTrigger, 1197894172, 26743, 18462, 128, 38, 255, 126, 20, 168, 17, 160); +RT_INTERFACE!{interface ILocationTrigger(ILocationTriggerVtbl): IInspectable(IInspectableVtbl) [IID_ILocationTrigger] { + fn get_TriggerType(&self, out: *mut LocationTriggerType) -> HRESULT +}} +impl ILocationTrigger { + #[inline] pub fn get_trigger_type(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_BadgeStyle)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_TriggerType)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn set_badge_style(&self, value: SocialItemBadgeStyle) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_BadgeStyle)(self as *const _ as *mut _, value); - if hr == S_OK { Ok(()) } else { err(hr) } +} +RT_CLASS!{class LocationTrigger: ILocationTrigger} +impl RtActivatable for LocationTrigger {} +impl LocationTrigger { + #[inline] pub fn create(triggerType: LocationTriggerType) -> Result> { + >::get_activation_factory().create(triggerType) + } +} +DEFINE_CLSID!(LocationTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,76,111,99,97,116,105,111,110,84,114,105,103,103,101,114,0]) [CLSID_LocationTrigger]); +DEFINE_IID!(IID_ILocationTriggerFactory, 285653767, 65385, 19977, 170, 139, 19, 132, 234, 71, 94, 152); +RT_INTERFACE!{static interface ILocationTriggerFactory(ILocationTriggerFactoryVtbl): IInspectable(IInspectableVtbl) [IID_ILocationTriggerFactory] { + fn Create(&self, triggerType: LocationTriggerType, out: *mut *mut LocationTrigger) -> HRESULT +}} +impl ILocationTriggerFactory { + #[inline] pub fn create(&self, triggerType: LocationTriggerType) -> Result> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, triggerType, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_badge_count_value(&self) -> Result { unsafe { +} +RT_ENUM! { enum LocationTriggerType: i32 { + Geofence (LocationTriggerType_Geofence) = 0, +}} +DEFINE_IID!(IID_IMaintenanceTrigger, 1746422915, 64546, 19685, 132, 26, 114, 57, 169, 129, 0, 71); +RT_INTERFACE!{interface IMaintenanceTrigger(IMaintenanceTriggerVtbl): IInspectable(IInspectableVtbl) [IID_IMaintenanceTrigger] { + fn get_FreshnessTime(&self, out: *mut u32) -> HRESULT, + fn get_OneShot(&self, out: *mut bool) -> HRESULT +}} +impl IMaintenanceTrigger { + #[inline] pub fn get_freshness_time(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_BadgeCountValue)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_FreshnessTime)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn set_badge_count_value(&self, value: i32) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_BadgeCountValue)(self as *const _ as *mut _, value); - if hr == S_OK { Ok(()) } else { err(hr) } + #[inline] pub fn get_one_shot(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_OneShot)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_remote_id(&self) -> Result { unsafe { +} +RT_CLASS!{class MaintenanceTrigger: IMaintenanceTrigger} +impl RtActivatable for MaintenanceTrigger {} +impl MaintenanceTrigger { + #[inline] pub fn create(freshnessTime: u32, oneShot: bool) -> Result> { + >::get_activation_factory().create(freshnessTime, oneShot) + } +} +DEFINE_CLSID!(MaintenanceTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,77,97,105,110,116,101,110,97,110,99,101,84,114,105,103,103,101,114,0]) [CLSID_MaintenanceTrigger]); +DEFINE_IID!(IID_IMaintenanceTriggerFactory, 1262345006, 38877, 17961, 136, 176, 176, 108, 249, 72, 42, 229); +RT_INTERFACE!{static interface IMaintenanceTriggerFactory(IMaintenanceTriggerFactoryVtbl): IInspectable(IInspectableVtbl) [IID_IMaintenanceTriggerFactory] { + fn Create(&self, freshnessTime: u32, oneShot: bool, out: *mut *mut MaintenanceTrigger) -> HRESULT +}} +impl IMaintenanceTriggerFactory { + #[inline] pub fn create(&self, freshnessTime: u32, oneShot: bool) -> Result> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_RemoteId)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } - }} - #[inline] pub fn set_remote_id(&self, value: &HStringArg) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_RemoteId)(self as *const _ as *mut _, value.get()); - if hr == S_OK { Ok(()) } else { err(hr) } + let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, freshnessTime, oneShot, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_child_item(&self) -> Result>> { unsafe { +} +DEFINE_IID!(IID_IMediaProcessingTrigger, 2593504869, 35410, 19248, 144, 17, 207, 56, 4, 14, 168, 176); +RT_INTERFACE!{interface IMediaProcessingTrigger(IMediaProcessingTriggerVtbl): IInspectable(IInspectableVtbl) [IID_IMediaProcessingTrigger] { + fn RequestAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn RequestAsyncWithArguments(&self, arguments: *mut foundation::collections::ValueSet, out: *mut *mut foundation::IAsyncOperation) -> HRESULT +}} +impl IMediaProcessingTrigger { + #[inline] pub fn request_async(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_ChildItem)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } - }} - #[inline] pub fn set_child_item(&self, value: &SocialFeedChildItem) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_ChildItem)(self as *const _ as *mut _, value as *const _ as *mut _); - if hr == S_OK { Ok(()) } else { err(hr) } - }} - #[inline] pub fn get_style(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_Style)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } + let hr = ((*self.lpVtbl).RequestAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn set_style(&self, value: SocialFeedItemStyle) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_Style)(self as *const _ as *mut _, value); - if hr == S_OK { Ok(()) } else { err(hr) } + #[inline] pub fn request_async_with_arguments(&self, arguments: &foundation::collections::ValueSet) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).RequestAsyncWithArguments)(self as *const _ as *mut _, arguments as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } -RT_CLASS!{class SocialFeedItem: ISocialFeedItem} -impl RtActivatable for SocialFeedItem {} -DEFINE_CLSID!(SocialFeedItem(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,83,111,99,105,97,108,73,110,102,111,46,83,111,99,105,97,108,70,101,101,100,73,116,101,109,0]) [CLSID_SocialFeedItem]); -RT_ENUM! { enum SocialFeedItemStyle: i32 { - Default (SocialFeedItemStyle_Default) = 0, Photo (SocialFeedItemStyle_Photo) = 1, +RT_CLASS!{class MediaProcessingTrigger: IMediaProcessingTrigger} +impl RtActivatable for MediaProcessingTrigger {} +DEFINE_CLSID!(MediaProcessingTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,77,101,100,105,97,80,114,111,99,101,115,115,105,110,103,84,114,105,103,103,101,114,0]) [CLSID_MediaProcessingTrigger]); +RT_ENUM! { enum MediaProcessingTriggerResult: i32 { + Allowed (MediaProcessingTriggerResult_Allowed) = 0, CurrentlyRunning (MediaProcessingTriggerResult_CurrentlyRunning) = 1, DisabledByPolicy (MediaProcessingTriggerResult_DisabledByPolicy) = 2, UnknownError (MediaProcessingTriggerResult_UnknownError) = 3, }} -RT_ENUM! { enum SocialFeedKind: i32 { - HomeFeed (SocialFeedKind_HomeFeed) = 0, ContactFeed (SocialFeedKind_ContactFeed) = 1, Dashboard (SocialFeedKind_Dashboard) = 2, +RT_CLASS!{class MobileBroadbandDeviceServiceNotificationTrigger: IBackgroundTrigger} +impl RtActivatable for MobileBroadbandDeviceServiceNotificationTrigger {} +DEFINE_CLSID!(MobileBroadbandDeviceServiceNotificationTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,77,111,98,105,108,101,66,114,111,97,100,98,97,110,100,68,101,118,105,99,101,83,101,114,118,105,99,101,78,111,116,105,102,105,99,97,116,105,111,110,84,114,105,103,103,101,114,0]) [CLSID_MobileBroadbandDeviceServiceNotificationTrigger]); +RT_CLASS!{class MobileBroadbandPcoDataChangeTrigger: IBackgroundTrigger} +impl RtActivatable for MobileBroadbandPcoDataChangeTrigger {} +DEFINE_CLSID!(MobileBroadbandPcoDataChangeTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,77,111,98,105,108,101,66,114,111,97,100,98,97,110,100,80,99,111,68,97,116,97,67,104,97,110,103,101,84,114,105,103,103,101,114,0]) [CLSID_MobileBroadbandPcoDataChangeTrigger]); +RT_CLASS!{class MobileBroadbandPinLockStateChangeTrigger: IBackgroundTrigger} +impl RtActivatable for MobileBroadbandPinLockStateChangeTrigger {} +DEFINE_CLSID!(MobileBroadbandPinLockStateChangeTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,77,111,98,105,108,101,66,114,111,97,100,98,97,110,100,80,105,110,76,111,99,107,83,116,97,116,101,67,104,97,110,103,101,84,114,105,103,103,101,114,0]) [CLSID_MobileBroadbandPinLockStateChangeTrigger]); +RT_CLASS!{class MobileBroadbandRadioStateChangeTrigger: IBackgroundTrigger} +impl RtActivatable for MobileBroadbandRadioStateChangeTrigger {} +DEFINE_CLSID!(MobileBroadbandRadioStateChangeTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,77,111,98,105,108,101,66,114,111,97,100,98,97,110,100,82,97,100,105,111,83,116,97,116,101,67,104,97,110,103,101,84,114,105,103,103,101,114,0]) [CLSID_MobileBroadbandRadioStateChangeTrigger]); +RT_CLASS!{class MobileBroadbandRegistrationStateChangeTrigger: IBackgroundTrigger} +impl RtActivatable for MobileBroadbandRegistrationStateChangeTrigger {} +DEFINE_CLSID!(MobileBroadbandRegistrationStateChangeTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,77,111,98,105,108,101,66,114,111,97,100,98,97,110,100,82,101,103,105,115,116,114,97,116,105,111,110,83,116,97,116,101,67,104,97,110,103,101,84,114,105,103,103,101,114,0]) [CLSID_MobileBroadbandRegistrationStateChangeTrigger]); +RT_CLASS!{class NetworkOperatorDataUsageTrigger: IBackgroundTrigger} +impl RtActivatable for NetworkOperatorDataUsageTrigger {} +DEFINE_CLSID!(NetworkOperatorDataUsageTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,78,101,116,119,111,114,107,79,112,101,114,97,116,111,114,68,97,116,97,85,115,97,103,101,84,114,105,103,103,101,114,0]) [CLSID_NetworkOperatorDataUsageTrigger]); +DEFINE_IID!(IID_INetworkOperatorHotspotAuthenticationTrigger, 3881224081, 12289, 19941, 131, 199, 222, 97, 216, 136, 49, 208); +RT_INTERFACE!{interface INetworkOperatorHotspotAuthenticationTrigger(INetworkOperatorHotspotAuthenticationTriggerVtbl): IInspectable(IInspectableVtbl) [IID_INetworkOperatorHotspotAuthenticationTrigger] { + }} -DEFINE_IID!(IID_ISocialFeedSharedItem, 2080087616, 42666, 17831, 159, 246, 84, 196, 33, 5, 221, 31); -RT_INTERFACE!{interface ISocialFeedSharedItem(ISocialFeedSharedItemVtbl): IInspectable(IInspectableVtbl) [IID_ISocialFeedSharedItem] { - fn get_OriginalSource(&self, out: *mut *mut foundation::Uri) -> HRESULT, - fn put_OriginalSource(&self, value: *mut foundation::Uri) -> HRESULT, - fn get_Content(&self, out: *mut *mut SocialFeedContent) -> HRESULT, - fn get_Timestamp(&self, out: *mut foundation::DateTime) -> HRESULT, - fn put_Timestamp(&self, value: foundation::DateTime) -> HRESULT, - fn get_TargetUri(&self, out: *mut *mut foundation::Uri) -> HRESULT, - fn put_TargetUri(&self, value: *mut foundation::Uri) -> HRESULT, - fn put_Thumbnail(&self, value: *mut SocialItemThumbnail) -> HRESULT, - fn get_Thumbnail(&self, out: *mut *mut SocialItemThumbnail) -> HRESULT +RT_CLASS!{class NetworkOperatorHotspotAuthenticationTrigger: INetworkOperatorHotspotAuthenticationTrigger} +impl RtActivatable for NetworkOperatorHotspotAuthenticationTrigger {} +DEFINE_CLSID!(NetworkOperatorHotspotAuthenticationTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,78,101,116,119,111,114,107,79,112,101,114,97,116,111,114,72,111,116,115,112,111,116,65,117,116,104,101,110,116,105,99,97,116,105,111,110,84,114,105,103,103,101,114,0]) [CLSID_NetworkOperatorHotspotAuthenticationTrigger]); +DEFINE_IID!(IID_INetworkOperatorNotificationTrigger, 2416483526, 25549, 18444, 149, 209, 110, 106, 239, 128, 30, 74); +RT_INTERFACE!{interface INetworkOperatorNotificationTrigger(INetworkOperatorNotificationTriggerVtbl): IInspectable(IInspectableVtbl) [IID_INetworkOperatorNotificationTrigger] { + fn get_NetworkAccountId(&self, out: *mut HSTRING) -> HRESULT }} -impl ISocialFeedSharedItem { - #[inline] pub fn get_original_source(&self) -> Result>> { unsafe { +impl INetworkOperatorNotificationTrigger { + #[inline] pub fn get_network_account_id(&self) -> Result { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_OriginalSource)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } - }} - #[inline] pub fn set_original_source(&self, value: &foundation::Uri) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_OriginalSource)(self as *const _ as *mut _, value as *const _ as *mut _); - if hr == S_OK { Ok(()) } else { err(hr) } + let hr = ((*self.lpVtbl).get_NetworkAccountId)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_content(&self) -> Result>> { unsafe { +} +RT_CLASS!{class NetworkOperatorNotificationTrigger: INetworkOperatorNotificationTrigger} +impl RtActivatable for NetworkOperatorNotificationTrigger {} +impl NetworkOperatorNotificationTrigger { + #[inline] pub fn create(networkAccountId: &HStringArg) -> Result> { + >::get_activation_factory().create(networkAccountId) + } +} +DEFINE_CLSID!(NetworkOperatorNotificationTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,78,101,116,119,111,114,107,79,112,101,114,97,116,111,114,78,111,116,105,102,105,99,97,116,105,111,110,84,114,105,103,103,101,114,0]) [CLSID_NetworkOperatorNotificationTrigger]); +DEFINE_IID!(IID_INetworkOperatorNotificationTriggerFactory, 170016256, 10199, 17235, 173, 185, 146, 101, 170, 234, 87, 157); +RT_INTERFACE!{static interface INetworkOperatorNotificationTriggerFactory(INetworkOperatorNotificationTriggerFactoryVtbl): IInspectable(IInspectableVtbl) [IID_INetworkOperatorNotificationTriggerFactory] { + fn Create(&self, networkAccountId: HSTRING, out: *mut *mut NetworkOperatorNotificationTrigger) -> HRESULT +}} +impl INetworkOperatorNotificationTriggerFactory { + #[inline] pub fn create(&self, networkAccountId: &HStringArg) -> Result> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Content)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, networkAccountId.get(), &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_timestamp(&self) -> Result { unsafe { +} +RT_CLASS!{class PaymentAppCanMakePaymentTrigger: IBackgroundTrigger} +impl RtActivatable for PaymentAppCanMakePaymentTrigger {} +DEFINE_CLSID!(PaymentAppCanMakePaymentTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,80,97,121,109,101,110,116,65,112,112,67,97,110,77,97,107,101,80,97,121,109,101,110,116,84,114,105,103,103,101,114,0]) [CLSID_PaymentAppCanMakePaymentTrigger]); +DEFINE_IID!(IID_IPhoneTrigger, 2379213211, 54469, 18929, 183, 211, 130, 232, 122, 14, 157, 222); +RT_INTERFACE!{interface IPhoneTrigger(IPhoneTriggerVtbl): IInspectable(IInspectableVtbl) [IID_IPhoneTrigger] { + fn get_OneShot(&self, out: *mut bool) -> HRESULT, + fn get_TriggerType(&self, out: *mut super::calls::background::PhoneTriggerType) -> HRESULT +}} +impl IPhoneTrigger { + #[inline] pub fn get_one_shot(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_Timestamp)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_OneShot)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn set_timestamp(&self, value: foundation::DateTime) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_Timestamp)(self as *const _ as *mut _, value); - if hr == S_OK { Ok(()) } else { err(hr) } + #[inline] pub fn get_trigger_type(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_TriggerType)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_target_uri(&self) -> Result>> { unsafe { +} +RT_CLASS!{class PhoneTrigger: IPhoneTrigger} +impl RtActivatable for PhoneTrigger {} +impl PhoneTrigger { + #[inline] pub fn create(type_: super::calls::background::PhoneTriggerType, oneShot: bool) -> Result> { + >::get_activation_factory().create(type_, oneShot) + } +} +DEFINE_CLSID!(PhoneTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,80,104,111,110,101,84,114,105,103,103,101,114,0]) [CLSID_PhoneTrigger]); +DEFINE_IID!(IID_IPhoneTriggerFactory, 2698591450, 24513, 18683, 165, 70, 50, 38, 32, 64, 21, 123); +RT_INTERFACE!{static interface IPhoneTriggerFactory(IPhoneTriggerFactoryVtbl): IInspectable(IInspectableVtbl) [IID_IPhoneTriggerFactory] { + fn Create(&self, type_: super::calls::background::PhoneTriggerType, oneShot: bool, out: *mut *mut PhoneTrigger) -> HRESULT +}} +impl IPhoneTriggerFactory { + #[inline] pub fn create(&self, type_: super::calls::background::PhoneTriggerType, oneShot: bool) -> Result> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_TargetUri)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, type_, oneShot, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn set_target_uri(&self, value: &foundation::Uri) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_TargetUri)(self as *const _ as *mut _, value as *const _ as *mut _); - if hr == S_OK { Ok(()) } else { err(hr) } - }} - #[inline] pub fn set_thumbnail(&self, value: &SocialItemThumbnail) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_Thumbnail)(self as *const _ as *mut _, value as *const _ as *mut _); - if hr == S_OK { Ok(()) } else { err(hr) } - }} - #[inline] pub fn get_thumbnail(&self) -> Result>> { unsafe { +} +RT_CLASS!{class PushNotificationTrigger: IBackgroundTrigger} +impl RtActivatable for PushNotificationTrigger {} +impl RtActivatable for PushNotificationTrigger {} +impl PushNotificationTrigger { + #[inline] pub fn create(applicationId: &HStringArg) -> Result> { + >::get_activation_factory().create(applicationId) + } +} +DEFINE_CLSID!(PushNotificationTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,80,117,115,104,78,111,116,105,102,105,99,97,116,105,111,110,84,114,105,103,103,101,114,0]) [CLSID_PushNotificationTrigger]); +DEFINE_IID!(IID_IPushNotificationTriggerFactory, 1842933019, 17806, 20418, 188, 46, 213, 102, 79, 119, 237, 25); +RT_INTERFACE!{static interface IPushNotificationTriggerFactory(IPushNotificationTriggerFactoryVtbl): IInspectable(IInspectableVtbl) [IID_IPushNotificationTriggerFactory] { + fn Create(&self, applicationId: HSTRING, out: *mut *mut PushNotificationTrigger) -> HRESULT +}} +impl IPushNotificationTriggerFactory { + #[inline] pub fn create(&self, applicationId: &HStringArg) -> Result> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Thumbnail)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, applicationId.get(), &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } -RT_CLASS!{class SocialFeedSharedItem: ISocialFeedSharedItem} -impl RtActivatable for SocialFeedSharedItem {} -DEFINE_CLSID!(SocialFeedSharedItem(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,83,111,99,105,97,108,73,110,102,111,46,83,111,99,105,97,108,70,101,101,100,83,104,97,114,101,100,73,116,101,109,0]) [CLSID_SocialFeedSharedItem]); -RT_ENUM! { enum SocialFeedUpdateMode: i32 { - Append (SocialFeedUpdateMode_Append) = 0, Replace (SocialFeedUpdateMode_Replace) = 1, -}} -RT_ENUM! { enum SocialItemBadgeStyle: i32 { - Hidden (SocialItemBadgeStyle_Hidden) = 0, Visible (SocialItemBadgeStyle_Visible) = 1, VisibleWithCount (SocialItemBadgeStyle_VisibleWithCount) = 2, +DEFINE_IID!(IID_IRcsEndUserMessageAvailableTrigger, 2557283690, 45814, 18047, 169, 120, 164, 64, 145, 193, 26, 102); +RT_INTERFACE!{interface IRcsEndUserMessageAvailableTrigger(IRcsEndUserMessageAvailableTriggerVtbl): IInspectable(IInspectableVtbl) [IID_IRcsEndUserMessageAvailableTrigger] { + }} -DEFINE_IID!(IID_ISocialItemThumbnail, 1556054810, 16136, 18815, 145, 127, 87, 224, 157, 132, 177, 65); -RT_INTERFACE!{interface ISocialItemThumbnail(ISocialItemThumbnailVtbl): IInspectable(IInspectableVtbl) [IID_ISocialItemThumbnail] { - fn get_TargetUri(&self, out: *mut *mut foundation::Uri) -> HRESULT, - fn put_TargetUri(&self, value: *mut foundation::Uri) -> HRESULT, - fn get_ImageUri(&self, out: *mut *mut foundation::Uri) -> HRESULT, - fn put_ImageUri(&self, value: *mut foundation::Uri) -> HRESULT, - #[cfg(not(feature="windows-graphics"))] fn __Dummy4(&self) -> (), - #[cfg(feature="windows-graphics")] fn get_BitmapSize(&self, out: *mut super::super::graphics::imaging::BitmapSize) -> HRESULT, - #[cfg(not(feature="windows-graphics"))] fn __Dummy5(&self) -> (), - #[cfg(feature="windows-graphics")] fn put_BitmapSize(&self, value: super::super::graphics::imaging::BitmapSize) -> HRESULT, - #[cfg(feature="windows-storage")] fn SetImageAsync(&self, image: *mut super::super::storage::streams::IInputStream, out: *mut *mut foundation::IAsyncAction) -> HRESULT +RT_CLASS!{class RcsEndUserMessageAvailableTrigger: IRcsEndUserMessageAvailableTrigger} +impl RtActivatable for RcsEndUserMessageAvailableTrigger {} +DEFINE_CLSID!(RcsEndUserMessageAvailableTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,82,99,115,69,110,100,85,115,101,114,77,101,115,115,97,103,101,65,118,97,105,108,97,98,108,101,84,114,105,103,103,101,114,0]) [CLSID_RcsEndUserMessageAvailableTrigger]); +DEFINE_IID!(IID_IRfcommConnectionTrigger, 3905211106, 2899, 17508, 147, 148, 253, 135, 86, 84, 222, 100); +RT_INTERFACE!{interface IRfcommConnectionTrigger(IRfcommConnectionTriggerVtbl): IInspectable(IInspectableVtbl) [IID_IRfcommConnectionTrigger] { + #[cfg(not(feature="windows-devices"))] fn __Dummy0(&self) -> (), + #[cfg(feature="windows-devices")] fn get_InboundConnection(&self, out: *mut *mut super::super::devices::bluetooth::background::RfcommInboundConnectionInformation) -> HRESULT, + #[cfg(not(feature="windows-devices"))] fn __Dummy1(&self) -> (), + #[cfg(feature="windows-devices")] fn get_OutboundConnection(&self, out: *mut *mut super::super::devices::bluetooth::background::RfcommOutboundConnectionInformation) -> HRESULT, + fn get_AllowMultipleConnections(&self, out: *mut bool) -> HRESULT, + fn put_AllowMultipleConnections(&self, value: bool) -> HRESULT, + #[cfg(feature="windows-networking")] fn get_ProtectionLevel(&self, out: *mut super::super::networking::sockets::SocketProtectionLevel) -> HRESULT, + #[cfg(feature="windows-networking")] fn put_ProtectionLevel(&self, value: super::super::networking::sockets::SocketProtectionLevel) -> HRESULT, + #[cfg(feature="windows-networking")] fn get_RemoteHostName(&self, out: *mut *mut super::super::networking::HostName) -> HRESULT, + #[cfg(feature="windows-networking")] fn put_RemoteHostName(&self, value: *mut super::super::networking::HostName) -> HRESULT }} -impl ISocialItemThumbnail { - #[inline] pub fn get_target_uri(&self) -> Result>> { unsafe { +impl IRfcommConnectionTrigger { + #[cfg(feature="windows-devices")] #[inline] pub fn get_inbound_connection(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_TargetUri)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_InboundConnection)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn set_target_uri(&self, value: &foundation::Uri) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_TargetUri)(self as *const _ as *mut _, value as *const _ as *mut _); - if hr == S_OK { Ok(()) } else { err(hr) } - }} - #[inline] pub fn get_image_uri(&self) -> Result>> { unsafe { + #[cfg(feature="windows-devices")] #[inline] pub fn get_outbound_connection(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_ImageUri)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_OutboundConnection)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn set_image_uri(&self, value: &foundation::Uri) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_ImageUri)(self as *const _ as *mut _, value as *const _ as *mut _); - if hr == S_OK { Ok(()) } else { err(hr) } - }} - #[cfg(feature="windows-graphics")] #[inline] pub fn get_bitmap_size(&self) -> Result { unsafe { + #[inline] pub fn get_allow_multiple_connections(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_BitmapSize)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_AllowMultipleConnections)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[cfg(feature="windows-graphics")] #[inline] pub fn set_bitmap_size(&self, value: super::super::graphics::imaging::BitmapSize) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_BitmapSize)(self as *const _ as *mut _, value); - if hr == S_OK { Ok(()) } else { err(hr) } - }} - #[cfg(feature="windows-storage")] #[inline] pub fn set_image_async(&self, image: &super::super::storage::streams::IInputStream) -> Result> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).SetImageAsync)(self as *const _ as *mut _, image as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } - }} -} -RT_CLASS!{class SocialItemThumbnail: ISocialItemThumbnail} -impl RtActivatable for SocialItemThumbnail {} -DEFINE_CLSID!(SocialItemThumbnail(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,83,111,99,105,97,108,73,110,102,111,46,83,111,99,105,97,108,73,116,101,109,84,104,117,109,98,110,97,105,108,0]) [CLSID_SocialItemThumbnail]); -DEFINE_IID!(IID_ISocialUserInfo, 2656967633, 37072, 19997, 149, 84, 132, 77, 70, 96, 127, 97); -RT_INTERFACE!{interface ISocialUserInfo(ISocialUserInfoVtbl): IInspectable(IInspectableVtbl) [IID_ISocialUserInfo] { - fn get_DisplayName(&self, out: *mut HSTRING) -> HRESULT, - fn put_DisplayName(&self, value: HSTRING) -> HRESULT, - fn get_UserName(&self, out: *mut HSTRING) -> HRESULT, - fn put_UserName(&self, value: HSTRING) -> HRESULT, - fn get_RemoteId(&self, out: *mut HSTRING) -> HRESULT, - fn put_RemoteId(&self, value: HSTRING) -> HRESULT, - fn get_TargetUri(&self, out: *mut *mut foundation::Uri) -> HRESULT, - fn put_TargetUri(&self, value: *mut foundation::Uri) -> HRESULT -}} -impl ISocialUserInfo { - #[inline] pub fn get_display_name(&self) -> Result { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_DisplayName)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } - }} - #[inline] pub fn set_display_name(&self, value: &HStringArg) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_DisplayName)(self as *const _ as *mut _, value.get()); - if hr == S_OK { Ok(()) } else { err(hr) } - }} - #[inline] pub fn get_user_name(&self) -> Result { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_UserName)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } - }} - #[inline] pub fn set_user_name(&self, value: &HStringArg) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_UserName)(self as *const _ as *mut _, value.get()); + #[inline] pub fn set_allow_multiple_connections(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_AllowMultipleConnections)(self as *const _ as *mut _, value); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_remote_id(&self) -> Result { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_RemoteId)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + #[cfg(feature="windows-networking")] #[inline] pub fn get_protection_level(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_ProtectionLevel)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn set_remote_id(&self, value: &HStringArg) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_RemoteId)(self as *const _ as *mut _, value.get()); + #[cfg(feature="windows-networking")] #[inline] pub fn set_protection_level(&self, value: super::super::networking::sockets::SocketProtectionLevel) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_ProtectionLevel)(self as *const _ as *mut _, value); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_target_uri(&self) -> Result>> { unsafe { + #[cfg(feature="windows-networking")] #[inline] pub fn get_remote_host_name(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_TargetUri)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_RemoteHostName)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn set_target_uri(&self, value: &foundation::Uri) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_TargetUri)(self as *const _ as *mut _, value as *const _ as *mut _); + #[cfg(feature="windows-networking")] #[inline] pub fn set_remote_host_name(&self, value: &super::super::networking::HostName) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_RemoteHostName)(self as *const _ as *mut _, value as *const _ as *mut _); if hr == S_OK { Ok(()) } else { err(hr) } }} } -RT_CLASS!{class SocialUserInfo: ISocialUserInfo} -pub mod provider { // Windows.ApplicationModel.SocialInfo.Provider -use ::prelude::*; -DEFINE_IID!(IID_ISocialDashboardItemUpdater, 1021222345, 18432, 18125, 134, 155, 25, 115, 236, 104, 91, 222); -RT_INTERFACE!{interface ISocialDashboardItemUpdater(ISocialDashboardItemUpdaterVtbl): IInspectable(IInspectableVtbl) [IID_ISocialDashboardItemUpdater] { - fn get_OwnerRemoteId(&self, out: *mut HSTRING) -> HRESULT, - fn get_Content(&self, out: *mut *mut super::SocialFeedContent) -> HRESULT, - fn get_Timestamp(&self, out: *mut foundation::DateTime) -> HRESULT, - fn put_Timestamp(&self, value: foundation::DateTime) -> HRESULT, - fn put_Thumbnail(&self, value: *mut super::SocialItemThumbnail) -> HRESULT, - fn get_Thumbnail(&self, out: *mut *mut super::SocialItemThumbnail) -> HRESULT, - fn CommitAsync(&self, out: *mut *mut foundation::IAsyncAction) -> HRESULT, - fn get_TargetUri(&self, out: *mut *mut foundation::Uri) -> HRESULT, - fn put_TargetUri(&self, value: *mut foundation::Uri) -> HRESULT +RT_CLASS!{class RfcommConnectionTrigger: IRfcommConnectionTrigger} +impl RtActivatable for RfcommConnectionTrigger {} +DEFINE_CLSID!(RfcommConnectionTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,82,102,99,111,109,109,67,111,110,110,101,99,116,105,111,110,84,114,105,103,103,101,114,0]) [CLSID_RfcommConnectionTrigger]); +DEFINE_IID!(IID_ISecondaryAuthenticationFactorAuthenticationTrigger, 4063752999, 20865, 20260, 150, 167, 112, 10, 78, 95, 172, 98); +RT_INTERFACE!{interface ISecondaryAuthenticationFactorAuthenticationTrigger(ISecondaryAuthenticationFactorAuthenticationTriggerVtbl): IInspectable(IInspectableVtbl) [IID_ISecondaryAuthenticationFactorAuthenticationTrigger] { + }} -impl ISocialDashboardItemUpdater { - #[inline] pub fn get_owner_remote_id(&self) -> Result { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_OwnerRemoteId)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } - }} - #[inline] pub fn get_content(&self) -> Result>> { unsafe { +RT_CLASS!{class SecondaryAuthenticationFactorAuthenticationTrigger: ISecondaryAuthenticationFactorAuthenticationTrigger} +impl RtActivatable for SecondaryAuthenticationFactorAuthenticationTrigger {} +DEFINE_CLSID!(SecondaryAuthenticationFactorAuthenticationTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,83,101,99,111,110,100,97,114,121,65,117,116,104,101,110,116,105,99,97,116,105,111,110,70,97,99,116,111,114,65,117,116,104,101,110,116,105,99,97,116,105,111,110,84,114,105,103,103,101,114,0]) [CLSID_SecondaryAuthenticationFactorAuthenticationTrigger]); +DEFINE_IID!(IID_ISensorDataThresholdTrigger, 1539371890, 54411, 19327, 171, 236, 21, 249, 186, 204, 18, 226); +RT_INTERFACE!{interface ISensorDataThresholdTrigger(ISensorDataThresholdTriggerVtbl): IInspectable(IInspectableVtbl) [IID_ISensorDataThresholdTrigger] { + +}} +RT_CLASS!{class SensorDataThresholdTrigger: ISensorDataThresholdTrigger} +impl RtActivatable for SensorDataThresholdTrigger {} +impl SensorDataThresholdTrigger { + #[cfg(feature="windows-devices")] #[inline] pub fn create(threshold: &super::super::devices::sensors::ISensorDataThreshold) -> Result> { + >::get_activation_factory().create(threshold) + } +} +DEFINE_CLSID!(SensorDataThresholdTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,83,101,110,115,111,114,68,97,116,97,84,104,114,101,115,104,111,108,100,84,114,105,103,103,101,114,0]) [CLSID_SensorDataThresholdTrigger]); +DEFINE_IID!(IID_ISensorDataThresholdTriggerFactory, 2451564149, 32240, 19875, 151, 179, 229, 68, 238, 133, 127, 230); +RT_INTERFACE!{static interface ISensorDataThresholdTriggerFactory(ISensorDataThresholdTriggerFactoryVtbl): IInspectable(IInspectableVtbl) [IID_ISensorDataThresholdTriggerFactory] { + #[cfg(feature="windows-devices")] fn Create(&self, threshold: *mut super::super::devices::sensors::ISensorDataThreshold, out: *mut *mut SensorDataThresholdTrigger) -> HRESULT +}} +impl ISensorDataThresholdTriggerFactory { + #[cfg(feature="windows-devices")] #[inline] pub fn create(&self, threshold: &super::super::devices::sensors::ISensorDataThreshold) -> Result> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Content)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, threshold as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_timestamp(&self) -> Result { unsafe { +} +DEFINE_IID!(IID_ISmartCardTrigger, 4114335148, 33994, 18802, 140, 233, 229, 143, 151, 179, 122, 80); +RT_INTERFACE!{interface ISmartCardTrigger(ISmartCardTriggerVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardTrigger] { + #[cfg(feature="windows-devices")] fn get_TriggerType(&self, out: *mut super::super::devices::smartcards::SmartCardTriggerType) -> HRESULT +}} +impl ISmartCardTrigger { + #[cfg(feature="windows-devices")] #[inline] pub fn get_trigger_type(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_Timestamp)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_TriggerType)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn set_timestamp(&self, value: foundation::DateTime) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_Timestamp)(self as *const _ as *mut _, value); - if hr == S_OK { Ok(()) } else { err(hr) } - }} - #[inline] pub fn set_thumbnail(&self, value: &super::SocialItemThumbnail) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_Thumbnail)(self as *const _ as *mut _, value as *const _ as *mut _); - if hr == S_OK { Ok(()) } else { err(hr) } - }} - #[inline] pub fn get_thumbnail(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Thumbnail)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } - }} - #[inline] pub fn commit_async(&self) -> Result> { unsafe { +} +RT_CLASS!{class SmartCardTrigger: ISmartCardTrigger} +impl RtActivatable for SmartCardTrigger {} +impl SmartCardTrigger { + #[cfg(feature="windows-devices")] #[inline] pub fn create(triggerType: super::super::devices::smartcards::SmartCardTriggerType) -> Result> { + >::get_activation_factory().create(triggerType) + } +} +DEFINE_CLSID!(SmartCardTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,83,109,97,114,116,67,97,114,100,84,114,105,103,103,101,114,0]) [CLSID_SmartCardTrigger]); +DEFINE_IID!(IID_ISmartCardTriggerFactory, 1673483459, 35265, 19968, 169, 211, 151, 198, 41, 38, 157, 173); +RT_INTERFACE!{static interface ISmartCardTriggerFactory(ISmartCardTriggerFactoryVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardTriggerFactory] { + #[cfg(feature="windows-devices")] fn Create(&self, triggerType: super::super::devices::smartcards::SmartCardTriggerType, out: *mut *mut SmartCardTrigger) -> HRESULT +}} +impl ISmartCardTriggerFactory { + #[cfg(feature="windows-devices")] #[inline] pub fn create(&self, triggerType: super::super::devices::smartcards::SmartCardTriggerType) -> Result> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).CommitAsync)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, triggerType, &mut out); if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_target_uri(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_TargetUri)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } - }} - #[inline] pub fn set_target_uri(&self, value: &foundation::Uri) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_TargetUri)(self as *const _ as *mut _, value as *const _ as *mut _); - if hr == S_OK { Ok(()) } else { err(hr) } - }} } -RT_CLASS!{class SocialDashboardItemUpdater: ISocialDashboardItemUpdater} -DEFINE_IID!(IID_ISocialFeedUpdater, 2047609511, 60809, 19413, 168, 217, 21, 244, 217, 134, 28, 16); -RT_INTERFACE!{interface ISocialFeedUpdater(ISocialFeedUpdaterVtbl): IInspectable(IInspectableVtbl) [IID_ISocialFeedUpdater] { - fn get_OwnerRemoteId(&self, out: *mut HSTRING) -> HRESULT, - fn get_Kind(&self, out: *mut super::SocialFeedKind) -> HRESULT, - fn get_Items(&self, out: *mut *mut foundation::collections::IVector) -> HRESULT, - fn CommitAsync(&self, out: *mut *mut foundation::IAsyncAction) -> HRESULT +RT_CLASS!{class SmsMessageReceivedTrigger: IBackgroundTrigger} +impl RtActivatable for SmsMessageReceivedTrigger {} +impl SmsMessageReceivedTrigger { + #[cfg(feature="windows-devices")] #[inline] pub fn create(filterRules: &super::super::devices::sms::SmsFilterRules) -> Result> { + >::get_activation_factory().create(filterRules) + } +} +DEFINE_CLSID!(SmsMessageReceivedTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,83,109,115,77,101,115,115,97,103,101,82,101,99,101,105,118,101,100,84,114,105,103,103,101,114,0]) [CLSID_SmsMessageReceivedTrigger]); +DEFINE_IID!(IID_ISmsMessageReceivedTriggerFactory, 3929725128, 27556, 19122, 141, 33, 188, 107, 9, 199, 117, 100); +RT_INTERFACE!{static interface ISmsMessageReceivedTriggerFactory(ISmsMessageReceivedTriggerFactoryVtbl): IInspectable(IInspectableVtbl) [IID_ISmsMessageReceivedTriggerFactory] { + #[cfg(feature="windows-devices")] fn Create(&self, filterRules: *mut super::super::devices::sms::SmsFilterRules, out: *mut *mut SmsMessageReceivedTrigger) -> HRESULT }} -impl ISocialFeedUpdater { - #[inline] pub fn get_owner_remote_id(&self) -> Result { unsafe { +impl ISmsMessageReceivedTriggerFactory { + #[cfg(feature="windows-devices")] #[inline] pub fn create(&self, filterRules: &super::super::devices::sms::SmsFilterRules) -> Result> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_OwnerRemoteId)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, filterRules as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_kind(&self) -> Result { unsafe { +} +DEFINE_IID!(IID_ISocketActivityTrigger, 2847668240, 40414, 20362, 131, 227, 176, 224, 231, 165, 13, 112); +RT_INTERFACE!{interface ISocketActivityTrigger(ISocketActivityTriggerVtbl): IInspectable(IInspectableVtbl) [IID_ISocketActivityTrigger] { + fn get_IsWakeFromLowPowerSupported(&self, out: *mut bool) -> HRESULT +}} +impl ISocketActivityTrigger { + #[inline] pub fn get_is_wake_from_low_power_supported(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_Kind)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_IsWakeFromLowPowerSupported)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_items(&self) -> Result>>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Items)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } - }} - #[inline] pub fn commit_async(&self) -> Result> { unsafe { +} +RT_CLASS!{class SocketActivityTrigger: IBackgroundTrigger} +impl RtActivatable for SocketActivityTrigger {} +DEFINE_CLSID!(SocketActivityTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,83,111,99,107,101,116,65,99,116,105,118,105,116,121,84,114,105,103,103,101,114,0]) [CLSID_SocketActivityTrigger]); +RT_CLASS!{class StorageLibraryChangeTrackerTrigger: IBackgroundTrigger} +impl RtActivatable for StorageLibraryChangeTrackerTrigger {} +impl StorageLibraryChangeTrackerTrigger { + #[cfg(feature="windows-storage")] #[inline] pub fn create(tracker: &super::super::storage::StorageLibraryChangeTracker) -> Result> { + >::get_activation_factory().create(tracker) + } +} +DEFINE_CLSID!(StorageLibraryChangeTrackerTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,83,116,111,114,97,103,101,76,105,98,114,97,114,121,67,104,97,110,103,101,84,114,97,99,107,101,114,84,114,105,103,103,101,114,0]) [CLSID_StorageLibraryChangeTrackerTrigger]); +DEFINE_IID!(IID_IStorageLibraryChangeTrackerTriggerFactory, 514916304, 23173, 18846, 168, 136, 130, 70, 7, 18, 79, 80); +RT_INTERFACE!{static interface IStorageLibraryChangeTrackerTriggerFactory(IStorageLibraryChangeTrackerTriggerFactoryVtbl): IInspectable(IInspectableVtbl) [IID_IStorageLibraryChangeTrackerTriggerFactory] { + #[cfg(feature="windows-storage")] fn Create(&self, tracker: *mut super::super::storage::StorageLibraryChangeTracker, out: *mut *mut StorageLibraryChangeTrackerTrigger) -> HRESULT +}} +impl IStorageLibraryChangeTrackerTriggerFactory { + #[cfg(feature="windows-storage")] #[inline] pub fn create(&self, tracker: &super::super::storage::StorageLibraryChangeTracker) -> Result> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).CommitAsync)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, tracker as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } -RT_CLASS!{class SocialFeedUpdater: ISocialFeedUpdater} -RT_CLASS!{static class SocialInfoProviderManager} -impl RtActivatable for SocialInfoProviderManager {} -impl SocialInfoProviderManager { - #[inline] pub fn create_social_feed_updater_async(kind: super::SocialFeedKind, mode: super::SocialFeedUpdateMode, ownerRemoteId: &HStringArg) -> Result>> { - >::get_activation_factory().create_social_feed_updater_async(kind, mode, ownerRemoteId) - } - #[inline] pub fn create_dashboard_item_updater_async(ownerRemoteId: &HStringArg) -> Result>> { - >::get_activation_factory().create_dashboard_item_updater_async(ownerRemoteId) - } - #[inline] pub fn update_badge_count_value(itemRemoteId: &HStringArg, newCount: i32) -> Result<()> { - >::get_activation_factory().update_badge_count_value(itemRemoteId, newCount) - } - #[inline] pub fn report_new_content_available(contactRemoteId: &HStringArg, kind: super::SocialFeedKind) -> Result<()> { - >::get_activation_factory().report_new_content_available(contactRemoteId, kind) - } - #[inline] pub fn provision_async() -> Result>> { - >::get_activation_factory().provision_async() +DEFINE_IID!(IID_IStorageLibraryContentChangedTrigger, 372760743, 33436, 17852, 146, 155, 161, 231, 234, 120, 216, 155); +RT_INTERFACE!{interface IStorageLibraryContentChangedTrigger(IStorageLibraryContentChangedTriggerVtbl): IInspectable(IInspectableVtbl) [IID_IStorageLibraryContentChangedTrigger] { + +}} +RT_CLASS!{class StorageLibraryContentChangedTrigger: IStorageLibraryContentChangedTrigger} +impl RtActivatable for StorageLibraryContentChangedTrigger {} +impl StorageLibraryContentChangedTrigger { + #[cfg(feature="windows-storage")] #[inline] pub fn create(storageLibrary: &super::super::storage::StorageLibrary) -> Result>> { + >::get_activation_factory().create(storageLibrary) } - #[inline] pub fn deprovision_async() -> Result> { - >::get_activation_factory().deprovision_async() + #[cfg(feature="windows-storage")] #[inline] pub fn create_from_libraries(storageLibraries: &foundation::collections::IIterable) -> Result>> { + >::get_activation_factory().create_from_libraries(storageLibraries) } } -DEFINE_CLSID!(SocialInfoProviderManager(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,83,111,99,105,97,108,73,110,102,111,46,80,114,111,118,105,100,101,114,46,83,111,99,105,97,108,73,110,102,111,80,114,111,118,105,100,101,114,77,97,110,97,103,101,114,0]) [CLSID_SocialInfoProviderManager]); -DEFINE_IID!(IID_ISocialInfoProviderManagerStatics, 461956395, 30599, 18646, 170, 18, 216, 232, 244, 122, 184, 90); -RT_INTERFACE!{static interface ISocialInfoProviderManagerStatics(ISocialInfoProviderManagerStaticsVtbl): IInspectable(IInspectableVtbl) [IID_ISocialInfoProviderManagerStatics] { - fn CreateSocialFeedUpdaterAsync(&self, kind: super::SocialFeedKind, mode: super::SocialFeedUpdateMode, ownerRemoteId: HSTRING, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, - fn CreateDashboardItemUpdaterAsync(&self, ownerRemoteId: HSTRING, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, - fn UpdateBadgeCountValue(&self, itemRemoteId: HSTRING, newCount: i32) -> HRESULT, - fn ReportNewContentAvailable(&self, contactRemoteId: HSTRING, kind: super::SocialFeedKind) -> HRESULT, - fn ProvisionAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, - fn DeprovisionAsync(&self, out: *mut *mut foundation::IAsyncAction) -> HRESULT +DEFINE_CLSID!(StorageLibraryContentChangedTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,83,116,111,114,97,103,101,76,105,98,114,97,114,121,67,111,110,116,101,110,116,67,104,97,110,103,101,100,84,114,105,103,103,101,114,0]) [CLSID_StorageLibraryContentChangedTrigger]); +DEFINE_IID!(IID_IStorageLibraryContentChangedTriggerStatics, 2141133625, 24464, 19986, 145, 78, 167, 216, 224, 187, 251, 24); +RT_INTERFACE!{static interface IStorageLibraryContentChangedTriggerStatics(IStorageLibraryContentChangedTriggerStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IStorageLibraryContentChangedTriggerStatics] { + #[cfg(feature="windows-storage")] fn Create(&self, storageLibrary: *mut super::super::storage::StorageLibrary, out: *mut *mut StorageLibraryContentChangedTrigger) -> HRESULT, + #[cfg(feature="windows-storage")] fn CreateFromLibraries(&self, storageLibraries: *mut foundation::collections::IIterable, out: *mut *mut StorageLibraryContentChangedTrigger) -> HRESULT }} -impl ISocialInfoProviderManagerStatics { - #[inline] pub fn create_social_feed_updater_async(&self, kind: super::SocialFeedKind, mode: super::SocialFeedUpdateMode, ownerRemoteId: &HStringArg) -> Result>> { unsafe { +impl IStorageLibraryContentChangedTriggerStatics { + #[cfg(feature="windows-storage")] #[inline] pub fn create(&self, storageLibrary: &super::super::storage::StorageLibrary) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).CreateSocialFeedUpdaterAsync)(self as *const _ as *mut _, kind, mode, ownerRemoteId.get(), &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, storageLibrary as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn create_dashboard_item_updater_async(&self, ownerRemoteId: &HStringArg) -> Result>> { unsafe { + #[cfg(feature="windows-storage")] #[inline] pub fn create_from_libraries(&self, storageLibraries: &foundation::collections::IIterable) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).CreateDashboardItemUpdaterAsync)(self as *const _ as *mut _, ownerRemoteId.get(), &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } - }} - #[inline] pub fn update_badge_count_value(&self, itemRemoteId: &HStringArg, newCount: i32) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).UpdateBadgeCountValue)(self as *const _ as *mut _, itemRemoteId.get(), newCount); - if hr == S_OK { Ok(()) } else { err(hr) } - }} - #[inline] pub fn report_new_content_available(&self, contactRemoteId: &HStringArg, kind: super::SocialFeedKind) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).ReportNewContentAvailable)(self as *const _ as *mut _, contactRemoteId.get(), kind); - if hr == S_OK { Ok(()) } else { err(hr) } + let hr = ((*self.lpVtbl).CreateFromLibraries)(self as *const _ as *mut _, storageLibraries as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn provision_async(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).ProvisionAsync)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } +} +DEFINE_IID!(IID_ISystemCondition, 3244274806, 35269, 16907, 171, 211, 251, 48, 48, 71, 33, 40); +RT_INTERFACE!{interface ISystemCondition(ISystemConditionVtbl): IInspectable(IInspectableVtbl) [IID_ISystemCondition] { + fn get_ConditionType(&self, out: *mut SystemConditionType) -> HRESULT +}} +impl ISystemCondition { + #[inline] pub fn get_condition_type(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_ConditionType)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn deprovision_async(&self) -> Result> { unsafe { +} +RT_CLASS!{class SystemCondition: ISystemCondition} +impl RtActivatable for SystemCondition {} +impl SystemCondition { + #[inline] pub fn create(conditionType: SystemConditionType) -> Result> { + >::get_activation_factory().create(conditionType) + } +} +DEFINE_CLSID!(SystemCondition(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,83,121,115,116,101,109,67,111,110,100,105,116,105,111,110,0]) [CLSID_SystemCondition]); +DEFINE_IID!(IID_ISystemConditionFactory, 3530150385, 1447, 18862, 135, 215, 22, 178, 184, 185, 165, 83); +RT_INTERFACE!{static interface ISystemConditionFactory(ISystemConditionFactoryVtbl): IInspectable(IInspectableVtbl) [IID_ISystemConditionFactory] { + fn Create(&self, conditionType: SystemConditionType, out: *mut *mut SystemCondition) -> HRESULT +}} +impl ISystemConditionFactory { + #[inline] pub fn create(&self, conditionType: SystemConditionType) -> Result> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).DeprovisionAsync)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, conditionType, &mut out); if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } -} // Windows.ApplicationModel.SocialInfo.Provider -} // Windows.ApplicationModel.SocialInfo -pub mod search { // Windows.ApplicationModel.Search -use ::prelude::*; -DEFINE_IID!(IID_ILocalContentSuggestionSettings, 4004425826, 29757, 17774, 132, 163, 35, 240, 111, 45, 21, 215); -RT_INTERFACE!{interface ILocalContentSuggestionSettings(ILocalContentSuggestionSettingsVtbl): IInspectable(IInspectableVtbl) [IID_ILocalContentSuggestionSettings] { - fn put_Enabled(&self, value: bool) -> HRESULT, - fn get_Enabled(&self, out: *mut bool) -> HRESULT, - #[cfg(not(feature="windows-storage"))] fn __Dummy2(&self) -> (), - #[cfg(feature="windows-storage")] fn get_Locations(&self, out: *mut *mut foundation::collections::IVector) -> HRESULT, - fn put_AqsFilter(&self, value: HSTRING) -> HRESULT, - fn get_AqsFilter(&self, out: *mut HSTRING) -> HRESULT, - fn get_PropertiesToMatch(&self, out: *mut *mut foundation::collections::IVector) -> HRESULT +RT_ENUM! { enum SystemConditionType: i32 { + Invalid (SystemConditionType_Invalid) = 0, UserPresent (SystemConditionType_UserPresent) = 1, UserNotPresent (SystemConditionType_UserNotPresent) = 2, InternetAvailable (SystemConditionType_InternetAvailable) = 3, InternetNotAvailable (SystemConditionType_InternetNotAvailable) = 4, SessionConnected (SystemConditionType_SessionConnected) = 5, SessionDisconnected (SystemConditionType_SessionDisconnected) = 6, FreeNetworkAvailable (SystemConditionType_FreeNetworkAvailable) = 7, BackgroundWorkCostNotHigh (SystemConditionType_BackgroundWorkCostNotHigh) = 8, }} -impl ILocalContentSuggestionSettings { - #[inline] pub fn set_enabled(&self, value: bool) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_Enabled)(self as *const _ as *mut _, value); - if hr == S_OK { Ok(()) } else { err(hr) } +DEFINE_IID!(IID_ISystemTrigger, 494978934, 14152, 17507, 141, 126, 39, 109, 193, 57, 172, 28); +RT_INTERFACE!{interface ISystemTrigger(ISystemTriggerVtbl): IInspectable(IInspectableVtbl) [IID_ISystemTrigger] { + fn get_OneShot(&self, out: *mut bool) -> HRESULT, + fn get_TriggerType(&self, out: *mut SystemTriggerType) -> HRESULT +}} +impl ISystemTrigger { + #[inline] pub fn get_one_shot(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_OneShot)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_enabled(&self) -> Result { unsafe { + #[inline] pub fn get_trigger_type(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_Enabled)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_TriggerType)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[cfg(feature="windows-storage")] #[inline] pub fn get_locations(&self) -> Result>>> { unsafe { +} +RT_CLASS!{class SystemTrigger: ISystemTrigger} +impl RtActivatable for SystemTrigger {} +impl SystemTrigger { + #[inline] pub fn create(triggerType: SystemTriggerType, oneShot: bool) -> Result> { + >::get_activation_factory().create(triggerType, oneShot) + } +} +DEFINE_CLSID!(SystemTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,83,121,115,116,101,109,84,114,105,103,103,101,114,0]) [CLSID_SystemTrigger]); +DEFINE_IID!(IID_ISystemTriggerFactory, 3892585428, 34705, 17785, 129, 38, 135, 236, 138, 170, 64, 122); +RT_INTERFACE!{static interface ISystemTriggerFactory(ISystemTriggerFactoryVtbl): IInspectable(IInspectableVtbl) [IID_ISystemTriggerFactory] { + fn Create(&self, triggerType: SystemTriggerType, oneShot: bool, out: *mut *mut SystemTrigger) -> HRESULT +}} +impl ISystemTriggerFactory { + #[inline] pub fn create(&self, triggerType: SystemTriggerType, oneShot: bool) -> Result> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Locations)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, triggerType, oneShot, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn set_aqs_filter(&self, value: &HStringArg) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_AqsFilter)(self as *const _ as *mut _, value.get()); - if hr == S_OK { Ok(()) } else { err(hr) } +} +RT_ENUM! { enum SystemTriggerType: i32 { + Invalid (SystemTriggerType_Invalid) = 0, SmsReceived (SystemTriggerType_SmsReceived) = 1, UserPresent (SystemTriggerType_UserPresent) = 2, UserAway (SystemTriggerType_UserAway) = 3, NetworkStateChange (SystemTriggerType_NetworkStateChange) = 4, ControlChannelReset (SystemTriggerType_ControlChannelReset) = 5, InternetAvailable (SystemTriggerType_InternetAvailable) = 6, SessionConnected (SystemTriggerType_SessionConnected) = 7, ServicingComplete (SystemTriggerType_ServicingComplete) = 8, LockScreenApplicationAdded (SystemTriggerType_LockScreenApplicationAdded) = 9, LockScreenApplicationRemoved (SystemTriggerType_LockScreenApplicationRemoved) = 10, TimeZoneChange (SystemTriggerType_TimeZoneChange) = 11, OnlineIdConnectedStateChange (SystemTriggerType_OnlineIdConnectedStateChange) = 12, BackgroundWorkCostChange (SystemTriggerType_BackgroundWorkCostChange) = 13, PowerStateChange (SystemTriggerType_PowerStateChange) = 14, DefaultSignInAccountChange (SystemTriggerType_DefaultSignInAccountChange) = 15, +}} +RT_CLASS!{class TetheringEntitlementCheckTrigger: IBackgroundTrigger} +impl RtActivatable for TetheringEntitlementCheckTrigger {} +DEFINE_CLSID!(TetheringEntitlementCheckTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,84,101,116,104,101,114,105,110,103,69,110,116,105,116,108,101,109,101,110,116,67,104,101,99,107,84,114,105,103,103,101,114,0]) [CLSID_TetheringEntitlementCheckTrigger]); +DEFINE_IID!(IID_ITimeTrigger, 1701729622, 2858, 17271, 186, 112, 59, 69, 169, 53, 84, 127); +RT_INTERFACE!{interface ITimeTrigger(ITimeTriggerVtbl): IInspectable(IInspectableVtbl) [IID_ITimeTrigger] { + fn get_FreshnessTime(&self, out: *mut u32) -> HRESULT, + fn get_OneShot(&self, out: *mut bool) -> HRESULT +}} +impl ITimeTrigger { + #[inline] pub fn get_freshness_time(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_FreshnessTime)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_aqs_filter(&self) -> Result { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_AqsFilter)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + #[inline] pub fn get_one_shot(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_OneShot)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_properties_to_match(&self) -> Result>>> { unsafe { +} +RT_CLASS!{class TimeTrigger: ITimeTrigger} +impl RtActivatable for TimeTrigger {} +impl TimeTrigger { + #[inline] pub fn create(freshnessTime: u32, oneShot: bool) -> Result> { + >::get_activation_factory().create(freshnessTime, oneShot) + } +} +DEFINE_CLSID!(TimeTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,84,105,109,101,84,114,105,103,103,101,114,0]) [CLSID_TimeTrigger]); +DEFINE_IID!(IID_ITimeTriggerFactory, 952533758, 39764, 17894, 178, 243, 38, 155, 135, 166, 247, 52); +RT_INTERFACE!{static interface ITimeTriggerFactory(ITimeTriggerFactoryVtbl): IInspectable(IInspectableVtbl) [IID_ITimeTriggerFactory] { + fn Create(&self, freshnessTime: u32, oneShot: bool, out: *mut *mut TimeTrigger) -> HRESULT +}} +impl ITimeTriggerFactory { + #[inline] pub fn create(&self, freshnessTime: u32, oneShot: bool) -> Result> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_PropertiesToMatch)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, freshnessTime, oneShot, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } -RT_CLASS!{class LocalContentSuggestionSettings: ILocalContentSuggestionSettings} -impl RtActivatable for LocalContentSuggestionSettings {} -DEFINE_CLSID!(LocalContentSuggestionSettings(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,83,101,97,114,99,104,46,76,111,99,97,108,67,111,110,116,101,110,116,83,117,103,103,101,115,116,105,111,110,83,101,116,116,105,110,103,115,0]) [CLSID_LocalContentSuggestionSettings]); -DEFINE_IID!(IID_ISearchPane, 4255968312, 14080, 19827, 145, 161, 47, 153, 134, 116, 35, 138); -RT_INTERFACE!{interface ISearchPane(ISearchPaneVtbl): IInspectable(IInspectableVtbl) [IID_ISearchPane] { - fn put_SearchHistoryEnabled(&self, value: bool) -> HRESULT, - fn get_SearchHistoryEnabled(&self, out: *mut bool) -> HRESULT, - fn put_SearchHistoryContext(&self, value: HSTRING) -> HRESULT, - fn get_SearchHistoryContext(&self, out: *mut HSTRING) -> HRESULT, - fn put_PlaceholderText(&self, value: HSTRING) -> HRESULT, - fn get_PlaceholderText(&self, out: *mut HSTRING) -> HRESULT, - fn get_QueryText(&self, out: *mut HSTRING) -> HRESULT, - fn get_Language(&self, out: *mut HSTRING) -> HRESULT, - fn get_Visible(&self, out: *mut bool) -> HRESULT, - fn add_VisibilityChanged(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, - fn remove_VisibilityChanged(&self, token: foundation::EventRegistrationToken) -> HRESULT, - fn add_QueryChanged(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, - fn remove_QueryChanged(&self, token: foundation::EventRegistrationToken) -> HRESULT, - fn add_SuggestionsRequested(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, - fn remove_SuggestionsRequested(&self, token: foundation::EventRegistrationToken) -> HRESULT, - fn add_QuerySubmitted(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, - fn remove_QuerySubmitted(&self, token: foundation::EventRegistrationToken) -> HRESULT, - fn add_ResultSuggestionChosen(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, - fn remove_ResultSuggestionChosen(&self, token: foundation::EventRegistrationToken) -> HRESULT, - fn SetLocalContentSuggestionSettings(&self, settings: *mut LocalContentSuggestionSettings) -> HRESULT, - fn ShowOverloadDefault(&self) -> HRESULT, - fn ShowOverloadWithQuery(&self, query: HSTRING) -> HRESULT, - fn put_ShowOnKeyboardInput(&self, value: bool) -> HRESULT, - fn get_ShowOnKeyboardInput(&self, out: *mut bool) -> HRESULT, - fn TrySetQueryText(&self, query: HSTRING, out: *mut bool) -> HRESULT +RT_CLASS!{class ToastNotificationActionTrigger: IBackgroundTrigger} +impl RtActivatable for ToastNotificationActionTrigger {} +impl RtActivatable for ToastNotificationActionTrigger {} +impl ToastNotificationActionTrigger { + #[inline] pub fn create(applicationId: &HStringArg) -> Result> { + >::get_activation_factory().create(applicationId) + } +} +DEFINE_CLSID!(ToastNotificationActionTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,84,111,97,115,116,78,111,116,105,102,105,99,97,116,105,111,110,65,99,116,105,111,110,84,114,105,103,103,101,114,0]) [CLSID_ToastNotificationActionTrigger]); +DEFINE_IID!(IID_IToastNotificationActionTriggerFactory, 2963143719, 25728, 17225, 129, 37, 151, 179, 239, 170, 10, 58); +RT_INTERFACE!{static interface IToastNotificationActionTriggerFactory(IToastNotificationActionTriggerFactoryVtbl): IInspectable(IInspectableVtbl) [IID_IToastNotificationActionTriggerFactory] { + fn Create(&self, applicationId: HSTRING, out: *mut *mut ToastNotificationActionTrigger) -> HRESULT }} -impl ISearchPane { - #[inline] pub fn set_search_history_enabled(&self, value: bool) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_SearchHistoryEnabled)(self as *const _ as *mut _, value); - if hr == S_OK { Ok(()) } else { err(hr) } - }} - #[inline] pub fn get_search_history_enabled(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_SearchHistoryEnabled)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } - }} - #[inline] pub fn set_search_history_context(&self, value: &HStringArg) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_SearchHistoryContext)(self as *const _ as *mut _, value.get()); - if hr == S_OK { Ok(()) } else { err(hr) } - }} - #[inline] pub fn get_search_history_context(&self) -> Result { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_SearchHistoryContext)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } - }} - #[inline] pub fn set_placeholder_text(&self, value: &HStringArg) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_PlaceholderText)(self as *const _ as *mut _, value.get()); - if hr == S_OK { Ok(()) } else { err(hr) } - }} - #[inline] pub fn get_placeholder_text(&self) -> Result { unsafe { +impl IToastNotificationActionTriggerFactory { + #[inline] pub fn create(&self, applicationId: &HStringArg) -> Result> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_PlaceholderText)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, applicationId.get(), &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_query_text(&self) -> Result { unsafe { +} +RT_CLASS!{class ToastNotificationHistoryChangedTrigger: IBackgroundTrigger} +impl RtActivatable for ToastNotificationHistoryChangedTrigger {} +impl RtActivatable for ToastNotificationHistoryChangedTrigger {} +impl ToastNotificationHistoryChangedTrigger { + #[inline] pub fn create(applicationId: &HStringArg) -> Result> { + >::get_activation_factory().create(applicationId) + } +} +DEFINE_CLSID!(ToastNotificationHistoryChangedTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,84,111,97,115,116,78,111,116,105,102,105,99,97,116,105,111,110,72,105,115,116,111,114,121,67,104,97,110,103,101,100,84,114,105,103,103,101,114,0]) [CLSID_ToastNotificationHistoryChangedTrigger]); +DEFINE_IID!(IID_IToastNotificationHistoryChangedTriggerFactory, 2177301165, 34711, 18309, 129, 180, 176, 204, 203, 115, 209, 217); +RT_INTERFACE!{static interface IToastNotificationHistoryChangedTriggerFactory(IToastNotificationHistoryChangedTriggerFactoryVtbl): IInspectable(IInspectableVtbl) [IID_IToastNotificationHistoryChangedTriggerFactory] { + fn Create(&self, applicationId: HSTRING, out: *mut *mut ToastNotificationHistoryChangedTrigger) -> HRESULT +}} +impl IToastNotificationHistoryChangedTriggerFactory { + #[inline] pub fn create(&self, applicationId: &HStringArg) -> Result> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_QueryText)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, applicationId.get(), &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_language(&self) -> Result { unsafe { +} +RT_CLASS!{class UserNotificationChangedTrigger: IBackgroundTrigger} +impl RtActivatable for UserNotificationChangedTrigger {} +impl UserNotificationChangedTrigger { + #[cfg(feature="windows-ui")] #[inline] pub fn create(notificationKinds: super::super::ui::notifications::NotificationKinds) -> Result> { + >::get_activation_factory().create(notificationKinds) + } +} +DEFINE_CLSID!(UserNotificationChangedTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,85,115,101,114,78,111,116,105,102,105,99,97,116,105,111,110,67,104,97,110,103,101,100,84,114,105,103,103,101,114,0]) [CLSID_UserNotificationChangedTrigger]); +DEFINE_IID!(IID_IUserNotificationChangedTriggerFactory, 3402908524, 27051, 19992, 164, 138, 94, 210, 172, 67, 89, 87); +RT_INTERFACE!{static interface IUserNotificationChangedTriggerFactory(IUserNotificationChangedTriggerFactoryVtbl): IInspectable(IInspectableVtbl) [IID_IUserNotificationChangedTriggerFactory] { + #[cfg(feature="windows-ui")] fn Create(&self, notificationKinds: super::super::ui::notifications::NotificationKinds, out: *mut *mut UserNotificationChangedTrigger) -> HRESULT +}} +impl IUserNotificationChangedTriggerFactory { + #[cfg(feature="windows-ui")] #[inline] pub fn create(&self, notificationKinds: super::super::ui::notifications::NotificationKinds) -> Result> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Language)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, notificationKinds, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_visible(&self) -> Result { unsafe { +} +} // Windows.ApplicationModel.Background +pub mod calls { // Windows.ApplicationModel.Calls +use ::prelude::*; +DEFINE_IID!(IID_ICallAnswerEventArgs, 4252538391, 11735, 19596, 178, 189, 149, 209, 122, 91, 183, 51); +RT_INTERFACE!{interface ICallAnswerEventArgs(ICallAnswerEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_ICallAnswerEventArgs] { + fn get_AcceptedMedia(&self, out: *mut VoipPhoneCallMedia) -> HRESULT +}} +impl ICallAnswerEventArgs { + #[inline] pub fn get_accepted_media(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_Visible)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_AcceptedMedia)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn add_visibility_changed(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { +} +RT_CLASS!{class CallAnswerEventArgs: ICallAnswerEventArgs} +DEFINE_IID!(IID_ICallRejectEventArgs, 3662150359, 5076, 19858, 161, 194, 183, 120, 17, 238, 55, 236); +RT_INTERFACE!{interface ICallRejectEventArgs(ICallRejectEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_ICallRejectEventArgs] { + fn get_RejectReason(&self, out: *mut VoipPhoneCallRejectReason) -> HRESULT +}} +impl ICallRejectEventArgs { + #[inline] pub fn get_reject_reason(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).add_VisibilityChanged)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_RejectReason)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn remove_visibility_changed(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).remove_VisibilityChanged)(self as *const _ as *mut _, token); - if hr == S_OK { Ok(()) } else { err(hr) } - }} - #[inline] pub fn add_query_changed(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { +} +RT_CLASS!{class CallRejectEventArgs: ICallRejectEventArgs} +DEFINE_IID!(IID_ICallStateChangeEventArgs, 3937547422, 26357, 18425, 159, 181, 69, 156, 81, 152, 199, 32); +RT_INTERFACE!{interface ICallStateChangeEventArgs(ICallStateChangeEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_ICallStateChangeEventArgs] { + fn get_State(&self, out: *mut VoipPhoneCallState) -> HRESULT +}} +impl ICallStateChangeEventArgs { + #[inline] pub fn get_state(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).add_QueryChanged)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_State)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn remove_query_changed(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).remove_QueryChanged)(self as *const _ as *mut _, token); +} +RT_CLASS!{class CallStateChangeEventArgs: ICallStateChangeEventArgs} +DEFINE_IID!(IID_ILockScreenCallEndCallDeferral, 769125645, 39149, 16449, 150, 50, 80, 255, 129, 43, 119, 63); +RT_INTERFACE!{interface ILockScreenCallEndCallDeferral(ILockScreenCallEndCallDeferralVtbl): IInspectable(IInspectableVtbl) [IID_ILockScreenCallEndCallDeferral] { + fn Complete(&self) -> HRESULT +}} +impl ILockScreenCallEndCallDeferral { + #[inline] pub fn complete(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).Complete)(self as *const _ as *mut _); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn add_suggestions_requested(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { +} +RT_CLASS!{class LockScreenCallEndCallDeferral: ILockScreenCallEndCallDeferral} +DEFINE_IID!(IID_ILockScreenCallEndRequestedEventArgs, 2173739875, 28455, 18153, 174, 182, 192, 174, 131, 228, 125, 199); +RT_INTERFACE!{interface ILockScreenCallEndRequestedEventArgs(ILockScreenCallEndRequestedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_ILockScreenCallEndRequestedEventArgs] { + fn GetDeferral(&self, out: *mut *mut LockScreenCallEndCallDeferral) -> HRESULT, + fn get_Deadline(&self, out: *mut foundation::DateTime) -> HRESULT +}} +impl ILockScreenCallEndRequestedEventArgs { + #[inline] pub fn get_deferral(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetDeferral)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_deadline(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).add_SuggestionsRequested)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_Deadline)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn remove_suggestions_requested(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).remove_SuggestionsRequested)(self as *const _ as *mut _, token); +} +RT_CLASS!{class LockScreenCallEndRequestedEventArgs: ILockScreenCallEndRequestedEventArgs} +DEFINE_IID!(IID_ILockScreenCallUI, 3315006861, 29641, 18964, 176, 33, 236, 28, 80, 163, 183, 39); +RT_INTERFACE!{interface ILockScreenCallUI(ILockScreenCallUIVtbl): IInspectable(IInspectableVtbl) [IID_ILockScreenCallUI] { + fn Dismiss(&self) -> HRESULT, + fn add_EndRequested(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_EndRequested(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn add_Closed(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_Closed(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn get_CallTitle(&self, out: *mut HSTRING) -> HRESULT, + fn put_CallTitle(&self, value: HSTRING) -> HRESULT +}} +impl ILockScreenCallUI { + #[inline] pub fn dismiss(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).Dismiss)(self as *const _ as *mut _); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn add_query_submitted(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + #[inline] pub fn add_end_requested(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).add_QuerySubmitted)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).add_EndRequested)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn remove_query_submitted(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).remove_QuerySubmitted)(self as *const _ as *mut _, token); + #[inline] pub fn remove_end_requested(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_EndRequested)(self as *const _ as *mut _, token); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn add_result_suggestion_chosen(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + #[inline] pub fn add_closed(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).add_ResultSuggestionChosen)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).add_Closed)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn remove_result_suggestion_chosen(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).remove_ResultSuggestionChosen)(self as *const _ as *mut _, token); - if hr == S_OK { Ok(()) } else { err(hr) } - }} - #[inline] pub fn set_local_content_suggestion_settings(&self, settings: &LocalContentSuggestionSettings) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).SetLocalContentSuggestionSettings)(self as *const _ as *mut _, settings as *const _ as *mut _); - if hr == S_OK { Ok(()) } else { err(hr) } - }} - #[inline] pub fn show_overload_default(&self) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).ShowOverloadDefault)(self as *const _ as *mut _); + #[inline] pub fn remove_closed(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_Closed)(self as *const _ as *mut _, token); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn show_overload_with_query(&self, query: &HStringArg) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).ShowOverloadWithQuery)(self as *const _ as *mut _, query.get()); - if hr == S_OK { Ok(()) } else { err(hr) } + #[inline] pub fn get_call_title(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_CallTitle)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} - #[inline] pub fn set_show_on_keyboard_input(&self, value: bool) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_ShowOnKeyboardInput)(self as *const _ as *mut _, value); + #[inline] pub fn set_call_title(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_CallTitle)(self as *const _ as *mut _, value.get()); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_show_on_keyboard_input(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_ShowOnKeyboardInput)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } - }} - #[inline] pub fn try_set_query_text(&self, query: &HStringArg) -> Result { unsafe { +} +RT_CLASS!{class LockScreenCallUI: ILockScreenCallUI} +DEFINE_IID!(IID_IMuteChangeEventArgs, 2240143705, 3137, 17196, 129, 77, 197, 241, 253, 245, 48, 190); +RT_INTERFACE!{interface IMuteChangeEventArgs(IMuteChangeEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IMuteChangeEventArgs] { + fn get_Muted(&self, out: *mut bool) -> HRESULT +}} +impl IMuteChangeEventArgs { + #[inline] pub fn get_muted(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).TrySetQueryText)(self as *const _ as *mut _, query.get(), &mut out); + let hr = ((*self.lpVtbl).get_Muted)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} } -RT_CLASS!{class SearchPane: ISearchPane} -impl RtActivatable for SearchPane {} -impl RtActivatable for SearchPane {} -impl SearchPane { - #[inline] pub fn get_for_current_view() -> Result>> { - >::get_activation_factory().get_for_current_view() - } - #[inline] pub fn hide_this_application() -> Result<()> { - >::get_activation_factory().hide_this_application() - } -} -DEFINE_CLSID!(SearchPane(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,83,101,97,114,99,104,46,83,101,97,114,99,104,80,97,110,101,0]) [CLSID_SearchPane]); -DEFINE_IID!(IID_ISearchPaneQueryChangedEventArgs, 1007046633, 9041, 16968, 165, 41, 113, 16, 244, 100, 167, 133); -RT_INTERFACE!{interface ISearchPaneQueryChangedEventArgs(ISearchPaneQueryChangedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_ISearchPaneQueryChangedEventArgs] { - fn get_QueryText(&self, out: *mut HSTRING) -> HRESULT, - fn get_Language(&self, out: *mut HSTRING) -> HRESULT, - fn get_LinguisticDetails(&self, out: *mut *mut SearchPaneQueryLinguisticDetails) -> HRESULT -}} -impl ISearchPaneQueryChangedEventArgs { - #[inline] pub fn get_query_text(&self) -> Result { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_QueryText)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } - }} - #[inline] pub fn get_language(&self) -> Result { unsafe { +RT_CLASS!{class MuteChangeEventArgs: IMuteChangeEventArgs} +DEFINE_IID!(IID_IPhoneCallHistoryEntry, 4205895977, 12964, 19333, 131, 209, 249, 13, 140, 35, 168, 87); +RT_INTERFACE!{interface IPhoneCallHistoryEntry(IPhoneCallHistoryEntryVtbl): IInspectable(IInspectableVtbl) [IID_IPhoneCallHistoryEntry] { + fn get_Id(&self, out: *mut HSTRING) -> HRESULT, + fn get_Address(&self, out: *mut *mut PhoneCallHistoryEntryAddress) -> HRESULT, + fn put_Address(&self, value: *mut PhoneCallHistoryEntryAddress) -> HRESULT, + fn get_Duration(&self, out: *mut *mut foundation::IReference) -> HRESULT, + fn put_Duration(&self, value: *mut foundation::IReference) -> HRESULT, + fn get_IsCallerIdBlocked(&self, out: *mut bool) -> HRESULT, + fn put_IsCallerIdBlocked(&self, value: bool) -> HRESULT, + fn get_IsEmergency(&self, out: *mut bool) -> HRESULT, + fn put_IsEmergency(&self, value: bool) -> HRESULT, + fn get_IsIncoming(&self, out: *mut bool) -> HRESULT, + fn put_IsIncoming(&self, value: bool) -> HRESULT, + fn get_IsMissed(&self, out: *mut bool) -> HRESULT, + fn put_IsMissed(&self, value: bool) -> HRESULT, + fn get_IsRinging(&self, out: *mut bool) -> HRESULT, + fn put_IsRinging(&self, value: bool) -> HRESULT, + fn get_IsSeen(&self, out: *mut bool) -> HRESULT, + fn put_IsSeen(&self, value: bool) -> HRESULT, + fn get_IsSuppressed(&self, out: *mut bool) -> HRESULT, + fn put_IsSuppressed(&self, value: bool) -> HRESULT, + fn get_IsVoicemail(&self, out: *mut bool) -> HRESULT, + fn put_IsVoicemail(&self, value: bool) -> HRESULT, + fn get_Media(&self, out: *mut PhoneCallHistoryEntryMedia) -> HRESULT, + fn put_Media(&self, value: PhoneCallHistoryEntryMedia) -> HRESULT, + fn get_OtherAppReadAccess(&self, out: *mut PhoneCallHistoryEntryOtherAppReadAccess) -> HRESULT, + fn put_OtherAppReadAccess(&self, value: PhoneCallHistoryEntryOtherAppReadAccess) -> HRESULT, + fn get_RemoteId(&self, out: *mut HSTRING) -> HRESULT, + fn put_RemoteId(&self, value: HSTRING) -> HRESULT, + fn get_SourceDisplayName(&self, out: *mut HSTRING) -> HRESULT, + fn get_SourceId(&self, out: *mut HSTRING) -> HRESULT, + fn put_SourceId(&self, value: HSTRING) -> HRESULT, + fn get_SourceIdKind(&self, out: *mut PhoneCallHistorySourceIdKind) -> HRESULT, + fn put_SourceIdKind(&self, value: PhoneCallHistorySourceIdKind) -> HRESULT, + fn get_StartTime(&self, out: *mut foundation::DateTime) -> HRESULT, + fn put_StartTime(&self, value: foundation::DateTime) -> HRESULT +}} +impl IPhoneCallHistoryEntry { + #[inline] pub fn get_id(&self) -> Result { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Language)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_Id)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_linguistic_details(&self) -> Result>> { unsafe { + #[inline] pub fn get_address(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_LinguisticDetails)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_Address)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} -} -RT_CLASS!{class SearchPaneQueryChangedEventArgs: ISearchPaneQueryChangedEventArgs} -DEFINE_IID!(IID_ISearchPaneQueryLinguisticDetails, 2197505550, 2368, 19309, 184, 208, 100, 43, 48, 152, 158, 21); -RT_INTERFACE!{interface ISearchPaneQueryLinguisticDetails(ISearchPaneQueryLinguisticDetailsVtbl): IInspectable(IInspectableVtbl) [IID_ISearchPaneQueryLinguisticDetails] { - fn get_QueryTextAlternatives(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT, - fn get_QueryTextCompositionStart(&self, out: *mut u32) -> HRESULT, - fn get_QueryTextCompositionLength(&self, out: *mut u32) -> HRESULT -}} -impl ISearchPaneQueryLinguisticDetails { - #[inline] pub fn get_query_text_alternatives(&self) -> Result>>> { unsafe { + #[inline] pub fn set_address(&self, value: &PhoneCallHistoryEntryAddress) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Address)(self as *const _ as *mut _, value as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_duration(&self) -> Result>>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_QueryTextAlternatives)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_Duration)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn get_query_text_composition_start(&self) -> Result { unsafe { + #[inline] pub fn set_duration(&self, value: &foundation::IReference) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Duration)(self as *const _ as *mut _, value as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_is_caller_id_blocked(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_QueryTextCompositionStart)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_IsCallerIdBlocked)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_query_text_composition_length(&self) -> Result { unsafe { + #[inline] pub fn set_is_caller_id_blocked(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_IsCallerIdBlocked)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_is_emergency(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_QueryTextCompositionLength)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_IsEmergency)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} -} -RT_CLASS!{class SearchPaneQueryLinguisticDetails: ISearchPaneQueryLinguisticDetails} -DEFINE_IID!(IID_ISearchPaneQuerySubmittedEventArgs, 339453180, 59845, 18230, 145, 178, 232, 235, 156, 184, 131, 86); -RT_INTERFACE!{interface ISearchPaneQuerySubmittedEventArgs(ISearchPaneQuerySubmittedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_ISearchPaneQuerySubmittedEventArgs] { - fn get_QueryText(&self, out: *mut HSTRING) -> HRESULT, - fn get_Language(&self, out: *mut HSTRING) -> HRESULT -}} -impl ISearchPaneQuerySubmittedEventArgs { - #[inline] pub fn get_query_text(&self) -> Result { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_QueryText)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } - }} - #[inline] pub fn get_language(&self) -> Result { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Language)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + #[inline] pub fn set_is_emergency(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_IsEmergency)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } }} -} -RT_CLASS!{class SearchPaneQuerySubmittedEventArgs: ISearchPaneQuerySubmittedEventArgs} -DEFINE_IID!(IID_ISearchPaneQuerySubmittedEventArgsWithLinguisticDetails, 1175229157, 19506, 17720, 164, 212, 182, 180, 64, 13, 20, 15); -RT_INTERFACE!{interface ISearchPaneQuerySubmittedEventArgsWithLinguisticDetails(ISearchPaneQuerySubmittedEventArgsWithLinguisticDetailsVtbl): IInspectable(IInspectableVtbl) [IID_ISearchPaneQuerySubmittedEventArgsWithLinguisticDetails] { - fn get_LinguisticDetails(&self, out: *mut *mut SearchPaneQueryLinguisticDetails) -> HRESULT -}} -impl ISearchPaneQuerySubmittedEventArgsWithLinguisticDetails { - #[inline] pub fn get_linguistic_details(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_LinguisticDetails)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + #[inline] pub fn get_is_incoming(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_IsIncoming)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} -} -DEFINE_IID!(IID_ISearchPaneResultSuggestionChosenEventArgs, 3358682304, 44754, 16864, 188, 224, 194, 108, 167, 79, 133, 236); -RT_INTERFACE!{interface ISearchPaneResultSuggestionChosenEventArgs(ISearchPaneResultSuggestionChosenEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_ISearchPaneResultSuggestionChosenEventArgs] { - fn get_Tag(&self, out: *mut HSTRING) -> HRESULT -}} -impl ISearchPaneResultSuggestionChosenEventArgs { - #[inline] pub fn get_tag(&self) -> Result { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Tag)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + #[inline] pub fn set_is_incoming(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_IsIncoming)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } }} -} -RT_CLASS!{class SearchPaneResultSuggestionChosenEventArgs: ISearchPaneResultSuggestionChosenEventArgs} -DEFINE_IID!(IID_ISearchPaneStatics, 2507320817, 36637, 18463, 161, 91, 198, 22, 85, 241, 106, 14); -RT_INTERFACE!{static interface ISearchPaneStatics(ISearchPaneStaticsVtbl): IInspectable(IInspectableVtbl) [IID_ISearchPaneStatics] { - fn GetForCurrentView(&self, out: *mut *mut SearchPane) -> HRESULT -}} -impl ISearchPaneStatics { - #[inline] pub fn get_for_current_view(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetForCurrentView)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + #[inline] pub fn get_is_missed(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_IsMissed)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} -} -DEFINE_IID!(IID_ISearchPaneStaticsWithHideThisApplication, 7546928, 20721, 19715, 153, 172, 198, 100, 76, 142, 216, 181); -RT_INTERFACE!{static interface ISearchPaneStaticsWithHideThisApplication(ISearchPaneStaticsWithHideThisApplicationVtbl): IInspectable(IInspectableVtbl) [IID_ISearchPaneStaticsWithHideThisApplication] { - fn HideThisApplication(&self) -> HRESULT -}} -impl ISearchPaneStaticsWithHideThisApplication { - #[inline] pub fn hide_this_application(&self) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).HideThisApplication)(self as *const _ as *mut _); + #[inline] pub fn set_is_missed(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_IsMissed)(self as *const _ as *mut _, value); if hr == S_OK { Ok(()) } else { err(hr) } }} -} -DEFINE_IID!(IID_ISearchPaneSuggestionsRequest, 2175863580, 58721, 16531, 155, 77, 42, 212, 130, 121, 74, 83); -RT_INTERFACE!{interface ISearchPaneSuggestionsRequest(ISearchPaneSuggestionsRequestVtbl): IInspectable(IInspectableVtbl) [IID_ISearchPaneSuggestionsRequest] { - fn get_IsCanceled(&self, out: *mut bool) -> HRESULT, - fn get_SearchSuggestionCollection(&self, out: *mut *mut SearchSuggestionCollection) -> HRESULT, - fn GetDeferral(&self, out: *mut *mut SearchPaneSuggestionsRequestDeferral) -> HRESULT -}} -impl ISearchPaneSuggestionsRequest { - #[inline] pub fn get_is_canceled(&self) -> Result { unsafe { + #[inline] pub fn get_is_ringing(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_IsCanceled)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_IsRinging)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_search_suggestion_collection(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_SearchSuggestionCollection)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + #[inline] pub fn set_is_ringing(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_IsRinging)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_deferral(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetDeferral)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + #[inline] pub fn get_is_seen(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_IsSeen)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} -} -RT_CLASS!{class SearchPaneSuggestionsRequest: ISearchPaneSuggestionsRequest} -DEFINE_IID!(IID_ISearchPaneSuggestionsRequestDeferral, 2697988599, 34632, 20194, 173, 68, 175, 166, 190, 153, 124, 81); -RT_INTERFACE!{interface ISearchPaneSuggestionsRequestDeferral(ISearchPaneSuggestionsRequestDeferralVtbl): IInspectable(IInspectableVtbl) [IID_ISearchPaneSuggestionsRequestDeferral] { - fn Complete(&self) -> HRESULT -}} -impl ISearchPaneSuggestionsRequestDeferral { - #[inline] pub fn complete(&self) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).Complete)(self as *const _ as *mut _); + #[inline] pub fn set_is_seen(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_IsSeen)(self as *const _ as *mut _, value); if hr == S_OK { Ok(()) } else { err(hr) } }} -} -RT_CLASS!{class SearchPaneSuggestionsRequestDeferral: ISearchPaneSuggestionsRequestDeferral} -DEFINE_IID!(IID_ISearchPaneSuggestionsRequestedEventArgs, 3365636655, 44118, 17504, 141, 47, 128, 2, 59, 236, 79, 197); -RT_INTERFACE!{interface ISearchPaneSuggestionsRequestedEventArgs(ISearchPaneSuggestionsRequestedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_ISearchPaneSuggestionsRequestedEventArgs] { - fn get_Request(&self, out: *mut *mut SearchPaneSuggestionsRequest) -> HRESULT -}} -impl ISearchPaneSuggestionsRequestedEventArgs { - #[inline] pub fn get_request(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Request)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + #[inline] pub fn get_is_suppressed(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_IsSuppressed)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} -} -RT_CLASS!{class SearchPaneSuggestionsRequestedEventArgs: ISearchPaneSuggestionsRequestedEventArgs} -DEFINE_IID!(IID_ISearchPaneVisibilityChangedEventArgs, 1011691590, 44107, 18930, 151, 214, 2, 14, 97, 130, 203, 156); -RT_INTERFACE!{interface ISearchPaneVisibilityChangedEventArgs(ISearchPaneVisibilityChangedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_ISearchPaneVisibilityChangedEventArgs] { - fn get_Visible(&self, out: *mut bool) -> HRESULT -}} -impl ISearchPaneVisibilityChangedEventArgs { - #[inline] pub fn get_visible(&self) -> Result { unsafe { + #[inline] pub fn set_is_suppressed(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_IsSuppressed)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_is_voicemail(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_Visible)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_IsVoicemail)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} -} -RT_CLASS!{class SearchPaneVisibilityChangedEventArgs: ISearchPaneVisibilityChangedEventArgs} -DEFINE_IID!(IID_ISearchQueryLinguisticDetails, 1184964699, 27081, 18245, 183, 47, 168, 164, 252, 143, 36, 174); -RT_INTERFACE!{interface ISearchQueryLinguisticDetails(ISearchQueryLinguisticDetailsVtbl): IInspectable(IInspectableVtbl) [IID_ISearchQueryLinguisticDetails] { - fn get_QueryTextAlternatives(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT, - fn get_QueryTextCompositionStart(&self, out: *mut u32) -> HRESULT, - fn get_QueryTextCompositionLength(&self, out: *mut u32) -> HRESULT -}} -impl ISearchQueryLinguisticDetails { - #[inline] pub fn get_query_text_alternatives(&self) -> Result>>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_QueryTextAlternatives)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + #[inline] pub fn set_is_voicemail(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_IsVoicemail)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_query_text_composition_start(&self) -> Result { unsafe { + #[inline] pub fn get_media(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_QueryTextCompositionStart)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_Media)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_query_text_composition_length(&self) -> Result { unsafe { + #[inline] pub fn set_media(&self, value: PhoneCallHistoryEntryMedia) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Media)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_other_app_read_access(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_QueryTextCompositionLength)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_OtherAppReadAccess)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} -} -RT_CLASS!{class SearchQueryLinguisticDetails: ISearchQueryLinguisticDetails} -impl RtActivatable for SearchQueryLinguisticDetails {} -impl SearchQueryLinguisticDetails { - #[inline] pub fn create_instance(queryTextAlternatives: &foundation::collections::IIterable, queryTextCompositionStart: u32, queryTextCompositionLength: u32) -> Result> { - >::get_activation_factory().create_instance(queryTextAlternatives, queryTextCompositionStart, queryTextCompositionLength) - } -} -DEFINE_CLSID!(SearchQueryLinguisticDetails(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,83,101,97,114,99,104,46,83,101,97,114,99,104,81,117,101,114,121,76,105,110,103,117,105,115,116,105,99,68,101,116,97,105,108,115,0]) [CLSID_SearchQueryLinguisticDetails]); -DEFINE_IID!(IID_ISearchQueryLinguisticDetailsFactory, 3402023864, 15460, 19965, 173, 159, 71, 158, 77, 64, 101, 164); -RT_INTERFACE!{static interface ISearchQueryLinguisticDetailsFactory(ISearchQueryLinguisticDetailsFactoryVtbl): IInspectable(IInspectableVtbl) [IID_ISearchQueryLinguisticDetailsFactory] { - fn CreateInstance(&self, queryTextAlternatives: *mut foundation::collections::IIterable, queryTextCompositionStart: u32, queryTextCompositionLength: u32, out: *mut *mut SearchQueryLinguisticDetails) -> HRESULT -}} -impl ISearchQueryLinguisticDetailsFactory { - #[inline] pub fn create_instance(&self, queryTextAlternatives: &foundation::collections::IIterable, queryTextCompositionStart: u32, queryTextCompositionLength: u32) -> Result> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).CreateInstance)(self as *const _ as *mut _, queryTextAlternatives as *const _ as *mut _, queryTextCompositionStart, queryTextCompositionLength, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + #[inline] pub fn set_other_app_read_access(&self, value: PhoneCallHistoryEntryOtherAppReadAccess) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_OtherAppReadAccess)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } }} -} -DEFINE_IID!(IID_ISearchSuggestionCollection, 842697291, 64490, 17478, 171, 188, 61, 167, 145, 95, 221, 58); -RT_INTERFACE!{interface ISearchSuggestionCollection(ISearchSuggestionCollectionVtbl): IInspectable(IInspectableVtbl) [IID_ISearchSuggestionCollection] { - fn get_Size(&self, out: *mut u32) -> HRESULT, - fn AppendQuerySuggestion(&self, text: HSTRING) -> HRESULT, - fn AppendQuerySuggestions(&self, suggestions: *mut foundation::collections::IIterable) -> HRESULT, - #[cfg(not(feature="windows-storage"))] fn __Dummy3(&self) -> (), - #[cfg(feature="windows-storage")] fn AppendResultSuggestion(&self, text: HSTRING, detailText: HSTRING, tag: HSTRING, image: *mut super::super::storage::streams::IRandomAccessStreamReference, imageAlternateText: HSTRING) -> HRESULT, - fn AppendSearchSeparator(&self, label: HSTRING) -> HRESULT -}} -impl ISearchSuggestionCollection { - #[inline] pub fn get_size(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_Size)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } + #[inline] pub fn get_remote_id(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_RemoteId)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} - #[inline] pub fn append_query_suggestion(&self, text: &HStringArg) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).AppendQuerySuggestion)(self as *const _ as *mut _, text.get()); + #[inline] pub fn set_remote_id(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_RemoteId)(self as *const _ as *mut _, value.get()); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn append_query_suggestions(&self, suggestions: &foundation::collections::IIterable) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).AppendQuerySuggestions)(self as *const _ as *mut _, suggestions as *const _ as *mut _); - if hr == S_OK { Ok(()) } else { err(hr) } + #[inline] pub fn get_source_display_name(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_SourceDisplayName)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} - #[cfg(feature="windows-storage")] #[inline] pub fn append_result_suggestion(&self, text: &HStringArg, detailText: &HStringArg, tag: &HStringArg, image: &super::super::storage::streams::IRandomAccessStreamReference, imageAlternateText: &HStringArg) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).AppendResultSuggestion)(self as *const _ as *mut _, text.get(), detailText.get(), tag.get(), image as *const _ as *mut _, imageAlternateText.get()); - if hr == S_OK { Ok(()) } else { err(hr) } + #[inline] pub fn get_source_id(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_SourceId)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} - #[inline] pub fn append_search_separator(&self, label: &HStringArg) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).AppendSearchSeparator)(self as *const _ as *mut _, label.get()); + #[inline] pub fn set_source_id(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_SourceId)(self as *const _ as *mut _, value.get()); if hr == S_OK { Ok(()) } else { err(hr) } }} -} -RT_CLASS!{class SearchSuggestionCollection: ISearchSuggestionCollection} -DEFINE_IID!(IID_ISearchSuggestionsRequest, 1313744551, 17637, 16441, 144, 153, 96, 0, 234, 209, 240, 198); -RT_INTERFACE!{interface ISearchSuggestionsRequest(ISearchSuggestionsRequestVtbl): IInspectable(IInspectableVtbl) [IID_ISearchSuggestionsRequest] { - fn get_IsCanceled(&self, out: *mut bool) -> HRESULT, - fn get_SearchSuggestionCollection(&self, out: *mut *mut SearchSuggestionCollection) -> HRESULT, - fn GetDeferral(&self, out: *mut *mut SearchSuggestionsRequestDeferral) -> HRESULT -}} -impl ISearchSuggestionsRequest { - #[inline] pub fn get_is_canceled(&self) -> Result { unsafe { + #[inline] pub fn get_source_id_kind(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_IsCanceled)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_SourceIdKind)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_search_suggestion_collection(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_SearchSuggestionCollection)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + #[inline] pub fn set_source_id_kind(&self, value: PhoneCallHistorySourceIdKind) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_SourceIdKind)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_deferral(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetDeferral)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + #[inline] pub fn get_start_time(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_StartTime)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} -} -RT_CLASS!{class SearchSuggestionsRequest: ISearchSuggestionsRequest} -DEFINE_IID!(IID_ISearchSuggestionsRequestDeferral, 3071645865, 49253, 17773, 168, 69, 30, 204, 236, 93, 194, 139); -RT_INTERFACE!{interface ISearchSuggestionsRequestDeferral(ISearchSuggestionsRequestDeferralVtbl): IInspectable(IInspectableVtbl) [IID_ISearchSuggestionsRequestDeferral] { - fn Complete(&self) -> HRESULT -}} -impl ISearchSuggestionsRequestDeferral { - #[inline] pub fn complete(&self) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).Complete)(self as *const _ as *mut _); + #[inline] pub fn set_start_time(&self, value: foundation::DateTime) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_StartTime)(self as *const _ as *mut _, value); if hr == S_OK { Ok(()) } else { err(hr) } }} } -RT_CLASS!{class SearchSuggestionsRequestDeferral: ISearchSuggestionsRequestDeferral} -pub mod core { // Windows.ApplicationModel.Search.Core -use ::prelude::*; -DEFINE_IID!(IID_IRequestingFocusOnKeyboardInputEventArgs, 2702794535, 45479, 16802, 135, 157, 106, 104, 104, 126, 89, 133); -RT_INTERFACE!{interface IRequestingFocusOnKeyboardInputEventArgs(IRequestingFocusOnKeyboardInputEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IRequestingFocusOnKeyboardInputEventArgs] { - -}} -RT_CLASS!{class RequestingFocusOnKeyboardInputEventArgs: IRequestingFocusOnKeyboardInputEventArgs} -DEFINE_IID!(IID_ISearchSuggestion, 1532318896, 5415, 17275, 149, 197, 141, 24, 210, 184, 175, 85); -RT_INTERFACE!{interface ISearchSuggestion(ISearchSuggestionVtbl): IInspectable(IInspectableVtbl) [IID_ISearchSuggestion] { - fn get_Kind(&self, out: *mut SearchSuggestionKind) -> HRESULT, - fn get_Text(&self, out: *mut HSTRING) -> HRESULT, - fn get_Tag(&self, out: *mut HSTRING) -> HRESULT, - fn get_DetailText(&self, out: *mut HSTRING) -> HRESULT, - #[cfg(not(feature="windows-storage"))] fn __Dummy4(&self) -> (), - #[cfg(feature="windows-storage")] fn get_Image(&self, out: *mut *mut ::rt::gen::windows::storage::streams::IRandomAccessStreamReference) -> HRESULT, - fn get_ImageAlternateText(&self, out: *mut HSTRING) -> HRESULT +RT_CLASS!{class PhoneCallHistoryEntry: IPhoneCallHistoryEntry} +impl RtActivatable for PhoneCallHistoryEntry {} +DEFINE_CLSID!(PhoneCallHistoryEntry(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,67,97,108,108,115,46,80,104,111,110,101,67,97,108,108,72,105,115,116,111,114,121,69,110,116,114,121,0]) [CLSID_PhoneCallHistoryEntry]); +DEFINE_IID!(IID_IPhoneCallHistoryEntryAddress, 821123546, 14677, 16450, 132, 230, 102, 238, 191, 130, 230, 127); +RT_INTERFACE!{interface IPhoneCallHistoryEntryAddress(IPhoneCallHistoryEntryAddressVtbl): IInspectable(IInspectableVtbl) [IID_IPhoneCallHistoryEntryAddress] { + fn get_ContactId(&self, out: *mut HSTRING) -> HRESULT, + fn put_ContactId(&self, value: HSTRING) -> HRESULT, + fn get_DisplayName(&self, out: *mut HSTRING) -> HRESULT, + fn put_DisplayName(&self, value: HSTRING) -> HRESULT, + fn get_RawAddress(&self, out: *mut HSTRING) -> HRESULT, + fn put_RawAddress(&self, value: HSTRING) -> HRESULT, + fn get_RawAddressKind(&self, out: *mut PhoneCallHistoryEntryRawAddressKind) -> HRESULT, + fn put_RawAddressKind(&self, value: PhoneCallHistoryEntryRawAddressKind) -> HRESULT }} -impl ISearchSuggestion { - #[inline] pub fn get_kind(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_Kind)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } - }} - #[inline] pub fn get_text(&self) -> Result { unsafe { +impl IPhoneCallHistoryEntryAddress { + #[inline] pub fn get_contact_id(&self) -> Result { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Text)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_ContactId)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_tag(&self) -> Result { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Tag)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + #[inline] pub fn set_contact_id(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_ContactId)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_detail_text(&self) -> Result { unsafe { + #[inline] pub fn get_display_name(&self) -> Result { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_DetailText)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_DisplayName)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} - #[cfg(feature="windows-storage")] #[inline] pub fn get_image(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Image)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + #[inline] pub fn set_display_name(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_DisplayName)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_image_alternate_text(&self) -> Result { unsafe { + #[inline] pub fn get_raw_address(&self) -> Result { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_ImageAlternateText)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_RawAddress)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} -} -RT_CLASS!{class SearchSuggestion: ISearchSuggestion} -RT_ENUM! { enum SearchSuggestionKind: i32 { - Query (SearchSuggestionKind_Query) = 0, Result (SearchSuggestionKind_Result) = 1, Separator (SearchSuggestionKind_Separator) = 2, -}} -DEFINE_IID!(IID_ISearchSuggestionManager, 1057771681, 52125, 18811, 181, 0, 60, 4, 172, 149, 154, 210); -RT_INTERFACE!{interface ISearchSuggestionManager(ISearchSuggestionManagerVtbl): IInspectable(IInspectableVtbl) [IID_ISearchSuggestionManager] { - fn get_SearchHistoryEnabled(&self, out: *mut bool) -> HRESULT, - fn put_SearchHistoryEnabled(&self, value: bool) -> HRESULT, - fn get_SearchHistoryContext(&self, out: *mut HSTRING) -> HRESULT, - fn put_SearchHistoryContext(&self, value: HSTRING) -> HRESULT, - fn SetLocalContentSuggestionSettings(&self, settings: *mut super::LocalContentSuggestionSettings) -> HRESULT, - fn SetQuery(&self, queryText: HSTRING) -> HRESULT, - fn SetQueryWithLanguage(&self, queryText: HSTRING, language: HSTRING) -> HRESULT, - fn SetQueryWithSearchQueryLinguisticDetails(&self, queryText: HSTRING, language: HSTRING, linguisticDetails: *mut super::SearchQueryLinguisticDetails) -> HRESULT, - fn get_Suggestions(&self, out: *mut *mut foundation::collections::IObservableVector) -> HRESULT, - fn AddToHistory(&self, queryText: HSTRING) -> HRESULT, - fn AddToHistoryWithLanguage(&self, queryText: HSTRING, language: HSTRING) -> HRESULT, - fn ClearHistory(&self) -> HRESULT, - fn add_SuggestionsRequested(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, - fn remove_SuggestionsRequested(&self, token: foundation::EventRegistrationToken) -> HRESULT, - fn add_RequestingFocusOnKeyboardInput(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, - fn remove_RequestingFocusOnKeyboardInput(&self, token: foundation::EventRegistrationToken) -> HRESULT -}} -impl ISearchSuggestionManager { - #[inline] pub fn get_search_history_enabled(&self) -> Result { unsafe { + #[inline] pub fn set_raw_address(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_RawAddress)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_raw_address_kind(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_SearchHistoryEnabled)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_RawAddressKind)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn set_search_history_enabled(&self, value: bool) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_SearchHistoryEnabled)(self as *const _ as *mut _, value); + #[inline] pub fn set_raw_address_kind(&self, value: PhoneCallHistoryEntryRawAddressKind) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_RawAddressKind)(self as *const _ as *mut _, value); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_search_history_context(&self) -> Result { unsafe { +} +RT_CLASS!{class PhoneCallHistoryEntryAddress: IPhoneCallHistoryEntryAddress} +impl RtActivatable for PhoneCallHistoryEntryAddress {} +impl RtActivatable for PhoneCallHistoryEntryAddress {} +impl PhoneCallHistoryEntryAddress { + #[inline] pub fn create(rawAddress: &HStringArg, rawAddressKind: PhoneCallHistoryEntryRawAddressKind) -> Result> { + >::get_activation_factory().create(rawAddress, rawAddressKind) + } +} +DEFINE_CLSID!(PhoneCallHistoryEntryAddress(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,67,97,108,108,115,46,80,104,111,110,101,67,97,108,108,72,105,115,116,111,114,121,69,110,116,114,121,65,100,100,114,101,115,115,0]) [CLSID_PhoneCallHistoryEntryAddress]); +DEFINE_IID!(IID_IPhoneCallHistoryEntryAddressFactory, 4212108730, 51184, 19382, 159, 107, 186, 93, 115, 32, 154, 202); +RT_INTERFACE!{static interface IPhoneCallHistoryEntryAddressFactory(IPhoneCallHistoryEntryAddressFactoryVtbl): IInspectable(IInspectableVtbl) [IID_IPhoneCallHistoryEntryAddressFactory] { + fn Create(&self, rawAddress: HSTRING, rawAddressKind: PhoneCallHistoryEntryRawAddressKind, out: *mut *mut PhoneCallHistoryEntryAddress) -> HRESULT +}} +impl IPhoneCallHistoryEntryAddressFactory { + #[inline] pub fn create(&self, rawAddress: &HStringArg, rawAddressKind: PhoneCallHistoryEntryRawAddressKind) -> Result> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_SearchHistoryContext)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, rawAddress.get(), rawAddressKind, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn set_search_history_context(&self, value: &HStringArg) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_SearchHistoryContext)(self as *const _ as *mut _, value.get()); - if hr == S_OK { Ok(()) } else { err(hr) } +} +RT_ENUM! { enum PhoneCallHistoryEntryMedia: i32 { + Audio (PhoneCallHistoryEntryMedia_Audio) = 0, Video (PhoneCallHistoryEntryMedia_Video) = 1, +}} +RT_ENUM! { enum PhoneCallHistoryEntryOtherAppReadAccess: i32 { + Full (PhoneCallHistoryEntryOtherAppReadAccess_Full) = 0, SystemOnly (PhoneCallHistoryEntryOtherAppReadAccess_SystemOnly) = 1, +}} +RT_ENUM! { enum PhoneCallHistoryEntryQueryDesiredMedia: u32 { + None (PhoneCallHistoryEntryQueryDesiredMedia_None) = 0, Audio (PhoneCallHistoryEntryQueryDesiredMedia_Audio) = 1, Video (PhoneCallHistoryEntryQueryDesiredMedia_Video) = 2, All (PhoneCallHistoryEntryQueryDesiredMedia_All) = 4294967295, +}} +DEFINE_IID!(IID_IPhoneCallHistoryEntryQueryOptions, 2623529308, 35821, 16586, 176, 110, 196, 202, 142, 174, 92, 135); +RT_INTERFACE!{interface IPhoneCallHistoryEntryQueryOptions(IPhoneCallHistoryEntryQueryOptionsVtbl): IInspectable(IInspectableVtbl) [IID_IPhoneCallHistoryEntryQueryOptions] { + fn get_DesiredMedia(&self, out: *mut PhoneCallHistoryEntryQueryDesiredMedia) -> HRESULT, + fn put_DesiredMedia(&self, value: PhoneCallHistoryEntryQueryDesiredMedia) -> HRESULT, + fn get_SourceIds(&self, out: *mut *mut foundation::collections::IVector) -> HRESULT +}} +impl IPhoneCallHistoryEntryQueryOptions { + #[inline] pub fn get_desired_media(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_DesiredMedia)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn set_local_content_suggestion_settings(&self, settings: &super::LocalContentSuggestionSettings) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).SetLocalContentSuggestionSettings)(self as *const _ as *mut _, settings as *const _ as *mut _); + #[inline] pub fn set_desired_media(&self, value: PhoneCallHistoryEntryQueryDesiredMedia) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_DesiredMedia)(self as *const _ as *mut _, value); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn set_query(&self, queryText: &HStringArg) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).SetQuery)(self as *const _ as *mut _, queryText.get()); - if hr == S_OK { Ok(()) } else { err(hr) } + #[inline] pub fn get_source_ids(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_SourceIds)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn set_query_with_language(&self, queryText: &HStringArg, language: &HStringArg) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).SetQueryWithLanguage)(self as *const _ as *mut _, queryText.get(), language.get()); - if hr == S_OK { Ok(()) } else { err(hr) } +} +RT_CLASS!{class PhoneCallHistoryEntryQueryOptions: IPhoneCallHistoryEntryQueryOptions} +impl RtActivatable for PhoneCallHistoryEntryQueryOptions {} +DEFINE_CLSID!(PhoneCallHistoryEntryQueryOptions(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,67,97,108,108,115,46,80,104,111,110,101,67,97,108,108,72,105,115,116,111,114,121,69,110,116,114,121,81,117,101,114,121,79,112,116,105,111,110,115,0]) [CLSID_PhoneCallHistoryEntryQueryOptions]); +RT_ENUM! { enum PhoneCallHistoryEntryRawAddressKind: i32 { + PhoneNumber (PhoneCallHistoryEntryRawAddressKind_PhoneNumber) = 0, Custom (PhoneCallHistoryEntryRawAddressKind_Custom) = 1, +}} +DEFINE_IID!(IID_IPhoneCallHistoryEntryReader, 1642915006, 36230, 18335, 132, 4, 169, 132, 105, 32, 254, 230); +RT_INTERFACE!{interface IPhoneCallHistoryEntryReader(IPhoneCallHistoryEntryReaderVtbl): IInspectable(IInspectableVtbl) [IID_IPhoneCallHistoryEntryReader] { + fn ReadBatchAsync(&self, out: *mut *mut foundation::IAsyncOperation>) -> HRESULT +}} +impl IPhoneCallHistoryEntryReader { + #[inline] pub fn read_batch_async(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).ReadBatchAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn set_query_with_search_query_linguistic_details(&self, queryText: &HStringArg, language: &HStringArg, linguisticDetails: &super::SearchQueryLinguisticDetails) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).SetQueryWithSearchQueryLinguisticDetails)(self as *const _ as *mut _, queryText.get(), language.get(), linguisticDetails as *const _ as *mut _); - if hr == S_OK { Ok(()) } else { err(hr) } +} +RT_CLASS!{class PhoneCallHistoryEntryReader: IPhoneCallHistoryEntryReader} +RT_CLASS!{static class PhoneCallHistoryManager} +impl RtActivatable for PhoneCallHistoryManager {} +impl RtActivatable for PhoneCallHistoryManager {} +impl PhoneCallHistoryManager { + #[inline] pub fn request_store_async(accessType: PhoneCallHistoryStoreAccessType) -> Result>> { + >::get_activation_factory().request_store_async(accessType) + } + #[cfg(feature="windows-system")] #[inline] pub fn get_for_user(user: &super::super::system::User) -> Result>> { + >::get_activation_factory().get_for_user(user) + } +} +DEFINE_CLSID!(PhoneCallHistoryManager(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,67,97,108,108,115,46,80,104,111,110,101,67,97,108,108,72,105,115,116,111,114,121,77,97,110,97,103,101,114,0]) [CLSID_PhoneCallHistoryManager]); +DEFINE_IID!(IID_IPhoneCallHistoryManagerForUser, 3643131171, 62815, 17235, 157, 180, 2, 5, 165, 38, 90, 85); +RT_INTERFACE!{interface IPhoneCallHistoryManagerForUser(IPhoneCallHistoryManagerForUserVtbl): IInspectable(IInspectableVtbl) [IID_IPhoneCallHistoryManagerForUser] { + fn RequestStoreAsync(&self, accessType: PhoneCallHistoryStoreAccessType, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + #[cfg(feature="windows-system")] fn get_User(&self, out: *mut *mut super::super::system::User) -> HRESULT +}} +impl IPhoneCallHistoryManagerForUser { + #[inline] pub fn request_store_async(&self, accessType: PhoneCallHistoryStoreAccessType) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).RequestStoreAsync)(self as *const _ as *mut _, accessType, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_suggestions(&self) -> Result>>> { unsafe { + #[cfg(feature="windows-system")] #[inline] pub fn get_user(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Suggestions)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_User)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn add_to_history(&self, queryText: &HStringArg) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).AddToHistory)(self as *const _ as *mut _, queryText.get()); - if hr == S_OK { Ok(()) } else { err(hr) } - }} - #[inline] pub fn add_to_history_with_language(&self, queryText: &HStringArg, language: &HStringArg) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).AddToHistoryWithLanguage)(self as *const _ as *mut _, queryText.get(), language.get()); - if hr == S_OK { Ok(()) } else { err(hr) } - }} - #[inline] pub fn clear_history(&self) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).ClearHistory)(self as *const _ as *mut _); - if hr == S_OK { Ok(()) } else { err(hr) } - }} - #[inline] pub fn add_suggestions_requested(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).add_SuggestionsRequested)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } - }} - #[inline] pub fn remove_suggestions_requested(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).remove_SuggestionsRequested)(self as *const _ as *mut _, token); - if hr == S_OK { Ok(()) } else { err(hr) } - }} - #[inline] pub fn add_requesting_focus_on_keyboard_input(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).add_RequestingFocusOnKeyboardInput)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } - }} - #[inline] pub fn remove_requesting_focus_on_keyboard_input(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).remove_RequestingFocusOnKeyboardInput)(self as *const _ as *mut _, token); - if hr == S_OK { Ok(()) } else { err(hr) } - }} } -RT_CLASS!{class SearchSuggestionManager: ISearchSuggestionManager} -impl RtActivatable for SearchSuggestionManager {} -DEFINE_CLSID!(SearchSuggestionManager(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,83,101,97,114,99,104,46,67,111,114,101,46,83,101,97,114,99,104,83,117,103,103,101,115,116,105,111,110,77,97,110,97,103,101,114,0]) [CLSID_SearchSuggestionManager]); -DEFINE_IID!(IID_ISearchSuggestionsRequestedEventArgs, 1876236773, 40574, 19124, 139, 227, 199, 107, 27, 212, 52, 74); -RT_INTERFACE!{interface ISearchSuggestionsRequestedEventArgs(ISearchSuggestionsRequestedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_ISearchSuggestionsRequestedEventArgs] { - fn get_QueryText(&self, out: *mut HSTRING) -> HRESULT, - fn get_Language(&self, out: *mut HSTRING) -> HRESULT, - fn get_LinguisticDetails(&self, out: *mut *mut super::SearchQueryLinguisticDetails) -> HRESULT, - fn get_Request(&self, out: *mut *mut super::SearchSuggestionsRequest) -> HRESULT +RT_CLASS!{class PhoneCallHistoryManagerForUser: IPhoneCallHistoryManagerForUser} +DEFINE_IID!(IID_IPhoneCallHistoryManagerStatics, 4121352761, 45855, 20293, 172, 142, 27, 8, 137, 60, 27, 80); +RT_INTERFACE!{static interface IPhoneCallHistoryManagerStatics(IPhoneCallHistoryManagerStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IPhoneCallHistoryManagerStatics] { + fn RequestStoreAsync(&self, accessType: PhoneCallHistoryStoreAccessType, out: *mut *mut foundation::IAsyncOperation) -> HRESULT }} -impl ISearchSuggestionsRequestedEventArgs { - #[inline] pub fn get_query_text(&self) -> Result { unsafe { +impl IPhoneCallHistoryManagerStatics { + #[inline] pub fn request_store_async(&self, accessType: PhoneCallHistoryStoreAccessType) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_QueryText)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).RequestStoreAsync)(self as *const _ as *mut _, accessType, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_language(&self) -> Result { unsafe { +} +DEFINE_IID!(IID_IPhoneCallHistoryManagerStatics2, 4023678192, 41691, 16776, 158, 146, 188, 60, 250, 104, 19, 207); +RT_INTERFACE!{static interface IPhoneCallHistoryManagerStatics2(IPhoneCallHistoryManagerStatics2Vtbl): IInspectable(IInspectableVtbl) [IID_IPhoneCallHistoryManagerStatics2] { + #[cfg(feature="windows-system")] fn GetForUser(&self, user: *mut super::super::system::User, out: *mut *mut PhoneCallHistoryManagerForUser) -> HRESULT +}} +impl IPhoneCallHistoryManagerStatics2 { + #[cfg(feature="windows-system")] #[inline] pub fn get_for_user(&self, user: &super::super::system::User) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Language)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).GetForUser)(self as *const _ as *mut _, user as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn get_linguistic_details(&self) -> Result>> { unsafe { +} +RT_ENUM! { enum PhoneCallHistorySourceIdKind: i32 { + CellularPhoneLineId (PhoneCallHistorySourceIdKind_CellularPhoneLineId) = 0, PackageFamilyName (PhoneCallHistorySourceIdKind_PackageFamilyName) = 1, +}} +DEFINE_IID!(IID_IPhoneCallHistoryStore, 797998520, 46094, 16939, 133, 69, 203, 25, 16, 166, 28, 82); +RT_INTERFACE!{interface IPhoneCallHistoryStore(IPhoneCallHistoryStoreVtbl): IInspectable(IInspectableVtbl) [IID_IPhoneCallHistoryStore] { + fn GetEntryAsync(&self, callHistoryEntryId: HSTRING, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn GetEntryReader(&self, out: *mut *mut PhoneCallHistoryEntryReader) -> HRESULT, + fn GetEntryReaderWithOptions(&self, queryOptions: *mut PhoneCallHistoryEntryQueryOptions, out: *mut *mut PhoneCallHistoryEntryReader) -> HRESULT, + fn SaveEntryAsync(&self, callHistoryEntry: *mut PhoneCallHistoryEntry, out: *mut *mut foundation::IAsyncAction) -> HRESULT, + fn DeleteEntryAsync(&self, callHistoryEntry: *mut PhoneCallHistoryEntry, out: *mut *mut foundation::IAsyncAction) -> HRESULT, + fn DeleteEntriesAsync(&self, callHistoryEntries: *mut foundation::collections::IIterable, out: *mut *mut foundation::IAsyncAction) -> HRESULT, + fn MarkEntryAsSeenAsync(&self, callHistoryEntry: *mut PhoneCallHistoryEntry, out: *mut *mut foundation::IAsyncAction) -> HRESULT, + fn MarkEntriesAsSeenAsync(&self, callHistoryEntries: *mut foundation::collections::IIterable, out: *mut *mut foundation::IAsyncAction) -> HRESULT, + fn GetUnseenCountAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn MarkAllAsSeenAsync(&self, out: *mut *mut foundation::IAsyncAction) -> HRESULT, + fn GetSourcesUnseenCountAsync(&self, sourceIds: *mut foundation::collections::IIterable, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn MarkSourcesAsSeenAsync(&self, sourceIds: *mut foundation::collections::IIterable, out: *mut *mut foundation::IAsyncAction) -> HRESULT +}} +impl IPhoneCallHistoryStore { + #[inline] pub fn get_entry_async(&self, callHistoryEntryId: &HStringArg) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_LinguisticDetails)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).GetEntryAsync)(self as *const _ as *mut _, callHistoryEntryId.get(), &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_request(&self) -> Result>> { unsafe { + #[inline] pub fn get_entry_reader(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Request)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).GetEntryReader)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} -} -RT_CLASS!{class SearchSuggestionsRequestedEventArgs: ISearchSuggestionsRequestedEventArgs} -} // Windows.ApplicationModel.Search.Core -} // Windows.ApplicationModel.Search -pub mod background { // Windows.ApplicationModel.Background -use ::prelude::*; -DEFINE_IID!(IID_IActivitySensorTrigger, 3504161602, 58235, 18467, 165, 254, 107, 49, 223, 239, 222, 176); -RT_INTERFACE!{interface IActivitySensorTrigger(IActivitySensorTriggerVtbl): IInspectable(IInspectableVtbl) [IID_IActivitySensorTrigger] { - #[cfg(not(feature="windows-devices"))] fn __Dummy0(&self) -> (), - #[cfg(feature="windows-devices")] fn get_SubscribedActivities(&self, out: *mut *mut foundation::collections::IVector) -> HRESULT, - fn get_ReportInterval(&self, out: *mut u32) -> HRESULT, - #[cfg(not(feature="windows-devices"))] fn __Dummy2(&self) -> (), - #[cfg(feature="windows-devices")] fn get_SupportedActivities(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT, - fn get_MinimumReportInterval(&self, out: *mut u32) -> HRESULT -}} -impl IActivitySensorTrigger { - #[cfg(feature="windows-devices")] #[inline] pub fn get_subscribed_activities(&self) -> Result>>> { unsafe { + #[inline] pub fn get_entry_reader_with_options(&self, queryOptions: &PhoneCallHistoryEntryQueryOptions) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_SubscribedActivities)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).GetEntryReaderWithOptions)(self as *const _ as *mut _, queryOptions as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn get_report_interval(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_ReportInterval)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } + #[inline] pub fn save_entry_async(&self, callHistoryEntry: &PhoneCallHistoryEntry) -> Result> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).SaveEntryAsync)(self as *const _ as *mut _, callHistoryEntry as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[cfg(feature="windows-devices")] #[inline] pub fn get_supported_activities(&self) -> Result>>> { unsafe { + #[inline] pub fn delete_entry_async(&self, callHistoryEntry: &PhoneCallHistoryEntry) -> Result> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_SupportedActivities)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).DeleteEntryAsync)(self as *const _ as *mut _, callHistoryEntry as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_minimum_report_interval(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_MinimumReportInterval)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } + #[inline] pub fn delete_entries_async(&self, callHistoryEntries: &foundation::collections::IIterable) -> Result> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).DeleteEntriesAsync)(self as *const _ as *mut _, callHistoryEntries as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} -} -RT_CLASS!{class ActivitySensorTrigger: IActivitySensorTrigger} -impl RtActivatable for ActivitySensorTrigger {} -impl ActivitySensorTrigger { - #[inline] pub fn create(reportIntervalInMilliseconds: u32) -> Result> { - >::get_activation_factory().create(reportIntervalInMilliseconds) - } -} -DEFINE_CLSID!(ActivitySensorTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,65,99,116,105,118,105,116,121,83,101,110,115,111,114,84,114,105,103,103,101,114,0]) [CLSID_ActivitySensorTrigger]); -DEFINE_IID!(IID_IActivitySensorTriggerFactory, 2804322755, 14391, 17655, 131, 27, 1, 50, 204, 135, 43, 195); -RT_INTERFACE!{static interface IActivitySensorTriggerFactory(IActivitySensorTriggerFactoryVtbl): IInspectable(IInspectableVtbl) [IID_IActivitySensorTriggerFactory] { - fn Create(&self, reportIntervalInMilliseconds: u32, out: *mut *mut ActivitySensorTrigger) -> HRESULT -}} -impl IActivitySensorTriggerFactory { - #[inline] pub fn create(&self, reportIntervalInMilliseconds: u32) -> Result> { unsafe { + #[inline] pub fn mark_entry_as_seen_async(&self, callHistoryEntry: &PhoneCallHistoryEntry) -> Result> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, reportIntervalInMilliseconds, &mut out); + let hr = ((*self.lpVtbl).MarkEntryAsSeenAsync)(self as *const _ as *mut _, callHistoryEntry as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} -} -RT_ENUM! { enum AlarmAccessStatus: i32 { - Unspecified (AlarmAccessStatus_Unspecified) = 0, AllowedWithWakeupCapability (AlarmAccessStatus_AllowedWithWakeupCapability) = 1, AllowedWithoutWakeupCapability (AlarmAccessStatus_AllowedWithoutWakeupCapability) = 2, Denied (AlarmAccessStatus_Denied) = 3, -}} -RT_CLASS!{static class AlarmApplicationManager} -impl RtActivatable for AlarmApplicationManager {} -impl AlarmApplicationManager { - #[inline] pub fn request_access_async() -> Result>> { - >::get_activation_factory().request_access_async() - } - #[inline] pub fn get_access_status() -> Result { - >::get_activation_factory().get_access_status() - } -} -DEFINE_CLSID!(AlarmApplicationManager(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,65,108,97,114,109,65,112,112,108,105,99,97,116,105,111,110,77,97,110,97,103,101,114,0]) [CLSID_AlarmApplicationManager]); -DEFINE_IID!(IID_IAlarmApplicationManagerStatics, 3389258299, 52454, 19938, 176, 155, 150, 40, 189, 51, 187, 190); -RT_INTERFACE!{static interface IAlarmApplicationManagerStatics(IAlarmApplicationManagerStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IAlarmApplicationManagerStatics] { - fn RequestAccessAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, - fn GetAccessStatus(&self, out: *mut AlarmAccessStatus) -> HRESULT -}} -impl IAlarmApplicationManagerStatics { - #[inline] pub fn request_access_async(&self) -> Result>> { unsafe { + #[inline] pub fn mark_entries_as_seen_async(&self, callHistoryEntries: &foundation::collections::IIterable) -> Result> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).RequestAccessAsync)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).MarkEntriesAsSeenAsync)(self as *const _ as *mut _, callHistoryEntries as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_access_status(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).GetAccessStatus)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } + #[inline] pub fn get_unseen_count_async(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetUnseenCountAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} -} -DEFINE_IID!(IID_IAppBroadcastTrigger, 1960113302, 36151, 17644, 148, 129, 42, 11, 152, 84, 235, 72); -RT_INTERFACE!{interface IAppBroadcastTrigger(IAppBroadcastTriggerVtbl): IInspectable(IInspectableVtbl) [IID_IAppBroadcastTrigger] { - fn put_ProviderInfo(&self, value: *mut AppBroadcastTriggerProviderInfo) -> HRESULT, - fn get_ProviderInfo(&self, out: *mut *mut AppBroadcastTriggerProviderInfo) -> HRESULT -}} -impl IAppBroadcastTrigger { - #[inline] pub fn set_provider_info(&self, value: &AppBroadcastTriggerProviderInfo) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_ProviderInfo)(self as *const _ as *mut _, value as *const _ as *mut _); - if hr == S_OK { Ok(()) } else { err(hr) } + #[inline] pub fn mark_all_as_seen_async(&self) -> Result> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).MarkAllAsSeenAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_provider_info(&self) -> Result>> { unsafe { + #[inline] pub fn get_sources_unseen_count_async(&self, sourceIds: &foundation::collections::IIterable) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_ProviderInfo)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).GetSourcesUnseenCountAsync)(self as *const _ as *mut _, sourceIds as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} -} -RT_CLASS!{class AppBroadcastTrigger: IAppBroadcastTrigger} -impl RtActivatable for AppBroadcastTrigger {} -impl AppBroadcastTrigger { - #[inline] pub fn create_app_broadcast_trigger(providerKey: &HStringArg) -> Result> { - >::get_activation_factory().create_app_broadcast_trigger(providerKey) - } -} -DEFINE_CLSID!(AppBroadcastTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,65,112,112,66,114,111,97,100,99,97,115,116,84,114,105,103,103,101,114,0]) [CLSID_AppBroadcastTrigger]); -DEFINE_IID!(IID_IAppBroadcastTriggerFactory, 671850308, 8948, 17944, 160, 46, 231, 228, 17, 235, 114, 56); -RT_INTERFACE!{static interface IAppBroadcastTriggerFactory(IAppBroadcastTriggerFactoryVtbl): IInspectable(IInspectableVtbl) [IID_IAppBroadcastTriggerFactory] { - fn CreateAppBroadcastTrigger(&self, providerKey: HSTRING, out: *mut *mut AppBroadcastTrigger) -> HRESULT -}} -impl IAppBroadcastTriggerFactory { - #[inline] pub fn create_app_broadcast_trigger(&self, providerKey: &HStringArg) -> Result> { unsafe { + #[inline] pub fn mark_sources_as_seen_async(&self, sourceIds: &foundation::collections::IIterable) -> Result> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).CreateAppBroadcastTrigger)(self as *const _ as *mut _, providerKey.get(), &mut out); + let hr = ((*self.lpVtbl).MarkSourcesAsSeenAsync)(self as *const _ as *mut _, sourceIds as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } -DEFINE_IID!(IID_IAppBroadcastTriggerProviderInfo, 4061738285, 40424, 17440, 156, 226, 94, 255, 143, 23, 55, 107); -RT_INTERFACE!{interface IAppBroadcastTriggerProviderInfo(IAppBroadcastTriggerProviderInfoVtbl): IInspectable(IInspectableVtbl) [IID_IAppBroadcastTriggerProviderInfo] { - fn put_DisplayNameResource(&self, value: HSTRING) -> HRESULT, - fn get_DisplayNameResource(&self, out: *mut HSTRING) -> HRESULT, - fn put_LogoResource(&self, value: HSTRING) -> HRESULT, - fn get_LogoResource(&self, out: *mut HSTRING) -> HRESULT, - fn put_VideoKeyFrameInterval(&self, value: foundation::TimeSpan) -> HRESULT, - fn get_VideoKeyFrameInterval(&self, out: *mut foundation::TimeSpan) -> HRESULT, - fn put_MaxVideoBitrate(&self, value: u32) -> HRESULT, - fn get_MaxVideoBitrate(&self, out: *mut u32) -> HRESULT, - fn put_MaxVideoWidth(&self, value: u32) -> HRESULT, - fn get_MaxVideoWidth(&self, out: *mut u32) -> HRESULT, - fn put_MaxVideoHeight(&self, value: u32) -> HRESULT, - fn get_MaxVideoHeight(&self, out: *mut u32) -> HRESULT +RT_CLASS!{class PhoneCallHistoryStore: IPhoneCallHistoryStore} +RT_ENUM! { enum PhoneCallHistoryStoreAccessType: i32 { + AppEntriesReadWrite (PhoneCallHistoryStoreAccessType_AppEntriesReadWrite) = 0, AllEntriesLimitedReadWrite (PhoneCallHistoryStoreAccessType_AllEntriesLimitedReadWrite) = 1, AllEntriesReadWrite (PhoneCallHistoryStoreAccessType_AllEntriesReadWrite) = 2, }} -impl IAppBroadcastTriggerProviderInfo { - #[inline] pub fn set_display_name_resource(&self, value: &HStringArg) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_DisplayNameResource)(self as *const _ as *mut _, value.get()); +DEFINE_IID!(IID_IVoipCallCoordinator, 1326549967, 59631, 17460, 156, 95, 168, 216, 147, 250, 254, 121); +RT_INTERFACE!{interface IVoipCallCoordinator(IVoipCallCoordinatorVtbl): IInspectable(IInspectableVtbl) [IID_IVoipCallCoordinator] { + fn ReserveCallResourcesAsync(&self, taskEntryPoint: HSTRING, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn add_MuteStateChanged(&self, muteChangeHandler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_MuteStateChanged(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn RequestNewIncomingCall(&self, context: HSTRING, contactName: HSTRING, contactNumber: HSTRING, contactImage: *mut foundation::Uri, serviceName: HSTRING, brandingImage: *mut foundation::Uri, callDetails: HSTRING, ringtone: *mut foundation::Uri, media: VoipPhoneCallMedia, ringTimeout: foundation::TimeSpan, out: *mut *mut VoipPhoneCall) -> HRESULT, + fn RequestNewOutgoingCall(&self, context: HSTRING, contactName: HSTRING, serviceName: HSTRING, media: VoipPhoneCallMedia, out: *mut *mut VoipPhoneCall) -> HRESULT, + fn NotifyMuted(&self) -> HRESULT, + fn NotifyUnmuted(&self) -> HRESULT, + fn RequestOutgoingUpgradeToVideoCall(&self, callUpgradeGuid: Guid, context: HSTRING, contactName: HSTRING, serviceName: HSTRING, out: *mut *mut VoipPhoneCall) -> HRESULT, + fn RequestIncomingUpgradeToVideoCall(&self, context: HSTRING, contactName: HSTRING, contactNumber: HSTRING, contactImage: *mut foundation::Uri, serviceName: HSTRING, brandingImage: *mut foundation::Uri, callDetails: HSTRING, ringtone: *mut foundation::Uri, ringTimeout: foundation::TimeSpan, out: *mut *mut VoipPhoneCall) -> HRESULT, + fn TerminateCellularCall(&self, callUpgradeGuid: Guid) -> HRESULT, + fn CancelUpgrade(&self, callUpgradeGuid: Guid) -> HRESULT +}} +impl IVoipCallCoordinator { + #[inline] pub fn reserve_call_resources_async(&self, taskEntryPoint: &HStringArg) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).ReserveCallResourcesAsync)(self as *const _ as *mut _, taskEntryPoint.get(), &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn add_mute_state_changed(&self, muteChangeHandler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_MuteStateChanged)(self as *const _ as *mut _, muteChangeHandler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_mute_state_changed(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_MuteStateChanged)(self as *const _ as *mut _, token); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_display_name_resource(&self) -> Result { unsafe { + #[inline] pub fn request_new_incoming_call(&self, context: &HStringArg, contactName: &HStringArg, contactNumber: &HStringArg, contactImage: &foundation::Uri, serviceName: &HStringArg, brandingImage: &foundation::Uri, callDetails: &HStringArg, ringtone: &foundation::Uri, media: VoipPhoneCallMedia, ringTimeout: foundation::TimeSpan) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_DisplayNameResource)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).RequestNewIncomingCall)(self as *const _ as *mut _, context.get(), contactName.get(), contactNumber.get(), contactImage as *const _ as *mut _, serviceName.get(), brandingImage as *const _ as *mut _, callDetails.get(), ringtone as *const _ as *mut _, media, ringTimeout, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn set_logo_resource(&self, value: &HStringArg) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_LogoResource)(self as *const _ as *mut _, value.get()); + #[inline] pub fn request_new_outgoing_call(&self, context: &HStringArg, contactName: &HStringArg, serviceName: &HStringArg, media: VoipPhoneCallMedia) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).RequestNewOutgoingCall)(self as *const _ as *mut _, context.get(), contactName.get(), serviceName.get(), media, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn notify_muted(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).NotifyMuted)(self as *const _ as *mut _); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_logo_resource(&self) -> Result { unsafe { + #[inline] pub fn notify_unmuted(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).NotifyUnmuted)(self as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn request_outgoing_upgrade_to_video_call(&self, callUpgradeGuid: Guid, context: &HStringArg, contactName: &HStringArg, serviceName: &HStringArg) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_LogoResource)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).RequestOutgoingUpgradeToVideoCall)(self as *const _ as *mut _, callUpgradeGuid, context.get(), contactName.get(), serviceName.get(), &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn set_video_key_frame_interval(&self, value: foundation::TimeSpan) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_VideoKeyFrameInterval)(self as *const _ as *mut _, value); + #[inline] pub fn request_incoming_upgrade_to_video_call(&self, context: &HStringArg, contactName: &HStringArg, contactNumber: &HStringArg, contactImage: &foundation::Uri, serviceName: &HStringArg, brandingImage: &foundation::Uri, callDetails: &HStringArg, ringtone: &foundation::Uri, ringTimeout: foundation::TimeSpan) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).RequestIncomingUpgradeToVideoCall)(self as *const _ as *mut _, context.get(), contactName.get(), contactNumber.get(), contactImage as *const _ as *mut _, serviceName.get(), brandingImage as *const _ as *mut _, callDetails.get(), ringtone as *const _ as *mut _, ringTimeout, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn terminate_cellular_call(&self, callUpgradeGuid: Guid) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).TerminateCellularCall)(self as *const _ as *mut _, callUpgradeGuid); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_video_key_frame_interval(&self) -> Result { unsafe { + #[inline] pub fn cancel_upgrade(&self, callUpgradeGuid: Guid) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).CancelUpgrade)(self as *const _ as *mut _, callUpgradeGuid); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class VoipCallCoordinator: IVoipCallCoordinator} +impl RtActivatable for VoipCallCoordinator {} +impl VoipCallCoordinator { + #[inline] pub fn get_default() -> Result>> { + >::get_activation_factory().get_default() + } +} +DEFINE_CLSID!(VoipCallCoordinator(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,67,97,108,108,115,46,86,111,105,112,67,97,108,108,67,111,111,114,100,105,110,97,116,111,114,0]) [CLSID_VoipCallCoordinator]); +DEFINE_IID!(IID_IVoipCallCoordinator2, 3199511027, 50948, 16948, 137, 206, 232, 140, 192, 210, 143, 190); +RT_INTERFACE!{interface IVoipCallCoordinator2(IVoipCallCoordinator2Vtbl): IInspectable(IInspectableVtbl) [IID_IVoipCallCoordinator2] { + fn SetupNewAcceptedCall(&self, context: HSTRING, contactName: HSTRING, contactNumber: HSTRING, serviceName: HSTRING, media: VoipPhoneCallMedia, out: *mut *mut VoipPhoneCall) -> HRESULT +}} +impl IVoipCallCoordinator2 { + #[inline] pub fn setup_new_accepted_call(&self, context: &HStringArg, contactName: &HStringArg, contactNumber: &HStringArg, serviceName: &HStringArg, media: VoipPhoneCallMedia) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).SetupNewAcceptedCall)(self as *const _ as *mut _, context.get(), contactName.get(), contactNumber.get(), serviceName.get(), media, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +DEFINE_IID!(IID_IVoipCallCoordinator3, 864881855, 39765, 16417, 135, 202, 230, 75, 155, 214, 102, 199); +RT_INTERFACE!{interface IVoipCallCoordinator3(IVoipCallCoordinator3Vtbl): IInspectable(IInspectableVtbl) [IID_IVoipCallCoordinator3] { + fn RequestNewAppInitiatedCall(&self, context: HSTRING, contactName: HSTRING, contactNumber: HSTRING, serviceName: HSTRING, media: VoipPhoneCallMedia, out: *mut *mut VoipPhoneCall) -> HRESULT, + fn RequestNewIncomingCallWithContactRemoteId(&self, context: HSTRING, contactName: HSTRING, contactNumber: HSTRING, contactImage: *mut foundation::Uri, serviceName: HSTRING, brandingImage: *mut foundation::Uri, callDetails: HSTRING, ringtone: *mut foundation::Uri, media: VoipPhoneCallMedia, ringTimeout: foundation::TimeSpan, contactRemoteId: HSTRING, out: *mut *mut VoipPhoneCall) -> HRESULT +}} +impl IVoipCallCoordinator3 { + #[inline] pub fn request_new_app_initiated_call(&self, context: &HStringArg, contactName: &HStringArg, contactNumber: &HStringArg, serviceName: &HStringArg, media: VoipPhoneCallMedia) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).RequestNewAppInitiatedCall)(self as *const _ as *mut _, context.get(), contactName.get(), contactNumber.get(), serviceName.get(), media, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn request_new_incoming_call_with_contact_remote_id(&self, context: &HStringArg, contactName: &HStringArg, contactNumber: &HStringArg, contactImage: &foundation::Uri, serviceName: &HStringArg, brandingImage: &foundation::Uri, callDetails: &HStringArg, ringtone: &foundation::Uri, media: VoipPhoneCallMedia, ringTimeout: foundation::TimeSpan, contactRemoteId: &HStringArg) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).RequestNewIncomingCallWithContactRemoteId)(self as *const _ as *mut _, context.get(), contactName.get(), contactNumber.get(), contactImage as *const _ as *mut _, serviceName.get(), brandingImage as *const _ as *mut _, callDetails.get(), ringtone as *const _ as *mut _, media, ringTimeout, contactRemoteId.get(), &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +DEFINE_IID!(IID_IVoipCallCoordinatorStatics, 2136809259, 57418, 19728, 179, 26, 165, 92, 146, 44, 194, 251); +RT_INTERFACE!{static interface IVoipCallCoordinatorStatics(IVoipCallCoordinatorStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IVoipCallCoordinatorStatics] { + fn GetDefault(&self, out: *mut *mut VoipCallCoordinator) -> HRESULT +}} +impl IVoipCallCoordinatorStatics { + #[inline] pub fn get_default(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetDefault)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +DEFINE_IID!(IID_IVoipPhoneCall, 1827795354, 30612, 19034, 140, 104, 174, 135, 148, 122, 105, 144); +RT_INTERFACE!{interface IVoipPhoneCall(IVoipPhoneCallVtbl): IInspectable(IInspectableVtbl) [IID_IVoipPhoneCall] { + fn add_EndRequested(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_EndRequested(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn add_HoldRequested(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_HoldRequested(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn add_ResumeRequested(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_ResumeRequested(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn add_AnswerRequested(&self, acceptHandler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_AnswerRequested(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn add_RejectRequested(&self, rejectHandler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_RejectRequested(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn NotifyCallHeld(&self) -> HRESULT, + fn NotifyCallActive(&self) -> HRESULT, + fn NotifyCallEnded(&self) -> HRESULT, + fn get_ContactName(&self, out: *mut HSTRING) -> HRESULT, + fn put_ContactName(&self, value: HSTRING) -> HRESULT, + fn get_StartTime(&self, out: *mut foundation::DateTime) -> HRESULT, + fn put_StartTime(&self, value: foundation::DateTime) -> HRESULT, + fn get_CallMedia(&self, out: *mut VoipPhoneCallMedia) -> HRESULT, + fn put_CallMedia(&self, value: VoipPhoneCallMedia) -> HRESULT, + fn NotifyCallReady(&self) -> HRESULT +}} +impl IVoipPhoneCall { + #[inline] pub fn add_end_requested(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_VideoKeyFrameInterval)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).add_EndRequested)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn set_max_video_bitrate(&self, value: u32) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_MaxVideoBitrate)(self as *const _ as *mut _, value); + #[inline] pub fn remove_end_requested(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_EndRequested)(self as *const _ as *mut _, token); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_max_video_bitrate(&self) -> Result { unsafe { + #[inline] pub fn add_hold_requested(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_MaxVideoBitrate)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).add_HoldRequested)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn set_max_video_width(&self, value: u32) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_MaxVideoWidth)(self as *const _ as *mut _, value); + #[inline] pub fn remove_hold_requested(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_HoldRequested)(self as *const _ as *mut _, token); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_max_video_width(&self) -> Result { unsafe { + #[inline] pub fn add_resume_requested(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_MaxVideoWidth)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).add_ResumeRequested)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn set_max_video_height(&self, value: u32) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_MaxVideoHeight)(self as *const _ as *mut _, value); + #[inline] pub fn remove_resume_requested(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_ResumeRequested)(self as *const _ as *mut _, token); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_max_video_height(&self) -> Result { unsafe { + #[inline] pub fn add_answer_requested(&self, acceptHandler: &foundation::TypedEventHandler) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_MaxVideoHeight)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).add_AnswerRequested)(self as *const _ as *mut _, acceptHandler as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} -} -RT_CLASS!{class AppBroadcastTriggerProviderInfo: IAppBroadcastTriggerProviderInfo} -DEFINE_IID!(IID_IApplicationTrigger, 189171248, 38260, 18732, 158, 147, 26, 58, 230, 51, 95, 233); -RT_INTERFACE!{interface IApplicationTrigger(IApplicationTriggerVtbl): IInspectable(IInspectableVtbl) [IID_IApplicationTrigger] { - fn RequestAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, - fn RequestAsyncWithArguments(&self, arguments: *mut foundation::collections::ValueSet, out: *mut *mut foundation::IAsyncOperation) -> HRESULT -}} -impl IApplicationTrigger { - #[inline] pub fn request_async(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).RequestAsync)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + #[inline] pub fn remove_answer_requested(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_AnswerRequested)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn request_async_with_arguments(&self, arguments: &foundation::collections::ValueSet) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).RequestAsyncWithArguments)(self as *const _ as *mut _, arguments as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + #[inline] pub fn add_reject_requested(&self, rejectHandler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_RejectRequested)(self as *const _ as *mut _, rejectHandler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} -} -RT_CLASS!{class ApplicationTrigger: IApplicationTrigger} -impl RtActivatable for ApplicationTrigger {} -DEFINE_CLSID!(ApplicationTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,65,112,112,108,105,99,97,116,105,111,110,84,114,105,103,103,101,114,0]) [CLSID_ApplicationTrigger]); -DEFINE_IID!(IID_IApplicationTriggerDetails, 2547804850, 8729, 19102, 156, 94, 65, 208, 71, 247, 110, 130); -RT_INTERFACE!{interface IApplicationTriggerDetails(IApplicationTriggerDetailsVtbl): IInspectable(IInspectableVtbl) [IID_IApplicationTriggerDetails] { - fn get_Arguments(&self, out: *mut *mut foundation::collections::ValueSet) -> HRESULT -}} -impl IApplicationTriggerDetails { - #[inline] pub fn get_arguments(&self) -> Result>> { unsafe { + #[inline] pub fn remove_reject_requested(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_RejectRequested)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn notify_call_held(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).NotifyCallHeld)(self as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn notify_call_active(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).NotifyCallActive)(self as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn notify_call_ended(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).NotifyCallEnded)(self as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_contact_name(&self) -> Result { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Arguments)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).get_ContactName)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} -} -RT_CLASS!{class ApplicationTriggerDetails: IApplicationTriggerDetails} -RT_ENUM! { enum ApplicationTriggerResult: i32 { - Allowed (ApplicationTriggerResult_Allowed) = 0, CurrentlyRunning (ApplicationTriggerResult_CurrentlyRunning) = 1, DisabledByPolicy (ApplicationTriggerResult_DisabledByPolicy) = 2, UnknownError (ApplicationTriggerResult_UnknownError) = 3, -}} -DEFINE_IID!(IID_IAppointmentStoreNotificationTrigger, 1691616268, 49665, 17069, 170, 42, 226, 27, 163, 66, 91, 109); -RT_INTERFACE!{interface IAppointmentStoreNotificationTrigger(IAppointmentStoreNotificationTriggerVtbl): IInspectable(IInspectableVtbl) [IID_IAppointmentStoreNotificationTrigger] { - -}} -RT_CLASS!{class AppointmentStoreNotificationTrigger: IAppointmentStoreNotificationTrigger} -impl RtActivatable for AppointmentStoreNotificationTrigger {} -DEFINE_CLSID!(AppointmentStoreNotificationTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,65,112,112,111,105,110,116,109,101,110,116,83,116,111,114,101,78,111,116,105,102,105,99,97,116,105,111,110,84,114,105,103,103,101,114,0]) [CLSID_AppointmentStoreNotificationTrigger]); -RT_ENUM! { enum BackgroundAccessStatus: i32 { - Unspecified (BackgroundAccessStatus_Unspecified) = 0, AllowedWithAlwaysOnRealTimeConnectivity (BackgroundAccessStatus_AllowedWithAlwaysOnRealTimeConnectivity) = 1, AllowedMayUseActiveRealTimeConnectivity (BackgroundAccessStatus_AllowedMayUseActiveRealTimeConnectivity) = 2, Denied (BackgroundAccessStatus_Denied) = 3, AlwaysAllowed (BackgroundAccessStatus_AlwaysAllowed) = 4, AllowedSubjectToSystemPolicy (BackgroundAccessStatus_AllowedSubjectToSystemPolicy) = 5, DeniedBySystemPolicy (BackgroundAccessStatus_DeniedBySystemPolicy) = 6, DeniedByUser (BackgroundAccessStatus_DeniedByUser) = 7, -}} -DEFINE_IID!(IID_IBackgroundCondition, 2923995630, 35153, 16394, 131, 2, 156, 156, 154, 42, 58, 59); -RT_INTERFACE!{interface IBackgroundCondition(IBackgroundConditionVtbl): IInspectable(IInspectableVtbl) [IID_IBackgroundCondition] { - -}} -RT_CLASS!{static class BackgroundExecutionManager} -impl RtActivatable for BackgroundExecutionManager {} -impl BackgroundExecutionManager { - #[inline] pub fn request_access_async() -> Result>> { - >::get_activation_factory().request_access_async() - } - #[inline] pub fn request_access_for_application_async(applicationId: &HStringArg) -> Result>> { - >::get_activation_factory().request_access_for_application_async(applicationId) - } - #[inline] pub fn remove_access() -> Result<()> { - >::get_activation_factory().remove_access() - } - #[inline] pub fn remove_access_for_application(applicationId: &HStringArg) -> Result<()> { - >::get_activation_factory().remove_access_for_application(applicationId) - } - #[inline] pub fn get_access_status() -> Result { - >::get_activation_factory().get_access_status() - } - #[inline] pub fn get_access_status_for_application(applicationId: &HStringArg) -> Result { - >::get_activation_factory().get_access_status_for_application(applicationId) - } -} -DEFINE_CLSID!(BackgroundExecutionManager(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,66,97,99,107,103,114,111,117,110,100,69,120,101,99,117,116,105,111,110,77,97,110,97,103,101,114,0]) [CLSID_BackgroundExecutionManager]); -DEFINE_IID!(IID_IBackgroundExecutionManagerStatics, 3894864472, 26281, 19777, 131, 212, 180, 193, 140, 135, 184, 70); -RT_INTERFACE!{static interface IBackgroundExecutionManagerStatics(IBackgroundExecutionManagerStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IBackgroundExecutionManagerStatics] { - fn RequestAccessAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, - fn RequestAccessForApplicationAsync(&self, applicationId: HSTRING, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, - fn RemoveAccess(&self) -> HRESULT, - fn RemoveAccessForApplication(&self, applicationId: HSTRING) -> HRESULT, - fn GetAccessStatus(&self, out: *mut BackgroundAccessStatus) -> HRESULT, - fn GetAccessStatusForApplication(&self, applicationId: HSTRING, out: *mut BackgroundAccessStatus) -> HRESULT -}} -impl IBackgroundExecutionManagerStatics { - #[inline] pub fn request_access_async(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).RequestAccessAsync)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } - }} - #[inline] pub fn request_access_for_application_async(&self, applicationId: &HStringArg) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).RequestAccessForApplicationAsync)(self as *const _ as *mut _, applicationId.get(), &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } - }} - #[inline] pub fn remove_access(&self) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).RemoveAccess)(self as *const _ as *mut _); - if hr == S_OK { Ok(()) } else { err(hr) } - }} - #[inline] pub fn remove_access_for_application(&self, applicationId: &HStringArg) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).RemoveAccessForApplication)(self as *const _ as *mut _, applicationId.get()); + #[inline] pub fn set_contact_name(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_ContactName)(self as *const _ as *mut _, value.get()); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_access_status(&self) -> Result { unsafe { + #[inline] pub fn get_start_time(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).GetAccessStatus)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_StartTime)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_access_status_for_application(&self, applicationId: &HStringArg) -> Result { unsafe { + #[inline] pub fn set_start_time(&self, value: foundation::DateTime) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_StartTime)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_call_media(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).GetAccessStatusForApplication)(self as *const _ as *mut _, applicationId.get(), &mut out); + let hr = ((*self.lpVtbl).get_CallMedia)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} + #[inline] pub fn set_call_media(&self, value: VoipPhoneCallMedia) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_CallMedia)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn notify_call_ready(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).NotifyCallReady)(self as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} } -DEFINE_IID!(IID_IBackgroundTask, 2098451764, 64786, 17358, 140, 34, 234, 31, 241, 60, 6, 223); -RT_INTERFACE!{interface IBackgroundTask(IBackgroundTaskVtbl): IInspectable(IInspectableVtbl) [IID_IBackgroundTask] { - fn Run(&self, taskInstance: *mut IBackgroundTaskInstance) -> HRESULT +RT_CLASS!{class VoipPhoneCall: IVoipPhoneCall} +DEFINE_IID!(IID_IVoipPhoneCall2, 1947944673, 9311, 16883, 147, 153, 49, 65, 210, 91, 82, 227); +RT_INTERFACE!{interface IVoipPhoneCall2(IVoipPhoneCall2Vtbl): IInspectable(IInspectableVtbl) [IID_IVoipPhoneCall2] { + fn TryShowAppUI(&self) -> HRESULT }} -impl IBackgroundTask { - #[inline] pub fn run(&self, taskInstance: &IBackgroundTaskInstance) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).Run)(self as *const _ as *mut _, taskInstance as *const _ as *mut _); +impl IVoipPhoneCall2 { + #[inline] pub fn try_show_app_ui(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).TryShowAppUI)(self as *const _ as *mut _); if hr == S_OK { Ok(()) } else { err(hr) } }} } -DEFINE_IID!(IID_IBackgroundTaskBuilder, 55661838, 15972, 17778, 169, 58, 132, 7, 90, 55, 201, 23); -RT_INTERFACE!{interface IBackgroundTaskBuilder(IBackgroundTaskBuilderVtbl): IInspectable(IInspectableVtbl) [IID_IBackgroundTaskBuilder] { - fn put_TaskEntryPoint(&self, value: HSTRING) -> HRESULT, - fn get_TaskEntryPoint(&self, out: *mut HSTRING) -> HRESULT, - fn SetTrigger(&self, trigger: *mut IBackgroundTrigger) -> HRESULT, - fn AddCondition(&self, condition: *mut IBackgroundCondition) -> HRESULT, - fn put_Name(&self, value: HSTRING) -> HRESULT, - fn get_Name(&self, out: *mut HSTRING) -> HRESULT, - fn Register(&self, out: *mut *mut BackgroundTaskRegistration) -> HRESULT +DEFINE_IID!(IID_IVoipPhoneCall3, 227087650, 57944, 19113, 144, 122, 26, 164, 19, 194, 85, 35); +RT_INTERFACE!{interface IVoipPhoneCall3(IVoipPhoneCall3Vtbl): IInspectable(IInspectableVtbl) [IID_IVoipPhoneCall3] { + fn NotifyCallAccepted(&self, media: VoipPhoneCallMedia) -> HRESULT }} -impl IBackgroundTaskBuilder { - #[inline] pub fn set_task_entry_point(&self, value: &HStringArg) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_TaskEntryPoint)(self as *const _ as *mut _, value.get()); +impl IVoipPhoneCall3 { + #[inline] pub fn notify_call_accepted(&self, media: VoipPhoneCallMedia) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).NotifyCallAccepted)(self as *const _ as *mut _, media); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_task_entry_point(&self) -> Result { unsafe { +} +RT_ENUM! { enum VoipPhoneCallMedia: u32 { + None (VoipPhoneCallMedia_None) = 0, Audio (VoipPhoneCallMedia_Audio) = 1, Video (VoipPhoneCallMedia_Video) = 2, +}} +RT_ENUM! { enum VoipPhoneCallRejectReason: i32 { + UserIgnored (VoipPhoneCallRejectReason_UserIgnored) = 0, TimedOut (VoipPhoneCallRejectReason_TimedOut) = 1, OtherIncomingCall (VoipPhoneCallRejectReason_OtherIncomingCall) = 2, EmergencyCallExists (VoipPhoneCallRejectReason_EmergencyCallExists) = 3, InvalidCallState (VoipPhoneCallRejectReason_InvalidCallState) = 4, +}} +RT_ENUM! { enum VoipPhoneCallResourceReservationStatus: i32 { + Success (VoipPhoneCallResourceReservationStatus_Success) = 0, ResourcesNotAvailable (VoipPhoneCallResourceReservationStatus_ResourcesNotAvailable) = 1, +}} +RT_ENUM! { enum VoipPhoneCallState: i32 { + Ended (VoipPhoneCallState_Ended) = 0, Held (VoipPhoneCallState_Held) = 1, Active (VoipPhoneCallState_Active) = 2, Incoming (VoipPhoneCallState_Incoming) = 3, Outgoing (VoipPhoneCallState_Outgoing) = 4, +}} +pub mod background { // Windows.ApplicationModel.Calls.Background +use ::prelude::*; +RT_ENUM! { enum PhoneCallBlockedReason: i32 { + InCallBlockingList (PhoneCallBlockedReason_InCallBlockingList) = 0, PrivateNumber (PhoneCallBlockedReason_PrivateNumber) = 1, UnknownNumber (PhoneCallBlockedReason_UnknownNumber) = 2, +}} +DEFINE_IID!(IID_IPhoneCallBlockedTriggerDetails, 2762379426, 58561, 17023, 134, 78, 228, 112, 71, 125, 219, 103); +RT_INTERFACE!{interface IPhoneCallBlockedTriggerDetails(IPhoneCallBlockedTriggerDetailsVtbl): IInspectable(IInspectableVtbl) [IID_IPhoneCallBlockedTriggerDetails] { + fn get_PhoneNumber(&self, out: *mut HSTRING) -> HRESULT, + fn get_LineId(&self, out: *mut Guid) -> HRESULT, + fn get_CallBlockedReason(&self, out: *mut PhoneCallBlockedReason) -> HRESULT +}} +impl IPhoneCallBlockedTriggerDetails { + #[inline] pub fn get_phone_number(&self) -> Result { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_TaskEntryPoint)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_PhoneNumber)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} - #[inline] pub fn set_trigger(&self, trigger: &IBackgroundTrigger) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).SetTrigger)(self as *const _ as *mut _, trigger as *const _ as *mut _); - if hr == S_OK { Ok(()) } else { err(hr) } + #[inline] pub fn get_line_id(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_LineId)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn add_condition(&self, condition: &IBackgroundCondition) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).AddCondition)(self as *const _ as *mut _, condition as *const _ as *mut _); - if hr == S_OK { Ok(()) } else { err(hr) } + #[inline] pub fn get_call_blocked_reason(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_CallBlockedReason)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn set_name(&self, value: &HStringArg) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_Name)(self as *const _ as *mut _, value.get()); - if hr == S_OK { Ok(()) } else { err(hr) } +} +RT_CLASS!{class PhoneCallBlockedTriggerDetails: IPhoneCallBlockedTriggerDetails} +DEFINE_IID!(IID_IPhoneCallOriginDataRequestTriggerDetails, 1855675199, 50507, 20098, 76, 201, 227, 41, 164, 24, 69, 146); +RT_INTERFACE!{interface IPhoneCallOriginDataRequestTriggerDetails(IPhoneCallOriginDataRequestTriggerDetailsVtbl): IInspectable(IInspectableVtbl) [IID_IPhoneCallOriginDataRequestTriggerDetails] { + fn get_RequestId(&self, out: *mut Guid) -> HRESULT, + fn get_PhoneNumber(&self, out: *mut HSTRING) -> HRESULT +}} +impl IPhoneCallOriginDataRequestTriggerDetails { + #[inline] pub fn get_request_id(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_RequestId)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_name(&self) -> Result { unsafe { + #[inline] pub fn get_phone_number(&self) -> Result { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Name)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_PhoneNumber)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} - #[inline] pub fn register(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).Register)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } - }} } -RT_CLASS!{class BackgroundTaskBuilder: IBackgroundTaskBuilder} -impl RtActivatable for BackgroundTaskBuilder {} -DEFINE_CLSID!(BackgroundTaskBuilder(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,66,97,99,107,103,114,111,117,110,100,84,97,115,107,66,117,105,108,100,101,114,0]) [CLSID_BackgroundTaskBuilder]); -DEFINE_IID!(IID_IBackgroundTaskBuilder2, 1793576881, 4175, 16493, 141, 182, 132, 74, 87, 15, 66, 187); -RT_INTERFACE!{interface IBackgroundTaskBuilder2(IBackgroundTaskBuilder2Vtbl): IInspectable(IInspectableVtbl) [IID_IBackgroundTaskBuilder2] { - fn put_CancelOnConditionLoss(&self, value: bool) -> HRESULT, - fn get_CancelOnConditionLoss(&self, out: *mut bool) -> HRESULT +RT_CLASS!{class PhoneCallOriginDataRequestTriggerDetails: IPhoneCallOriginDataRequestTriggerDetails} +DEFINE_IID!(IID_IPhoneLineChangedTriggerDetails, 3335725543, 53533, 16600, 178, 183, 228, 10, 1, 214, 98, 73); +RT_INTERFACE!{interface IPhoneLineChangedTriggerDetails(IPhoneLineChangedTriggerDetailsVtbl): IInspectable(IInspectableVtbl) [IID_IPhoneLineChangedTriggerDetails] { + fn get_LineId(&self, out: *mut Guid) -> HRESULT, + fn get_ChangeType(&self, out: *mut PhoneLineChangeKind) -> HRESULT, + fn HasLinePropertyChanged(&self, lineProperty: PhoneLineProperties, out: *mut bool) -> HRESULT }} -impl IBackgroundTaskBuilder2 { - #[inline] pub fn set_cancel_on_condition_loss(&self, value: bool) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_CancelOnConditionLoss)(self as *const _ as *mut _, value); - if hr == S_OK { Ok(()) } else { err(hr) } +impl IPhoneLineChangedTriggerDetails { + #[inline] pub fn get_line_id(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_LineId)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_cancel_on_condition_loss(&self) -> Result { unsafe { + #[inline] pub fn get_change_type(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_CancelOnConditionLoss)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_ChangeType)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn has_line_property_changed(&self, lineProperty: PhoneLineProperties) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).HasLinePropertyChanged)(self as *const _ as *mut _, lineProperty, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} } -DEFINE_IID!(IID_IBackgroundTaskBuilder3, 684150602, 35753, 19465, 162, 79, 25, 104, 62, 44, 146, 76); -RT_INTERFACE!{interface IBackgroundTaskBuilder3(IBackgroundTaskBuilder3Vtbl): IInspectable(IInspectableVtbl) [IID_IBackgroundTaskBuilder3] { - fn put_IsNetworkRequested(&self, value: bool) -> HRESULT, - fn get_IsNetworkRequested(&self, out: *mut bool) -> HRESULT +RT_CLASS!{class PhoneLineChangedTriggerDetails: IPhoneLineChangedTriggerDetails} +RT_ENUM! { enum PhoneLineChangeKind: i32 { + Added (PhoneLineChangeKind_Added) = 0, Removed (PhoneLineChangeKind_Removed) = 1, PropertiesChanged (PhoneLineChangeKind_PropertiesChanged) = 2, }} -impl IBackgroundTaskBuilder3 { - #[inline] pub fn set_is_network_requested(&self, value: bool) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_IsNetworkRequested)(self as *const _ as *mut _, value); - if hr == S_OK { Ok(()) } else { err(hr) } +RT_ENUM! { enum PhoneLineProperties: u32 { + None (PhoneLineProperties_None) = 0, BrandingOptions (PhoneLineProperties_BrandingOptions) = 1, CanDial (PhoneLineProperties_CanDial) = 2, CellularDetails (PhoneLineProperties_CellularDetails) = 4, DisplayColor (PhoneLineProperties_DisplayColor) = 8, DisplayName (PhoneLineProperties_DisplayName) = 16, NetworkName (PhoneLineProperties_NetworkName) = 32, NetworkState (PhoneLineProperties_NetworkState) = 64, Transport (PhoneLineProperties_Transport) = 128, Voicemail (PhoneLineProperties_Voicemail) = 256, +}} +DEFINE_IID!(IID_IPhoneNewVoicemailMessageTriggerDetails, 329826331, 47153, 18643, 139, 169, 141, 34, 166, 88, 13, 207); +RT_INTERFACE!{interface IPhoneNewVoicemailMessageTriggerDetails(IPhoneNewVoicemailMessageTriggerDetailsVtbl): IInspectable(IInspectableVtbl) [IID_IPhoneNewVoicemailMessageTriggerDetails] { + fn get_LineId(&self, out: *mut Guid) -> HRESULT, + fn get_VoicemailCount(&self, out: *mut i32) -> HRESULT, + fn get_OperatorMessage(&self, out: *mut HSTRING) -> HRESULT +}} +impl IPhoneNewVoicemailMessageTriggerDetails { + #[inline] pub fn get_line_id(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_LineId)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_is_network_requested(&self) -> Result { unsafe { + #[inline] pub fn get_voicemail_count(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_IsNetworkRequested)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_VoicemailCount)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} -} -DEFINE_IID!(IID_IBackgroundTaskBuilder4, 1196811554, 52130, 20021, 189, 22, 166, 218, 127, 28, 25, 170); -RT_INTERFACE!{interface IBackgroundTaskBuilder4(IBackgroundTaskBuilder4Vtbl): IInspectable(IInspectableVtbl) [IID_IBackgroundTaskBuilder4] { - fn get_TaskGroup(&self, out: *mut *mut BackgroundTaskRegistrationGroup) -> HRESULT, - fn put_TaskGroup(&self, value: *mut BackgroundTaskRegistrationGroup) -> HRESULT -}} -impl IBackgroundTaskBuilder4 { - #[inline] pub fn get_task_group(&self) -> Result>> { unsafe { + #[inline] pub fn get_operator_message(&self) -> Result { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_TaskGroup)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } - }} - #[inline] pub fn set_task_group(&self, value: &BackgroundTaskRegistrationGroup) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_TaskGroup)(self as *const _ as *mut _, value as *const _ as *mut _); - if hr == S_OK { Ok(()) } else { err(hr) } + let hr = ((*self.lpVtbl).get_OperatorMessage)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} } -DEFINE_IID!(IID_BackgroundTaskCanceledEventHandler, 2797910720, 20984, 19543, 172, 63, 21, 109, 209, 104, 12, 79); -RT_DELEGATE!{delegate BackgroundTaskCanceledEventHandler(BackgroundTaskCanceledEventHandlerVtbl, BackgroundTaskCanceledEventHandlerImpl) [IID_BackgroundTaskCanceledEventHandler] { - fn Invoke(&self, sender: *mut IBackgroundTaskInstance, reason: BackgroundTaskCancellationReason) -> HRESULT +RT_CLASS!{class PhoneNewVoicemailMessageTriggerDetails: IPhoneNewVoicemailMessageTriggerDetails} +RT_ENUM! { enum PhoneTriggerType: i32 { + NewVoicemailMessage (PhoneTriggerType_NewVoicemailMessage) = 0, CallHistoryChanged (PhoneTriggerType_CallHistoryChanged) = 1, LineChanged (PhoneTriggerType_LineChanged) = 2, AirplaneModeDisabledForEmergencyCall (PhoneTriggerType_AirplaneModeDisabledForEmergencyCall) = 3, CallOriginDataRequest (PhoneTriggerType_CallOriginDataRequest) = 4, CallBlocked (PhoneTriggerType_CallBlocked) = 5, }} -impl BackgroundTaskCanceledEventHandler { - #[inline] pub fn invoke(&self, sender: &IBackgroundTaskInstance, reason: BackgroundTaskCancellationReason) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).Invoke)(self as *const _ as *mut _, sender as *const _ as *mut _, reason); - if hr == S_OK { Ok(()) } else { err(hr) } - }} -} -RT_ENUM! { enum BackgroundTaskCancellationReason: i32 { - Abort (BackgroundTaskCancellationReason_Abort) = 0, Terminating (BackgroundTaskCancellationReason_Terminating) = 1, LoggingOff (BackgroundTaskCancellationReason_LoggingOff) = 2, ServicingUpdate (BackgroundTaskCancellationReason_ServicingUpdate) = 3, IdleTask (BackgroundTaskCancellationReason_IdleTask) = 4, Uninstall (BackgroundTaskCancellationReason_Uninstall) = 5, ConditionLoss (BackgroundTaskCancellationReason_ConditionLoss) = 6, SystemPolicy (BackgroundTaskCancellationReason_SystemPolicy) = 7, QuietHoursEntered (BackgroundTaskCancellationReason_QuietHoursEntered) = 8, ExecutionTimeExceeded (BackgroundTaskCancellationReason_ExecutionTimeExceeded) = 9, ResourceRevocation (BackgroundTaskCancellationReason_ResourceRevocation) = 10, EnergySaver (BackgroundTaskCancellationReason_EnergySaver) = 11, -}} -DEFINE_IID!(IID_IBackgroundTaskCompletedEventArgs, 1448945103, 61961, 18676, 153, 103, 43, 24, 79, 123, 251, 240); -RT_INTERFACE!{interface IBackgroundTaskCompletedEventArgs(IBackgroundTaskCompletedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IBackgroundTaskCompletedEventArgs] { - fn get_InstanceId(&self, out: *mut Guid) -> HRESULT, - fn CheckResult(&self) -> HRESULT +} // Windows.ApplicationModel.Calls.Background +} // Windows.ApplicationModel.Calls +pub mod socialinfo { // Windows.ApplicationModel.SocialInfo +use ::prelude::*; +DEFINE_IID!(IID_ISocialFeedChildItem, 191535194, 54685, 16574, 152, 12, 72, 138, 42, 179, 10, 131); +RT_INTERFACE!{interface ISocialFeedChildItem(ISocialFeedChildItemVtbl): IInspectable(IInspectableVtbl) [IID_ISocialFeedChildItem] { + fn get_Author(&self, out: *mut *mut SocialUserInfo) -> HRESULT, + fn get_PrimaryContent(&self, out: *mut *mut SocialFeedContent) -> HRESULT, + fn get_SecondaryContent(&self, out: *mut *mut SocialFeedContent) -> HRESULT, + fn get_Timestamp(&self, out: *mut foundation::DateTime) -> HRESULT, + fn put_Timestamp(&self, value: foundation::DateTime) -> HRESULT, + fn get_TargetUri(&self, out: *mut *mut foundation::Uri) -> HRESULT, + fn put_TargetUri(&self, value: *mut foundation::Uri) -> HRESULT, + fn get_Thumbnails(&self, out: *mut *mut foundation::collections::IVector) -> HRESULT, + fn get_SharedItem(&self, out: *mut *mut SocialFeedSharedItem) -> HRESULT, + fn put_SharedItem(&self, value: *mut SocialFeedSharedItem) -> HRESULT }} -impl IBackgroundTaskCompletedEventArgs { - #[inline] pub fn get_instance_id(&self) -> Result { unsafe { +impl ISocialFeedChildItem { + #[inline] pub fn get_author(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Author)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_primary_content(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_PrimaryContent)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_secondary_content(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_SecondaryContent)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_timestamp(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_InstanceId)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_Timestamp)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn check_result(&self) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).CheckResult)(self as *const _ as *mut _); + #[inline] pub fn set_timestamp(&self, value: foundation::DateTime) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Timestamp)(self as *const _ as *mut _, value); if hr == S_OK { Ok(()) } else { err(hr) } }} -} -RT_CLASS!{class BackgroundTaskCompletedEventArgs: IBackgroundTaskCompletedEventArgs} -DEFINE_IID!(IID_BackgroundTaskCompletedEventHandler, 1530456361, 41094, 18087, 166, 120, 67, 145, 53, 130, 43, 207); -RT_DELEGATE!{delegate BackgroundTaskCompletedEventHandler(BackgroundTaskCompletedEventHandlerVtbl, BackgroundTaskCompletedEventHandlerImpl) [IID_BackgroundTaskCompletedEventHandler] { - fn Invoke(&self, sender: *mut BackgroundTaskRegistration, args: *mut BackgroundTaskCompletedEventArgs) -> HRESULT -}} -impl BackgroundTaskCompletedEventHandler { - #[inline] pub fn invoke(&self, sender: &BackgroundTaskRegistration, args: &BackgroundTaskCompletedEventArgs) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).Invoke)(self as *const _ as *mut _, sender as *const _ as *mut _, args as *const _ as *mut _); + #[inline] pub fn get_target_uri(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_TargetUri)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn set_target_uri(&self, value: &foundation::Uri) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_TargetUri)(self as *const _ as *mut _, value as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_thumbnails(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Thumbnails)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_shared_item(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_SharedItem)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn set_shared_item(&self, value: &SocialFeedSharedItem) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_SharedItem)(self as *const _ as *mut _, value as *const _ as *mut _); if hr == S_OK { Ok(()) } else { err(hr) } }} } -DEFINE_IID!(IID_IBackgroundTaskDeferral, 2479625581, 44839, 19923, 132, 110, 36, 238, 64, 202, 221, 37); -RT_INTERFACE!{interface IBackgroundTaskDeferral(IBackgroundTaskDeferralVtbl): IInspectable(IInspectableVtbl) [IID_IBackgroundTaskDeferral] { - fn Complete(&self) -> HRESULT +RT_CLASS!{class SocialFeedChildItem: ISocialFeedChildItem} +impl RtActivatable for SocialFeedChildItem {} +DEFINE_CLSID!(SocialFeedChildItem(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,83,111,99,105,97,108,73,110,102,111,46,83,111,99,105,97,108,70,101,101,100,67,104,105,108,100,73,116,101,109,0]) [CLSID_SocialFeedChildItem]); +DEFINE_IID!(IID_ISocialFeedContent, 2721375273, 15929, 18765, 163, 124, 244, 98, 162, 73, 69, 20); +RT_INTERFACE!{interface ISocialFeedContent(ISocialFeedContentVtbl): IInspectable(IInspectableVtbl) [IID_ISocialFeedContent] { + fn get_Title(&self, out: *mut HSTRING) -> HRESULT, + fn put_Title(&self, value: HSTRING) -> HRESULT, + fn get_Message(&self, out: *mut HSTRING) -> HRESULT, + fn put_Message(&self, value: HSTRING) -> HRESULT, + fn get_TargetUri(&self, out: *mut *mut foundation::Uri) -> HRESULT, + fn put_TargetUri(&self, value: *mut foundation::Uri) -> HRESULT }} -impl IBackgroundTaskDeferral { - #[inline] pub fn complete(&self) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).Complete)(self as *const _ as *mut _); +impl ISocialFeedContent { + #[inline] pub fn get_title(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Title)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn set_title(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Title)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_message(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Message)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn set_message(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Message)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_target_uri(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_TargetUri)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn set_target_uri(&self, value: &foundation::Uri) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_TargetUri)(self as *const _ as *mut _, value as *const _ as *mut _); if hr == S_OK { Ok(()) } else { err(hr) } }} } -RT_CLASS!{class BackgroundTaskDeferral: IBackgroundTaskDeferral} -DEFINE_IID!(IID_IBackgroundTaskInstance, 2254166650, 8664, 17779, 143, 50, 146, 138, 27, 6, 65, 246); -RT_INTERFACE!{interface IBackgroundTaskInstance(IBackgroundTaskInstanceVtbl): IInspectable(IInspectableVtbl) [IID_IBackgroundTaskInstance] { - fn get_InstanceId(&self, out: *mut Guid) -> HRESULT, - fn get_Task(&self, out: *mut *mut BackgroundTaskRegistration) -> HRESULT, - fn get_Progress(&self, out: *mut u32) -> HRESULT, - fn put_Progress(&self, value: u32) -> HRESULT, - fn get_TriggerDetails(&self, out: *mut *mut IInspectable) -> HRESULT, - fn add_Canceled(&self, cancelHandler: *mut BackgroundTaskCanceledEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, - fn remove_Canceled(&self, cookie: foundation::EventRegistrationToken) -> HRESULT, - fn get_SuspendedCount(&self, out: *mut u32) -> HRESULT, - fn GetDeferral(&self, out: *mut *mut BackgroundTaskDeferral) -> HRESULT +RT_CLASS!{class SocialFeedContent: ISocialFeedContent} +DEFINE_IID!(IID_ISocialFeedItem, 1326682795, 8050, 19763, 182, 149, 222, 62, 29, 182, 3, 23); +RT_INTERFACE!{interface ISocialFeedItem(ISocialFeedItemVtbl): IInspectable(IInspectableVtbl) [IID_ISocialFeedItem] { + fn get_Author(&self, out: *mut *mut SocialUserInfo) -> HRESULT, + fn get_PrimaryContent(&self, out: *mut *mut SocialFeedContent) -> HRESULT, + fn get_SecondaryContent(&self, out: *mut *mut SocialFeedContent) -> HRESULT, + fn get_Timestamp(&self, out: *mut foundation::DateTime) -> HRESULT, + fn put_Timestamp(&self, value: foundation::DateTime) -> HRESULT, + fn get_TargetUri(&self, out: *mut *mut foundation::Uri) -> HRESULT, + fn put_TargetUri(&self, value: *mut foundation::Uri) -> HRESULT, + fn get_Thumbnails(&self, out: *mut *mut foundation::collections::IVector) -> HRESULT, + fn get_SharedItem(&self, out: *mut *mut SocialFeedSharedItem) -> HRESULT, + fn put_SharedItem(&self, value: *mut SocialFeedSharedItem) -> HRESULT, + fn get_BadgeStyle(&self, out: *mut SocialItemBadgeStyle) -> HRESULT, + fn put_BadgeStyle(&self, value: SocialItemBadgeStyle) -> HRESULT, + fn get_BadgeCountValue(&self, out: *mut i32) -> HRESULT, + fn put_BadgeCountValue(&self, value: i32) -> HRESULT, + fn get_RemoteId(&self, out: *mut HSTRING) -> HRESULT, + fn put_RemoteId(&self, value: HSTRING) -> HRESULT, + fn get_ChildItem(&self, out: *mut *mut SocialFeedChildItem) -> HRESULT, + fn put_ChildItem(&self, value: *mut SocialFeedChildItem) -> HRESULT, + fn get_Style(&self, out: *mut SocialFeedItemStyle) -> HRESULT, + fn put_Style(&self, value: SocialFeedItemStyle) -> HRESULT }} -impl IBackgroundTaskInstance { - #[inline] pub fn get_instance_id(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_InstanceId)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } +impl ISocialFeedItem { + #[inline] pub fn get_author(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Author)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn get_task(&self) -> Result>> { unsafe { + #[inline] pub fn get_primary_content(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Task)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_PrimaryContent)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn get_progress(&self) -> Result { unsafe { + #[inline] pub fn get_secondary_content(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_SecondaryContent)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_timestamp(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_Progress)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_Timestamp)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn set_progress(&self, value: u32) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_Progress)(self as *const _ as *mut _, value); + #[inline] pub fn set_timestamp(&self, value: foundation::DateTime) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Timestamp)(self as *const _ as *mut _, value); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_trigger_details(&self) -> Result>> { unsafe { + #[inline] pub fn get_target_uri(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_TriggerDetails)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_TargetUri)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn add_canceled(&self, cancelHandler: &BackgroundTaskCanceledEventHandler) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).add_Canceled)(self as *const _ as *mut _, cancelHandler as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } - }} - #[inline] pub fn remove_canceled(&self, cookie: foundation::EventRegistrationToken) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).remove_Canceled)(self as *const _ as *mut _, cookie); + #[inline] pub fn set_target_uri(&self, value: &foundation::Uri) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_TargetUri)(self as *const _ as *mut _, value as *const _ as *mut _); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_suspended_count(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_SuspendedCount)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } - }} - #[inline] pub fn get_deferral(&self) -> Result>> { unsafe { + #[inline] pub fn get_thumbnails(&self) -> Result>>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetDeferral)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_Thumbnails)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} -} -DEFINE_IID!(IID_IBackgroundTaskInstance2, 1333592438, 3190, 20404, 137, 109, 93, 225, 134, 65, 34, 246); -RT_INTERFACE!{interface IBackgroundTaskInstance2(IBackgroundTaskInstance2Vtbl): IInspectable(IInspectableVtbl) [IID_IBackgroundTaskInstance2] { - fn GetThrottleCount(&self, counter: BackgroundTaskThrottleCounter, out: *mut u32) -> HRESULT -}} -impl IBackgroundTaskInstance2 { - #[inline] pub fn get_throttle_count(&self, counter: BackgroundTaskThrottleCounter) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).GetThrottleCount)(self as *const _ as *mut _, counter, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } - }} -} -DEFINE_IID!(IID_IBackgroundTaskInstance4, 2133455420, 43524, 19208, 151, 176, 6, 216, 116, 205, 171, 245); -RT_INTERFACE!{interface IBackgroundTaskInstance4(IBackgroundTaskInstance4Vtbl): IInspectable(IInspectableVtbl) [IID_IBackgroundTaskInstance4] { - #[cfg(feature="windows-system")] fn get_User(&self, out: *mut *mut super::super::system::User) -> HRESULT -}} -impl IBackgroundTaskInstance4 { - #[cfg(feature="windows-system")] #[inline] pub fn get_user(&self) -> Result>> { unsafe { + #[inline] pub fn get_shared_item(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_User)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_SharedItem)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} -} -DEFINE_IID!(IID_IBackgroundTaskProgressEventArgs, 4212418732, 33586, 19722, 149, 50, 3, 234, 230, 132, 218, 49); -RT_INTERFACE!{interface IBackgroundTaskProgressEventArgs(IBackgroundTaskProgressEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IBackgroundTaskProgressEventArgs] { - fn get_InstanceId(&self, out: *mut Guid) -> HRESULT, - fn get_Progress(&self, out: *mut u32) -> HRESULT -}} -impl IBackgroundTaskProgressEventArgs { - #[inline] pub fn get_instance_id(&self) -> Result { unsafe { + #[inline] pub fn set_shared_item(&self, value: &SocialFeedSharedItem) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_SharedItem)(self as *const _ as *mut _, value as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_badge_style(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_InstanceId)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_BadgeStyle)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_progress(&self) -> Result { unsafe { + #[inline] pub fn set_badge_style(&self, value: SocialItemBadgeStyle) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_BadgeStyle)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_badge_count_value(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_Progress)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_BadgeCountValue)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} -} -RT_CLASS!{class BackgroundTaskProgressEventArgs: IBackgroundTaskProgressEventArgs} -DEFINE_IID!(IID_BackgroundTaskProgressEventHandler, 1189111868, 35464, 19609, 128, 76, 118, 137, 127, 98, 119, 166); -RT_DELEGATE!{delegate BackgroundTaskProgressEventHandler(BackgroundTaskProgressEventHandlerVtbl, BackgroundTaskProgressEventHandlerImpl) [IID_BackgroundTaskProgressEventHandler] { - fn Invoke(&self, sender: *mut BackgroundTaskRegistration, args: *mut BackgroundTaskProgressEventArgs) -> HRESULT -}} -impl BackgroundTaskProgressEventHandler { - #[inline] pub fn invoke(&self, sender: &BackgroundTaskRegistration, args: &BackgroundTaskProgressEventArgs) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).Invoke)(self as *const _ as *mut _, sender as *const _ as *mut _, args as *const _ as *mut _); + #[inline] pub fn set_badge_count_value(&self, value: i32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_BadgeCountValue)(self as *const _ as *mut _, value); if hr == S_OK { Ok(()) } else { err(hr) } }} -} -DEFINE_IID!(IID_IBackgroundTaskRegistration, 275074242, 41582, 17343, 140, 18, 31, 180, 13, 191, 191, 160); -RT_INTERFACE!{interface IBackgroundTaskRegistration(IBackgroundTaskRegistrationVtbl): IInspectable(IInspectableVtbl) [IID_IBackgroundTaskRegistration] { - fn get_TaskId(&self, out: *mut Guid) -> HRESULT, - fn get_Name(&self, out: *mut HSTRING) -> HRESULT, - fn add_Progress(&self, handler: *mut BackgroundTaskProgressEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, - fn remove_Progress(&self, cookie: foundation::EventRegistrationToken) -> HRESULT, - fn add_Completed(&self, handler: *mut BackgroundTaskCompletedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, - fn remove_Completed(&self, cookie: foundation::EventRegistrationToken) -> HRESULT, - fn Unregister(&self, cancelTask: bool) -> HRESULT -}} -impl IBackgroundTaskRegistration { - #[inline] pub fn get_task_id(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_TaskId)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } - }} - #[inline] pub fn get_name(&self) -> Result { unsafe { + #[inline] pub fn get_remote_id(&self) -> Result { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Name)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_RemoteId)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} - #[inline] pub fn add_progress(&self, handler: &BackgroundTaskProgressEventHandler) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).add_Progress)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } + #[inline] pub fn set_remote_id(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_RemoteId)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn remove_progress(&self, cookie: foundation::EventRegistrationToken) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).remove_Progress)(self as *const _ as *mut _, cookie); + #[inline] pub fn get_child_item(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ChildItem)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn set_child_item(&self, value: &SocialFeedChildItem) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_ChildItem)(self as *const _ as *mut _, value as *const _ as *mut _); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn add_completed(&self, handler: &BackgroundTaskCompletedEventHandler) -> Result { unsafe { + #[inline] pub fn get_style(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).add_Completed)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_Style)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn remove_completed(&self, cookie: foundation::EventRegistrationToken) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).remove_Completed)(self as *const _ as *mut _, cookie); - if hr == S_OK { Ok(()) } else { err(hr) } - }} - #[inline] pub fn unregister(&self, cancelTask: bool) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).Unregister)(self as *const _ as *mut _, cancelTask); + #[inline] pub fn set_style(&self, value: SocialFeedItemStyle) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Style)(self as *const _ as *mut _, value); if hr == S_OK { Ok(()) } else { err(hr) } }} } -RT_CLASS!{class BackgroundTaskRegistration: IBackgroundTaskRegistration} -impl RtActivatable for BackgroundTaskRegistration {} -impl RtActivatable for BackgroundTaskRegistration {} -impl BackgroundTaskRegistration { - #[inline] pub fn get_all_tasks() -> Result>>> { - >::get_activation_factory().get_all_tasks() - } - #[inline] pub fn get_all_task_groups() -> Result>>> { - >::get_activation_factory().get_all_task_groups() - } - #[inline] pub fn get_task_group(groupId: &HStringArg) -> Result>> { - >::get_activation_factory().get_task_group(groupId) - } -} -DEFINE_CLSID!(BackgroundTaskRegistration(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,66,97,99,107,103,114,111,117,110,100,84,97,115,107,82,101,103,105,115,116,114,97,116,105,111,110,0]) [CLSID_BackgroundTaskRegistration]); -DEFINE_IID!(IID_IBackgroundTaskRegistration2, 1631110915, 48006, 16658, 175, 195, 127, 147, 155, 22, 110, 59); -RT_INTERFACE!{interface IBackgroundTaskRegistration2(IBackgroundTaskRegistration2Vtbl): IInspectable(IInspectableVtbl) [IID_IBackgroundTaskRegistration2] { - fn get_Trigger(&self, out: *mut *mut IBackgroundTrigger) -> HRESULT +RT_CLASS!{class SocialFeedItem: ISocialFeedItem} +impl RtActivatable for SocialFeedItem {} +DEFINE_CLSID!(SocialFeedItem(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,83,111,99,105,97,108,73,110,102,111,46,83,111,99,105,97,108,70,101,101,100,73,116,101,109,0]) [CLSID_SocialFeedItem]); +RT_ENUM! { enum SocialFeedItemStyle: i32 { + Default (SocialFeedItemStyle_Default) = 0, Photo (SocialFeedItemStyle_Photo) = 1, }} -impl IBackgroundTaskRegistration2 { - #[inline] pub fn get_trigger(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Trigger)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } - }} -} -DEFINE_IID!(IID_IBackgroundTaskRegistration3, 4264788373, 37923, 19851, 131, 13, 177, 221, 44, 123, 173, 213); -RT_INTERFACE!{interface IBackgroundTaskRegistration3(IBackgroundTaskRegistration3Vtbl): IInspectable(IInspectableVtbl) [IID_IBackgroundTaskRegistration3] { - fn get_TaskGroup(&self, out: *mut *mut BackgroundTaskRegistrationGroup) -> HRESULT +RT_ENUM! { enum SocialFeedKind: i32 { + HomeFeed (SocialFeedKind_HomeFeed) = 0, ContactFeed (SocialFeedKind_ContactFeed) = 1, Dashboard (SocialFeedKind_Dashboard) = 2, }} -impl IBackgroundTaskRegistration3 { - #[inline] pub fn get_task_group(&self) -> Result>> { unsafe { +DEFINE_IID!(IID_ISocialFeedSharedItem, 2080087616, 42666, 17831, 159, 246, 84, 196, 33, 5, 221, 31); +RT_INTERFACE!{interface ISocialFeedSharedItem(ISocialFeedSharedItemVtbl): IInspectable(IInspectableVtbl) [IID_ISocialFeedSharedItem] { + fn get_OriginalSource(&self, out: *mut *mut foundation::Uri) -> HRESULT, + fn put_OriginalSource(&self, value: *mut foundation::Uri) -> HRESULT, + fn get_Content(&self, out: *mut *mut SocialFeedContent) -> HRESULT, + fn get_Timestamp(&self, out: *mut foundation::DateTime) -> HRESULT, + fn put_Timestamp(&self, value: foundation::DateTime) -> HRESULT, + fn get_TargetUri(&self, out: *mut *mut foundation::Uri) -> HRESULT, + fn put_TargetUri(&self, value: *mut foundation::Uri) -> HRESULT, + fn put_Thumbnail(&self, value: *mut SocialItemThumbnail) -> HRESULT, + fn get_Thumbnail(&self, out: *mut *mut SocialItemThumbnail) -> HRESULT +}} +impl ISocialFeedSharedItem { + #[inline] pub fn get_original_source(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_TaskGroup)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_OriginalSource)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} -} -DEFINE_IID!(IID_IBackgroundTaskRegistrationGroup, 716280218, 34587, 16743, 138, 118, 5, 92, 214, 123, 91, 35); -RT_INTERFACE!{interface IBackgroundTaskRegistrationGroup(IBackgroundTaskRegistrationGroupVtbl): IInspectable(IInspectableVtbl) [IID_IBackgroundTaskRegistrationGroup] { - fn get_Id(&self, out: *mut HSTRING) -> HRESULT, - fn get_Name(&self, out: *mut HSTRING) -> HRESULT, - fn add_BackgroundActivated(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, - fn remove_BackgroundActivated(&self, token: foundation::EventRegistrationToken) -> HRESULT, - fn get_AllTasks(&self, out: *mut *mut foundation::collections::IMapView) -> HRESULT -}} -impl IBackgroundTaskRegistrationGroup { - #[inline] pub fn get_id(&self) -> Result { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Id)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + #[inline] pub fn set_original_source(&self, value: &foundation::Uri) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_OriginalSource)(self as *const _ as *mut _, value as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_name(&self) -> Result { unsafe { + #[inline] pub fn get_content(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Name)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).get_Content)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn add_background_activated(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + #[inline] pub fn get_timestamp(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).add_BackgroundActivated)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_Timestamp)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn remove_background_activated(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).remove_BackgroundActivated)(self as *const _ as *mut _, token); + #[inline] pub fn set_timestamp(&self, value: foundation::DateTime) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Timestamp)(self as *const _ as *mut _, value); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_all_tasks(&self) -> Result>>> { unsafe { + #[inline] pub fn get_target_uri(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_AllTasks)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_TargetUri)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} -} -RT_CLASS!{class BackgroundTaskRegistrationGroup: IBackgroundTaskRegistrationGroup} -impl RtActivatable for BackgroundTaskRegistrationGroup {} -impl BackgroundTaskRegistrationGroup { - #[inline] pub fn create(id: &HStringArg) -> Result> { - >::get_activation_factory().create(id) - } - #[inline] pub fn create_with_name(id: &HStringArg, name: &HStringArg) -> Result> { - >::get_activation_factory().create_with_name(id, name) - } -} -DEFINE_CLSID!(BackgroundTaskRegistrationGroup(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,66,97,99,107,103,114,111,117,110,100,84,97,115,107,82,101,103,105,115,116,114,97,116,105,111,110,71,114,111,117,112,0]) [CLSID_BackgroundTaskRegistrationGroup]); -DEFINE_IID!(IID_IBackgroundTaskRegistrationGroupFactory, 2212047721, 17615, 17969, 151, 64, 3, 199, 216, 116, 27, 197); -RT_INTERFACE!{static interface IBackgroundTaskRegistrationGroupFactory(IBackgroundTaskRegistrationGroupFactoryVtbl): IInspectable(IInspectableVtbl) [IID_IBackgroundTaskRegistrationGroupFactory] { - fn Create(&self, id: HSTRING, out: *mut *mut BackgroundTaskRegistrationGroup) -> HRESULT, - fn CreateWithName(&self, id: HSTRING, name: HSTRING, out: *mut *mut BackgroundTaskRegistrationGroup) -> HRESULT -}} -impl IBackgroundTaskRegistrationGroupFactory { - #[inline] pub fn create(&self, id: &HStringArg) -> Result> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, id.get(), &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + #[inline] pub fn set_target_uri(&self, value: &foundation::Uri) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_TargetUri)(self as *const _ as *mut _, value as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn create_with_name(&self, id: &HStringArg, name: &HStringArg) -> Result> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).CreateWithName)(self as *const _ as *mut _, id.get(), name.get(), &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + #[inline] pub fn set_thumbnail(&self, value: &SocialItemThumbnail) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Thumbnail)(self as *const _ as *mut _, value as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } }} -} -DEFINE_IID!(IID_IBackgroundTaskRegistrationStatics, 1280585577, 45056, 17082, 160, 147, 106, 86, 60, 101, 227, 248); -RT_INTERFACE!{static interface IBackgroundTaskRegistrationStatics(IBackgroundTaskRegistrationStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IBackgroundTaskRegistrationStatics] { - fn get_AllTasks(&self, out: *mut *mut foundation::collections::IMapView) -> HRESULT -}} -impl IBackgroundTaskRegistrationStatics { - #[inline] pub fn get_all_tasks(&self) -> Result>>> { unsafe { + #[inline] pub fn get_thumbnail(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_AllTasks)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_Thumbnail)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } -DEFINE_IID!(IID_IBackgroundTaskRegistrationStatics2, 390817566, 45581, 20393, 173, 154, 233, 58, 214, 199, 30, 1); -RT_INTERFACE!{static interface IBackgroundTaskRegistrationStatics2(IBackgroundTaskRegistrationStatics2Vtbl): IInspectable(IInspectableVtbl) [IID_IBackgroundTaskRegistrationStatics2] { - fn get_AllTaskGroups(&self, out: *mut *mut foundation::collections::IMapView) -> HRESULT, - fn GetTaskGroup(&self, groupId: HSTRING, out: *mut *mut BackgroundTaskRegistrationGroup) -> HRESULT +RT_CLASS!{class SocialFeedSharedItem: ISocialFeedSharedItem} +impl RtActivatable for SocialFeedSharedItem {} +DEFINE_CLSID!(SocialFeedSharedItem(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,83,111,99,105,97,108,73,110,102,111,46,83,111,99,105,97,108,70,101,101,100,83,104,97,114,101,100,73,116,101,109,0]) [CLSID_SocialFeedSharedItem]); +RT_ENUM! { enum SocialFeedUpdateMode: i32 { + Append (SocialFeedUpdateMode_Append) = 0, Replace (SocialFeedUpdateMode_Replace) = 1, }} -impl IBackgroundTaskRegistrationStatics2 { - #[inline] pub fn get_all_task_groups(&self) -> Result>>> { unsafe { +RT_ENUM! { enum SocialItemBadgeStyle: i32 { + Hidden (SocialItemBadgeStyle_Hidden) = 0, Visible (SocialItemBadgeStyle_Visible) = 1, VisibleWithCount (SocialItemBadgeStyle_VisibleWithCount) = 2, +}} +DEFINE_IID!(IID_ISocialItemThumbnail, 1556054810, 16136, 18815, 145, 127, 87, 224, 157, 132, 177, 65); +RT_INTERFACE!{interface ISocialItemThumbnail(ISocialItemThumbnailVtbl): IInspectable(IInspectableVtbl) [IID_ISocialItemThumbnail] { + fn get_TargetUri(&self, out: *mut *mut foundation::Uri) -> HRESULT, + fn put_TargetUri(&self, value: *mut foundation::Uri) -> HRESULT, + fn get_ImageUri(&self, out: *mut *mut foundation::Uri) -> HRESULT, + fn put_ImageUri(&self, value: *mut foundation::Uri) -> HRESULT, + #[cfg(not(feature="windows-graphics"))] fn __Dummy4(&self) -> (), + #[cfg(feature="windows-graphics")] fn get_BitmapSize(&self, out: *mut super::super::graphics::imaging::BitmapSize) -> HRESULT, + #[cfg(not(feature="windows-graphics"))] fn __Dummy5(&self) -> (), + #[cfg(feature="windows-graphics")] fn put_BitmapSize(&self, value: super::super::graphics::imaging::BitmapSize) -> HRESULT, + #[cfg(feature="windows-storage")] fn SetImageAsync(&self, image: *mut super::super::storage::streams::IInputStream, out: *mut *mut foundation::IAsyncAction) -> HRESULT +}} +impl ISocialItemThumbnail { + #[inline] pub fn get_target_uri(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_AllTaskGroups)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_TargetUri)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn get_task_group(&self, groupId: &HStringArg) -> Result>> { unsafe { + #[inline] pub fn set_target_uri(&self, value: &foundation::Uri) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_TargetUri)(self as *const _ as *mut _, value as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_image_uri(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetTaskGroup)(self as *const _ as *mut _, groupId.get(), &mut out); + let hr = ((*self.lpVtbl).get_ImageUri)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} -} -RT_ENUM! { enum BackgroundTaskThrottleCounter: i32 { - All (BackgroundTaskThrottleCounter_All) = 0, Cpu (BackgroundTaskThrottleCounter_Cpu) = 1, Network (BackgroundTaskThrottleCounter_Network) = 2, -}} -DEFINE_IID!(IID_IBackgroundTrigger, 2226364504, 24615, 19335, 151, 144, 189, 243, 247, 87, 219, 215); -RT_INTERFACE!{interface IBackgroundTrigger(IBackgroundTriggerVtbl): IInspectable(IInspectableVtbl) [IID_IBackgroundTrigger] { - -}} -RT_CLASS!{static class BackgroundWorkCost} -impl RtActivatable for BackgroundWorkCost {} -impl BackgroundWorkCost { - #[inline] pub fn get_current_background_work_cost() -> Result { - >::get_activation_factory().get_current_background_work_cost() - } -} -DEFINE_CLSID!(BackgroundWorkCost(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,66,97,99,107,103,114,111,117,110,100,87,111,114,107,67,111,115,116,0]) [CLSID_BackgroundWorkCost]); -DEFINE_IID!(IID_IBackgroundWorkCostStatics, 3342902882, 49936, 19330, 179, 227, 59, 207, 185, 228, 199, 125); -RT_INTERFACE!{static interface IBackgroundWorkCostStatics(IBackgroundWorkCostStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IBackgroundWorkCostStatics] { - fn get_CurrentBackgroundWorkCost(&self, out: *mut BackgroundWorkCostValue) -> HRESULT -}} -impl IBackgroundWorkCostStatics { - #[inline] pub fn get_current_background_work_cost(&self) -> Result { unsafe { + #[inline] pub fn set_image_uri(&self, value: &foundation::Uri) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_ImageUri)(self as *const _ as *mut _, value as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[cfg(feature="windows-graphics")] #[inline] pub fn get_bitmap_size(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_CurrentBackgroundWorkCost)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_BitmapSize)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} -} -RT_ENUM! { enum BackgroundWorkCostValue: i32 { - Low (BackgroundWorkCostValue_Low) = 0, Medium (BackgroundWorkCostValue_Medium) = 1, High (BackgroundWorkCostValue_High) = 2, -}} -DEFINE_IID!(IID_IBluetoothLEAdvertisementPublisherTrigger, 2872976914, 9683, 18606, 135, 36, 216, 24, 119, 174, 97, 41); -RT_INTERFACE!{interface IBluetoothLEAdvertisementPublisherTrigger(IBluetoothLEAdvertisementPublisherTriggerVtbl): IInspectable(IInspectableVtbl) [IID_IBluetoothLEAdvertisementPublisherTrigger] { - #[cfg(feature="windows-devices")] fn get_Advertisement(&self, out: *mut *mut super::super::devices::bluetooth::advertisement::BluetoothLEAdvertisement) -> HRESULT -}} -impl IBluetoothLEAdvertisementPublisherTrigger { - #[cfg(feature="windows-devices")] #[inline] pub fn get_advertisement(&self) -> Result>> { unsafe { + #[cfg(feature="windows-graphics")] #[inline] pub fn set_bitmap_size(&self, value: super::super::graphics::imaging::BitmapSize) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_BitmapSize)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[cfg(feature="windows-storage")] #[inline] pub fn set_image_async(&self, image: &super::super::storage::streams::IInputStream) -> Result> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Advertisement)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).SetImageAsync)(self as *const _ as *mut _, image as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } -RT_CLASS!{class BluetoothLEAdvertisementPublisherTrigger: IBluetoothLEAdvertisementPublisherTrigger} -impl RtActivatable for BluetoothLEAdvertisementPublisherTrigger {} -DEFINE_CLSID!(BluetoothLEAdvertisementPublisherTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,66,108,117,101,116,111,111,116,104,76,69,65,100,118,101,114,116,105,115,101,109,101,110,116,80,117,98,108,105,115,104,101,114,84,114,105,103,103,101,114,0]) [CLSID_BluetoothLEAdvertisementPublisherTrigger]); -DEFINE_IID!(IID_IBluetoothLEAdvertisementWatcherTrigger, 447420441, 48353, 18667, 168, 39, 89, 251, 124, 238, 82, 166); -RT_INTERFACE!{interface IBluetoothLEAdvertisementWatcherTrigger(IBluetoothLEAdvertisementWatcherTriggerVtbl): IInspectable(IInspectableVtbl) [IID_IBluetoothLEAdvertisementWatcherTrigger] { - fn get_MinSamplingInterval(&self, out: *mut foundation::TimeSpan) -> HRESULT, - fn get_MaxSamplingInterval(&self, out: *mut foundation::TimeSpan) -> HRESULT, - fn get_MinOutOfRangeTimeout(&self, out: *mut foundation::TimeSpan) -> HRESULT, - fn get_MaxOutOfRangeTimeout(&self, out: *mut foundation::TimeSpan) -> HRESULT, - #[cfg(feature="windows-devices")] fn get_SignalStrengthFilter(&self, out: *mut *mut super::super::devices::bluetooth::BluetoothSignalStrengthFilter) -> HRESULT, - #[cfg(feature="windows-devices")] fn put_SignalStrengthFilter(&self, value: *mut super::super::devices::bluetooth::BluetoothSignalStrengthFilter) -> HRESULT, - #[cfg(feature="windows-devices")] fn get_AdvertisementFilter(&self, out: *mut *mut super::super::devices::bluetooth::advertisement::BluetoothLEAdvertisementFilter) -> HRESULT, - #[cfg(feature="windows-devices")] fn put_AdvertisementFilter(&self, value: *mut super::super::devices::bluetooth::advertisement::BluetoothLEAdvertisementFilter) -> HRESULT +RT_CLASS!{class SocialItemThumbnail: ISocialItemThumbnail} +impl RtActivatable for SocialItemThumbnail {} +DEFINE_CLSID!(SocialItemThumbnail(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,83,111,99,105,97,108,73,110,102,111,46,83,111,99,105,97,108,73,116,101,109,84,104,117,109,98,110,97,105,108,0]) [CLSID_SocialItemThumbnail]); +DEFINE_IID!(IID_ISocialUserInfo, 2656967633, 37072, 19997, 149, 84, 132, 77, 70, 96, 127, 97); +RT_INTERFACE!{interface ISocialUserInfo(ISocialUserInfoVtbl): IInspectable(IInspectableVtbl) [IID_ISocialUserInfo] { + fn get_DisplayName(&self, out: *mut HSTRING) -> HRESULT, + fn put_DisplayName(&self, value: HSTRING) -> HRESULT, + fn get_UserName(&self, out: *mut HSTRING) -> HRESULT, + fn put_UserName(&self, value: HSTRING) -> HRESULT, + fn get_RemoteId(&self, out: *mut HSTRING) -> HRESULT, + fn put_RemoteId(&self, value: HSTRING) -> HRESULT, + fn get_TargetUri(&self, out: *mut *mut foundation::Uri) -> HRESULT, + fn put_TargetUri(&self, value: *mut foundation::Uri) -> HRESULT }} -impl IBluetoothLEAdvertisementWatcherTrigger { - #[inline] pub fn get_min_sampling_interval(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_MinSamplingInterval)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } +impl ISocialUserInfo { + #[inline] pub fn get_display_name(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_DisplayName)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_max_sampling_interval(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_MaxSamplingInterval)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } + #[inline] pub fn set_display_name(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_DisplayName)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_min_out_of_range_timeout(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_MinOutOfRangeTimeout)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } + #[inline] pub fn get_user_name(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_UserName)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_max_out_of_range_timeout(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_MaxOutOfRangeTimeout)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } + #[inline] pub fn set_user_name(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_UserName)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } }} - #[cfg(feature="windows-devices")] #[inline] pub fn get_signal_strength_filter(&self) -> Result>> { unsafe { + #[inline] pub fn get_remote_id(&self) -> Result { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_SignalStrengthFilter)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).get_RemoteId)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} - #[cfg(feature="windows-devices")] #[inline] pub fn set_signal_strength_filter(&self, value: &super::super::devices::bluetooth::BluetoothSignalStrengthFilter) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_SignalStrengthFilter)(self as *const _ as *mut _, value as *const _ as *mut _); + #[inline] pub fn set_remote_id(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_RemoteId)(self as *const _ as *mut _, value.get()); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[cfg(feature="windows-devices")] #[inline] pub fn get_advertisement_filter(&self) -> Result>> { unsafe { + #[inline] pub fn get_target_uri(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_AdvertisementFilter)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_TargetUri)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[cfg(feature="windows-devices")] #[inline] pub fn set_advertisement_filter(&self, value: &super::super::devices::bluetooth::advertisement::BluetoothLEAdvertisementFilter) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_AdvertisementFilter)(self as *const _ as *mut _, value as *const _ as *mut _); + #[inline] pub fn set_target_uri(&self, value: &foundation::Uri) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_TargetUri)(self as *const _ as *mut _, value as *const _ as *mut _); if hr == S_OK { Ok(()) } else { err(hr) } }} } -RT_CLASS!{class BluetoothLEAdvertisementWatcherTrigger: IBluetoothLEAdvertisementWatcherTrigger} -impl RtActivatable for BluetoothLEAdvertisementWatcherTrigger {} -DEFINE_CLSID!(BluetoothLEAdvertisementWatcherTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,66,108,117,101,116,111,111,116,104,76,69,65,100,118,101,114,116,105,115,101,109,101,110,116,87,97,116,99,104,101,114,84,114,105,103,103,101,114,0]) [CLSID_BluetoothLEAdvertisementWatcherTrigger]); -DEFINE_IID!(IID_ICachedFileUpdaterTrigger, 3793530603, 13042, 19761, 181, 83, 185, 224, 27, 222, 55, 224); -RT_INTERFACE!{interface ICachedFileUpdaterTrigger(ICachedFileUpdaterTriggerVtbl): IInspectable(IInspectableVtbl) [IID_ICachedFileUpdaterTrigger] { - -}} -RT_CLASS!{class CachedFileUpdaterTrigger: ICachedFileUpdaterTrigger} -impl RtActivatable for CachedFileUpdaterTrigger {} -DEFINE_CLSID!(CachedFileUpdaterTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,67,97,99,104,101,100,70,105,108,101,85,112,100,97,116,101,114,84,114,105,103,103,101,114,0]) [CLSID_CachedFileUpdaterTrigger]); -DEFINE_IID!(IID_ICachedFileUpdaterTriggerDetails, 1904446483, 4884, 18356, 149, 151, 220, 126, 36, 140, 23, 204); -RT_INTERFACE!{interface ICachedFileUpdaterTriggerDetails(ICachedFileUpdaterTriggerDetailsVtbl): IInspectable(IInspectableVtbl) [IID_ICachedFileUpdaterTriggerDetails] { - #[cfg(not(feature="windows-storage"))] fn __Dummy0(&self) -> (), - #[cfg(feature="windows-storage")] fn get_UpdateTarget(&self, out: *mut super::super::storage::provider::CachedFileTarget) -> HRESULT, - #[cfg(not(feature="windows-storage"))] fn __Dummy1(&self) -> (), - #[cfg(feature="windows-storage")] fn get_UpdateRequest(&self, out: *mut *mut super::super::storage::provider::FileUpdateRequest) -> HRESULT, - fn get_CanRequestUserInput(&self, out: *mut bool) -> HRESULT +RT_CLASS!{class SocialUserInfo: ISocialUserInfo} +pub mod provider { // Windows.ApplicationModel.SocialInfo.Provider +use ::prelude::*; +DEFINE_IID!(IID_ISocialDashboardItemUpdater, 1021222345, 18432, 18125, 134, 155, 25, 115, 236, 104, 91, 222); +RT_INTERFACE!{interface ISocialDashboardItemUpdater(ISocialDashboardItemUpdaterVtbl): IInspectable(IInspectableVtbl) [IID_ISocialDashboardItemUpdater] { + fn get_OwnerRemoteId(&self, out: *mut HSTRING) -> HRESULT, + fn get_Content(&self, out: *mut *mut super::SocialFeedContent) -> HRESULT, + fn get_Timestamp(&self, out: *mut foundation::DateTime) -> HRESULT, + fn put_Timestamp(&self, value: foundation::DateTime) -> HRESULT, + fn put_Thumbnail(&self, value: *mut super::SocialItemThumbnail) -> HRESULT, + fn get_Thumbnail(&self, out: *mut *mut super::SocialItemThumbnail) -> HRESULT, + fn CommitAsync(&self, out: *mut *mut foundation::IAsyncAction) -> HRESULT, + fn get_TargetUri(&self, out: *mut *mut foundation::Uri) -> HRESULT, + fn put_TargetUri(&self, value: *mut foundation::Uri) -> HRESULT }} -impl ICachedFileUpdaterTriggerDetails { - #[cfg(feature="windows-storage")] #[inline] pub fn get_update_target(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_UpdateTarget)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } +impl ISocialDashboardItemUpdater { + #[inline] pub fn get_owner_remote_id(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_OwnerRemoteId)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} - #[cfg(feature="windows-storage")] #[inline] pub fn get_update_request(&self) -> Result>> { unsafe { + #[inline] pub fn get_content(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_UpdateRequest)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_Content)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn get_can_request_user_input(&self) -> Result { unsafe { + #[inline] pub fn get_timestamp(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_CanRequestUserInput)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_Timestamp)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} -} -RT_CLASS!{class CachedFileUpdaterTriggerDetails: ICachedFileUpdaterTriggerDetails} -DEFINE_IID!(IID_IChatMessageNotificationTrigger, 1362838463, 7488, 23645, 120, 245, 201, 35, 254, 227, 115, 158); -RT_INTERFACE!{interface IChatMessageNotificationTrigger(IChatMessageNotificationTriggerVtbl): IInspectable(IInspectableVtbl) [IID_IChatMessageNotificationTrigger] { - -}} -RT_CLASS!{class ChatMessageNotificationTrigger: IChatMessageNotificationTrigger} -impl RtActivatable for ChatMessageNotificationTrigger {} -DEFINE_CLSID!(ChatMessageNotificationTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,67,104,97,116,77,101,115,115,97,103,101,78,111,116,105,102,105,99,97,116,105,111,110,84,114,105,103,103,101,114,0]) [CLSID_ChatMessageNotificationTrigger]); -DEFINE_IID!(IID_IChatMessageReceivedNotificationTrigger, 1050899982, 47861, 16503, 136, 233, 6, 12, 246, 240, 198, 213); -RT_INTERFACE!{interface IChatMessageReceivedNotificationTrigger(IChatMessageReceivedNotificationTriggerVtbl): IInspectable(IInspectableVtbl) [IID_IChatMessageReceivedNotificationTrigger] { - -}} -RT_CLASS!{class ChatMessageReceivedNotificationTrigger: IChatMessageReceivedNotificationTrigger} -impl RtActivatable for ChatMessageReceivedNotificationTrigger {} -DEFINE_CLSID!(ChatMessageReceivedNotificationTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,67,104,97,116,77,101,115,115,97,103,101,82,101,99,101,105,118,101,100,78,111,116,105,102,105,99,97,116,105,111,110,84,114,105,103,103,101,114,0]) [CLSID_ChatMessageReceivedNotificationTrigger]); -DEFINE_IID!(IID_IContactStoreNotificationTrigger, 3358802331, 18181, 17777, 154, 22, 6, 185, 151, 191, 156, 150); -RT_INTERFACE!{interface IContactStoreNotificationTrigger(IContactStoreNotificationTriggerVtbl): IInspectable(IInspectableVtbl) [IID_IContactStoreNotificationTrigger] { - -}} -RT_CLASS!{class ContactStoreNotificationTrigger: IContactStoreNotificationTrigger} -impl RtActivatable for ContactStoreNotificationTrigger {} -DEFINE_CLSID!(ContactStoreNotificationTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,67,111,110,116,97,99,116,83,116,111,114,101,78,111,116,105,102,105,99,97,116,105,111,110,84,114,105,103,103,101,114,0]) [CLSID_ContactStoreNotificationTrigger]); -DEFINE_IID!(IID_IContentPrefetchTrigger, 1896228846, 1274, 17419, 128, 192, 23, 50, 2, 25, 158, 93); -RT_INTERFACE!{interface IContentPrefetchTrigger(IContentPrefetchTriggerVtbl): IInspectable(IInspectableVtbl) [IID_IContentPrefetchTrigger] { - fn get_WaitInterval(&self, out: *mut foundation::TimeSpan) -> HRESULT -}} -impl IContentPrefetchTrigger { - #[inline] pub fn get_wait_interval(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_WaitInterval)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } + #[inline] pub fn set_timestamp(&self, value: foundation::DateTime) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Timestamp)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } }} -} -RT_CLASS!{class ContentPrefetchTrigger: IContentPrefetchTrigger} -impl RtActivatable for ContentPrefetchTrigger {} -impl RtActivatable for ContentPrefetchTrigger {} -impl ContentPrefetchTrigger { - #[inline] pub fn create(waitInterval: foundation::TimeSpan) -> Result> { - >::get_activation_factory().create(waitInterval) - } -} -DEFINE_CLSID!(ContentPrefetchTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,67,111,110,116,101,110,116,80,114,101,102,101,116,99,104,84,114,105,103,103,101,114,0]) [CLSID_ContentPrefetchTrigger]); -DEFINE_IID!(IID_IContentPrefetchTriggerFactory, 3261349594, 35331, 16542, 184, 196, 136, 129, 76, 40, 204, 182); -RT_INTERFACE!{static interface IContentPrefetchTriggerFactory(IContentPrefetchTriggerFactoryVtbl): IInspectable(IInspectableVtbl) [IID_IContentPrefetchTriggerFactory] { - fn Create(&self, waitInterval: foundation::TimeSpan, out: *mut *mut ContentPrefetchTrigger) -> HRESULT -}} -impl IContentPrefetchTriggerFactory { - #[inline] pub fn create(&self, waitInterval: foundation::TimeSpan) -> Result> { unsafe { + #[inline] pub fn set_thumbnail(&self, value: &super::SocialItemThumbnail) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Thumbnail)(self as *const _ as *mut _, value as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_thumbnail(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, waitInterval, &mut out); + let hr = ((*self.lpVtbl).get_Thumbnail)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn commit_async(&self) -> Result> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).CommitAsync)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} + #[inline] pub fn get_target_uri(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_TargetUri)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn set_target_uri(&self, value: &foundation::Uri) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_TargetUri)(self as *const _ as *mut _, value as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} } -DEFINE_IID!(IID_IDeviceConnectionChangeTrigger, 2424790628, 15581, 20219, 171, 28, 91, 59, 106, 96, 206, 52); -RT_INTERFACE!{interface IDeviceConnectionChangeTrigger(IDeviceConnectionChangeTriggerVtbl): IInspectable(IInspectableVtbl) [IID_IDeviceConnectionChangeTrigger] { - fn get_DeviceId(&self, out: *mut HSTRING) -> HRESULT, - fn get_CanMaintainConnection(&self, out: *mut bool) -> HRESULT, - fn get_MaintainConnection(&self, out: *mut bool) -> HRESULT, - fn put_MaintainConnection(&self, value: bool) -> HRESULT +RT_CLASS!{class SocialDashboardItemUpdater: ISocialDashboardItemUpdater} +DEFINE_IID!(IID_ISocialFeedUpdater, 2047609511, 60809, 19413, 168, 217, 21, 244, 217, 134, 28, 16); +RT_INTERFACE!{interface ISocialFeedUpdater(ISocialFeedUpdaterVtbl): IInspectable(IInspectableVtbl) [IID_ISocialFeedUpdater] { + fn get_OwnerRemoteId(&self, out: *mut HSTRING) -> HRESULT, + fn get_Kind(&self, out: *mut super::SocialFeedKind) -> HRESULT, + fn get_Items(&self, out: *mut *mut foundation::collections::IVector) -> HRESULT, + fn CommitAsync(&self, out: *mut *mut foundation::IAsyncAction) -> HRESULT }} -impl IDeviceConnectionChangeTrigger { - #[inline] pub fn get_device_id(&self) -> Result { unsafe { +impl ISocialFeedUpdater { + #[inline] pub fn get_owner_remote_id(&self) -> Result { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_DeviceId)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_OwnerRemoteId)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_can_maintain_connection(&self) -> Result { unsafe { + #[inline] pub fn get_kind(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_CanMaintainConnection)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_Kind)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_maintain_connection(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_MaintainConnection)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } + #[inline] pub fn get_items(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Items)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn set_maintain_connection(&self, value: bool) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_MaintainConnection)(self as *const _ as *mut _, value); - if hr == S_OK { Ok(()) } else { err(hr) } + #[inline] pub fn commit_async(&self) -> Result> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).CommitAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } -RT_CLASS!{class DeviceConnectionChangeTrigger: IDeviceConnectionChangeTrigger} -impl RtActivatable for DeviceConnectionChangeTrigger {} -impl DeviceConnectionChangeTrigger { - #[inline] pub fn from_id_async(deviceId: &HStringArg) -> Result>> { - >::get_activation_factory().from_id_async(deviceId) +RT_CLASS!{class SocialFeedUpdater: ISocialFeedUpdater} +RT_CLASS!{static class SocialInfoProviderManager} +impl RtActivatable for SocialInfoProviderManager {} +impl SocialInfoProviderManager { + #[inline] pub fn create_social_feed_updater_async(kind: super::SocialFeedKind, mode: super::SocialFeedUpdateMode, ownerRemoteId: &HStringArg) -> Result>> { + >::get_activation_factory().create_social_feed_updater_async(kind, mode, ownerRemoteId) } -} -DEFINE_CLSID!(DeviceConnectionChangeTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,68,101,118,105,99,101,67,111,110,110,101,99,116,105,111,110,67,104,97,110,103,101,84,114,105,103,103,101,114,0]) [CLSID_DeviceConnectionChangeTrigger]); -DEFINE_IID!(IID_IDeviceConnectionChangeTriggerStatics, 3286901866, 20221, 17560, 170, 96, 164, 228, 227, 177, 122, 185); -RT_INTERFACE!{static interface IDeviceConnectionChangeTriggerStatics(IDeviceConnectionChangeTriggerStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IDeviceConnectionChangeTriggerStatics] { - fn FromIdAsync(&self, deviceId: HSTRING, out: *mut *mut foundation::IAsyncOperation) -> HRESULT -}} -impl IDeviceConnectionChangeTriggerStatics { - #[inline] pub fn from_id_async(&self, deviceId: &HStringArg) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).FromIdAsync)(self as *const _ as *mut _, deviceId.get(), &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } - }} -} -DEFINE_IID!(IID_IDeviceManufacturerNotificationTrigger, 2166852277, 16811, 5850, 134, 194, 127, 123, 240, 145, 47, 91); -RT_INTERFACE!{interface IDeviceManufacturerNotificationTrigger(IDeviceManufacturerNotificationTriggerVtbl): IInspectable(IInspectableVtbl) [IID_IDeviceManufacturerNotificationTrigger] { - fn get_TriggerQualifier(&self, out: *mut HSTRING) -> HRESULT, - fn get_OneShot(&self, out: *mut bool) -> HRESULT -}} -impl IDeviceManufacturerNotificationTrigger { - #[inline] pub fn get_trigger_qualifier(&self) -> Result { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_TriggerQualifier)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } - }} - #[inline] pub fn get_one_shot(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_OneShot)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } - }} -} -RT_CLASS!{class DeviceManufacturerNotificationTrigger: IDeviceManufacturerNotificationTrigger} -impl RtActivatable for DeviceManufacturerNotificationTrigger {} -impl DeviceManufacturerNotificationTrigger { - #[inline] pub fn create(triggerQualifier: &HStringArg, oneShot: bool) -> Result> { - >::get_activation_factory().create(triggerQualifier, oneShot) + #[inline] pub fn create_dashboard_item_updater_async(ownerRemoteId: &HStringArg) -> Result>> { + >::get_activation_factory().create_dashboard_item_updater_async(ownerRemoteId) + } + #[inline] pub fn update_badge_count_value(itemRemoteId: &HStringArg, newCount: i32) -> Result<()> { + >::get_activation_factory().update_badge_count_value(itemRemoteId, newCount) + } + #[inline] pub fn report_new_content_available(contactRemoteId: &HStringArg, kind: super::SocialFeedKind) -> Result<()> { + >::get_activation_factory().report_new_content_available(contactRemoteId, kind) + } + #[inline] pub fn provision_async() -> Result>> { + >::get_activation_factory().provision_async() + } + #[inline] pub fn deprovision_async() -> Result> { + >::get_activation_factory().deprovision_async() } } -DEFINE_CLSID!(DeviceManufacturerNotificationTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,68,101,118,105,99,101,77,97,110,117,102,97,99,116,117,114,101,114,78,111,116,105,102,105,99,97,116,105,111,110,84,114,105,103,103,101,114,0]) [CLSID_DeviceManufacturerNotificationTrigger]); -DEFINE_IID!(IID_IDeviceManufacturerNotificationTriggerFactory, 2035670645, 9659, 16723, 161, 162, 48, 41, 252, 171, 182, 82); -RT_INTERFACE!{static interface IDeviceManufacturerNotificationTriggerFactory(IDeviceManufacturerNotificationTriggerFactoryVtbl): IInspectable(IInspectableVtbl) [IID_IDeviceManufacturerNotificationTriggerFactory] { - fn Create(&self, triggerQualifier: HSTRING, oneShot: bool, out: *mut *mut DeviceManufacturerNotificationTrigger) -> HRESULT +DEFINE_CLSID!(SocialInfoProviderManager(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,83,111,99,105,97,108,73,110,102,111,46,80,114,111,118,105,100,101,114,46,83,111,99,105,97,108,73,110,102,111,80,114,111,118,105,100,101,114,77,97,110,97,103,101,114,0]) [CLSID_SocialInfoProviderManager]); +DEFINE_IID!(IID_ISocialInfoProviderManagerStatics, 461956395, 30599, 18646, 170, 18, 216, 232, 244, 122, 184, 90); +RT_INTERFACE!{static interface ISocialInfoProviderManagerStatics(ISocialInfoProviderManagerStaticsVtbl): IInspectable(IInspectableVtbl) [IID_ISocialInfoProviderManagerStatics] { + fn CreateSocialFeedUpdaterAsync(&self, kind: super::SocialFeedKind, mode: super::SocialFeedUpdateMode, ownerRemoteId: HSTRING, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn CreateDashboardItemUpdaterAsync(&self, ownerRemoteId: HSTRING, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn UpdateBadgeCountValue(&self, itemRemoteId: HSTRING, newCount: i32) -> HRESULT, + fn ReportNewContentAvailable(&self, contactRemoteId: HSTRING, kind: super::SocialFeedKind) -> HRESULT, + fn ProvisionAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn DeprovisionAsync(&self, out: *mut *mut foundation::IAsyncAction) -> HRESULT }} -impl IDeviceManufacturerNotificationTriggerFactory { - #[inline] pub fn create(&self, triggerQualifier: &HStringArg, oneShot: bool) -> Result> { unsafe { +impl ISocialInfoProviderManagerStatics { + #[inline] pub fn create_social_feed_updater_async(&self, kind: super::SocialFeedKind, mode: super::SocialFeedUpdateMode, ownerRemoteId: &HStringArg) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, triggerQualifier.get(), oneShot, &mut out); + let hr = ((*self.lpVtbl).CreateSocialFeedUpdaterAsync)(self as *const _ as *mut _, kind, mode, ownerRemoteId.get(), &mut out); if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} -} -DEFINE_IID!(IID_IDeviceServicingTrigger, 447879085, 28212, 18899, 158, 111, 23, 241, 182, 223, 168, 129); -RT_INTERFACE!{interface IDeviceServicingTrigger(IDeviceServicingTriggerVtbl): IInspectable(IInspectableVtbl) [IID_IDeviceServicingTrigger] { - fn RequestAsyncSimple(&self, deviceId: HSTRING, expectedDuration: foundation::TimeSpan, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, - fn RequestAsyncWithArguments(&self, deviceId: HSTRING, expectedDuration: foundation::TimeSpan, arguments: HSTRING, out: *mut *mut foundation::IAsyncOperation) -> HRESULT -}} -impl IDeviceServicingTrigger { - #[inline] pub fn request_async_simple(&self, deviceId: &HStringArg, expectedDuration: foundation::TimeSpan) -> Result>> { unsafe { + #[inline] pub fn create_dashboard_item_updater_async(&self, ownerRemoteId: &HStringArg) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).RequestAsyncSimple)(self as *const _ as *mut _, deviceId.get(), expectedDuration, &mut out); + let hr = ((*self.lpVtbl).CreateDashboardItemUpdaterAsync)(self as *const _ as *mut _, ownerRemoteId.get(), &mut out); if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn request_async_with_arguments(&self, deviceId: &HStringArg, expectedDuration: foundation::TimeSpan, arguments: &HStringArg) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).RequestAsyncWithArguments)(self as *const _ as *mut _, deviceId.get(), expectedDuration, arguments.get(), &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + #[inline] pub fn update_badge_count_value(&self, itemRemoteId: &HStringArg, newCount: i32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).UpdateBadgeCountValue)(self as *const _ as *mut _, itemRemoteId.get(), newCount); + if hr == S_OK { Ok(()) } else { err(hr) } }} -} -RT_CLASS!{class DeviceServicingTrigger: IDeviceServicingTrigger} -impl RtActivatable for DeviceServicingTrigger {} -DEFINE_CLSID!(DeviceServicingTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,68,101,118,105,99,101,83,101,114,118,105,99,105,110,103,84,114,105,103,103,101,114,0]) [CLSID_DeviceServicingTrigger]); -RT_ENUM! { enum DeviceTriggerResult: i32 { - Allowed (DeviceTriggerResult_Allowed) = 0, DeniedByUser (DeviceTriggerResult_DeniedByUser) = 1, DeniedBySystem (DeviceTriggerResult_DeniedBySystem) = 2, LowBattery (DeviceTriggerResult_LowBattery) = 3, -}} -DEFINE_IID!(IID_IDeviceUseTrigger, 229015569, 13135, 19799, 182, 236, 109, 202, 100, 180, 18, 228); -RT_INTERFACE!{interface IDeviceUseTrigger(IDeviceUseTriggerVtbl): IInspectable(IInspectableVtbl) [IID_IDeviceUseTrigger] { - fn RequestAsyncSimple(&self, deviceId: HSTRING, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, - fn RequestAsyncWithArguments(&self, deviceId: HSTRING, arguments: HSTRING, out: *mut *mut foundation::IAsyncOperation) -> HRESULT -}} -impl IDeviceUseTrigger { - #[inline] pub fn request_async_simple(&self, deviceId: &HStringArg) -> Result>> { unsafe { + #[inline] pub fn report_new_content_available(&self, contactRemoteId: &HStringArg, kind: super::SocialFeedKind) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).ReportNewContentAvailable)(self as *const _ as *mut _, contactRemoteId.get(), kind); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn provision_async(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).RequestAsyncSimple)(self as *const _ as *mut _, deviceId.get(), &mut out); + let hr = ((*self.lpVtbl).ProvisionAsync)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn request_async_with_arguments(&self, deviceId: &HStringArg, arguments: &HStringArg) -> Result>> { unsafe { + #[inline] pub fn deprovision_async(&self) -> Result> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).RequestAsyncWithArguments)(self as *const _ as *mut _, deviceId.get(), arguments.get(), &mut out); + let hr = ((*self.lpVtbl).DeprovisionAsync)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } -RT_CLASS!{class DeviceUseTrigger: IDeviceUseTrigger} -impl RtActivatable for DeviceUseTrigger {} -DEFINE_CLSID!(DeviceUseTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,68,101,118,105,99,101,85,115,101,84,114,105,103,103,101,114,0]) [CLSID_DeviceUseTrigger]); -DEFINE_IID!(IID_IDeviceWatcherTrigger, 2757853149, 34163, 16992, 190, 252, 91, 236, 137, 203, 105, 61); -RT_INTERFACE!{interface IDeviceWatcherTrigger(IDeviceWatcherTriggerVtbl): IInspectable(IInspectableVtbl) [IID_IDeviceWatcherTrigger] { - -}} -RT_CLASS!{class DeviceWatcherTrigger: IDeviceWatcherTrigger} -DEFINE_IID!(IID_IEmailStoreNotificationTrigger, 2557282010, 18411, 17000, 164, 242, 243, 247, 113, 136, 56, 138); -RT_INTERFACE!{interface IEmailStoreNotificationTrigger(IEmailStoreNotificationTriggerVtbl): IInspectable(IInspectableVtbl) [IID_IEmailStoreNotificationTrigger] { - -}} -RT_CLASS!{class EmailStoreNotificationTrigger: IEmailStoreNotificationTrigger} -impl RtActivatable for EmailStoreNotificationTrigger {} -DEFINE_CLSID!(EmailStoreNotificationTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,69,109,97,105,108,83,116,111,114,101,78,111,116,105,102,105,99,97,116,105,111,110,84,114,105,103,103,101,114,0]) [CLSID_EmailStoreNotificationTrigger]); -DEFINE_IID!(IID_IGattCharacteristicNotificationTrigger, 3797913544, 1686, 18255, 167, 50, 242, 146, 176, 206, 188, 93); -RT_INTERFACE!{interface IGattCharacteristicNotificationTrigger(IGattCharacteristicNotificationTriggerVtbl): IInspectable(IInspectableVtbl) [IID_IGattCharacteristicNotificationTrigger] { - #[cfg(feature="windows-devices")] fn get_Characteristic(&self, out: *mut *mut super::super::devices::bluetooth::genericattributeprofile::GattCharacteristic) -> HRESULT +} // Windows.ApplicationModel.SocialInfo.Provider +} // Windows.ApplicationModel.SocialInfo +pub mod search { // Windows.ApplicationModel.Search +use ::prelude::*; +DEFINE_IID!(IID_ILocalContentSuggestionSettings, 4004425826, 29757, 17774, 132, 163, 35, 240, 111, 45, 21, 215); +RT_INTERFACE!{interface ILocalContentSuggestionSettings(ILocalContentSuggestionSettingsVtbl): IInspectable(IInspectableVtbl) [IID_ILocalContentSuggestionSettings] { + fn put_Enabled(&self, value: bool) -> HRESULT, + fn get_Enabled(&self, out: *mut bool) -> HRESULT, + #[cfg(not(feature="windows-storage"))] fn __Dummy2(&self) -> (), + #[cfg(feature="windows-storage")] fn get_Locations(&self, out: *mut *mut foundation::collections::IVector) -> HRESULT, + fn put_AqsFilter(&self, value: HSTRING) -> HRESULT, + fn get_AqsFilter(&self, out: *mut HSTRING) -> HRESULT, + fn get_PropertiesToMatch(&self, out: *mut *mut foundation::collections::IVector) -> HRESULT }} -impl IGattCharacteristicNotificationTrigger { - #[cfg(feature="windows-devices")] #[inline] pub fn get_characteristic(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Characteristic)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } +impl ILocalContentSuggestionSettings { + #[inline] pub fn set_enabled(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Enabled)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } }} -} -RT_CLASS!{class GattCharacteristicNotificationTrigger: IGattCharacteristicNotificationTrigger} -impl RtActivatable for GattCharacteristicNotificationTrigger {} -impl RtActivatable for GattCharacteristicNotificationTrigger {} -impl GattCharacteristicNotificationTrigger { - #[cfg(feature="windows-devices")] #[inline] pub fn create(characteristic: &super::super::devices::bluetooth::genericattributeprofile::GattCharacteristic) -> Result> { - >::get_activation_factory().create(characteristic) - } - #[cfg(feature="windows-devices")] #[inline] pub fn create_with_event_triggering_mode(characteristic: &super::super::devices::bluetooth::genericattributeprofile::GattCharacteristic, eventTriggeringMode: super::super::devices::bluetooth::background::BluetoothEventTriggeringMode) -> Result> { - >::get_activation_factory().create_with_event_triggering_mode(characteristic, eventTriggeringMode) - } -} -DEFINE_CLSID!(GattCharacteristicNotificationTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,71,97,116,116,67,104,97,114,97,99,116,101,114,105,115,116,105,99,78,111,116,105,102,105,99,97,116,105,111,110,84,114,105,103,103,101,114,0]) [CLSID_GattCharacteristicNotificationTrigger]); -DEFINE_IID!(IID_IGattCharacteristicNotificationTrigger2, 2468520644, 44558, 17138, 178, 140, 245, 19, 114, 230, 146, 69); -RT_INTERFACE!{interface IGattCharacteristicNotificationTrigger2(IGattCharacteristicNotificationTrigger2Vtbl): IInspectable(IInspectableVtbl) [IID_IGattCharacteristicNotificationTrigger2] { - #[cfg(feature="windows-devices")] fn get_EventTriggeringMode(&self, out: *mut super::super::devices::bluetooth::background::BluetoothEventTriggeringMode) -> HRESULT -}} -impl IGattCharacteristicNotificationTrigger2 { - #[cfg(feature="windows-devices")] #[inline] pub fn get_event_triggering_mode(&self) -> Result { unsafe { + #[inline] pub fn get_enabled(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_EventTriggeringMode)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_Enabled)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} -} -DEFINE_IID!(IID_IGattCharacteristicNotificationTriggerFactory, 1471814037, 45379, 17781, 159, 107, 253, 89, 217, 58, 206, 26); -RT_INTERFACE!{static interface IGattCharacteristicNotificationTriggerFactory(IGattCharacteristicNotificationTriggerFactoryVtbl): IInspectable(IInspectableVtbl) [IID_IGattCharacteristicNotificationTriggerFactory] { - #[cfg(feature="windows-devices")] fn Create(&self, characteristic: *mut super::super::devices::bluetooth::genericattributeprofile::GattCharacteristic, out: *mut *mut GattCharacteristicNotificationTrigger) -> HRESULT -}} -impl IGattCharacteristicNotificationTriggerFactory { - #[cfg(feature="windows-devices")] #[inline] pub fn create(&self, characteristic: &super::super::devices::bluetooth::genericattributeprofile::GattCharacteristic) -> Result> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, characteristic as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } - }} -} -DEFINE_IID!(IID_IGattCharacteristicNotificationTriggerFactory2, 1503193375, 35411, 20127, 163, 44, 35, 205, 51, 102, 76, 238); -RT_INTERFACE!{static interface IGattCharacteristicNotificationTriggerFactory2(IGattCharacteristicNotificationTriggerFactory2Vtbl): IInspectable(IInspectableVtbl) [IID_IGattCharacteristicNotificationTriggerFactory2] { - #[cfg(feature="windows-devices")] fn CreateWithEventTriggeringMode(&self, characteristic: *mut super::super::devices::bluetooth::genericattributeprofile::GattCharacteristic, eventTriggeringMode: super::super::devices::bluetooth::background::BluetoothEventTriggeringMode, out: *mut *mut GattCharacteristicNotificationTrigger) -> HRESULT -}} -impl IGattCharacteristicNotificationTriggerFactory2 { - #[cfg(feature="windows-devices")] #[inline] pub fn create_with_event_triggering_mode(&self, characteristic: &super::super::devices::bluetooth::genericattributeprofile::GattCharacteristic, eventTriggeringMode: super::super::devices::bluetooth::background::BluetoothEventTriggeringMode) -> Result> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).CreateWithEventTriggeringMode)(self as *const _ as *mut _, characteristic as *const _ as *mut _, eventTriggeringMode, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } - }} -} -DEFINE_IID!(IID_IGattServiceProviderTrigger, 3720782825, 5463, 19416, 133, 66, 70, 138, 160, 198, 150, 246); -RT_INTERFACE!{interface IGattServiceProviderTrigger(IGattServiceProviderTriggerVtbl): IInspectable(IInspectableVtbl) [IID_IGattServiceProviderTrigger] { - fn get_TriggerId(&self, out: *mut HSTRING) -> HRESULT, - #[cfg(feature="windows-devices")] fn get_Service(&self, out: *mut *mut super::super::devices::bluetooth::genericattributeprofile::GattLocalService) -> HRESULT, - #[cfg(feature="windows-devices")] fn put_AdvertisingParameters(&self, value: *mut super::super::devices::bluetooth::genericattributeprofile::GattServiceProviderAdvertisingParameters) -> HRESULT, - #[cfg(feature="windows-devices")] fn get_AdvertisingParameters(&self, out: *mut *mut super::super::devices::bluetooth::genericattributeprofile::GattServiceProviderAdvertisingParameters) -> HRESULT -}} -impl IGattServiceProviderTrigger { - #[inline] pub fn get_trigger_id(&self) -> Result { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_TriggerId)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } - }} - #[cfg(feature="windows-devices")] #[inline] pub fn get_service(&self) -> Result>> { unsafe { + #[cfg(feature="windows-storage")] #[inline] pub fn get_locations(&self) -> Result>>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Service)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_Locations)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[cfg(feature="windows-devices")] #[inline] pub fn set_advertising_parameters(&self, value: &super::super::devices::bluetooth::genericattributeprofile::GattServiceProviderAdvertisingParameters) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_AdvertisingParameters)(self as *const _ as *mut _, value as *const _ as *mut _); + #[inline] pub fn set_aqs_filter(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_AqsFilter)(self as *const _ as *mut _, value.get()); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[cfg(feature="windows-devices")] #[inline] pub fn get_advertising_parameters(&self) -> Result>> { unsafe { + #[inline] pub fn get_aqs_filter(&self) -> Result { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_AdvertisingParameters)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).get_AqsFilter)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} -} -RT_CLASS!{class GattServiceProviderTrigger: IGattServiceProviderTrigger} -impl RtActivatable for GattServiceProviderTrigger {} -impl GattServiceProviderTrigger { - #[inline] pub fn create_async(triggerId: &HStringArg, serviceUuid: Guid) -> Result>> { - >::get_activation_factory().create_async(triggerId, serviceUuid) - } -} -DEFINE_CLSID!(GattServiceProviderTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,71,97,116,116,83,101,114,118,105,99,101,80,114,111,118,105,100,101,114,84,114,105,103,103,101,114,0]) [CLSID_GattServiceProviderTrigger]); -DEFINE_IID!(IID_IGattServiceProviderTriggerResult, 1011257777, 45464, 20100, 186, 212, 207, 74, 210, 153, 237, 58); -RT_INTERFACE!{interface IGattServiceProviderTriggerResult(IGattServiceProviderTriggerResultVtbl): IInspectable(IInspectableVtbl) [IID_IGattServiceProviderTriggerResult] { - fn get_Trigger(&self, out: *mut *mut GattServiceProviderTrigger) -> HRESULT, - #[cfg(feature="windows-devices")] fn get_Error(&self, out: *mut super::super::devices::bluetooth::BluetoothError) -> HRESULT -}} -impl IGattServiceProviderTriggerResult { - #[inline] pub fn get_trigger(&self) -> Result>> { unsafe { + #[inline] pub fn get_properties_to_match(&self) -> Result>>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Trigger)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_PropertiesToMatch)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[cfg(feature="windows-devices")] #[inline] pub fn get_error(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_Error)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } - }} } -RT_CLASS!{class GattServiceProviderTriggerResult: IGattServiceProviderTriggerResult} -DEFINE_IID!(IID_IGattServiceProviderTriggerStatics, 3021185898, 58004, 17809, 165, 166, 100, 137, 26, 130, 129, 83); -RT_INTERFACE!{static interface IGattServiceProviderTriggerStatics(IGattServiceProviderTriggerStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IGattServiceProviderTriggerStatics] { - fn CreateAsync(&self, triggerId: HSTRING, serviceUuid: Guid, out: *mut *mut foundation::IAsyncOperation) -> HRESULT +RT_CLASS!{class LocalContentSuggestionSettings: ILocalContentSuggestionSettings} +impl RtActivatable for LocalContentSuggestionSettings {} +DEFINE_CLSID!(LocalContentSuggestionSettings(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,83,101,97,114,99,104,46,76,111,99,97,108,67,111,110,116,101,110,116,83,117,103,103,101,115,116,105,111,110,83,101,116,116,105,110,103,115,0]) [CLSID_LocalContentSuggestionSettings]); +DEFINE_IID!(IID_ISearchPane, 4255968312, 14080, 19827, 145, 161, 47, 153, 134, 116, 35, 138); +RT_INTERFACE!{interface ISearchPane(ISearchPaneVtbl): IInspectable(IInspectableVtbl) [IID_ISearchPane] { + fn put_SearchHistoryEnabled(&self, value: bool) -> HRESULT, + fn get_SearchHistoryEnabled(&self, out: *mut bool) -> HRESULT, + fn put_SearchHistoryContext(&self, value: HSTRING) -> HRESULT, + fn get_SearchHistoryContext(&self, out: *mut HSTRING) -> HRESULT, + fn put_PlaceholderText(&self, value: HSTRING) -> HRESULT, + fn get_PlaceholderText(&self, out: *mut HSTRING) -> HRESULT, + fn get_QueryText(&self, out: *mut HSTRING) -> HRESULT, + fn get_Language(&self, out: *mut HSTRING) -> HRESULT, + fn get_Visible(&self, out: *mut bool) -> HRESULT, + fn add_VisibilityChanged(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_VisibilityChanged(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn add_QueryChanged(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_QueryChanged(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn add_SuggestionsRequested(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_SuggestionsRequested(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn add_QuerySubmitted(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_QuerySubmitted(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn add_ResultSuggestionChosen(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_ResultSuggestionChosen(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn SetLocalContentSuggestionSettings(&self, settings: *mut LocalContentSuggestionSettings) -> HRESULT, + fn ShowOverloadDefault(&self) -> HRESULT, + fn ShowOverloadWithQuery(&self, query: HSTRING) -> HRESULT, + fn put_ShowOnKeyboardInput(&self, value: bool) -> HRESULT, + fn get_ShowOnKeyboardInput(&self, out: *mut bool) -> HRESULT, + fn TrySetQueryText(&self, query: HSTRING, out: *mut bool) -> HRESULT }} -impl IGattServiceProviderTriggerStatics { - #[inline] pub fn create_async(&self, triggerId: &HStringArg, serviceUuid: Guid) -> Result>> { unsafe { +impl ISearchPane { + #[inline] pub fn set_search_history_enabled(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_SearchHistoryEnabled)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_search_history_enabled(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_SearchHistoryEnabled)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_search_history_context(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_SearchHistoryContext)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_search_history_context(&self) -> Result { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).CreateAsync)(self as *const _ as *mut _, triggerId.get(), serviceUuid, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).get_SearchHistoryContext)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} -} -DEFINE_IID!(IID_IGeovisitTrigger, 1209593258, 1249, 16679, 154, 76, 25, 53, 27, 138, 128, 164); -RT_INTERFACE!{interface IGeovisitTrigger(IGeovisitTriggerVtbl): IInspectable(IInspectableVtbl) [IID_IGeovisitTrigger] { - #[cfg(feature="windows-devices")] fn get_MonitoringScope(&self, out: *mut super::super::devices::geolocation::VisitMonitoringScope) -> HRESULT, - #[cfg(feature="windows-devices")] fn put_MonitoringScope(&self, value: super::super::devices::geolocation::VisitMonitoringScope) -> HRESULT -}} -impl IGeovisitTrigger { - #[cfg(feature="windows-devices")] #[inline] pub fn get_monitoring_scope(&self) -> Result { unsafe { + #[inline] pub fn set_placeholder_text(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_PlaceholderText)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_placeholder_text(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_PlaceholderText)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_query_text(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_QueryText)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_language(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Language)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_visible(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_MonitoringScope)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_Visible)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[cfg(feature="windows-devices")] #[inline] pub fn set_monitoring_scope(&self, value: super::super::devices::geolocation::VisitMonitoringScope) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_MonitoringScope)(self as *const _ as *mut _, value); + #[inline] pub fn add_visibility_changed(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_VisibilityChanged)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_visibility_changed(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_VisibilityChanged)(self as *const _ as *mut _, token); if hr == S_OK { Ok(()) } else { err(hr) } }} -} -RT_CLASS!{class GeovisitTrigger: IGeovisitTrigger} -impl RtActivatable for GeovisitTrigger {} -DEFINE_CLSID!(GeovisitTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,71,101,111,118,105,115,105,116,84,114,105,103,103,101,114,0]) [CLSID_GeovisitTrigger]); -DEFINE_IID!(IID_ILocationTrigger, 1197894172, 26743, 18462, 128, 38, 255, 126, 20, 168, 17, 160); -RT_INTERFACE!{interface ILocationTrigger(ILocationTriggerVtbl): IInspectable(IInspectableVtbl) [IID_ILocationTrigger] { - fn get_TriggerType(&self, out: *mut LocationTriggerType) -> HRESULT -}} -impl ILocationTrigger { - #[inline] pub fn get_trigger_type(&self) -> Result { unsafe { + #[inline] pub fn add_query_changed(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_TriggerType)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).add_QueryChanged)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} -} -RT_CLASS!{class LocationTrigger: ILocationTrigger} -impl RtActivatable for LocationTrigger {} -impl LocationTrigger { - #[inline] pub fn create(triggerType: LocationTriggerType) -> Result> { - >::get_activation_factory().create(triggerType) - } -} -DEFINE_CLSID!(LocationTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,76,111,99,97,116,105,111,110,84,114,105,103,103,101,114,0]) [CLSID_LocationTrigger]); -DEFINE_IID!(IID_ILocationTriggerFactory, 285653767, 65385, 19977, 170, 139, 19, 132, 234, 71, 94, 152); -RT_INTERFACE!{static interface ILocationTriggerFactory(ILocationTriggerFactoryVtbl): IInspectable(IInspectableVtbl) [IID_ILocationTriggerFactory] { - fn Create(&self, triggerType: LocationTriggerType, out: *mut *mut LocationTrigger) -> HRESULT -}} -impl ILocationTriggerFactory { - #[inline] pub fn create(&self, triggerType: LocationTriggerType) -> Result> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, triggerType, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + #[inline] pub fn remove_query_changed(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_QueryChanged)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } }} -} -RT_ENUM! { enum LocationTriggerType: i32 { - Geofence (LocationTriggerType_Geofence) = 0, -}} -DEFINE_IID!(IID_IMaintenanceTrigger, 1746422915, 64546, 19685, 132, 26, 114, 57, 169, 129, 0, 71); -RT_INTERFACE!{interface IMaintenanceTrigger(IMaintenanceTriggerVtbl): IInspectable(IInspectableVtbl) [IID_IMaintenanceTrigger] { - fn get_FreshnessTime(&self, out: *mut u32) -> HRESULT, - fn get_OneShot(&self, out: *mut bool) -> HRESULT -}} -impl IMaintenanceTrigger { - #[inline] pub fn get_freshness_time(&self) -> Result { unsafe { + #[inline] pub fn add_suggestions_requested(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_FreshnessTime)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).add_SuggestionsRequested)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_one_shot(&self) -> Result { unsafe { + #[inline] pub fn remove_suggestions_requested(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_SuggestionsRequested)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_query_submitted(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_OneShot)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).add_QuerySubmitted)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_query_submitted(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_QuerySubmitted)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_result_suggestion_chosen(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_ResultSuggestionChosen)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_result_suggestion_chosen(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_ResultSuggestionChosen)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn set_local_content_suggestion_settings(&self, settings: &LocalContentSuggestionSettings) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).SetLocalContentSuggestionSettings)(self as *const _ as *mut _, settings as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn show_overload_default(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).ShowOverloadDefault)(self as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn show_overload_with_query(&self, query: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).ShowOverloadWithQuery)(self as *const _ as *mut _, query.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn set_show_on_keyboard_input(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_ShowOnKeyboardInput)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_show_on_keyboard_input(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_ShowOnKeyboardInput)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn try_set_query_text(&self, query: &HStringArg) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).TrySetQueryText)(self as *const _ as *mut _, query.get(), &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} } -RT_CLASS!{class MaintenanceTrigger: IMaintenanceTrigger} -impl RtActivatable for MaintenanceTrigger {} -impl MaintenanceTrigger { - #[inline] pub fn create(freshnessTime: u32, oneShot: bool) -> Result> { - >::get_activation_factory().create(freshnessTime, oneShot) +RT_CLASS!{class SearchPane: ISearchPane} +impl RtActivatable for SearchPane {} +impl RtActivatable for SearchPane {} +impl SearchPane { + #[inline] pub fn get_for_current_view() -> Result>> { + >::get_activation_factory().get_for_current_view() + } + #[inline] pub fn hide_this_application() -> Result<()> { + >::get_activation_factory().hide_this_application() } } -DEFINE_CLSID!(MaintenanceTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,77,97,105,110,116,101,110,97,110,99,101,84,114,105,103,103,101,114,0]) [CLSID_MaintenanceTrigger]); -DEFINE_IID!(IID_IMaintenanceTriggerFactory, 1262345006, 38877, 17961, 136, 176, 176, 108, 249, 72, 42, 229); -RT_INTERFACE!{static interface IMaintenanceTriggerFactory(IMaintenanceTriggerFactoryVtbl): IInspectable(IInspectableVtbl) [IID_IMaintenanceTriggerFactory] { - fn Create(&self, freshnessTime: u32, oneShot: bool, out: *mut *mut MaintenanceTrigger) -> HRESULT +DEFINE_CLSID!(SearchPane(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,83,101,97,114,99,104,46,83,101,97,114,99,104,80,97,110,101,0]) [CLSID_SearchPane]); +DEFINE_IID!(IID_ISearchPaneQueryChangedEventArgs, 1007046633, 9041, 16968, 165, 41, 113, 16, 244, 100, 167, 133); +RT_INTERFACE!{interface ISearchPaneQueryChangedEventArgs(ISearchPaneQueryChangedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_ISearchPaneQueryChangedEventArgs] { + fn get_QueryText(&self, out: *mut HSTRING) -> HRESULT, + fn get_Language(&self, out: *mut HSTRING) -> HRESULT, + fn get_LinguisticDetails(&self, out: *mut *mut SearchPaneQueryLinguisticDetails) -> HRESULT }} -impl IMaintenanceTriggerFactory { - #[inline] pub fn create(&self, freshnessTime: u32, oneShot: bool) -> Result> { unsafe { +impl ISearchPaneQueryChangedEventArgs { + #[inline] pub fn get_query_text(&self) -> Result { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, freshnessTime, oneShot, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).get_QueryText)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} -} -DEFINE_IID!(IID_IMediaProcessingTrigger, 2593504869, 35410, 19248, 144, 17, 207, 56, 4, 14, 168, 176); -RT_INTERFACE!{interface IMediaProcessingTrigger(IMediaProcessingTriggerVtbl): IInspectable(IInspectableVtbl) [IID_IMediaProcessingTrigger] { - fn RequestAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, - fn RequestAsyncWithArguments(&self, arguments: *mut foundation::collections::ValueSet, out: *mut *mut foundation::IAsyncOperation) -> HRESULT -}} -impl IMediaProcessingTrigger { - #[inline] pub fn request_async(&self) -> Result>> { unsafe { + #[inline] pub fn get_language(&self) -> Result { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).RequestAsync)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).get_Language)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} - #[inline] pub fn request_async_with_arguments(&self, arguments: &foundation::collections::ValueSet) -> Result>> { unsafe { + #[inline] pub fn get_linguistic_details(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).RequestAsyncWithArguments)(self as *const _ as *mut _, arguments as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).get_LinguisticDetails)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } -RT_CLASS!{class MediaProcessingTrigger: IMediaProcessingTrigger} -impl RtActivatable for MediaProcessingTrigger {} -DEFINE_CLSID!(MediaProcessingTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,77,101,100,105,97,80,114,111,99,101,115,115,105,110,103,84,114,105,103,103,101,114,0]) [CLSID_MediaProcessingTrigger]); -RT_ENUM! { enum MediaProcessingTriggerResult: i32 { - Allowed (MediaProcessingTriggerResult_Allowed) = 0, CurrentlyRunning (MediaProcessingTriggerResult_CurrentlyRunning) = 1, DisabledByPolicy (MediaProcessingTriggerResult_DisabledByPolicy) = 2, UnknownError (MediaProcessingTriggerResult_UnknownError) = 3, +RT_CLASS!{class SearchPaneQueryChangedEventArgs: ISearchPaneQueryChangedEventArgs} +DEFINE_IID!(IID_ISearchPaneQueryLinguisticDetails, 2197505550, 2368, 19309, 184, 208, 100, 43, 48, 152, 158, 21); +RT_INTERFACE!{interface ISearchPaneQueryLinguisticDetails(ISearchPaneQueryLinguisticDetailsVtbl): IInspectable(IInspectableVtbl) [IID_ISearchPaneQueryLinguisticDetails] { + fn get_QueryTextAlternatives(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT, + fn get_QueryTextCompositionStart(&self, out: *mut u32) -> HRESULT, + fn get_QueryTextCompositionLength(&self, out: *mut u32) -> HRESULT }} -RT_CLASS!{class MobileBroadbandDeviceServiceNotificationTrigger: IBackgroundTrigger} -impl RtActivatable for MobileBroadbandDeviceServiceNotificationTrigger {} -DEFINE_CLSID!(MobileBroadbandDeviceServiceNotificationTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,77,111,98,105,108,101,66,114,111,97,100,98,97,110,100,68,101,118,105,99,101,83,101,114,118,105,99,101,78,111,116,105,102,105,99,97,116,105,111,110,84,114,105,103,103,101,114,0]) [CLSID_MobileBroadbandDeviceServiceNotificationTrigger]); -RT_CLASS!{class MobileBroadbandPinLockStateChangeTrigger: IBackgroundTrigger} -impl RtActivatable for MobileBroadbandPinLockStateChangeTrigger {} -DEFINE_CLSID!(MobileBroadbandPinLockStateChangeTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,77,111,98,105,108,101,66,114,111,97,100,98,97,110,100,80,105,110,76,111,99,107,83,116,97,116,101,67,104,97,110,103,101,84,114,105,103,103,101,114,0]) [CLSID_MobileBroadbandPinLockStateChangeTrigger]); -RT_CLASS!{class MobileBroadbandRadioStateChangeTrigger: IBackgroundTrigger} -impl RtActivatable for MobileBroadbandRadioStateChangeTrigger {} -DEFINE_CLSID!(MobileBroadbandRadioStateChangeTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,77,111,98,105,108,101,66,114,111,97,100,98,97,110,100,82,97,100,105,111,83,116,97,116,101,67,104,97,110,103,101,84,114,105,103,103,101,114,0]) [CLSID_MobileBroadbandRadioStateChangeTrigger]); -RT_CLASS!{class MobileBroadbandRegistrationStateChangeTrigger: IBackgroundTrigger} -impl RtActivatable for MobileBroadbandRegistrationStateChangeTrigger {} -DEFINE_CLSID!(MobileBroadbandRegistrationStateChangeTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,77,111,98,105,108,101,66,114,111,97,100,98,97,110,100,82,101,103,105,115,116,114,97,116,105,111,110,83,116,97,116,101,67,104,97,110,103,101,84,114,105,103,103,101,114,0]) [CLSID_MobileBroadbandRegistrationStateChangeTrigger]); -DEFINE_IID!(IID_INetworkOperatorHotspotAuthenticationTrigger, 3881224081, 12289, 19941, 131, 199, 222, 97, 216, 136, 49, 208); -RT_INTERFACE!{interface INetworkOperatorHotspotAuthenticationTrigger(INetworkOperatorHotspotAuthenticationTriggerVtbl): IInspectable(IInspectableVtbl) [IID_INetworkOperatorHotspotAuthenticationTrigger] { - -}} -RT_CLASS!{class NetworkOperatorHotspotAuthenticationTrigger: INetworkOperatorHotspotAuthenticationTrigger} -impl RtActivatable for NetworkOperatorHotspotAuthenticationTrigger {} -DEFINE_CLSID!(NetworkOperatorHotspotAuthenticationTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,78,101,116,119,111,114,107,79,112,101,114,97,116,111,114,72,111,116,115,112,111,116,65,117,116,104,101,110,116,105,99,97,116,105,111,110,84,114,105,103,103,101,114,0]) [CLSID_NetworkOperatorHotspotAuthenticationTrigger]); -DEFINE_IID!(IID_INetworkOperatorNotificationTrigger, 2416483526, 25549, 18444, 149, 209, 110, 106, 239, 128, 30, 74); -RT_INTERFACE!{interface INetworkOperatorNotificationTrigger(INetworkOperatorNotificationTriggerVtbl): IInspectable(IInspectableVtbl) [IID_INetworkOperatorNotificationTrigger] { - fn get_NetworkAccountId(&self, out: *mut HSTRING) -> HRESULT -}} -impl INetworkOperatorNotificationTrigger { - #[inline] pub fn get_network_account_id(&self) -> Result { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_NetworkAccountId)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } - }} -} -RT_CLASS!{class NetworkOperatorNotificationTrigger: INetworkOperatorNotificationTrigger} -impl RtActivatable for NetworkOperatorNotificationTrigger {} -impl NetworkOperatorNotificationTrigger { - #[inline] pub fn create(networkAccountId: &HStringArg) -> Result> { - >::get_activation_factory().create(networkAccountId) - } -} -DEFINE_CLSID!(NetworkOperatorNotificationTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,78,101,116,119,111,114,107,79,112,101,114,97,116,111,114,78,111,116,105,102,105,99,97,116,105,111,110,84,114,105,103,103,101,114,0]) [CLSID_NetworkOperatorNotificationTrigger]); -DEFINE_IID!(IID_INetworkOperatorNotificationTriggerFactory, 170016256, 10199, 17235, 173, 185, 146, 101, 170, 234, 87, 157); -RT_INTERFACE!{static interface INetworkOperatorNotificationTriggerFactory(INetworkOperatorNotificationTriggerFactoryVtbl): IInspectable(IInspectableVtbl) [IID_INetworkOperatorNotificationTriggerFactory] { - fn Create(&self, networkAccountId: HSTRING, out: *mut *mut NetworkOperatorNotificationTrigger) -> HRESULT -}} -impl INetworkOperatorNotificationTriggerFactory { - #[inline] pub fn create(&self, networkAccountId: &HStringArg) -> Result> { unsafe { +impl ISearchPaneQueryLinguisticDetails { + #[inline] pub fn get_query_text_alternatives(&self) -> Result>>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, networkAccountId.get(), &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).get_QueryTextAlternatives)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} -} -RT_CLASS!{class PaymentAppCanMakePaymentTrigger: IBackgroundTrigger} -impl RtActivatable for PaymentAppCanMakePaymentTrigger {} -DEFINE_CLSID!(PaymentAppCanMakePaymentTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,80,97,121,109,101,110,116,65,112,112,67,97,110,77,97,107,101,80,97,121,109,101,110,116,84,114,105,103,103,101,114,0]) [CLSID_PaymentAppCanMakePaymentTrigger]); -DEFINE_IID!(IID_IPhoneTrigger, 2379213211, 54469, 18929, 183, 211, 130, 232, 122, 14, 157, 222); -RT_INTERFACE!{interface IPhoneTrigger(IPhoneTriggerVtbl): IInspectable(IInspectableVtbl) [IID_IPhoneTrigger] { - fn get_OneShot(&self, out: *mut bool) -> HRESULT, - fn get_TriggerType(&self, out: *mut super::calls::background::PhoneTriggerType) -> HRESULT -}} -impl IPhoneTrigger { - #[inline] pub fn get_one_shot(&self) -> Result { unsafe { + #[inline] pub fn get_query_text_composition_start(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_OneShot)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_QueryTextCompositionStart)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_trigger_type(&self) -> Result { unsafe { + #[inline] pub fn get_query_text_composition_length(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_TriggerType)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_QueryTextCompositionLength)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} } -RT_CLASS!{class PhoneTrigger: IPhoneTrigger} -impl RtActivatable for PhoneTrigger {} -impl PhoneTrigger { - #[inline] pub fn create(type_: super::calls::background::PhoneTriggerType, oneShot: bool) -> Result> { - >::get_activation_factory().create(type_, oneShot) - } -} -DEFINE_CLSID!(PhoneTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,80,104,111,110,101,84,114,105,103,103,101,114,0]) [CLSID_PhoneTrigger]); -DEFINE_IID!(IID_IPhoneTriggerFactory, 2698591450, 24513, 18683, 165, 70, 50, 38, 32, 64, 21, 123); -RT_INTERFACE!{static interface IPhoneTriggerFactory(IPhoneTriggerFactoryVtbl): IInspectable(IInspectableVtbl) [IID_IPhoneTriggerFactory] { - fn Create(&self, type_: super::calls::background::PhoneTriggerType, oneShot: bool, out: *mut *mut PhoneTrigger) -> HRESULT +RT_CLASS!{class SearchPaneQueryLinguisticDetails: ISearchPaneQueryLinguisticDetails} +DEFINE_IID!(IID_ISearchPaneQuerySubmittedEventArgs, 339453180, 59845, 18230, 145, 178, 232, 235, 156, 184, 131, 86); +RT_INTERFACE!{interface ISearchPaneQuerySubmittedEventArgs(ISearchPaneQuerySubmittedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_ISearchPaneQuerySubmittedEventArgs] { + fn get_QueryText(&self, out: *mut HSTRING) -> HRESULT, + fn get_Language(&self, out: *mut HSTRING) -> HRESULT }} -impl IPhoneTriggerFactory { - #[inline] pub fn create(&self, type_: super::calls::background::PhoneTriggerType, oneShot: bool) -> Result> { unsafe { +impl ISearchPaneQuerySubmittedEventArgs { + #[inline] pub fn get_query_text(&self) -> Result { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, type_, oneShot, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).get_QueryText)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_language(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Language)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} } -RT_CLASS!{class PushNotificationTrigger: IBackgroundTrigger} -impl RtActivatable for PushNotificationTrigger {} -impl RtActivatable for PushNotificationTrigger {} -impl PushNotificationTrigger { - #[inline] pub fn create(applicationId: &HStringArg) -> Result> { - >::get_activation_factory().create(applicationId) - } -} -DEFINE_CLSID!(PushNotificationTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,80,117,115,104,78,111,116,105,102,105,99,97,116,105,111,110,84,114,105,103,103,101,114,0]) [CLSID_PushNotificationTrigger]); -DEFINE_IID!(IID_IPushNotificationTriggerFactory, 1842933019, 17806, 20418, 188, 46, 213, 102, 79, 119, 237, 25); -RT_INTERFACE!{static interface IPushNotificationTriggerFactory(IPushNotificationTriggerFactoryVtbl): IInspectable(IInspectableVtbl) [IID_IPushNotificationTriggerFactory] { - fn Create(&self, applicationId: HSTRING, out: *mut *mut PushNotificationTrigger) -> HRESULT +RT_CLASS!{class SearchPaneQuerySubmittedEventArgs: ISearchPaneQuerySubmittedEventArgs} +DEFINE_IID!(IID_ISearchPaneQuerySubmittedEventArgsWithLinguisticDetails, 1175229157, 19506, 17720, 164, 212, 182, 180, 64, 13, 20, 15); +RT_INTERFACE!{interface ISearchPaneQuerySubmittedEventArgsWithLinguisticDetails(ISearchPaneQuerySubmittedEventArgsWithLinguisticDetailsVtbl): IInspectable(IInspectableVtbl) [IID_ISearchPaneQuerySubmittedEventArgsWithLinguisticDetails] { + fn get_LinguisticDetails(&self, out: *mut *mut SearchPaneQueryLinguisticDetails) -> HRESULT }} -impl IPushNotificationTriggerFactory { - #[inline] pub fn create(&self, applicationId: &HStringArg) -> Result> { unsafe { +impl ISearchPaneQuerySubmittedEventArgsWithLinguisticDetails { + #[inline] pub fn get_linguistic_details(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, applicationId.get(), &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).get_LinguisticDetails)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } -DEFINE_IID!(IID_IRcsEndUserMessageAvailableTrigger, 2557283690, 45814, 18047, 169, 120, 164, 64, 145, 193, 26, 102); -RT_INTERFACE!{interface IRcsEndUserMessageAvailableTrigger(IRcsEndUserMessageAvailableTriggerVtbl): IInspectable(IInspectableVtbl) [IID_IRcsEndUserMessageAvailableTrigger] { - -}} -RT_CLASS!{class RcsEndUserMessageAvailableTrigger: IRcsEndUserMessageAvailableTrigger} -impl RtActivatable for RcsEndUserMessageAvailableTrigger {} -DEFINE_CLSID!(RcsEndUserMessageAvailableTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,82,99,115,69,110,100,85,115,101,114,77,101,115,115,97,103,101,65,118,97,105,108,97,98,108,101,84,114,105,103,103,101,114,0]) [CLSID_RcsEndUserMessageAvailableTrigger]); -DEFINE_IID!(IID_IRfcommConnectionTrigger, 3905211106, 2899, 17508, 147, 148, 253, 135, 86, 84, 222, 100); -RT_INTERFACE!{interface IRfcommConnectionTrigger(IRfcommConnectionTriggerVtbl): IInspectable(IInspectableVtbl) [IID_IRfcommConnectionTrigger] { - #[cfg(not(feature="windows-devices"))] fn __Dummy0(&self) -> (), - #[cfg(feature="windows-devices")] fn get_InboundConnection(&self, out: *mut *mut super::super::devices::bluetooth::background::RfcommInboundConnectionInformation) -> HRESULT, - #[cfg(not(feature="windows-devices"))] fn __Dummy1(&self) -> (), - #[cfg(feature="windows-devices")] fn get_OutboundConnection(&self, out: *mut *mut super::super::devices::bluetooth::background::RfcommOutboundConnectionInformation) -> HRESULT, - fn get_AllowMultipleConnections(&self, out: *mut bool) -> HRESULT, - fn put_AllowMultipleConnections(&self, value: bool) -> HRESULT, - #[cfg(feature="windows-networking")] fn get_ProtectionLevel(&self, out: *mut super::super::networking::sockets::SocketProtectionLevel) -> HRESULT, - #[cfg(feature="windows-networking")] fn put_ProtectionLevel(&self, value: super::super::networking::sockets::SocketProtectionLevel) -> HRESULT, - #[cfg(feature="windows-networking")] fn get_RemoteHostName(&self, out: *mut *mut super::super::networking::HostName) -> HRESULT, - #[cfg(feature="windows-networking")] fn put_RemoteHostName(&self, value: *mut super::super::networking::HostName) -> HRESULT +DEFINE_IID!(IID_ISearchPaneResultSuggestionChosenEventArgs, 3358682304, 44754, 16864, 188, 224, 194, 108, 167, 79, 133, 236); +RT_INTERFACE!{interface ISearchPaneResultSuggestionChosenEventArgs(ISearchPaneResultSuggestionChosenEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_ISearchPaneResultSuggestionChosenEventArgs] { + fn get_Tag(&self, out: *mut HSTRING) -> HRESULT }} -impl IRfcommConnectionTrigger { - #[cfg(feature="windows-devices")] #[inline] pub fn get_inbound_connection(&self) -> Result>> { unsafe { +impl ISearchPaneResultSuggestionChosenEventArgs { + #[inline] pub fn get_tag(&self) -> Result { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_InboundConnection)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).get_Tag)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} - #[cfg(feature="windows-devices")] #[inline] pub fn get_outbound_connection(&self) -> Result>> { unsafe { +} +RT_CLASS!{class SearchPaneResultSuggestionChosenEventArgs: ISearchPaneResultSuggestionChosenEventArgs} +DEFINE_IID!(IID_ISearchPaneStatics, 2507320817, 36637, 18463, 161, 91, 198, 22, 85, 241, 106, 14); +RT_INTERFACE!{static interface ISearchPaneStatics(ISearchPaneStaticsVtbl): IInspectable(IInspectableVtbl) [IID_ISearchPaneStatics] { + fn GetForCurrentView(&self, out: *mut *mut SearchPane) -> HRESULT +}} +impl ISearchPaneStatics { + #[inline] pub fn get_for_current_view(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_OutboundConnection)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).GetForCurrentView)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn get_allow_multiple_connections(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_AllowMultipleConnections)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } - }} - #[inline] pub fn set_allow_multiple_connections(&self, value: bool) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_AllowMultipleConnections)(self as *const _ as *mut _, value); +} +DEFINE_IID!(IID_ISearchPaneStaticsWithHideThisApplication, 7546928, 20721, 19715, 153, 172, 198, 100, 76, 142, 216, 181); +RT_INTERFACE!{static interface ISearchPaneStaticsWithHideThisApplication(ISearchPaneStaticsWithHideThisApplicationVtbl): IInspectable(IInspectableVtbl) [IID_ISearchPaneStaticsWithHideThisApplication] { + fn HideThisApplication(&self) -> HRESULT +}} +impl ISearchPaneStaticsWithHideThisApplication { + #[inline] pub fn hide_this_application(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).HideThisApplication)(self as *const _ as *mut _); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[cfg(feature="windows-networking")] #[inline] pub fn get_protection_level(&self) -> Result { unsafe { +} +DEFINE_IID!(IID_ISearchPaneSuggestionsRequest, 2175863580, 58721, 16531, 155, 77, 42, 212, 130, 121, 74, 83); +RT_INTERFACE!{interface ISearchPaneSuggestionsRequest(ISearchPaneSuggestionsRequestVtbl): IInspectable(IInspectableVtbl) [IID_ISearchPaneSuggestionsRequest] { + fn get_IsCanceled(&self, out: *mut bool) -> HRESULT, + fn get_SearchSuggestionCollection(&self, out: *mut *mut SearchSuggestionCollection) -> HRESULT, + fn GetDeferral(&self, out: *mut *mut SearchPaneSuggestionsRequestDeferral) -> HRESULT +}} +impl ISearchPaneSuggestionsRequest { + #[inline] pub fn get_is_canceled(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_ProtectionLevel)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_IsCanceled)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[cfg(feature="windows-networking")] #[inline] pub fn set_protection_level(&self, value: super::super::networking::sockets::SocketProtectionLevel) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_ProtectionLevel)(self as *const _ as *mut _, value); - if hr == S_OK { Ok(()) } else { err(hr) } - }} - #[cfg(feature="windows-networking")] #[inline] pub fn get_remote_host_name(&self) -> Result>> { unsafe { + #[inline] pub fn get_search_suggestion_collection(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_RemoteHostName)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_SearchSuggestionCollection)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[cfg(feature="windows-networking")] #[inline] pub fn set_remote_host_name(&self, value: &super::super::networking::HostName) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_RemoteHostName)(self as *const _ as *mut _, value as *const _ as *mut _); - if hr == S_OK { Ok(()) } else { err(hr) } + #[inline] pub fn get_deferral(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetDeferral)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } -RT_CLASS!{class RfcommConnectionTrigger: IRfcommConnectionTrigger} -impl RtActivatable for RfcommConnectionTrigger {} -DEFINE_CLSID!(RfcommConnectionTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,82,102,99,111,109,109,67,111,110,110,101,99,116,105,111,110,84,114,105,103,103,101,114,0]) [CLSID_RfcommConnectionTrigger]); -DEFINE_IID!(IID_ISecondaryAuthenticationFactorAuthenticationTrigger, 4063752999, 20865, 20260, 150, 167, 112, 10, 78, 95, 172, 98); -RT_INTERFACE!{interface ISecondaryAuthenticationFactorAuthenticationTrigger(ISecondaryAuthenticationFactorAuthenticationTriggerVtbl): IInspectable(IInspectableVtbl) [IID_ISecondaryAuthenticationFactorAuthenticationTrigger] { - -}} -RT_CLASS!{class SecondaryAuthenticationFactorAuthenticationTrigger: ISecondaryAuthenticationFactorAuthenticationTrigger} -impl RtActivatable for SecondaryAuthenticationFactorAuthenticationTrigger {} -DEFINE_CLSID!(SecondaryAuthenticationFactorAuthenticationTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,83,101,99,111,110,100,97,114,121,65,117,116,104,101,110,116,105,99,97,116,105,111,110,70,97,99,116,111,114,65,117,116,104,101,110,116,105,99,97,116,105,111,110,84,114,105,103,103,101,114,0]) [CLSID_SecondaryAuthenticationFactorAuthenticationTrigger]); -DEFINE_IID!(IID_ISensorDataThresholdTrigger, 1539371890, 54411, 19327, 171, 236, 21, 249, 186, 204, 18, 226); -RT_INTERFACE!{interface ISensorDataThresholdTrigger(ISensorDataThresholdTriggerVtbl): IInspectable(IInspectableVtbl) [IID_ISensorDataThresholdTrigger] { - +RT_CLASS!{class SearchPaneSuggestionsRequest: ISearchPaneSuggestionsRequest} +DEFINE_IID!(IID_ISearchPaneSuggestionsRequestDeferral, 2697988599, 34632, 20194, 173, 68, 175, 166, 190, 153, 124, 81); +RT_INTERFACE!{interface ISearchPaneSuggestionsRequestDeferral(ISearchPaneSuggestionsRequestDeferralVtbl): IInspectable(IInspectableVtbl) [IID_ISearchPaneSuggestionsRequestDeferral] { + fn Complete(&self) -> HRESULT }} -RT_CLASS!{class SensorDataThresholdTrigger: ISensorDataThresholdTrigger} -impl RtActivatable for SensorDataThresholdTrigger {} -impl SensorDataThresholdTrigger { - #[cfg(feature="windows-devices")] #[inline] pub fn create(threshold: &super::super::devices::sensors::ISensorDataThreshold) -> Result> { - >::get_activation_factory().create(threshold) - } +impl ISearchPaneSuggestionsRequestDeferral { + #[inline] pub fn complete(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).Complete)(self as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} } -DEFINE_CLSID!(SensorDataThresholdTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,83,101,110,115,111,114,68,97,116,97,84,104,114,101,115,104,111,108,100,84,114,105,103,103,101,114,0]) [CLSID_SensorDataThresholdTrigger]); -DEFINE_IID!(IID_ISensorDataThresholdTriggerFactory, 2451564149, 32240, 19875, 151, 179, 229, 68, 238, 133, 127, 230); -RT_INTERFACE!{static interface ISensorDataThresholdTriggerFactory(ISensorDataThresholdTriggerFactoryVtbl): IInspectable(IInspectableVtbl) [IID_ISensorDataThresholdTriggerFactory] { - #[cfg(feature="windows-devices")] fn Create(&self, threshold: *mut super::super::devices::sensors::ISensorDataThreshold, out: *mut *mut SensorDataThresholdTrigger) -> HRESULT +RT_CLASS!{class SearchPaneSuggestionsRequestDeferral: ISearchPaneSuggestionsRequestDeferral} +DEFINE_IID!(IID_ISearchPaneSuggestionsRequestedEventArgs, 3365636655, 44118, 17504, 141, 47, 128, 2, 59, 236, 79, 197); +RT_INTERFACE!{interface ISearchPaneSuggestionsRequestedEventArgs(ISearchPaneSuggestionsRequestedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_ISearchPaneSuggestionsRequestedEventArgs] { + fn get_Request(&self, out: *mut *mut SearchPaneSuggestionsRequest) -> HRESULT }} -impl ISensorDataThresholdTriggerFactory { - #[cfg(feature="windows-devices")] #[inline] pub fn create(&self, threshold: &super::super::devices::sensors::ISensorDataThreshold) -> Result> { unsafe { +impl ISearchPaneSuggestionsRequestedEventArgs { + #[inline] pub fn get_request(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, threshold as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).get_Request)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } -DEFINE_IID!(IID_ISmartCardTrigger, 4114335148, 33994, 18802, 140, 233, 229, 143, 151, 179, 122, 80); -RT_INTERFACE!{interface ISmartCardTrigger(ISmartCardTriggerVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardTrigger] { - #[cfg(feature="windows-devices")] fn get_TriggerType(&self, out: *mut super::super::devices::smartcards::SmartCardTriggerType) -> HRESULT +RT_CLASS!{class SearchPaneSuggestionsRequestedEventArgs: ISearchPaneSuggestionsRequestedEventArgs} +DEFINE_IID!(IID_ISearchPaneVisibilityChangedEventArgs, 1011691590, 44107, 18930, 151, 214, 2, 14, 97, 130, 203, 156); +RT_INTERFACE!{interface ISearchPaneVisibilityChangedEventArgs(ISearchPaneVisibilityChangedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_ISearchPaneVisibilityChangedEventArgs] { + fn get_Visible(&self, out: *mut bool) -> HRESULT }} -impl ISmartCardTrigger { - #[cfg(feature="windows-devices")] #[inline] pub fn get_trigger_type(&self) -> Result { unsafe { +impl ISearchPaneVisibilityChangedEventArgs { + #[inline] pub fn get_visible(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_TriggerType)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_Visible)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} } -RT_CLASS!{class SmartCardTrigger: ISmartCardTrigger} -impl RtActivatable for SmartCardTrigger {} -impl SmartCardTrigger { - #[cfg(feature="windows-devices")] #[inline] pub fn create(triggerType: super::super::devices::smartcards::SmartCardTriggerType) -> Result> { - >::get_activation_factory().create(triggerType) - } -} -DEFINE_CLSID!(SmartCardTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,83,109,97,114,116,67,97,114,100,84,114,105,103,103,101,114,0]) [CLSID_SmartCardTrigger]); -DEFINE_IID!(IID_ISmartCardTriggerFactory, 1673483459, 35265, 19968, 169, 211, 151, 198, 41, 38, 157, 173); -RT_INTERFACE!{static interface ISmartCardTriggerFactory(ISmartCardTriggerFactoryVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardTriggerFactory] { - #[cfg(feature="windows-devices")] fn Create(&self, triggerType: super::super::devices::smartcards::SmartCardTriggerType, out: *mut *mut SmartCardTrigger) -> HRESULT +RT_CLASS!{class SearchPaneVisibilityChangedEventArgs: ISearchPaneVisibilityChangedEventArgs} +DEFINE_IID!(IID_ISearchQueryLinguisticDetails, 1184964699, 27081, 18245, 183, 47, 168, 164, 252, 143, 36, 174); +RT_INTERFACE!{interface ISearchQueryLinguisticDetails(ISearchQueryLinguisticDetailsVtbl): IInspectable(IInspectableVtbl) [IID_ISearchQueryLinguisticDetails] { + fn get_QueryTextAlternatives(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT, + fn get_QueryTextCompositionStart(&self, out: *mut u32) -> HRESULT, + fn get_QueryTextCompositionLength(&self, out: *mut u32) -> HRESULT }} -impl ISmartCardTriggerFactory { - #[cfg(feature="windows-devices")] #[inline] pub fn create(&self, triggerType: super::super::devices::smartcards::SmartCardTriggerType) -> Result> { unsafe { +impl ISearchQueryLinguisticDetails { + #[inline] pub fn get_query_text_alternatives(&self) -> Result>>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, triggerType, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).get_QueryTextAlternatives)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_query_text_composition_start(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_QueryTextCompositionStart)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_query_text_composition_length(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_QueryTextCompositionLength)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} } -RT_CLASS!{class SmsMessageReceivedTrigger: IBackgroundTrigger} -impl RtActivatable for SmsMessageReceivedTrigger {} -impl SmsMessageReceivedTrigger { - #[cfg(feature="windows-devices")] #[inline] pub fn create(filterRules: &super::super::devices::sms::SmsFilterRules) -> Result> { - >::get_activation_factory().create(filterRules) +RT_CLASS!{class SearchQueryLinguisticDetails: ISearchQueryLinguisticDetails} +impl RtActivatable for SearchQueryLinguisticDetails {} +impl SearchQueryLinguisticDetails { + #[inline] pub fn create_instance(queryTextAlternatives: &foundation::collections::IIterable, queryTextCompositionStart: u32, queryTextCompositionLength: u32) -> Result> { + >::get_activation_factory().create_instance(queryTextAlternatives, queryTextCompositionStart, queryTextCompositionLength) } } -DEFINE_CLSID!(SmsMessageReceivedTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,83,109,115,77,101,115,115,97,103,101,82,101,99,101,105,118,101,100,84,114,105,103,103,101,114,0]) [CLSID_SmsMessageReceivedTrigger]); -DEFINE_IID!(IID_ISmsMessageReceivedTriggerFactory, 3929725128, 27556, 19122, 141, 33, 188, 107, 9, 199, 117, 100); -RT_INTERFACE!{static interface ISmsMessageReceivedTriggerFactory(ISmsMessageReceivedTriggerFactoryVtbl): IInspectable(IInspectableVtbl) [IID_ISmsMessageReceivedTriggerFactory] { - #[cfg(feature="windows-devices")] fn Create(&self, filterRules: *mut super::super::devices::sms::SmsFilterRules, out: *mut *mut SmsMessageReceivedTrigger) -> HRESULT +DEFINE_CLSID!(SearchQueryLinguisticDetails(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,83,101,97,114,99,104,46,83,101,97,114,99,104,81,117,101,114,121,76,105,110,103,117,105,115,116,105,99,68,101,116,97,105,108,115,0]) [CLSID_SearchQueryLinguisticDetails]); +DEFINE_IID!(IID_ISearchQueryLinguisticDetailsFactory, 3402023864, 15460, 19965, 173, 159, 71, 158, 77, 64, 101, 164); +RT_INTERFACE!{static interface ISearchQueryLinguisticDetailsFactory(ISearchQueryLinguisticDetailsFactoryVtbl): IInspectable(IInspectableVtbl) [IID_ISearchQueryLinguisticDetailsFactory] { + fn CreateInstance(&self, queryTextAlternatives: *mut foundation::collections::IIterable, queryTextCompositionStart: u32, queryTextCompositionLength: u32, out: *mut *mut SearchQueryLinguisticDetails) -> HRESULT }} -impl ISmsMessageReceivedTriggerFactory { - #[cfg(feature="windows-devices")] #[inline] pub fn create(&self, filterRules: &super::super::devices::sms::SmsFilterRules) -> Result> { unsafe { +impl ISearchQueryLinguisticDetailsFactory { + #[inline] pub fn create_instance(&self, queryTextAlternatives: &foundation::collections::IIterable, queryTextCompositionStart: u32, queryTextCompositionLength: u32) -> Result> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, filterRules as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).CreateInstance)(self as *const _ as *mut _, queryTextAlternatives as *const _ as *mut _, queryTextCompositionStart, queryTextCompositionLength, &mut out); if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } -DEFINE_IID!(IID_ISocketActivityTrigger, 2847668240, 40414, 20362, 131, 227, 176, 224, 231, 165, 13, 112); -RT_INTERFACE!{interface ISocketActivityTrigger(ISocketActivityTriggerVtbl): IInspectable(IInspectableVtbl) [IID_ISocketActivityTrigger] { - fn get_IsWakeFromLowPowerSupported(&self, out: *mut bool) -> HRESULT +DEFINE_IID!(IID_ISearchSuggestionCollection, 842697291, 64490, 17478, 171, 188, 61, 167, 145, 95, 221, 58); +RT_INTERFACE!{interface ISearchSuggestionCollection(ISearchSuggestionCollectionVtbl): IInspectable(IInspectableVtbl) [IID_ISearchSuggestionCollection] { + fn get_Size(&self, out: *mut u32) -> HRESULT, + fn AppendQuerySuggestion(&self, text: HSTRING) -> HRESULT, + fn AppendQuerySuggestions(&self, suggestions: *mut foundation::collections::IIterable) -> HRESULT, + #[cfg(not(feature="windows-storage"))] fn __Dummy3(&self) -> (), + #[cfg(feature="windows-storage")] fn AppendResultSuggestion(&self, text: HSTRING, detailText: HSTRING, tag: HSTRING, image: *mut super::super::storage::streams::IRandomAccessStreamReference, imageAlternateText: HSTRING) -> HRESULT, + fn AppendSearchSeparator(&self, label: HSTRING) -> HRESULT }} -impl ISocketActivityTrigger { - #[inline] pub fn get_is_wake_from_low_power_supported(&self) -> Result { unsafe { +impl ISearchSuggestionCollection { + #[inline] pub fn get_size(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_IsWakeFromLowPowerSupported)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_Size)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} + #[inline] pub fn append_query_suggestion(&self, text: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).AppendQuerySuggestion)(self as *const _ as *mut _, text.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn append_query_suggestions(&self, suggestions: &foundation::collections::IIterable) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).AppendQuerySuggestions)(self as *const _ as *mut _, suggestions as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[cfg(feature="windows-storage")] #[inline] pub fn append_result_suggestion(&self, text: &HStringArg, detailText: &HStringArg, tag: &HStringArg, image: &super::super::storage::streams::IRandomAccessStreamReference, imageAlternateText: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).AppendResultSuggestion)(self as *const _ as *mut _, text.get(), detailText.get(), tag.get(), image as *const _ as *mut _, imageAlternateText.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn append_search_separator(&self, label: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).AppendSearchSeparator)(self as *const _ as *mut _, label.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} } -RT_CLASS!{class SocketActivityTrigger: IBackgroundTrigger} -impl RtActivatable for SocketActivityTrigger {} -DEFINE_CLSID!(SocketActivityTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,83,111,99,107,101,116,65,99,116,105,118,105,116,121,84,114,105,103,103,101,114,0]) [CLSID_SocketActivityTrigger]); -DEFINE_IID!(IID_IStorageLibraryContentChangedTrigger, 372760743, 33436, 17852, 146, 155, 161, 231, 234, 120, 216, 155); -RT_INTERFACE!{interface IStorageLibraryContentChangedTrigger(IStorageLibraryContentChangedTriggerVtbl): IInspectable(IInspectableVtbl) [IID_IStorageLibraryContentChangedTrigger] { - -}} -RT_CLASS!{class StorageLibraryContentChangedTrigger: IStorageLibraryContentChangedTrigger} -impl RtActivatable for StorageLibraryContentChangedTrigger {} -impl StorageLibraryContentChangedTrigger { - #[cfg(feature="windows-storage")] #[inline] pub fn create(storageLibrary: &super::super::storage::StorageLibrary) -> Result>> { - >::get_activation_factory().create(storageLibrary) - } - #[cfg(feature="windows-storage")] #[inline] pub fn create_from_libraries(storageLibraries: &foundation::collections::IIterable) -> Result>> { - >::get_activation_factory().create_from_libraries(storageLibraries) - } -} -DEFINE_CLSID!(StorageLibraryContentChangedTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,83,116,111,114,97,103,101,76,105,98,114,97,114,121,67,111,110,116,101,110,116,67,104,97,110,103,101,100,84,114,105,103,103,101,114,0]) [CLSID_StorageLibraryContentChangedTrigger]); -DEFINE_IID!(IID_IStorageLibraryContentChangedTriggerStatics, 2141133625, 24464, 19986, 145, 78, 167, 216, 224, 187, 251, 24); -RT_INTERFACE!{static interface IStorageLibraryContentChangedTriggerStatics(IStorageLibraryContentChangedTriggerStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IStorageLibraryContentChangedTriggerStatics] { - #[cfg(feature="windows-storage")] fn Create(&self, storageLibrary: *mut super::super::storage::StorageLibrary, out: *mut *mut StorageLibraryContentChangedTrigger) -> HRESULT, - #[cfg(feature="windows-storage")] fn CreateFromLibraries(&self, storageLibraries: *mut foundation::collections::IIterable, out: *mut *mut StorageLibraryContentChangedTrigger) -> HRESULT +RT_CLASS!{class SearchSuggestionCollection: ISearchSuggestionCollection} +DEFINE_IID!(IID_ISearchSuggestionsRequest, 1313744551, 17637, 16441, 144, 153, 96, 0, 234, 209, 240, 198); +RT_INTERFACE!{interface ISearchSuggestionsRequest(ISearchSuggestionsRequestVtbl): IInspectable(IInspectableVtbl) [IID_ISearchSuggestionsRequest] { + fn get_IsCanceled(&self, out: *mut bool) -> HRESULT, + fn get_SearchSuggestionCollection(&self, out: *mut *mut SearchSuggestionCollection) -> HRESULT, + fn GetDeferral(&self, out: *mut *mut SearchSuggestionsRequestDeferral) -> HRESULT }} -impl IStorageLibraryContentChangedTriggerStatics { - #[cfg(feature="windows-storage")] #[inline] pub fn create(&self, storageLibrary: &super::super::storage::StorageLibrary) -> Result>> { unsafe { +impl ISearchSuggestionsRequest { + #[inline] pub fn get_is_canceled(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_IsCanceled)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_search_suggestion_collection(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, storageLibrary as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_SearchSuggestionCollection)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[cfg(feature="windows-storage")] #[inline] pub fn create_from_libraries(&self, storageLibraries: &foundation::collections::IIterable) -> Result>> { unsafe { + #[inline] pub fn get_deferral(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).CreateFromLibraries)(self as *const _ as *mut _, storageLibraries as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).GetDeferral)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } -DEFINE_IID!(IID_ISystemCondition, 3244274806, 35269, 16907, 171, 211, 251, 48, 48, 71, 33, 40); -RT_INTERFACE!{interface ISystemCondition(ISystemConditionVtbl): IInspectable(IInspectableVtbl) [IID_ISystemCondition] { - fn get_ConditionType(&self, out: *mut SystemConditionType) -> HRESULT -}} -impl ISystemCondition { - #[inline] pub fn get_condition_type(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_ConditionType)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } - }} -} -RT_CLASS!{class SystemCondition: ISystemCondition} -impl RtActivatable for SystemCondition {} -impl SystemCondition { - #[inline] pub fn create(conditionType: SystemConditionType) -> Result> { - >::get_activation_factory().create(conditionType) - } -} -DEFINE_CLSID!(SystemCondition(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,83,121,115,116,101,109,67,111,110,100,105,116,105,111,110,0]) [CLSID_SystemCondition]); -DEFINE_IID!(IID_ISystemConditionFactory, 3530150385, 1447, 18862, 135, 215, 22, 178, 184, 185, 165, 83); -RT_INTERFACE!{static interface ISystemConditionFactory(ISystemConditionFactoryVtbl): IInspectable(IInspectableVtbl) [IID_ISystemConditionFactory] { - fn Create(&self, conditionType: SystemConditionType, out: *mut *mut SystemCondition) -> HRESULT +RT_CLASS!{class SearchSuggestionsRequest: ISearchSuggestionsRequest} +DEFINE_IID!(IID_ISearchSuggestionsRequestDeferral, 3071645865, 49253, 17773, 168, 69, 30, 204, 236, 93, 194, 139); +RT_INTERFACE!{interface ISearchSuggestionsRequestDeferral(ISearchSuggestionsRequestDeferralVtbl): IInspectable(IInspectableVtbl) [IID_ISearchSuggestionsRequestDeferral] { + fn Complete(&self) -> HRESULT }} -impl ISystemConditionFactory { - #[inline] pub fn create(&self, conditionType: SystemConditionType) -> Result> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, conditionType, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } +impl ISearchSuggestionsRequestDeferral { + #[inline] pub fn complete(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).Complete)(self as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } }} } -RT_ENUM! { enum SystemConditionType: i32 { - Invalid (SystemConditionType_Invalid) = 0, UserPresent (SystemConditionType_UserPresent) = 1, UserNotPresent (SystemConditionType_UserNotPresent) = 2, InternetAvailable (SystemConditionType_InternetAvailable) = 3, InternetNotAvailable (SystemConditionType_InternetNotAvailable) = 4, SessionConnected (SystemConditionType_SessionConnected) = 5, SessionDisconnected (SystemConditionType_SessionDisconnected) = 6, FreeNetworkAvailable (SystemConditionType_FreeNetworkAvailable) = 7, BackgroundWorkCostNotHigh (SystemConditionType_BackgroundWorkCostNotHigh) = 8, +RT_CLASS!{class SearchSuggestionsRequestDeferral: ISearchSuggestionsRequestDeferral} +pub mod core { // Windows.ApplicationModel.Search.Core +use ::prelude::*; +DEFINE_IID!(IID_IRequestingFocusOnKeyboardInputEventArgs, 2702794535, 45479, 16802, 135, 157, 106, 104, 104, 126, 89, 133); +RT_INTERFACE!{interface IRequestingFocusOnKeyboardInputEventArgs(IRequestingFocusOnKeyboardInputEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IRequestingFocusOnKeyboardInputEventArgs] { + }} -DEFINE_IID!(IID_ISystemTrigger, 494978934, 14152, 17507, 141, 126, 39, 109, 193, 57, 172, 28); -RT_INTERFACE!{interface ISystemTrigger(ISystemTriggerVtbl): IInspectable(IInspectableVtbl) [IID_ISystemTrigger] { - fn get_OneShot(&self, out: *mut bool) -> HRESULT, - fn get_TriggerType(&self, out: *mut SystemTriggerType) -> HRESULT +RT_CLASS!{class RequestingFocusOnKeyboardInputEventArgs: IRequestingFocusOnKeyboardInputEventArgs} +DEFINE_IID!(IID_ISearchSuggestion, 1532318896, 5415, 17275, 149, 197, 141, 24, 210, 184, 175, 85); +RT_INTERFACE!{interface ISearchSuggestion(ISearchSuggestionVtbl): IInspectable(IInspectableVtbl) [IID_ISearchSuggestion] { + fn get_Kind(&self, out: *mut SearchSuggestionKind) -> HRESULT, + fn get_Text(&self, out: *mut HSTRING) -> HRESULT, + fn get_Tag(&self, out: *mut HSTRING) -> HRESULT, + fn get_DetailText(&self, out: *mut HSTRING) -> HRESULT, + #[cfg(not(feature="windows-storage"))] fn __Dummy4(&self) -> (), + #[cfg(feature="windows-storage")] fn get_Image(&self, out: *mut *mut ::rt::gen::windows::storage::streams::IRandomAccessStreamReference) -> HRESULT, + fn get_ImageAlternateText(&self, out: *mut HSTRING) -> HRESULT }} -impl ISystemTrigger { - #[inline] pub fn get_one_shot(&self) -> Result { unsafe { +impl ISearchSuggestion { + #[inline] pub fn get_kind(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_OneShot)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_Kind)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_trigger_type(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_TriggerType)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } + #[inline] pub fn get_text(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Text)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} -} -RT_CLASS!{class SystemTrigger: ISystemTrigger} -impl RtActivatable for SystemTrigger {} -impl SystemTrigger { - #[inline] pub fn create(triggerType: SystemTriggerType, oneShot: bool) -> Result> { - >::get_activation_factory().create(triggerType, oneShot) - } -} -DEFINE_CLSID!(SystemTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,83,121,115,116,101,109,84,114,105,103,103,101,114,0]) [CLSID_SystemTrigger]); -DEFINE_IID!(IID_ISystemTriggerFactory, 3892585428, 34705, 17785, 129, 38, 135, 236, 138, 170, 64, 122); -RT_INTERFACE!{static interface ISystemTriggerFactory(ISystemTriggerFactoryVtbl): IInspectable(IInspectableVtbl) [IID_ISystemTriggerFactory] { - fn Create(&self, triggerType: SystemTriggerType, oneShot: bool, out: *mut *mut SystemTrigger) -> HRESULT -}} -impl ISystemTriggerFactory { - #[inline] pub fn create(&self, triggerType: SystemTriggerType, oneShot: bool) -> Result> { unsafe { + #[inline] pub fn get_tag(&self) -> Result { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, triggerType, oneShot, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).get_Tag)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_detail_text(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_DetailText)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[cfg(feature="windows-storage")] #[inline] pub fn get_image(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Image)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_image_alternate_text(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ImageAlternateText)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} } -RT_ENUM! { enum SystemTriggerType: i32 { - Invalid (SystemTriggerType_Invalid) = 0, SmsReceived (SystemTriggerType_SmsReceived) = 1, UserPresent (SystemTriggerType_UserPresent) = 2, UserAway (SystemTriggerType_UserAway) = 3, NetworkStateChange (SystemTriggerType_NetworkStateChange) = 4, ControlChannelReset (SystemTriggerType_ControlChannelReset) = 5, InternetAvailable (SystemTriggerType_InternetAvailable) = 6, SessionConnected (SystemTriggerType_SessionConnected) = 7, ServicingComplete (SystemTriggerType_ServicingComplete) = 8, LockScreenApplicationAdded (SystemTriggerType_LockScreenApplicationAdded) = 9, LockScreenApplicationRemoved (SystemTriggerType_LockScreenApplicationRemoved) = 10, TimeZoneChange (SystemTriggerType_TimeZoneChange) = 11, OnlineIdConnectedStateChange (SystemTriggerType_OnlineIdConnectedStateChange) = 12, BackgroundWorkCostChange (SystemTriggerType_BackgroundWorkCostChange) = 13, PowerStateChange (SystemTriggerType_PowerStateChange) = 14, DefaultSignInAccountChange (SystemTriggerType_DefaultSignInAccountChange) = 15, +RT_CLASS!{class SearchSuggestion: ISearchSuggestion} +RT_ENUM! { enum SearchSuggestionKind: i32 { + Query (SearchSuggestionKind_Query) = 0, Result (SearchSuggestionKind_Result) = 1, Separator (SearchSuggestionKind_Separator) = 2, }} -DEFINE_IID!(IID_ITimeTrigger, 1701729622, 2858, 17271, 186, 112, 59, 69, 169, 53, 84, 127); -RT_INTERFACE!{interface ITimeTrigger(ITimeTriggerVtbl): IInspectable(IInspectableVtbl) [IID_ITimeTrigger] { - fn get_FreshnessTime(&self, out: *mut u32) -> HRESULT, - fn get_OneShot(&self, out: *mut bool) -> HRESULT +DEFINE_IID!(IID_ISearchSuggestionManager, 1057771681, 52125, 18811, 181, 0, 60, 4, 172, 149, 154, 210); +RT_INTERFACE!{interface ISearchSuggestionManager(ISearchSuggestionManagerVtbl): IInspectable(IInspectableVtbl) [IID_ISearchSuggestionManager] { + fn get_SearchHistoryEnabled(&self, out: *mut bool) -> HRESULT, + fn put_SearchHistoryEnabled(&self, value: bool) -> HRESULT, + fn get_SearchHistoryContext(&self, out: *mut HSTRING) -> HRESULT, + fn put_SearchHistoryContext(&self, value: HSTRING) -> HRESULT, + fn SetLocalContentSuggestionSettings(&self, settings: *mut super::LocalContentSuggestionSettings) -> HRESULT, + fn SetQuery(&self, queryText: HSTRING) -> HRESULT, + fn SetQueryWithLanguage(&self, queryText: HSTRING, language: HSTRING) -> HRESULT, + fn SetQueryWithSearchQueryLinguisticDetails(&self, queryText: HSTRING, language: HSTRING, linguisticDetails: *mut super::SearchQueryLinguisticDetails) -> HRESULT, + fn get_Suggestions(&self, out: *mut *mut foundation::collections::IObservableVector) -> HRESULT, + fn AddToHistory(&self, queryText: HSTRING) -> HRESULT, + fn AddToHistoryWithLanguage(&self, queryText: HSTRING, language: HSTRING) -> HRESULT, + fn ClearHistory(&self) -> HRESULT, + fn add_SuggestionsRequested(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_SuggestionsRequested(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn add_RequestingFocusOnKeyboardInput(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_RequestingFocusOnKeyboardInput(&self, token: foundation::EventRegistrationToken) -> HRESULT }} -impl ITimeTrigger { - #[inline] pub fn get_freshness_time(&self) -> Result { unsafe { +impl ISearchSuggestionManager { + #[inline] pub fn get_search_history_enabled(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_FreshnessTime)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_SearchHistoryEnabled)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_one_shot(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_OneShot)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } + #[inline] pub fn set_search_history_enabled(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_SearchHistoryEnabled)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } }} -} -RT_CLASS!{class TimeTrigger: ITimeTrigger} -impl RtActivatable for TimeTrigger {} -impl TimeTrigger { - #[inline] pub fn create(freshnessTime: u32, oneShot: bool) -> Result> { - >::get_activation_factory().create(freshnessTime, oneShot) - } -} -DEFINE_CLSID!(TimeTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,84,105,109,101,84,114,105,103,103,101,114,0]) [CLSID_TimeTrigger]); -DEFINE_IID!(IID_ITimeTriggerFactory, 952533758, 39764, 17894, 178, 243, 38, 155, 135, 166, 247, 52); -RT_INTERFACE!{static interface ITimeTriggerFactory(ITimeTriggerFactoryVtbl): IInspectable(IInspectableVtbl) [IID_ITimeTriggerFactory] { - fn Create(&self, freshnessTime: u32, oneShot: bool, out: *mut *mut TimeTrigger) -> HRESULT -}} -impl ITimeTriggerFactory { - #[inline] pub fn create(&self, freshnessTime: u32, oneShot: bool) -> Result> { unsafe { + #[inline] pub fn get_search_history_context(&self) -> Result { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, freshnessTime, oneShot, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).get_SearchHistoryContext)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} -} -RT_CLASS!{class ToastNotificationActionTrigger: IBackgroundTrigger} -impl RtActivatable for ToastNotificationActionTrigger {} -impl RtActivatable for ToastNotificationActionTrigger {} -impl ToastNotificationActionTrigger { - #[inline] pub fn create(applicationId: &HStringArg) -> Result> { - >::get_activation_factory().create(applicationId) - } -} -DEFINE_CLSID!(ToastNotificationActionTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,84,111,97,115,116,78,111,116,105,102,105,99,97,116,105,111,110,65,99,116,105,111,110,84,114,105,103,103,101,114,0]) [CLSID_ToastNotificationActionTrigger]); -DEFINE_IID!(IID_IToastNotificationActionTriggerFactory, 2963143719, 25728, 17225, 129, 37, 151, 179, 239, 170, 10, 58); -RT_INTERFACE!{static interface IToastNotificationActionTriggerFactory(IToastNotificationActionTriggerFactoryVtbl): IInspectable(IInspectableVtbl) [IID_IToastNotificationActionTriggerFactory] { - fn Create(&self, applicationId: HSTRING, out: *mut *mut ToastNotificationActionTrigger) -> HRESULT -}} -impl IToastNotificationActionTriggerFactory { - #[inline] pub fn create(&self, applicationId: &HStringArg) -> Result> { unsafe { + #[inline] pub fn set_search_history_context(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_SearchHistoryContext)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn set_local_content_suggestion_settings(&self, settings: &super::LocalContentSuggestionSettings) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).SetLocalContentSuggestionSettings)(self as *const _ as *mut _, settings as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn set_query(&self, queryText: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).SetQuery)(self as *const _ as *mut _, queryText.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn set_query_with_language(&self, queryText: &HStringArg, language: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).SetQueryWithLanguage)(self as *const _ as *mut _, queryText.get(), language.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn set_query_with_search_query_linguistic_details(&self, queryText: &HStringArg, language: &HStringArg, linguisticDetails: &super::SearchQueryLinguisticDetails) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).SetQueryWithSearchQueryLinguisticDetails)(self as *const _ as *mut _, queryText.get(), language.get(), linguisticDetails as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_suggestions(&self) -> Result>>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, applicationId.get(), &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).get_Suggestions)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn add_to_history(&self, queryText: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).AddToHistory)(self as *const _ as *mut _, queryText.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_to_history_with_language(&self, queryText: &HStringArg, language: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).AddToHistoryWithLanguage)(self as *const _ as *mut _, queryText.get(), language.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn clear_history(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).ClearHistory)(self as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_suggestions_requested(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_SuggestionsRequested)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_suggestions_requested(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_SuggestionsRequested)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_requesting_focus_on_keyboard_input(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_RequestingFocusOnKeyboardInput)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_requesting_focus_on_keyboard_input(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_RequestingFocusOnKeyboardInput)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } }} } -RT_CLASS!{class ToastNotificationHistoryChangedTrigger: IBackgroundTrigger} -impl RtActivatable for ToastNotificationHistoryChangedTrigger {} -impl RtActivatable for ToastNotificationHistoryChangedTrigger {} -impl ToastNotificationHistoryChangedTrigger { - #[inline] pub fn create(applicationId: &HStringArg) -> Result> { - >::get_activation_factory().create(applicationId) - } -} -DEFINE_CLSID!(ToastNotificationHistoryChangedTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,84,111,97,115,116,78,111,116,105,102,105,99,97,116,105,111,110,72,105,115,116,111,114,121,67,104,97,110,103,101,100,84,114,105,103,103,101,114,0]) [CLSID_ToastNotificationHistoryChangedTrigger]); -DEFINE_IID!(IID_IToastNotificationHistoryChangedTriggerFactory, 2177301165, 34711, 18309, 129, 180, 176, 204, 203, 115, 209, 217); -RT_INTERFACE!{static interface IToastNotificationHistoryChangedTriggerFactory(IToastNotificationHistoryChangedTriggerFactoryVtbl): IInspectable(IInspectableVtbl) [IID_IToastNotificationHistoryChangedTriggerFactory] { - fn Create(&self, applicationId: HSTRING, out: *mut *mut ToastNotificationHistoryChangedTrigger) -> HRESULT +RT_CLASS!{class SearchSuggestionManager: ISearchSuggestionManager} +impl RtActivatable for SearchSuggestionManager {} +DEFINE_CLSID!(SearchSuggestionManager(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,83,101,97,114,99,104,46,67,111,114,101,46,83,101,97,114,99,104,83,117,103,103,101,115,116,105,111,110,77,97,110,97,103,101,114,0]) [CLSID_SearchSuggestionManager]); +DEFINE_IID!(IID_ISearchSuggestionsRequestedEventArgs, 1876236773, 40574, 19124, 139, 227, 199, 107, 27, 212, 52, 74); +RT_INTERFACE!{interface ISearchSuggestionsRequestedEventArgs(ISearchSuggestionsRequestedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_ISearchSuggestionsRequestedEventArgs] { + fn get_QueryText(&self, out: *mut HSTRING) -> HRESULT, + fn get_Language(&self, out: *mut HSTRING) -> HRESULT, + fn get_LinguisticDetails(&self, out: *mut *mut super::SearchQueryLinguisticDetails) -> HRESULT, + fn get_Request(&self, out: *mut *mut super::SearchSuggestionsRequest) -> HRESULT }} -impl IToastNotificationHistoryChangedTriggerFactory { - #[inline] pub fn create(&self, applicationId: &HStringArg) -> Result> { unsafe { +impl ISearchSuggestionsRequestedEventArgs { + #[inline] pub fn get_query_text(&self) -> Result { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, applicationId.get(), &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).get_QueryText)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} -} -RT_CLASS!{class UserNotificationChangedTrigger: IBackgroundTrigger} -impl RtActivatable for UserNotificationChangedTrigger {} -impl UserNotificationChangedTrigger { - #[cfg(feature="windows-ui")] #[inline] pub fn create(notificationKinds: super::super::ui::notifications::NotificationKinds) -> Result> { - >::get_activation_factory().create(notificationKinds) - } -} -DEFINE_CLSID!(UserNotificationChangedTrigger(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,66,97,99,107,103,114,111,117,110,100,46,85,115,101,114,78,111,116,105,102,105,99,97,116,105,111,110,67,104,97,110,103,101,100,84,114,105,103,103,101,114,0]) [CLSID_UserNotificationChangedTrigger]); -DEFINE_IID!(IID_IUserNotificationChangedTriggerFactory, 3402908524, 27051, 19992, 164, 138, 94, 210, 172, 67, 89, 87); -RT_INTERFACE!{static interface IUserNotificationChangedTriggerFactory(IUserNotificationChangedTriggerFactoryVtbl): IInspectable(IInspectableVtbl) [IID_IUserNotificationChangedTriggerFactory] { - #[cfg(feature="windows-ui")] fn Create(&self, notificationKinds: super::super::ui::notifications::NotificationKinds, out: *mut *mut UserNotificationChangedTrigger) -> HRESULT -}} -impl IUserNotificationChangedTriggerFactory { - #[cfg(feature="windows-ui")] #[inline] pub fn create(&self, notificationKinds: super::super::ui::notifications::NotificationKinds) -> Result> { unsafe { + #[inline] pub fn get_language(&self) -> Result { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, notificationKinds, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).get_Language)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_linguistic_details(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_LinguisticDetails)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_request(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Request)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } -} // Windows.ApplicationModel.Background +RT_CLASS!{class SearchSuggestionsRequestedEventArgs: ISearchSuggestionsRequestedEventArgs} +} // Windows.ApplicationModel.Search.Core +} // Windows.ApplicationModel.Search pub mod core { // Windows.ApplicationModel.Core use ::prelude::*; DEFINE_IID!(IID_IAppListEntry, 4009816191, 8456, 18698, 135, 122, 138, 159, 23, 194, 95, 173); @@ -4937,6 +5190,17 @@ impl IAppListEntry2 { if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IAppListEntry3, 1620701837, 64562, 18186, 188, 105, 75, 6, 26, 118, 239, 46); +RT_INTERFACE!{interface IAppListEntry3(IAppListEntry3Vtbl): IInspectable(IInspectableVtbl) [IID_IAppListEntry3] { + #[cfg(feature="windows-system")] fn LaunchForUserAsync(&self, user: *mut super::super::system::User, out: *mut *mut foundation::IAsyncOperation) -> HRESULT +}} +impl IAppListEntry3 { + #[cfg(feature="windows-system")] #[inline] pub fn launch_for_user_async(&self, user: &super::super::system::User) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).LaunchForUserAsync)(self as *const _ as *mut _, user as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} +} RT_ENUM! { enum AppRestartFailureReason: i32 { RestartPending (AppRestartFailureReason_RestartPending) = 0, NotInForeground (AppRestartFailureReason_NotInForeground) = 1, InvalidUser (AppRestartFailureReason_InvalidUser) = 2, Other (AppRestartFailureReason_Other) = 3, }} @@ -8249,7 +8513,7 @@ impl IActivatedEventArgsWithUser { }} } RT_ENUM! { enum ActivationKind: i32 { - Launch (ActivationKind_Launch) = 0, Search (ActivationKind_Search) = 1, ShareTarget (ActivationKind_ShareTarget) = 2, File (ActivationKind_File) = 3, Protocol (ActivationKind_Protocol) = 4, FileOpenPicker (ActivationKind_FileOpenPicker) = 5, FileSavePicker (ActivationKind_FileSavePicker) = 6, CachedFileUpdater (ActivationKind_CachedFileUpdater) = 7, ContactPicker (ActivationKind_ContactPicker) = 8, Device (ActivationKind_Device) = 9, PrintTaskSettings (ActivationKind_PrintTaskSettings) = 10, CameraSettings (ActivationKind_CameraSettings) = 11, RestrictedLaunch (ActivationKind_RestrictedLaunch) = 12, AppointmentsProvider (ActivationKind_AppointmentsProvider) = 13, Contact (ActivationKind_Contact) = 14, LockScreenCall (ActivationKind_LockScreenCall) = 15, VoiceCommand (ActivationKind_VoiceCommand) = 16, LockScreen (ActivationKind_LockScreen) = 17, PickerReturned (ActivationKind_PickerReturned) = 1000, WalletAction (ActivationKind_WalletAction) = 1001, PickFileContinuation (ActivationKind_PickFileContinuation) = 1002, PickSaveFileContinuation (ActivationKind_PickSaveFileContinuation) = 1003, PickFolderContinuation (ActivationKind_PickFolderContinuation) = 1004, WebAuthenticationBrokerContinuation (ActivationKind_WebAuthenticationBrokerContinuation) = 1005, WebAccountProvider (ActivationKind_WebAccountProvider) = 1006, ComponentUI (ActivationKind_ComponentUI) = 1007, ProtocolForResults (ActivationKind_ProtocolForResults) = 1009, ToastNotification (ActivationKind_ToastNotification) = 1010, Print3DWorkflow (ActivationKind_Print3DWorkflow) = 1011, DialReceiver (ActivationKind_DialReceiver) = 1012, DevicePairing (ActivationKind_DevicePairing) = 1013, UserDataAccountsProvider (ActivationKind_UserDataAccountsProvider) = 1014, FilePickerExperience (ActivationKind_FilePickerExperience) = 1015, LockScreenComponent (ActivationKind_LockScreenComponent) = 1016, ContactPanel (ActivationKind_ContactPanel) = 1017, PrintWorkflowForegroundTask (ActivationKind_PrintWorkflowForegroundTask) = 1018, GameUIProvider (ActivationKind_GameUIProvider) = 1019, StartupTask (ActivationKind_StartupTask) = 1020, CommandLineLaunch (ActivationKind_CommandLineLaunch) = 1021, + Launch (ActivationKind_Launch) = 0, Search (ActivationKind_Search) = 1, ShareTarget (ActivationKind_ShareTarget) = 2, File (ActivationKind_File) = 3, Protocol (ActivationKind_Protocol) = 4, FileOpenPicker (ActivationKind_FileOpenPicker) = 5, FileSavePicker (ActivationKind_FileSavePicker) = 6, CachedFileUpdater (ActivationKind_CachedFileUpdater) = 7, ContactPicker (ActivationKind_ContactPicker) = 8, Device (ActivationKind_Device) = 9, PrintTaskSettings (ActivationKind_PrintTaskSettings) = 10, CameraSettings (ActivationKind_CameraSettings) = 11, RestrictedLaunch (ActivationKind_RestrictedLaunch) = 12, AppointmentsProvider (ActivationKind_AppointmentsProvider) = 13, Contact (ActivationKind_Contact) = 14, LockScreenCall (ActivationKind_LockScreenCall) = 15, VoiceCommand (ActivationKind_VoiceCommand) = 16, LockScreen (ActivationKind_LockScreen) = 17, PickerReturned (ActivationKind_PickerReturned) = 1000, WalletAction (ActivationKind_WalletAction) = 1001, PickFileContinuation (ActivationKind_PickFileContinuation) = 1002, PickSaveFileContinuation (ActivationKind_PickSaveFileContinuation) = 1003, PickFolderContinuation (ActivationKind_PickFolderContinuation) = 1004, WebAuthenticationBrokerContinuation (ActivationKind_WebAuthenticationBrokerContinuation) = 1005, WebAccountProvider (ActivationKind_WebAccountProvider) = 1006, ComponentUI (ActivationKind_ComponentUI) = 1007, ProtocolForResults (ActivationKind_ProtocolForResults) = 1009, ToastNotification (ActivationKind_ToastNotification) = 1010, Print3DWorkflow (ActivationKind_Print3DWorkflow) = 1011, DialReceiver (ActivationKind_DialReceiver) = 1012, DevicePairing (ActivationKind_DevicePairing) = 1013, UserDataAccountsProvider (ActivationKind_UserDataAccountsProvider) = 1014, FilePickerExperience (ActivationKind_FilePickerExperience) = 1015, LockScreenComponent (ActivationKind_LockScreenComponent) = 1016, ContactPanel (ActivationKind_ContactPanel) = 1017, PrintWorkflowForegroundTask (ActivationKind_PrintWorkflowForegroundTask) = 1018, GameUIProvider (ActivationKind_GameUIProvider) = 1019, StartupTask (ActivationKind_StartupTask) = 1020, CommandLineLaunch (ActivationKind_CommandLineLaunch) = 1021, BarcodeScannerProvider (ActivationKind_BarcodeScannerProvider) = 1022, }} RT_ENUM! { enum ApplicationExecutionState: i32 { NotRunning (ApplicationExecutionState_NotRunning) = 0, Running (ApplicationExecutionState_Running) = 1, Suspended (ApplicationExecutionState_Suspended) = 2, Terminated (ApplicationExecutionState_Terminated) = 3, ClosedByUser (ApplicationExecutionState_ClosedByUser) = 4, @@ -8366,6 +8630,18 @@ impl IBackgroundActivatedEventArgs { }} } RT_CLASS!{class BackgroundActivatedEventArgs: IBackgroundActivatedEventArgs} +DEFINE_IID!(IID_IBarcodeScannerPreviewActivatedEventArgs, 1735555452, 39359, 17225, 175, 34, 228, 18, 53, 96, 55, 28); +RT_INTERFACE!{interface IBarcodeScannerPreviewActivatedEventArgs(IBarcodeScannerPreviewActivatedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IBarcodeScannerPreviewActivatedEventArgs] { + fn get_ConnectionId(&self, out: *mut HSTRING) -> HRESULT +}} +impl IBarcodeScannerPreviewActivatedEventArgs { + #[inline] pub fn get_connection_id(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ConnectionId)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} +} +RT_CLASS!{class BarcodeScannerPreviewActivatedEventArgs: IBarcodeScannerPreviewActivatedEventArgs} DEFINE_IID!(IID_ICachedFileUpdaterActivatedEventArgs, 3496915399, 14341, 20171, 183, 87, 108, 241, 94, 38, 254, 243); RT_INTERFACE!{interface ICachedFileUpdaterActivatedEventArgs(ICachedFileUpdaterActivatedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_ICachedFileUpdaterActivatedEventArgs] { #[cfg(feature="windows-storage")] fn get_CachedFileUpdaterUI(&self, out: *mut *mut super::super::storage::provider::CachedFileUpdaterUI) -> HRESULT @@ -14780,6 +15056,22 @@ impl IDataPackagePropertySet3 { if hr == S_OK { Ok(()) } else { err(hr) } }} } +DEFINE_IID!(IID_IDataPackagePropertySet4, 1670441973, 5945, 19572, 178, 47, 134, 95, 171, 94, 133, 69); +RT_INTERFACE!{interface IDataPackagePropertySet4(IDataPackagePropertySet4Vtbl): IInspectable(IInspectableVtbl) [IID_IDataPackagePropertySet4] { + fn get_ContentSourceUserActivityJson(&self, out: *mut HSTRING) -> HRESULT, + fn put_ContentSourceUserActivityJson(&self, value: HSTRING) -> HRESULT +}} +impl IDataPackagePropertySet4 { + #[inline] pub fn get_content_source_user_activity_json(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ContentSourceUserActivityJson)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn set_content_source_user_activity_json(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_ContentSourceUserActivityJson)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} DEFINE_IID!(IID_IDataPackagePropertySetView, 3108826113, 3098, 19543, 190, 85, 117, 208, 18, 137, 115, 93); RT_INTERFACE!{interface IDataPackagePropertySetView(IDataPackagePropertySetViewVtbl): IInspectable(IInspectableVtbl) [IID_IDataPackagePropertySetView] { fn get_Title(&self, out: *mut HSTRING) -> HRESULT, @@ -14870,6 +15162,17 @@ impl IDataPackagePropertySetView3 { if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IDataPackagePropertySetView4, 1148504077, 53615, 16558, 149, 128, 111, 133, 98, 185, 66, 53); +RT_INTERFACE!{interface IDataPackagePropertySetView4(IDataPackagePropertySetView4Vtbl): IInspectable(IInspectableVtbl) [IID_IDataPackagePropertySetView4] { + fn get_ContentSourceUserActivityJson(&self, out: *mut HSTRING) -> HRESULT +}} +impl IDataPackagePropertySetView4 { + #[inline] pub fn get_content_source_user_activity_json(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ContentSourceUserActivityJson)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IDataPackageView, 2072249457, 22784, 19845, 169, 11, 16, 203, 133, 254, 53, 82); RT_INTERFACE!{interface IDataPackageView(IDataPackageViewVtbl): IInspectable(IInspectableVtbl) [IID_IDataPackageView] { fn get_Properties(&self, out: *mut *mut DataPackagePropertySetView) -> HRESULT, @@ -15482,6 +15785,7 @@ RT_ENUM! { enum ShareUITheme: i32 { RT_CLASS!{static class StandardDataFormats} impl RtActivatable for StandardDataFormats {} impl RtActivatable for StandardDataFormats {} +impl RtActivatable for StandardDataFormats {} impl StandardDataFormats { #[inline] pub fn get_text() -> Result { >::get_activation_factory().get_text() @@ -15507,6 +15811,9 @@ impl StandardDataFormats { #[inline] pub fn get_application_link() -> Result { >::get_activation_factory().get_application_link() } + #[inline] pub fn get_user_activity_json_array() -> Result { + >::get_activation_factory().get_user_activity_json_array() + } } DEFINE_CLSID!(StandardDataFormats(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,68,97,116,97,84,114,97,110,115,102,101,114,46,83,116,97,110,100,97,114,100,68,97,116,97,70,111,114,109,97,116,115,0]) [CLSID_StandardDataFormats]); DEFINE_IID!(IID_IStandardDataFormatsStatics, 2127987105, 43136, 16585, 180, 237, 11, 238, 30, 21, 245, 73); @@ -15567,6 +15874,17 @@ impl IStandardDataFormatsStatics2 { if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IStandardDataFormatsStatics3, 995602537, 468, 18252, 139, 95, 188, 142, 39, 243, 139, 33); +RT_INTERFACE!{static interface IStandardDataFormatsStatics3(IStandardDataFormatsStatics3Vtbl): IInspectable(IInspectableVtbl) [IID_IStandardDataFormatsStatics3] { + fn get_UserActivityJsonArray(&self, out: *mut HSTRING) -> HRESULT +}} +impl IStandardDataFormatsStatics3 { + #[inline] pub fn get_user_activity_json_array(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_UserActivityJsonArray)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_ITargetApplicationChosenEventArgs, 3396319404, 10631, 20195, 156, 84, 216, 175, 188, 184, 108, 29); RT_INTERFACE!{interface ITargetApplicationChosenEventArgs(ITargetApplicationChosenEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_ITargetApplicationChosenEventArgs] { fn get_ApplicationName(&self, out: *mut HSTRING) -> HRESULT @@ -20859,6 +21177,34 @@ impl IUserActivity { }} } RT_CLASS!{class UserActivity: IUserActivity} +impl RtActivatable for UserActivity {} +impl RtActivatable for UserActivity {} +impl UserActivity { + #[inline] pub fn create_with_activity_id(activityId: &HStringArg) -> Result> { + >::get_activation_factory().create_with_activity_id(activityId) + } + #[inline] pub fn try_parse_from_json(json: &HStringArg) -> Result>> { + >::get_activation_factory().try_parse_from_json(json) + } + #[inline] pub fn try_parse_from_json_array(json: &HStringArg) -> Result>>> { + >::get_activation_factory().try_parse_from_json_array(json) + } + #[inline] pub fn to_json_array(activities: &foundation::collections::IIterable) -> Result { + >::get_activation_factory().to_json_array(activities) + } +} +DEFINE_CLSID!(UserActivity(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,85,115,101,114,65,99,116,105,118,105,116,105,101,115,46,85,115,101,114,65,99,116,105,118,105,116,121,0]) [CLSID_UserActivity]); +DEFINE_IID!(IID_IUserActivity2, 2646871138, 2244, 18348, 170, 156, 43, 178, 34, 28, 85, 253); +RT_INTERFACE!{interface IUserActivity2(IUserActivity2Vtbl): IInspectable(IInspectableVtbl) [IID_IUserActivity2] { + fn ToJson(&self, out: *mut HSTRING) -> HRESULT +}} +impl IUserActivity2 { + #[inline] pub fn to_json(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).ToJson)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IUserActivityAttribution, 883280053, 34525, 19180, 164, 145, 106, 79, 174, 165, 210, 46); RT_INTERFACE!{interface IUserActivityAttribution(IUserActivityAttributionVtbl): IInspectable(IInspectableVtbl) [IID_IUserActivityAttribution] { fn get_IconUri(&self, out: *mut *mut foundation::Uri) -> HRESULT, @@ -20942,12 +21288,36 @@ impl IUserActivityChannel { } RT_CLASS!{class UserActivityChannel: IUserActivityChannel} impl RtActivatable for UserActivityChannel {} +impl RtActivatable for UserActivityChannel {} impl UserActivityChannel { #[inline] pub fn get_default() -> Result>> { >::get_activation_factory().get_default() } + #[inline] pub fn disable_auto_session_creation() -> Result<()> { + >::get_activation_factory().disable_auto_session_creation() + } + #[cfg(feature="windows-security")] #[inline] pub fn try_get_for_web_account(account: &super::super::security::credentials::WebAccount) -> Result>> { + >::get_activation_factory().try_get_for_web_account(account) + } } DEFINE_CLSID!(UserActivityChannel(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,85,115,101,114,65,99,116,105,118,105,116,105,101,115,46,85,115,101,114,65,99,116,105,118,105,116,121,67,104,97,110,110,101,108,0]) [CLSID_UserActivityChannel]); +DEFINE_IID!(IID_IUserActivityChannel2, 379118427, 60286, 20128, 191, 23, 164, 89, 232, 190, 112, 108); +RT_INTERFACE!{interface IUserActivityChannel2(IUserActivityChannel2Vtbl): IInspectable(IInspectableVtbl) [IID_IUserActivityChannel2] { + fn GetRecentUserActivitiesAsync(&self, maxUniqueActivities: i32, out: *mut *mut foundation::IAsyncOperation>) -> HRESULT, + fn GetSessionHistoryItemsForUserActivityAsync(&self, activityId: HSTRING, startTime: foundation::DateTime, out: *mut *mut foundation::IAsyncOperation>) -> HRESULT +}} +impl IUserActivityChannel2 { + #[inline] pub fn get_recent_user_activities_async(&self, maxUniqueActivities: i32) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetRecentUserActivitiesAsync)(self as *const _ as *mut _, maxUniqueActivities, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_session_history_items_for_user_activity_async(&self, activityId: &HStringArg, startTime: foundation::DateTime) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetSessionHistoryItemsForUserActivityAsync)(self as *const _ as *mut _, activityId.get(), startTime, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IUserActivityChannelStatics, 3368027563, 6541, 19840, 171, 178, 201, 119, 94, 196, 167, 41); RT_INTERFACE!{static interface IUserActivityChannelStatics(IUserActivityChannelStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IUserActivityChannelStatics] { fn GetDefault(&self, out: *mut *mut UserActivityChannel) -> HRESULT @@ -20959,6 +21329,22 @@ impl IUserActivityChannelStatics { if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IUserActivityChannelStatics2, 2391268912, 43599, 17956, 154, 208, 212, 15, 59, 160, 49, 124); +RT_INTERFACE!{static interface IUserActivityChannelStatics2(IUserActivityChannelStatics2Vtbl): IInspectable(IInspectableVtbl) [IID_IUserActivityChannelStatics2] { + fn DisableAutoSessionCreation(&self) -> HRESULT, + #[cfg(feature="windows-security")] fn TryGetForWebAccount(&self, account: *mut super::super::security::credentials::WebAccount, out: *mut *mut UserActivityChannel) -> HRESULT +}} +impl IUserActivityChannelStatics2 { + #[inline] pub fn disable_auto_session_creation(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).DisableAutoSessionCreation)(self as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[cfg(feature="windows-security")] #[inline] pub fn try_get_for_web_account(&self, account: &super::super::security::credentials::WebAccount) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).TryGetForWebAccount)(self as *const _ as *mut _, account as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IUserActivityContentInfo, 3013207469, 4991, 16541, 130, 45, 225, 175, 39, 206, 8, 220); RT_INTERFACE!{interface IUserActivityContentInfo(IUserActivityContentInfoVtbl): IInspectable(IInspectableVtbl) [IID_IUserActivityContentInfo] { fn ToJson(&self, out: *mut HSTRING) -> HRESULT @@ -20989,6 +21375,81 @@ impl IUserActivityContentInfoStatics { if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IUserActivityFactory, 2084067160, 13853, 19047, 138, 59, 52, 202, 41, 120, 249, 163); +RT_INTERFACE!{static interface IUserActivityFactory(IUserActivityFactoryVtbl): IInspectable(IInspectableVtbl) [IID_IUserActivityFactory] { + fn CreateWithActivityId(&self, activityId: HSTRING, out: *mut *mut UserActivity) -> HRESULT +}} +impl IUserActivityFactory { + #[inline] pub fn create_with_activity_id(&self, activityId: &HStringArg) -> Result> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreateWithActivityId)(self as *const _ as *mut _, activityId.get(), &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} +} +DEFINE_IID!(IID_IUserActivityRequest, 2700043093, 53045, 20464, 136, 51, 80, 203, 75, 114, 224, 109); +RT_INTERFACE!{interface IUserActivityRequest(IUserActivityRequestVtbl): IInspectable(IInspectableVtbl) [IID_IUserActivityRequest] { + fn SetUserActivity(&self, activity: *mut UserActivity) -> HRESULT +}} +impl IUserActivityRequest { + #[inline] pub fn set_user_activity(&self, activity: &UserActivity) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).SetUserActivity)(self as *const _ as *mut _, activity as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class UserActivityRequest: IUserActivityRequest} +DEFINE_IID!(IID_IUserActivityRequestedEventArgs, 2764864076, 33321, 19709, 163, 188, 198, 29, 49, 133, 117, 164); +RT_INTERFACE!{interface IUserActivityRequestedEventArgs(IUserActivityRequestedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IUserActivityRequestedEventArgs] { + fn get_Request(&self, out: *mut *mut UserActivityRequest) -> HRESULT, + fn GetDeferral(&self, out: *mut *mut foundation::Deferral) -> HRESULT +}} +impl IUserActivityRequestedEventArgs { + #[inline] pub fn get_request(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Request)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_deferral(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetDeferral)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +RT_CLASS!{class UserActivityRequestedEventArgs: IUserActivityRequestedEventArgs} +DEFINE_IID!(IID_IUserActivityRequestManager, 204521038, 36925, 18646, 130, 212, 64, 67, 237, 87, 121, 27); +RT_INTERFACE!{interface IUserActivityRequestManager(IUserActivityRequestManagerVtbl): IInspectable(IInspectableVtbl) [IID_IUserActivityRequestManager] { + fn add_UserActivityRequested(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_UserActivityRequested(&self, token: foundation::EventRegistrationToken) -> HRESULT +}} +impl IUserActivityRequestManager { + #[inline] pub fn add_user_activity_requested(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_UserActivityRequested)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_user_activity_requested(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_UserActivityRequested)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class UserActivityRequestManager: IUserActivityRequestManager} +impl RtActivatable for UserActivityRequestManager {} +impl UserActivityRequestManager { + #[inline] pub fn get_for_current_view() -> Result>> { + >::get_activation_factory().get_for_current_view() + } +} +DEFINE_CLSID!(UserActivityRequestManager(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,85,115,101,114,65,99,116,105,118,105,116,105,101,115,46,85,115,101,114,65,99,116,105,118,105,116,121,82,101,113,117,101,115,116,77,97,110,97,103,101,114,0]) [CLSID_UserActivityRequestManager]); +DEFINE_IID!(IID_IUserActivityRequestManagerStatics, 3224972785, 8778, 17196, 129, 229, 12, 118, 180, 196, 206, 250); +RT_INTERFACE!{static interface IUserActivityRequestManagerStatics(IUserActivityRequestManagerStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IUserActivityRequestManagerStatics] { + fn GetForCurrentView(&self, out: *mut *mut UserActivityRequestManager) -> HRESULT +}} +impl IUserActivityRequestManagerStatics { + #[inline] pub fn get_for_current_view(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetForCurrentView)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IUserActivitySession, 2923646328, 9466, 17571, 173, 72, 110, 218, 97, 170, 25, 36); RT_INTERFACE!{interface IUserActivitySession(IUserActivitySessionVtbl): IInspectable(IInspectableVtbl) [IID_IUserActivitySession] { fn get_ActivityId(&self, out: *mut HSTRING) -> HRESULT @@ -21001,9 +21462,56 @@ impl IUserActivitySession { }} } RT_CLASS!{class UserActivitySession: IUserActivitySession} +DEFINE_IID!(IID_IUserActivitySessionHistoryItem, 3906313171, 15965, 18941, 152, 215, 109, 169, 117, 33, 226, 85); +RT_INTERFACE!{interface IUserActivitySessionHistoryItem(IUserActivitySessionHistoryItemVtbl): IInspectable(IInspectableVtbl) [IID_IUserActivitySessionHistoryItem] { + fn get_UserActivity(&self, out: *mut *mut UserActivity) -> HRESULT, + fn get_StartTime(&self, out: *mut foundation::DateTime) -> HRESULT, + fn get_EndTime(&self, out: *mut *mut foundation::IReference) -> HRESULT +}} +impl IUserActivitySessionHistoryItem { + #[inline] pub fn get_user_activity(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_UserActivity)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_start_time(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_StartTime)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_end_time(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_EndTime)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +RT_CLASS!{class UserActivitySessionHistoryItem: IUserActivitySessionHistoryItem} RT_ENUM! { enum UserActivityState: i32 { New (UserActivityState_New) = 0, Published (UserActivityState_Published) = 1, }} +DEFINE_IID!(IID_IUserActivityStatics, 2358235955, 3593, 18422, 154, 199, 149, 207, 92, 57, 54, 123); +RT_INTERFACE!{static interface IUserActivityStatics(IUserActivityStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IUserActivityStatics] { + fn TryParseFromJson(&self, json: HSTRING, out: *mut *mut UserActivity) -> HRESULT, + fn TryParseFromJsonArray(&self, json: HSTRING, out: *mut *mut foundation::collections::IVector) -> HRESULT, + fn ToJsonArray(&self, activities: *mut foundation::collections::IIterable, out: *mut HSTRING) -> HRESULT +}} +impl IUserActivityStatics { + #[inline] pub fn try_parse_from_json(&self, json: &HStringArg) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).TryParseFromJson)(self as *const _ as *mut _, json.get(), &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn try_parse_from_json_array(&self, json: &HStringArg) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).TryParseFromJsonArray)(self as *const _ as *mut _, json.get(), &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn to_json_array(&self, activities: &foundation::collections::IIterable) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).ToJsonArray)(self as *const _ as *mut _, activities as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IUserActivityVisualElements, 2490725651, 9775, 18927, 187, 191, 155, 117, 210, 232, 82, 80); RT_INTERFACE!{interface IUserActivityVisualElements(IUserActivityVisualElementsVtbl): IInspectable(IInspectableVtbl) [IID_IUserActivityVisualElements] { fn get_DisplayText(&self, out: *mut HSTRING) -> HRESULT, @@ -21065,6 +21573,22 @@ impl IUserActivityVisualElements { }} } RT_CLASS!{class UserActivityVisualElements: IUserActivityVisualElements} +DEFINE_IID!(IID_IUserActivityVisualElements2, 3400433607, 16111, 17241, 130, 92, 157, 81, 185, 34, 13, 227); +RT_INTERFACE!{interface IUserActivityVisualElements2(IUserActivityVisualElements2Vtbl): IInspectable(IInspectableVtbl) [IID_IUserActivityVisualElements2] { + fn get_AttributionDisplayText(&self, out: *mut HSTRING) -> HRESULT, + fn put_AttributionDisplayText(&self, value: HSTRING) -> HRESULT +}} +impl IUserActivityVisualElements2 { + #[inline] pub fn get_attribution_display_text(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_AttributionDisplayText)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn set_attribution_display_text(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_AttributionDisplayText)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} pub mod core { // Windows.ApplicationModel.UserActivities.Core use ::prelude::*; RT_CLASS!{static class CoreUserActivityManager} @@ -25483,7 +26007,7 @@ impl IStorePreviewSkuInfo { } RT_CLASS!{class StorePreviewSkuInfo: IStorePreviewSkuInfo} RT_ENUM! { enum StoreSystemFeature: i32 { - ArchitectureX86 (StoreSystemFeature_ArchitectureX86) = 0, ArchitectureX64 (StoreSystemFeature_ArchitectureX64) = 1, ArchitectureArm (StoreSystemFeature_ArchitectureArm) = 2, DirectX9 (StoreSystemFeature_DirectX9) = 3, DirectX10 (StoreSystemFeature_DirectX10) = 4, DirectX11 (StoreSystemFeature_DirectX11) = 5, D3D12HardwareFL11 (StoreSystemFeature_D3D12HardwareFL11) = 6, D3D12HardwareFL12 (StoreSystemFeature_D3D12HardwareFL12) = 7, Memory300MB (StoreSystemFeature_Memory300MB) = 8, Memory750MB (StoreSystemFeature_Memory750MB) = 9, Memory1GB (StoreSystemFeature_Memory1GB) = 10, Memory2GB (StoreSystemFeature_Memory2GB) = 11, CameraFront (StoreSystemFeature_CameraFront) = 12, CameraRear (StoreSystemFeature_CameraRear) = 13, Gyroscope (StoreSystemFeature_Gyroscope) = 14, Hover (StoreSystemFeature_Hover) = 15, Magnetometer (StoreSystemFeature_Magnetometer) = 16, Nfc (StoreSystemFeature_Nfc) = 17, Resolution720P (StoreSystemFeature_Resolution720P) = 18, ResolutionWvga (StoreSystemFeature_ResolutionWvga) = 19, ResolutionWvgaOr720P (StoreSystemFeature_ResolutionWvgaOr720P) = 20, ResolutionWxga (StoreSystemFeature_ResolutionWxga) = 21, ResolutionWvgaOrWxga (StoreSystemFeature_ResolutionWvgaOrWxga) = 22, ResolutionWxgaOr720P (StoreSystemFeature_ResolutionWxgaOr720P) = 23, Memory4GB (StoreSystemFeature_Memory4GB) = 24, Memory6GB (StoreSystemFeature_Memory6GB) = 25, Memory8GB (StoreSystemFeature_Memory8GB) = 26, Memory12GB (StoreSystemFeature_Memory12GB) = 27, Memory16GB (StoreSystemFeature_Memory16GB) = 28, Memory20GB (StoreSystemFeature_Memory20GB) = 29, VideoMemory2GB (StoreSystemFeature_VideoMemory2GB) = 30, VideoMemory4GB (StoreSystemFeature_VideoMemory4GB) = 31, VideoMemory6GB (StoreSystemFeature_VideoMemory6GB) = 32, VideoMemory1GB (StoreSystemFeature_VideoMemory1GB) = 33, + ArchitectureX86 (StoreSystemFeature_ArchitectureX86) = 0, ArchitectureX64 (StoreSystemFeature_ArchitectureX64) = 1, ArchitectureArm (StoreSystemFeature_ArchitectureArm) = 2, DirectX9 (StoreSystemFeature_DirectX9) = 3, DirectX10 (StoreSystemFeature_DirectX10) = 4, DirectX11 (StoreSystemFeature_DirectX11) = 5, D3D12HardwareFL11 (StoreSystemFeature_D3D12HardwareFL11) = 6, D3D12HardwareFL12 (StoreSystemFeature_D3D12HardwareFL12) = 7, Memory300MB (StoreSystemFeature_Memory300MB) = 8, Memory750MB (StoreSystemFeature_Memory750MB) = 9, Memory1GB (StoreSystemFeature_Memory1GB) = 10, Memory2GB (StoreSystemFeature_Memory2GB) = 11, CameraFront (StoreSystemFeature_CameraFront) = 12, CameraRear (StoreSystemFeature_CameraRear) = 13, Gyroscope (StoreSystemFeature_Gyroscope) = 14, Hover (StoreSystemFeature_Hover) = 15, Magnetometer (StoreSystemFeature_Magnetometer) = 16, Nfc (StoreSystemFeature_Nfc) = 17, Resolution720P (StoreSystemFeature_Resolution720P) = 18, ResolutionWvga (StoreSystemFeature_ResolutionWvga) = 19, ResolutionWvgaOr720P (StoreSystemFeature_ResolutionWvgaOr720P) = 20, ResolutionWxga (StoreSystemFeature_ResolutionWxga) = 21, ResolutionWvgaOrWxga (StoreSystemFeature_ResolutionWvgaOrWxga) = 22, ResolutionWxgaOr720P (StoreSystemFeature_ResolutionWxgaOr720P) = 23, Memory4GB (StoreSystemFeature_Memory4GB) = 24, Memory6GB (StoreSystemFeature_Memory6GB) = 25, Memory8GB (StoreSystemFeature_Memory8GB) = 26, Memory12GB (StoreSystemFeature_Memory12GB) = 27, Memory16GB (StoreSystemFeature_Memory16GB) = 28, Memory20GB (StoreSystemFeature_Memory20GB) = 29, VideoMemory2GB (StoreSystemFeature_VideoMemory2GB) = 30, VideoMemory4GB (StoreSystemFeature_VideoMemory4GB) = 31, VideoMemory6GB (StoreSystemFeature_VideoMemory6GB) = 32, VideoMemory1GB (StoreSystemFeature_VideoMemory1GB) = 33, ArchitectureArm64 (StoreSystemFeature_ArchitectureArm64) = 34, }} DEFINE_IID!(IID_IWebAuthenticationCoreManagerHelper, 111478053, 59157, 16675, 146, 118, 157, 111, 134, 91, 165, 95); RT_INTERFACE!{static interface IWebAuthenticationCoreManagerHelper(IWebAuthenticationCoreManagerHelperVtbl): IInspectable(IInspectableVtbl) [IID_IWebAuthenticationCoreManagerHelper] { @@ -25625,6 +26149,22 @@ impl IAppInstallItem3 { if hr == S_OK { Ok(out) } else { err(hr) } }} } +DEFINE_IID!(IID_IAppInstallItem4, 3268529682, 29183, 20424, 181, 64, 69, 61, 75, 55, 225, 209); +RT_INTERFACE!{interface IAppInstallItem4(IAppInstallItem4Vtbl): IInspectable(IInspectableVtbl) [IID_IAppInstallItem4] { + fn get_LaunchAfterInstall(&self, out: *mut bool) -> HRESULT, + fn put_LaunchAfterInstall(&self, value: bool) -> HRESULT +}} +impl IAppInstallItem4 { + #[inline] pub fn get_launch_after_install(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_LaunchAfterInstall)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_launch_after_install(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_LaunchAfterInstall)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} DEFINE_IID!(IID_IAppInstallManager, 2471747952, 33857, 19269, 189, 114, 124, 47, 169, 37, 190, 238); RT_INTERFACE!{interface IAppInstallManager(IAppInstallManagerVtbl): IInspectable(IInspectableVtbl) [IID_IAppInstallManager] { fn get_AppInstallItems(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT, @@ -25884,6 +26424,59 @@ impl IAppInstallManager5 { if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IAppInstallManager6, 3387413512, 62074, 17521, 178, 244, 231, 110, 252, 190, 188, 202); +RT_INTERFACE!{interface IAppInstallManager6(IAppInstallManager6Vtbl): IInspectable(IInspectableVtbl) [IID_IAppInstallManager6] { + fn SearchForAllUpdatesWithUpdateOptionsAsync(&self, correlationVector: HSTRING, clientId: HSTRING, updateOptions: *mut AppUpdateOptions, out: *mut *mut foundation::IAsyncOperation>) -> HRESULT, + #[cfg(feature="windows-system")] fn SearchForAllUpdatesWithUpdateOptionsForUserAsync(&self, user: *mut ::rt::gen::windows::system::User, correlationVector: HSTRING, clientId: HSTRING, updateOptions: *mut AppUpdateOptions, out: *mut *mut foundation::IAsyncOperation>) -> HRESULT, + fn SearchForUpdatesWithUpdateOptionsAsync(&self, productId: HSTRING, skuId: HSTRING, correlationVector: HSTRING, clientId: HSTRING, updateOptions: *mut AppUpdateOptions, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + #[cfg(feature="windows-system")] fn SearchForUpdatesWithUpdateOptionsForUserAsync(&self, user: *mut ::rt::gen::windows::system::User, productId: HSTRING, skuId: HSTRING, correlationVector: HSTRING, clientId: HSTRING, updateOptions: *mut AppUpdateOptions, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn StartProductInstallWithOptionsAsync(&self, productId: HSTRING, flightId: HSTRING, clientId: HSTRING, correlationVector: HSTRING, installOptions: *mut AppInstallOptions, out: *mut *mut foundation::IAsyncOperation>) -> HRESULT, + #[cfg(feature="windows-system")] fn StartProductInstallWithOptionsForUserAsync(&self, user: *mut ::rt::gen::windows::system::User, productId: HSTRING, flightId: HSTRING, clientId: HSTRING, correlationVector: HSTRING, installOptions: *mut AppInstallOptions, out: *mut *mut foundation::IAsyncOperation>) -> HRESULT, + fn GetIsPackageIdentityAllowedToInstallAsync(&self, correlationVector: HSTRING, packageIdentityName: HSTRING, publisherCertificateName: HSTRING, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + #[cfg(feature="windows-system")] fn GetIsPackageIdentityAllowedToInstallForUserAsync(&self, user: *mut ::rt::gen::windows::system::User, correlationVector: HSTRING, packageIdentityName: HSTRING, publisherCertificateName: HSTRING, out: *mut *mut foundation::IAsyncOperation) -> HRESULT +}} +impl IAppInstallManager6 { + #[inline] pub fn search_for_all_updates_with_update_options_async(&self, correlationVector: &HStringArg, clientId: &HStringArg, updateOptions: &AppUpdateOptions) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).SearchForAllUpdatesWithUpdateOptionsAsync)(self as *const _ as *mut _, correlationVector.get(), clientId.get(), updateOptions as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[cfg(feature="windows-system")] #[inline] pub fn search_for_all_updates_with_update_options_for_user_async(&self, user: &::rt::gen::windows::system::User, correlationVector: &HStringArg, clientId: &HStringArg, updateOptions: &AppUpdateOptions) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).SearchForAllUpdatesWithUpdateOptionsForUserAsync)(self as *const _ as *mut _, user as *const _ as *mut _, correlationVector.get(), clientId.get(), updateOptions as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn search_for_updates_with_update_options_async(&self, productId: &HStringArg, skuId: &HStringArg, correlationVector: &HStringArg, clientId: &HStringArg, updateOptions: &AppUpdateOptions) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).SearchForUpdatesWithUpdateOptionsAsync)(self as *const _ as *mut _, productId.get(), skuId.get(), correlationVector.get(), clientId.get(), updateOptions as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[cfg(feature="windows-system")] #[inline] pub fn search_for_updates_with_update_options_for_user_async(&self, user: &::rt::gen::windows::system::User, productId: &HStringArg, skuId: &HStringArg, correlationVector: &HStringArg, clientId: &HStringArg, updateOptions: &AppUpdateOptions) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).SearchForUpdatesWithUpdateOptionsForUserAsync)(self as *const _ as *mut _, user as *const _ as *mut _, productId.get(), skuId.get(), correlationVector.get(), clientId.get(), updateOptions as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn start_product_install_with_options_async(&self, productId: &HStringArg, flightId: &HStringArg, clientId: &HStringArg, correlationVector: &HStringArg, installOptions: &AppInstallOptions) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).StartProductInstallWithOptionsAsync)(self as *const _ as *mut _, productId.get(), flightId.get(), clientId.get(), correlationVector.get(), installOptions as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[cfg(feature="windows-system")] #[inline] pub fn start_product_install_with_options_for_user_async(&self, user: &::rt::gen::windows::system::User, productId: &HStringArg, flightId: &HStringArg, clientId: &HStringArg, correlationVector: &HStringArg, installOptions: &AppInstallOptions) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).StartProductInstallWithOptionsForUserAsync)(self as *const _ as *mut _, user as *const _ as *mut _, productId.get(), flightId.get(), clientId.get(), correlationVector.get(), installOptions as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_is_package_identity_allowed_to_install_async(&self, correlationVector: &HStringArg, packageIdentityName: &HStringArg, publisherCertificateName: &HStringArg) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetIsPackageIdentityAllowedToInstallAsync)(self as *const _ as *mut _, correlationVector.get(), packageIdentityName.get(), publisherCertificateName.get(), &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[cfg(feature="windows-system")] #[inline] pub fn get_is_package_identity_allowed_to_install_for_user_async(&self, user: &::rt::gen::windows::system::User, correlationVector: &HStringArg, packageIdentityName: &HStringArg, publisherCertificateName: &HStringArg) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetIsPackageIdentityAllowedToInstallForUserAsync)(self as *const _ as *mut _, user as *const _ as *mut _, correlationVector.get(), packageIdentityName.get(), publisherCertificateName.get(), &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IAppInstallManagerItemEventArgs, 3159381827, 18036, 19921, 149, 126, 194, 86, 130, 8, 106, 20); RT_INTERFACE!{interface IAppInstallManagerItemEventArgs(IAppInstallManagerItemEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IAppInstallManagerItemEventArgs] { fn get_Item(&self, out: *mut *mut AppInstallItem) -> HRESULT @@ -25896,6 +26489,82 @@ impl IAppInstallManagerItemEventArgs { }} } RT_CLASS!{class AppInstallManagerItemEventArgs: IAppInstallManagerItemEventArgs} +DEFINE_IID!(IID_IAppInstallOptions, 3380642560, 7352, 20150, 140, 159, 106, 48, 198, 74, 91, 81); +RT_INTERFACE!{interface IAppInstallOptions(IAppInstallOptionsVtbl): IInspectable(IInspectableVtbl) [IID_IAppInstallOptions] { + fn get_CatalogId(&self, out: *mut HSTRING) -> HRESULT, + fn put_CatalogId(&self, value: HSTRING) -> HRESULT, + fn get_ForceUseOfNonRemovableStorage(&self, out: *mut bool) -> HRESULT, + fn put_ForceUseOfNonRemovableStorage(&self, value: bool) -> HRESULT, + fn get_AllowForcedAppRestart(&self, out: *mut bool) -> HRESULT, + fn put_AllowForcedAppRestart(&self, value: bool) -> HRESULT, + fn get_Repair(&self, out: *mut bool) -> HRESULT, + fn put_Repair(&self, value: bool) -> HRESULT, + #[cfg(not(feature="windows-management"))] fn __Dummy8(&self) -> (), + #[cfg(feature="windows-management")] fn get_TargetVolume(&self, out: *mut *mut ::rt::gen::windows::management::deployment::PackageVolume) -> HRESULT, + #[cfg(not(feature="windows-management"))] fn __Dummy9(&self) -> (), + #[cfg(feature="windows-management")] fn put_TargetVolume(&self, value: *mut ::rt::gen::windows::management::deployment::PackageVolume) -> HRESULT, + fn get_LaunchAfterInstall(&self, out: *mut bool) -> HRESULT, + fn put_LaunchAfterInstall(&self, value: bool) -> HRESULT +}} +impl IAppInstallOptions { + #[inline] pub fn get_catalog_id(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_CatalogId)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn set_catalog_id(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_CatalogId)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_force_use_of_non_removable_storage(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_ForceUseOfNonRemovableStorage)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_force_use_of_non_removable_storage(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_ForceUseOfNonRemovableStorage)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_allow_forced_app_restart(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_AllowForcedAppRestart)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_allow_forced_app_restart(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_AllowForcedAppRestart)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_repair(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Repair)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_repair(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Repair)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[cfg(feature="windows-management")] #[inline] pub fn get_target_volume(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_TargetVolume)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[cfg(feature="windows-management")] #[inline] pub fn set_target_volume(&self, value: &::rt::gen::windows::management::deployment::PackageVolume) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_TargetVolume)(self as *const _ as *mut _, value as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_launch_after_install(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_LaunchAfterInstall)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_launch_after_install(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_LaunchAfterInstall)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class AppInstallOptions: IAppInstallOptions} +impl RtActivatable for AppInstallOptions {} +DEFINE_CLSID!(AppInstallOptions(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,83,116,111,114,101,46,80,114,101,118,105,101,119,46,73,110,115,116,97,108,108,67,111,110,116,114,111,108,46,65,112,112,73,110,115,116,97,108,108,79,112,116,105,111,110,115,0]) [CLSID_AppInstallOptions]); RT_ENUM! { enum AppInstallState: i32 { Pending (AppInstallState_Pending) = 0, Starting (AppInstallState_Starting) = 1, AcquiringLicense (AppInstallState_AcquiringLicense) = 2, Downloading (AppInstallState_Downloading) = 3, RestoringData (AppInstallState_RestoringData) = 4, Installing (AppInstallState_Installing) = 5, Completed (AppInstallState_Completed) = 6, Canceled (AppInstallState_Canceled) = 7, Paused (AppInstallState_Paused) = 8, Error (AppInstallState_Error) = 9, PausedLowBattery (AppInstallState_PausedLowBattery) = 10, PausedWiFiRecommended (AppInstallState_PausedWiFiRecommended) = 11, PausedWiFiRequired (AppInstallState_PausedWiFiRequired) = 12, ReadyToDownload (AppInstallState_ReadyToDownload) = 13, }} @@ -25953,9 +26622,50 @@ impl IAppInstallStatus2 { if hr == S_OK { Ok(out) } else { err(hr) } }} } +DEFINE_IID!(IID_IAppInstallStatus3, 3414690902, 33659, 19276, 158, 187, 109, 68, 160, 169, 99, 7); +RT_INTERFACE!{interface IAppInstallStatus3(IAppInstallStatus3Vtbl): IInspectable(IInspectableVtbl) [IID_IAppInstallStatus3] { + fn get_IsStaged(&self, out: *mut bool) -> HRESULT +}} +impl IAppInstallStatus3 { + #[inline] pub fn get_is_staged(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_IsStaged)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} RT_ENUM! { enum AppInstallType: i32 { Install (AppInstallType_Install) = 0, Update (AppInstallType_Update) = 1, Repair (AppInstallType_Repair) = 2, }} +DEFINE_IID!(IID_IAppUpdateOptions, 653307951, 49907, 19178, 175, 140, 99, 8, 221, 157, 184, 95); +RT_INTERFACE!{interface IAppUpdateOptions(IAppUpdateOptionsVtbl): IInspectable(IInspectableVtbl) [IID_IAppUpdateOptions] { + fn get_CatalogId(&self, out: *mut HSTRING) -> HRESULT, + fn put_CatalogId(&self, value: HSTRING) -> HRESULT, + fn get_AllowForcedAppRestart(&self, out: *mut bool) -> HRESULT, + fn put_AllowForcedAppRestart(&self, value: bool) -> HRESULT +}} +impl IAppUpdateOptions { + #[inline] pub fn get_catalog_id(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_CatalogId)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn set_catalog_id(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_CatalogId)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_allow_forced_app_restart(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_AllowForcedAppRestart)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_allow_forced_app_restart(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_AllowForcedAppRestart)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class AppUpdateOptions: IAppUpdateOptions} +impl RtActivatable for AppUpdateOptions {} +DEFINE_CLSID!(AppUpdateOptions(&[87,105,110,100,111,119,115,46,65,112,112,108,105,99,97,116,105,111,110,77,111,100,101,108,46,83,116,111,114,101,46,80,114,101,118,105,101,119,46,73,110,115,116,97,108,108,67,111,110,116,114,111,108,46,65,112,112,85,112,100,97,116,101,79,112,116,105,111,110,115,0]) [CLSID_AppUpdateOptions]); RT_ENUM! { enum AutoUpdateSetting: i32 { Disabled (AutoUpdateSetting_Disabled) = 0, Enabled (AutoUpdateSetting_Enabled) = 1, DisabledByPolicy (AutoUpdateSetting_DisabledByPolicy) = 2, EnabledByPolicy (AutoUpdateSetting_EnabledByPolicy) = 3, }} diff --git a/src/rt/gen/windows/devices.rs b/src/rt/gen/windows/devices.rs index 335034e..76cd3b0 100644 --- a/src/rt/gen/windows/devices.rs +++ b/src/rt/gen/windows/devices.rs @@ -84,3651 +84,3651 @@ impl ILowLevelDevicesControllerStatics { if hr == S_OK { Ok(()) } else { err(hr) } }} } -pub mod custom { // Windows.Devices.Custom +pub mod smartcards { // Windows.Devices.SmartCards use ::prelude::*; -DEFINE_IID!(IID_ICustomDevice, 3710919967, 50315, 17341, 188, 177, 222, 200, 143, 21, 20, 62); -RT_INTERFACE!{interface ICustomDevice(ICustomDeviceVtbl): IInspectable(IInspectableVtbl) [IID_ICustomDevice] { - #[cfg(feature="windows-storage")] fn get_InputStream(&self, out: *mut *mut super::super::storage::streams::IInputStream) -> HRESULT, - #[cfg(feature="windows-storage")] fn get_OutputStream(&self, out: *mut *mut super::super::storage::streams::IOutputStream) -> HRESULT, - #[cfg(feature="windows-storage")] fn SendIOControlAsync(&self, ioControlCode: *mut IIOControlCode, inputBuffer: *mut super::super::storage::streams::IBuffer, outputBuffer: *mut super::super::storage::streams::IBuffer, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, - #[cfg(feature="windows-storage")] fn TrySendIOControlAsync(&self, ioControlCode: *mut IIOControlCode, inputBuffer: *mut super::super::storage::streams::IBuffer, outputBuffer: *mut super::super::storage::streams::IBuffer, out: *mut *mut foundation::IAsyncOperation) -> HRESULT +DEFINE_IID!(IID_ICardAddedEventArgs, 414969752, 61835, 19923, 177, 24, 223, 178, 200, 226, 60, 198); +RT_INTERFACE!{interface ICardAddedEventArgs(ICardAddedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_ICardAddedEventArgs] { + fn get_SmartCard(&self, out: *mut *mut SmartCard) -> HRESULT }} -impl ICustomDevice { - #[cfg(feature="windows-storage")] #[inline] pub fn get_input_stream(&self) -> Result>> { unsafe { +impl ICardAddedEventArgs { + #[inline] pub fn get_smart_card(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_InputStream)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_SmartCard)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[cfg(feature="windows-storage")] #[inline] pub fn get_output_stream(&self) -> Result>> { unsafe { +} +RT_CLASS!{class CardAddedEventArgs: ICardAddedEventArgs} +DEFINE_IID!(IID_ICardRemovedEventArgs, 355670703, 8919, 18757, 175, 201, 3, 180, 111, 66, 166, 205); +RT_INTERFACE!{interface ICardRemovedEventArgs(ICardRemovedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_ICardRemovedEventArgs] { + fn get_SmartCard(&self, out: *mut *mut SmartCard) -> HRESULT +}} +impl ICardRemovedEventArgs { + #[inline] pub fn get_smart_card(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_OutputStream)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_SmartCard)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[cfg(feature="windows-storage")] #[inline] pub fn send_iocontrol_async(&self, ioControlCode: &IIOControlCode, inputBuffer: &super::super::storage::streams::IBuffer, outputBuffer: &super::super::storage::streams::IBuffer) -> Result>> { unsafe { +} +RT_CLASS!{class CardRemovedEventArgs: ICardRemovedEventArgs} +DEFINE_IID!(IID_ISmartCard, 460425329, 25652, 17396, 181, 90, 106, 41, 98, 56, 112, 170); +RT_INTERFACE!{interface ISmartCard(ISmartCardVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCard] { + fn get_Reader(&self, out: *mut *mut SmartCardReader) -> HRESULT, + fn GetStatusAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + #[cfg(feature="windows-storage")] fn GetAnswerToResetAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT +}} +impl ISmartCard { + #[inline] pub fn get_reader(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).SendIOControlAsync)(self as *const _ as *mut _, ioControlCode as *const _ as *mut _, inputBuffer as *const _ as *mut _, outputBuffer as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_Reader)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_status_async(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetStatusAsync)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[cfg(feature="windows-storage")] #[inline] pub fn try_send_iocontrol_async(&self, ioControlCode: &IIOControlCode, inputBuffer: &super::super::storage::streams::IBuffer, outputBuffer: &super::super::storage::streams::IBuffer) -> Result>> { unsafe { + #[cfg(feature="windows-storage")] #[inline] pub fn get_answer_to_reset_async(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).TrySendIOControlAsync)(self as *const _ as *mut _, ioControlCode as *const _ as *mut _, inputBuffer as *const _ as *mut _, outputBuffer as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).GetAnswerToResetAsync)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } -RT_CLASS!{class CustomDevice: ICustomDevice} -impl RtActivatable for CustomDevice {} -impl CustomDevice { - #[inline] pub fn get_device_selector(classGuid: Guid) -> Result { - >::get_activation_factory().get_device_selector(classGuid) - } - #[inline] pub fn from_id_async(deviceId: &HStringArg, desiredAccess: DeviceAccessMode, sharingMode: DeviceSharingMode) -> Result>> { - >::get_activation_factory().from_id_async(deviceId, desiredAccess, sharingMode) - } -} -DEFINE_CLSID!(CustomDevice(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,67,117,115,116,111,109,46,67,117,115,116,111,109,68,101,118,105,99,101,0]) [CLSID_CustomDevice]); -DEFINE_IID!(IID_ICustomDeviceStatics, 3357672210, 61260, 18097, 165, 142, 238, 179, 8, 220, 137, 23); -RT_INTERFACE!{static interface ICustomDeviceStatics(ICustomDeviceStaticsVtbl): IInspectable(IInspectableVtbl) [IID_ICustomDeviceStatics] { - fn GetDeviceSelector(&self, classGuid: Guid, out: *mut HSTRING) -> HRESULT, - fn FromIdAsync(&self, deviceId: HSTRING, desiredAccess: DeviceAccessMode, sharingMode: DeviceSharingMode, out: *mut *mut foundation::IAsyncOperation) -> HRESULT +RT_CLASS!{class SmartCard: ISmartCard} +RT_ENUM! { enum SmartCardActivationPolicyChangeResult: i32 { + Denied (SmartCardActivationPolicyChangeResult_Denied) = 0, Allowed (SmartCardActivationPolicyChangeResult_Allowed) = 1, }} -impl ICustomDeviceStatics { - #[inline] pub fn get_device_selector(&self, classGuid: Guid) -> Result { unsafe { +DEFINE_IID!(IID_ISmartCardAppletIdGroup, 2108777958, 25188, 22260, 94, 3, 200, 99, 133, 57, 94, 177); +RT_INTERFACE!{interface ISmartCardAppletIdGroup(ISmartCardAppletIdGroupVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardAppletIdGroup] { + fn get_DisplayName(&self, out: *mut HSTRING) -> HRESULT, + fn put_DisplayName(&self, value: HSTRING) -> HRESULT, + #[cfg(not(feature="windows-storage"))] fn __Dummy2(&self) -> (), + #[cfg(feature="windows-storage")] fn get_AppletIds(&self, out: *mut *mut foundation::collections::IVector) -> HRESULT, + fn get_SmartCardEmulationCategory(&self, out: *mut SmartCardEmulationCategory) -> HRESULT, + fn put_SmartCardEmulationCategory(&self, value: SmartCardEmulationCategory) -> HRESULT, + fn get_SmartCardEmulationType(&self, out: *mut SmartCardEmulationType) -> HRESULT, + fn put_SmartCardEmulationType(&self, value: SmartCardEmulationType) -> HRESULT, + fn get_AutomaticEnablement(&self, out: *mut bool) -> HRESULT, + fn put_AutomaticEnablement(&self, value: bool) -> HRESULT +}} +impl ISmartCardAppletIdGroup { + #[inline] pub fn get_display_name(&self) -> Result { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetDeviceSelector)(self as *const _ as *mut _, classGuid, &mut out); + let hr = ((*self.lpVtbl).get_DisplayName)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} - #[inline] pub fn from_id_async(&self, deviceId: &HStringArg, desiredAccess: DeviceAccessMode, sharingMode: DeviceSharingMode) -> Result>> { unsafe { + #[inline] pub fn set_display_name(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_DisplayName)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[cfg(feature="windows-storage")] #[inline] pub fn get_applet_ids(&self) -> Result>>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).FromIdAsync)(self as *const _ as *mut _, deviceId.get(), desiredAccess, sharingMode, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).get_AppletIds)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} -} -RT_ENUM! { enum DeviceAccessMode: i32 { - Read (DeviceAccessMode_Read) = 0, Write (DeviceAccessMode_Write) = 1, ReadWrite (DeviceAccessMode_ReadWrite) = 2, -}} -RT_ENUM! { enum DeviceSharingMode: i32 { - Shared (DeviceSharingMode_Shared) = 0, Exclusive (DeviceSharingMode_Exclusive) = 1, -}} -DEFINE_IID!(IID_IIOControlCode, 244668903, 24776, 17269, 167, 97, 127, 136, 8, 6, 108, 96); -RT_INTERFACE!{interface IIOControlCode(IIOControlCodeVtbl): IInspectable(IInspectableVtbl) [IID_IIOControlCode] { - fn get_AccessMode(&self, out: *mut IOControlAccessMode) -> HRESULT, - fn get_BufferingMethod(&self, out: *mut IOControlBufferingMethod) -> HRESULT, - fn get_Function(&self, out: *mut u16) -> HRESULT, - fn get_DeviceType(&self, out: *mut u16) -> HRESULT, - fn get_ControlCode(&self, out: *mut u32) -> HRESULT -}} -impl IIOControlCode { - #[inline] pub fn get_access_mode(&self) -> Result { unsafe { + #[inline] pub fn get_smart_card_emulation_category(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_AccessMode)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_SmartCardEmulationCategory)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_buffering_method(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_BufferingMethod)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } + #[inline] pub fn set_smart_card_emulation_category(&self, value: SmartCardEmulationCategory) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_SmartCardEmulationCategory)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_function(&self) -> Result { unsafe { + #[inline] pub fn get_smart_card_emulation_type(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_Function)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_SmartCardEmulationType)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_device_type(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_DeviceType)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } + #[inline] pub fn set_smart_card_emulation_type(&self, value: SmartCardEmulationType) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_SmartCardEmulationType)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_control_code(&self) -> Result { unsafe { + #[inline] pub fn get_automatic_enablement(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_ControlCode)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_AutomaticEnablement)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} + #[inline] pub fn set_automatic_enablement(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_AutomaticEnablement)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} } -DEFINE_IID!(IID_IIOControlCodeFactory, 2238348528, 19473, 17582, 175, 198, 184, 212, 162, 18, 120, 143); -RT_INTERFACE!{static interface IIOControlCodeFactory(IIOControlCodeFactoryVtbl): IInspectable(IInspectableVtbl) [IID_IIOControlCodeFactory] { - fn CreateIOControlCode(&self, deviceType: u16, function: u16, accessMode: IOControlAccessMode, bufferingMethod: IOControlBufferingMethod, out: *mut *mut IOControlCode) -> HRESULT +RT_CLASS!{class SmartCardAppletIdGroup: ISmartCardAppletIdGroup} +impl RtActivatable for SmartCardAppletIdGroup {} +impl RtActivatable for SmartCardAppletIdGroup {} +impl RtActivatable for SmartCardAppletIdGroup {} +impl SmartCardAppletIdGroup { + #[cfg(feature="windows-storage")] #[inline] pub fn create(displayName: &HStringArg, appletIds: &foundation::collections::IVector, emulationCategory: SmartCardEmulationCategory, emulationType: SmartCardEmulationType) -> Result> { + >::get_activation_factory().create(displayName, appletIds, emulationCategory, emulationType) + } + #[inline] pub fn get_max_applet_ids() -> Result { + >::get_activation_factory().get_max_applet_ids() + } +} +DEFINE_CLSID!(SmartCardAppletIdGroup(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,83,109,97,114,116,67,97,114,100,115,46,83,109,97,114,116,67,97,114,100,65,112,112,108,101,116,73,100,71,114,111,117,112,0]) [CLSID_SmartCardAppletIdGroup]); +RT_ENUM! { enum SmartCardAppletIdGroupActivationPolicy: i32 { + Disabled (SmartCardAppletIdGroupActivationPolicy_Disabled) = 0, ForegroundOverride (SmartCardAppletIdGroupActivationPolicy_ForegroundOverride) = 1, Enabled (SmartCardAppletIdGroupActivationPolicy_Enabled) = 2, }} -impl IIOControlCodeFactory { - #[inline] pub fn create_iocontrol_code(&self, deviceType: u16, function: u16, accessMode: IOControlAccessMode, bufferingMethod: IOControlBufferingMethod) -> Result> { unsafe { +DEFINE_IID!(IID_ISmartCardAppletIdGroupFactory, 2433084237, 19045, 20033, 128, 97, 203, 232, 63, 54, 149, 229); +RT_INTERFACE!{static interface ISmartCardAppletIdGroupFactory(ISmartCardAppletIdGroupFactoryVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardAppletIdGroupFactory] { + #[cfg(feature="windows-storage")] fn Create(&self, displayName: HSTRING, appletIds: *mut foundation::collections::IVector, emulationCategory: SmartCardEmulationCategory, emulationType: SmartCardEmulationType, out: *mut *mut SmartCardAppletIdGroup) -> HRESULT +}} +impl ISmartCardAppletIdGroupFactory { + #[cfg(feature="windows-storage")] #[inline] pub fn create(&self, displayName: &HStringArg, appletIds: &foundation::collections::IVector, emulationCategory: SmartCardEmulationCategory, emulationType: SmartCardEmulationType) -> Result> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).CreateIOControlCode)(self as *const _ as *mut _, deviceType, function, accessMode, bufferingMethod, &mut out); + let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, displayName.get(), appletIds as *const _ as *mut _, emulationCategory, emulationType, &mut out); if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } -RT_CLASS!{static class KnownDeviceTypes} -impl RtActivatable for KnownDeviceTypes {} -impl KnownDeviceTypes { - #[inline] pub fn get_unknown() -> Result { - >::get_activation_factory().get_unknown() - } -} -DEFINE_CLSID!(KnownDeviceTypes(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,67,117,115,116,111,109,46,75,110,111,119,110,68,101,118,105,99,101,84,121,112,101,115,0]) [CLSID_KnownDeviceTypes]); -DEFINE_IID!(IID_IKnownDeviceTypesStatics, 3998513602, 21576, 17882, 173, 27, 36, 148, 140, 35, 144, 148); -RT_INTERFACE!{static interface IKnownDeviceTypesStatics(IKnownDeviceTypesStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IKnownDeviceTypesStatics] { - fn get_Unknown(&self, out: *mut u16) -> HRESULT +DEFINE_IID!(IID_ISmartCardAppletIdGroupRegistration, 3742501073, 12731, 21910, 67, 177, 109, 105, 160, 37, 123, 58); +RT_INTERFACE!{interface ISmartCardAppletIdGroupRegistration(ISmartCardAppletIdGroupRegistrationVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardAppletIdGroupRegistration] { + fn get_ActivationPolicy(&self, out: *mut SmartCardAppletIdGroupActivationPolicy) -> HRESULT, + fn get_AppletIdGroup(&self, out: *mut *mut SmartCardAppletIdGroup) -> HRESULT, + fn RequestActivationPolicyChangeAsync(&self, policy: SmartCardAppletIdGroupActivationPolicy, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn get_Id(&self, out: *mut Guid) -> HRESULT, + fn SetAutomaticResponseApdusAsync(&self, apdus: *mut foundation::collections::IIterable, out: *mut *mut foundation::IAsyncAction) -> HRESULT }} -impl IKnownDeviceTypesStatics { - #[inline] pub fn get_unknown(&self) -> Result { unsafe { +impl ISmartCardAppletIdGroupRegistration { + #[inline] pub fn get_activation_policy(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_Unknown)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_ActivationPolicy)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} -} -RT_ENUM! { enum IOControlAccessMode: i32 { - Any (IOControlAccessMode_Any) = 0, Read (IOControlAccessMode_Read) = 1, Write (IOControlAccessMode_Write) = 2, ReadWrite (IOControlAccessMode_ReadWrite) = 3, -}} -RT_ENUM! { enum IOControlBufferingMethod: i32 { - Buffered (IOControlBufferingMethod_Buffered) = 0, DirectInput (IOControlBufferingMethod_DirectInput) = 1, DirectOutput (IOControlBufferingMethod_DirectOutput) = 2, Neither (IOControlBufferingMethod_Neither) = 3, -}} -RT_CLASS!{class IOControlCode: IIOControlCode} -impl RtActivatable for IOControlCode {} -impl IOControlCode { - #[inline] pub fn create_iocontrol_code(deviceType: u16, function: u16, accessMode: IOControlAccessMode, bufferingMethod: IOControlBufferingMethod) -> Result> { - >::get_activation_factory().create_iocontrol_code(deviceType, function, accessMode, bufferingMethod) - } -} -DEFINE_CLSID!(IOControlCode(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,67,117,115,116,111,109,46,73,79,67,111,110,116,114,111,108,67,111,100,101,0]) [CLSID_IOControlCode]); -} // Windows.Devices.Custom -pub mod printers { // Windows.Devices.Printers -use ::prelude::*; -DEFINE_IID!(IID_IPrint3DDevice, 68959513, 38675, 17058, 152, 19, 125, 195, 51, 116, 40, 211); -RT_INTERFACE!{interface IPrint3DDevice(IPrint3DDeviceVtbl): IInspectable(IInspectableVtbl) [IID_IPrint3DDevice] { - fn get_PrintSchema(&self, out: *mut *mut PrintSchema) -> HRESULT -}} -impl IPrint3DDevice { - #[inline] pub fn get_print_schema(&self) -> Result>> { unsafe { + #[inline] pub fn get_applet_id_group(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_PrintSchema)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_AppletIdGroup)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} -} -RT_CLASS!{class Print3DDevice: IPrint3DDevice} -impl RtActivatable for Print3DDevice {} -impl Print3DDevice { - #[inline] pub fn from_id_async(deviceId: &HStringArg) -> Result>> { - >::get_activation_factory().from_id_async(deviceId) - } - #[inline] pub fn get_device_selector() -> Result { - >::get_activation_factory().get_device_selector() - } -} -DEFINE_CLSID!(Print3DDevice(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,80,114,105,110,116,101,114,115,46,80,114,105,110,116,51,68,68,101,118,105,99,101,0]) [CLSID_Print3DDevice]); -DEFINE_IID!(IID_IPrint3DDeviceStatics, 4259537418, 26573, 16823, 163, 68, 81, 80, 161, 253, 117, 181); -RT_INTERFACE!{static interface IPrint3DDeviceStatics(IPrint3DDeviceStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IPrint3DDeviceStatics] { - fn FromIdAsync(&self, deviceId: HSTRING, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, - fn GetDeviceSelector(&self, out: *mut HSTRING) -> HRESULT -}} -impl IPrint3DDeviceStatics { - #[inline] pub fn from_id_async(&self, deviceId: &HStringArg) -> Result>> { unsafe { + #[inline] pub fn request_activation_policy_change_async(&self, policy: SmartCardAppletIdGroupActivationPolicy) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).FromIdAsync)(self as *const _ as *mut _, deviceId.get(), &mut out); + let hr = ((*self.lpVtbl).RequestActivationPolicyChangeAsync)(self as *const _ as *mut _, policy, &mut out); if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_device_selector(&self) -> Result { unsafe { + #[inline] pub fn get_id(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Id)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_automatic_response_apdus_async(&self, apdus: &foundation::collections::IIterable) -> Result> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetDeviceSelector)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).SetAutomaticResponseApdusAsync)(self as *const _ as *mut _, apdus as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } -DEFINE_IID!(IID_IPrintSchema, 3266937622, 9912, 19451, 129, 56, 159, 150, 44, 34, 163, 91); -RT_INTERFACE!{interface IPrintSchema(IPrintSchemaVtbl): IInspectable(IInspectableVtbl) [IID_IPrintSchema] { - #[cfg(feature="windows-storage")] fn GetDefaultPrintTicketAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, - #[cfg(feature="windows-storage")] fn GetCapabilitiesAsync(&self, constrainTicket: *mut super::super::storage::streams::IRandomAccessStreamWithContentType, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, - #[cfg(feature="windows-storage")] fn MergeAndValidateWithDefaultPrintTicketAsync(&self, deltaTicket: *mut super::super::storage::streams::IRandomAccessStreamWithContentType, out: *mut *mut foundation::IAsyncOperation) -> HRESULT +RT_CLASS!{class SmartCardAppletIdGroupRegistration: ISmartCardAppletIdGroupRegistration} +DEFINE_IID!(IID_ISmartCardAppletIdGroupStatics, 2871564713, 59244, 17871, 191, 29, 144, 234, 166, 32, 89, 39); +RT_INTERFACE!{static interface ISmartCardAppletIdGroupStatics(ISmartCardAppletIdGroupStaticsVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardAppletIdGroupStatics] { + fn get_MaxAppletIds(&self, out: *mut u16) -> HRESULT }} -impl IPrintSchema { - #[cfg(feature="windows-storage")] #[inline] pub fn get_default_print_ticket_async(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetDefaultPrintTicketAsync)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } - }} - #[cfg(feature="windows-storage")] #[inline] pub fn get_capabilities_async(&self, constrainTicket: &super::super::storage::streams::IRandomAccessStreamWithContentType) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetCapabilitiesAsync)(self as *const _ as *mut _, constrainTicket as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } - }} - #[cfg(feature="windows-storage")] #[inline] pub fn merge_and_validate_with_default_print_ticket_async(&self, deltaTicket: &super::super::storage::streams::IRandomAccessStreamWithContentType) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).MergeAndValidateWithDefaultPrintTicketAsync)(self as *const _ as *mut _, deltaTicket as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } +impl ISmartCardAppletIdGroupStatics { + #[inline] pub fn get_max_applet_ids(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_MaxAppletIds)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} } -RT_CLASS!{class PrintSchema: IPrintSchema} -pub mod extensions { // Windows.Devices.Printers.Extensions -use ::prelude::*; -DEFINE_IID!(IID_IPrint3DWorkflow, 3312415933, 13929, 19046, 171, 66, 200, 21, 25, 48, 205, 52); -RT_INTERFACE!{interface IPrint3DWorkflow(IPrint3DWorkflowVtbl): IInspectable(IInspectableVtbl) [IID_IPrint3DWorkflow] { - fn get_DeviceID(&self, out: *mut HSTRING) -> HRESULT, - fn GetPrintModelPackage(&self, out: *mut *mut IInspectable) -> HRESULT, - fn get_IsPrintReady(&self, out: *mut bool) -> HRESULT, - fn put_IsPrintReady(&self, value: bool) -> HRESULT, - fn add_PrintRequested(&self, eventHandler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, - fn remove_PrintRequested(&self, eventCookie: foundation::EventRegistrationToken) -> HRESULT +DEFINE_IID!(IID_ISmartCardAutomaticResponseApdu, 1377119147, 50750, 17713, 168, 87, 215, 86, 217, 155, 152, 106); +RT_INTERFACE!{interface ISmartCardAutomaticResponseApdu(ISmartCardAutomaticResponseApduVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardAutomaticResponseApdu] { + #[cfg(feature="windows-storage")] fn get_CommandApdu(&self, out: *mut *mut super::super::storage::streams::IBuffer) -> HRESULT, + #[cfg(feature="windows-storage")] fn put_CommandApdu(&self, value: *mut super::super::storage::streams::IBuffer) -> HRESULT, + #[cfg(feature="windows-storage")] fn get_CommandApduBitMask(&self, out: *mut *mut super::super::storage::streams::IBuffer) -> HRESULT, + #[cfg(feature="windows-storage")] fn put_CommandApduBitMask(&self, value: *mut super::super::storage::streams::IBuffer) -> HRESULT, + fn get_ShouldMatchLength(&self, out: *mut bool) -> HRESULT, + fn put_ShouldMatchLength(&self, value: bool) -> HRESULT, + #[cfg(feature="windows-storage")] fn get_AppletId(&self, out: *mut *mut super::super::storage::streams::IBuffer) -> HRESULT, + #[cfg(feature="windows-storage")] fn put_AppletId(&self, value: *mut super::super::storage::streams::IBuffer) -> HRESULT, + #[cfg(feature="windows-storage")] fn get_ResponseApdu(&self, out: *mut *mut super::super::storage::streams::IBuffer) -> HRESULT, + #[cfg(feature="windows-storage")] fn put_ResponseApdu(&self, value: *mut super::super::storage::streams::IBuffer) -> HRESULT }} -impl IPrint3DWorkflow { - #[inline] pub fn get_device_id(&self) -> Result { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_DeviceID)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } - }} - #[inline] pub fn get_print_model_package(&self) -> Result>> { unsafe { +impl ISmartCardAutomaticResponseApdu { + #[cfg(feature="windows-storage")] #[inline] pub fn get_command_apdu(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetPrintModelPackage)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_CommandApdu)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn get_is_print_ready(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_IsPrintReady)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } - }} - #[inline] pub fn set_is_print_ready(&self, value: bool) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_IsPrintReady)(self as *const _ as *mut _, value); + #[cfg(feature="windows-storage")] #[inline] pub fn set_command_apdu(&self, value: &super::super::storage::streams::IBuffer) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_CommandApdu)(self as *const _ as *mut _, value as *const _ as *mut _); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn add_print_requested(&self, eventHandler: &foundation::TypedEventHandler) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).add_PrintRequested)(self as *const _ as *mut _, eventHandler as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } + #[cfg(feature="windows-storage")] #[inline] pub fn get_command_apdu_bit_mask(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_CommandApduBitMask)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn remove_print_requested(&self, eventCookie: foundation::EventRegistrationToken) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).remove_PrintRequested)(self as *const _ as *mut _, eventCookie); + #[cfg(feature="windows-storage")] #[inline] pub fn set_command_apdu_bit_mask(&self, value: &super::super::storage::streams::IBuffer) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_CommandApduBitMask)(self as *const _ as *mut _, value as *const _ as *mut _); if hr == S_OK { Ok(()) } else { err(hr) } }} -} -RT_CLASS!{class Print3DWorkflow: IPrint3DWorkflow} -DEFINE_IID!(IID_IPrint3DWorkflow2, 2728838479, 35521, 18712, 151, 65, 227, 79, 48, 4, 35, 158); -RT_INTERFACE!{interface IPrint3DWorkflow2(IPrint3DWorkflow2Vtbl): IInspectable(IInspectableVtbl) [IID_IPrint3DWorkflow2] { - fn add_PrinterChanged(&self, eventHandler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, - fn remove_PrinterChanged(&self, eventCookie: foundation::EventRegistrationToken) -> HRESULT -}} -impl IPrint3DWorkflow2 { - #[inline] pub fn add_printer_changed(&self, eventHandler: &foundation::TypedEventHandler) -> Result { unsafe { + #[inline] pub fn get_should_match_length(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).add_PrinterChanged)(self as *const _ as *mut _, eventHandler as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_ShouldMatchLength)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn remove_printer_changed(&self, eventCookie: foundation::EventRegistrationToken) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).remove_PrinterChanged)(self as *const _ as *mut _, eventCookie); + #[inline] pub fn set_should_match_length(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_ShouldMatchLength)(self as *const _ as *mut _, value); if hr == S_OK { Ok(()) } else { err(hr) } }} -} -RT_ENUM! { enum Print3DWorkflowDetail: i32 { - Unknown (Print3DWorkflowDetail_Unknown) = 0, ModelExceedsPrintBed (Print3DWorkflowDetail_ModelExceedsPrintBed) = 1, UploadFailed (Print3DWorkflowDetail_UploadFailed) = 2, InvalidMaterialSelection (Print3DWorkflowDetail_InvalidMaterialSelection) = 3, InvalidModel (Print3DWorkflowDetail_InvalidModel) = 4, ModelNotManifold (Print3DWorkflowDetail_ModelNotManifold) = 5, InvalidPrintTicket (Print3DWorkflowDetail_InvalidPrintTicket) = 6, -}} -DEFINE_IID!(IID_IPrint3DWorkflowPrinterChangedEventArgs, 1159881730, 38396, 18503, 147, 179, 19, 77, 191, 92, 96, 247); -RT_INTERFACE!{interface IPrint3DWorkflowPrinterChangedEventArgs(IPrint3DWorkflowPrinterChangedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IPrint3DWorkflowPrinterChangedEventArgs] { - fn get_NewDeviceId(&self, out: *mut HSTRING) -> HRESULT -}} -impl IPrint3DWorkflowPrinterChangedEventArgs { - #[inline] pub fn get_new_device_id(&self) -> Result { unsafe { + #[cfg(feature="windows-storage")] #[inline] pub fn get_applet_id(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_NewDeviceId)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } - }} -} -RT_CLASS!{class Print3DWorkflowPrinterChangedEventArgs: IPrint3DWorkflowPrinterChangedEventArgs} -DEFINE_IID!(IID_IPrint3DWorkflowPrintRequestedEventArgs, 435734616, 23240, 19285, 138, 95, 230, 21, 103, 218, 251, 77); -RT_INTERFACE!{interface IPrint3DWorkflowPrintRequestedEventArgs(IPrint3DWorkflowPrintRequestedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IPrint3DWorkflowPrintRequestedEventArgs] { - fn get_Status(&self, out: *mut Print3DWorkflowStatus) -> HRESULT, - fn SetExtendedStatus(&self, value: Print3DWorkflowDetail) -> HRESULT, - fn SetSource(&self, source: *mut IInspectable) -> HRESULT, - fn SetSourceChanged(&self, value: bool) -> HRESULT -}} -impl IPrint3DWorkflowPrintRequestedEventArgs { - #[inline] pub fn get_status(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_Status)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } + let hr = ((*self.lpVtbl).get_AppletId)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn set_extended_status(&self, value: Print3DWorkflowDetail) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).SetExtendedStatus)(self as *const _ as *mut _, value); + #[cfg(feature="windows-storage")] #[inline] pub fn set_applet_id(&self, value: &super::super::storage::streams::IBuffer) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_AppletId)(self as *const _ as *mut _, value as *const _ as *mut _); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn set_source(&self, source: &IInspectable) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).SetSource)(self as *const _ as *mut _, source as *const _ as *mut _); - if hr == S_OK { Ok(()) } else { err(hr) } + #[cfg(feature="windows-storage")] #[inline] pub fn get_response_apdu(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ResponseApdu)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn set_source_changed(&self, value: bool) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).SetSourceChanged)(self as *const _ as *mut _, value); + #[cfg(feature="windows-storage")] #[inline] pub fn set_response_apdu(&self, value: &super::super::storage::streams::IBuffer) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_ResponseApdu)(self as *const _ as *mut _, value as *const _ as *mut _); if hr == S_OK { Ok(()) } else { err(hr) } }} } -RT_CLASS!{class Print3DWorkflowPrintRequestedEventArgs: IPrint3DWorkflowPrintRequestedEventArgs} -RT_ENUM! { enum Print3DWorkflowStatus: i32 { - Abandoned (Print3DWorkflowStatus_Abandoned) = 0, Canceled (Print3DWorkflowStatus_Canceled) = 1, Failed (Print3DWorkflowStatus_Failed) = 2, Slicing (Print3DWorkflowStatus_Slicing) = 3, Submitted (Print3DWorkflowStatus_Submitted) = 4, -}} -RT_CLASS!{static class PrintExtensionContext} -impl RtActivatable for PrintExtensionContext {} -impl PrintExtensionContext { - #[inline] pub fn from_device_id(deviceId: &HStringArg) -> Result>> { - >::get_activation_factory().from_device_id(deviceId) +RT_CLASS!{class SmartCardAutomaticResponseApdu: ISmartCardAutomaticResponseApdu} +impl RtActivatable for SmartCardAutomaticResponseApdu {} +impl SmartCardAutomaticResponseApdu { + #[cfg(feature="windows-storage")] #[inline] pub fn create(commandApdu: &super::super::storage::streams::IBuffer, responseApdu: &super::super::storage::streams::IBuffer) -> Result> { + >::get_activation_factory().create(commandApdu, responseApdu) } } -DEFINE_CLSID!(PrintExtensionContext(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,80,114,105,110,116,101,114,115,46,69,120,116,101,110,115,105,111,110,115,46,80,114,105,110,116,69,120,116,101,110,115,105,111,110,67,111,110,116,101,120,116,0]) [CLSID_PrintExtensionContext]); -DEFINE_IID!(IID_IPrintExtensionContextStatic, 3876429761, 65401, 19108, 140, 155, 12, 147, 174, 223, 222, 138); -RT_INTERFACE!{static interface IPrintExtensionContextStatic(IPrintExtensionContextStaticVtbl): IInspectable(IInspectableVtbl) [IID_IPrintExtensionContextStatic] { - fn FromDeviceId(&self, deviceId: HSTRING, out: *mut *mut IInspectable) -> HRESULT +DEFINE_CLSID!(SmartCardAutomaticResponseApdu(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,83,109,97,114,116,67,97,114,100,115,46,83,109,97,114,116,67,97,114,100,65,117,116,111,109,97,116,105,99,82,101,115,112,111,110,115,101,65,112,100,117,0]) [CLSID_SmartCardAutomaticResponseApdu]); +DEFINE_IID!(IID_ISmartCardAutomaticResponseApdu2, 1152301844, 21917, 17713, 78, 81, 137, 219, 111, 168, 165, 122); +RT_INTERFACE!{interface ISmartCardAutomaticResponseApdu2(ISmartCardAutomaticResponseApdu2Vtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardAutomaticResponseApdu2] { + fn get_InputState(&self, out: *mut *mut foundation::IReference) -> HRESULT, + fn put_InputState(&self, value: *mut foundation::IReference) -> HRESULT, + fn get_OutputState(&self, out: *mut *mut foundation::IReference) -> HRESULT, + fn put_OutputState(&self, value: *mut foundation::IReference) -> HRESULT }} -impl IPrintExtensionContextStatic { - #[inline] pub fn from_device_id(&self, deviceId: &HStringArg) -> Result>> { unsafe { +impl ISmartCardAutomaticResponseApdu2 { + #[inline] pub fn get_input_state(&self) -> Result>>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).FromDeviceId)(self as *const _ as *mut _, deviceId.get(), &mut out); + let hr = ((*self.lpVtbl).get_InputState)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} -} -DEFINE_IID!(IID_IPrintNotificationEventDetails, 3759033482, 18472, 19873, 139, 184, 134, 114, 223, 133, 21, 231); -RT_INTERFACE!{interface IPrintNotificationEventDetails(IPrintNotificationEventDetailsVtbl): IInspectable(IInspectableVtbl) [IID_IPrintNotificationEventDetails] { - fn get_PrinterName(&self, out: *mut HSTRING) -> HRESULT, - fn get_EventData(&self, out: *mut HSTRING) -> HRESULT, - fn put_EventData(&self, value: HSTRING) -> HRESULT -}} -impl IPrintNotificationEventDetails { - #[inline] pub fn get_printer_name(&self) -> Result { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_PrinterName)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + #[inline] pub fn set_input_state(&self, value: &foundation::IReference) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_InputState)(self as *const _ as *mut _, value as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_event_data(&self) -> Result { unsafe { + #[inline] pub fn get_output_state(&self) -> Result>>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_EventData)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).get_OutputState)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn set_event_data(&self, value: &HStringArg) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_EventData)(self as *const _ as *mut _, value.get()); + #[inline] pub fn set_output_state(&self, value: &foundation::IReference) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_OutputState)(self as *const _ as *mut _, value as *const _ as *mut _); if hr == S_OK { Ok(()) } else { err(hr) } }} } -RT_CLASS!{class PrintNotificationEventDetails: IPrintNotificationEventDetails} -DEFINE_IID!(IID_IPrintTaskConfiguration, 3821151313, 15012, 18565, 146, 64, 49, 31, 95, 143, 190, 157); -RT_INTERFACE!{interface IPrintTaskConfiguration(IPrintTaskConfigurationVtbl): IInspectable(IInspectableVtbl) [IID_IPrintTaskConfiguration] { - fn get_PrinterExtensionContext(&self, out: *mut *mut IInspectable) -> HRESULT, - fn add_SaveRequested(&self, eventHandler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, - fn remove_SaveRequested(&self, eventCookie: foundation::EventRegistrationToken) -> HRESULT +DEFINE_IID!(IID_ISmartCardAutomaticResponseApdu3, 3208895092, 25974, 17298, 147, 103, 254, 59, 201, 226, 212, 150); +RT_INTERFACE!{interface ISmartCardAutomaticResponseApdu3(ISmartCardAutomaticResponseApdu3Vtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardAutomaticResponseApdu3] { + fn get_AllowWhenCryptogramGeneratorNotPrepared(&self, out: *mut bool) -> HRESULT, + fn put_AllowWhenCryptogramGeneratorNotPrepared(&self, value: bool) -> HRESULT }} -impl IPrintTaskConfiguration { - #[inline] pub fn get_printer_extension_context(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_PrinterExtensionContext)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } - }} - #[inline] pub fn add_save_requested(&self, eventHandler: &foundation::TypedEventHandler) -> Result { unsafe { +impl ISmartCardAutomaticResponseApdu3 { + #[inline] pub fn get_allow_when_cryptogram_generator_not_prepared(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).add_SaveRequested)(self as *const _ as *mut _, eventHandler as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_AllowWhenCryptogramGeneratorNotPrepared)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn remove_save_requested(&self, eventCookie: foundation::EventRegistrationToken) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).remove_SaveRequested)(self as *const _ as *mut _, eventCookie); + #[inline] pub fn set_allow_when_cryptogram_generator_not_prepared(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_AllowWhenCryptogramGeneratorNotPrepared)(self as *const _ as *mut _, value); if hr == S_OK { Ok(()) } else { err(hr) } }} } -RT_CLASS!{class PrintTaskConfiguration: IPrintTaskConfiguration} -DEFINE_IID!(IID_IPrintTaskConfigurationSaveRequest, 4004458443, 25118, 19298, 172, 119, 178, 129, 204, 224, 141, 96); -RT_INTERFACE!{interface IPrintTaskConfigurationSaveRequest(IPrintTaskConfigurationSaveRequestVtbl): IInspectable(IInspectableVtbl) [IID_IPrintTaskConfigurationSaveRequest] { - fn Cancel(&self) -> HRESULT, - fn Save(&self, printerExtensionContext: *mut IInspectable) -> HRESULT, - fn GetDeferral(&self, out: *mut *mut PrintTaskConfigurationSaveRequestedDeferral) -> HRESULT, - fn get_Deadline(&self, out: *mut foundation::DateTime) -> HRESULT +DEFINE_IID!(IID_ISmartCardAutomaticResponseApduFactory, 3917390586, 53292, 19541, 176, 42, 140, 255, 127, 169, 240, 91); +RT_INTERFACE!{static interface ISmartCardAutomaticResponseApduFactory(ISmartCardAutomaticResponseApduFactoryVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardAutomaticResponseApduFactory] { + #[cfg(feature="windows-storage")] fn Create(&self, commandApdu: *mut super::super::storage::streams::IBuffer, responseApdu: *mut super::super::storage::streams::IBuffer, out: *mut *mut SmartCardAutomaticResponseApdu) -> HRESULT }} -impl IPrintTaskConfigurationSaveRequest { - #[inline] pub fn cancel(&self) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).Cancel)(self as *const _ as *mut _); - if hr == S_OK { Ok(()) } else { err(hr) } - }} - #[inline] pub fn save(&self, printerExtensionContext: &IInspectable) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).Save)(self as *const _ as *mut _, printerExtensionContext as *const _ as *mut _); - if hr == S_OK { Ok(()) } else { err(hr) } - }} - #[inline] pub fn get_deferral(&self) -> Result>> { unsafe { +impl ISmartCardAutomaticResponseApduFactory { + #[cfg(feature="windows-storage")] #[inline] pub fn create(&self, commandApdu: &super::super::storage::streams::IBuffer, responseApdu: &super::super::storage::streams::IBuffer) -> Result> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetDeferral)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } - }} - #[inline] pub fn get_deadline(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_Deadline)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } + let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, commandApdu as *const _ as *mut _, responseApdu as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } -RT_CLASS!{class PrintTaskConfigurationSaveRequest: IPrintTaskConfigurationSaveRequest} -DEFINE_IID!(IID_IPrintTaskConfigurationSaveRequestedDeferral, 3914978664, 63273, 17572, 135, 29, 189, 6, 40, 105, 106, 51); -RT_INTERFACE!{interface IPrintTaskConfigurationSaveRequestedDeferral(IPrintTaskConfigurationSaveRequestedDeferralVtbl): IInspectable(IInspectableVtbl) [IID_IPrintTaskConfigurationSaveRequestedDeferral] { - fn Complete(&self) -> HRESULT +RT_ENUM! { enum SmartCardAutomaticResponseStatus: i32 { + None (SmartCardAutomaticResponseStatus_None) = 0, Success (SmartCardAutomaticResponseStatus_Success) = 1, UnknownError (SmartCardAutomaticResponseStatus_UnknownError) = 2, }} -impl IPrintTaskConfigurationSaveRequestedDeferral { - #[inline] pub fn complete(&self) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).Complete)(self as *const _ as *mut _); - if hr == S_OK { Ok(()) } else { err(hr) } - }} -} -RT_CLASS!{class PrintTaskConfigurationSaveRequestedDeferral: IPrintTaskConfigurationSaveRequestedDeferral} -DEFINE_IID!(IID_IPrintTaskConfigurationSaveRequestedEventArgs, 3765184633, 3425, 18744, 145, 208, 150, 164, 91, 238, 132, 121); -RT_INTERFACE!{interface IPrintTaskConfigurationSaveRequestedEventArgs(IPrintTaskConfigurationSaveRequestedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IPrintTaskConfigurationSaveRequestedEventArgs] { - fn get_Request(&self, out: *mut *mut PrintTaskConfigurationSaveRequest) -> HRESULT +DEFINE_IID!(IID_ISmartCardChallengeContext, 422204185, 51652, 18759, 129, 204, 68, 121, 74, 97, 239, 145); +RT_INTERFACE!{interface ISmartCardChallengeContext(ISmartCardChallengeContextVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardChallengeContext] { + #[cfg(feature="windows-storage")] fn get_Challenge(&self, out: *mut *mut super::super::storage::streams::IBuffer) -> HRESULT, + #[cfg(feature="windows-storage")] fn VerifyResponseAsync(&self, response: *mut super::super::storage::streams::IBuffer, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + #[cfg(feature="windows-storage")] fn ProvisionAsync(&self, response: *mut super::super::storage::streams::IBuffer, formatCard: bool, out: *mut *mut foundation::IAsyncAction) -> HRESULT, + #[cfg(feature="windows-storage")] fn ProvisionAsyncWithNewCardId(&self, response: *mut super::super::storage::streams::IBuffer, formatCard: bool, newCardId: Guid, out: *mut *mut foundation::IAsyncAction) -> HRESULT, + #[cfg(feature="windows-storage")] fn ChangeAdministrativeKeyAsync(&self, response: *mut super::super::storage::streams::IBuffer, newAdministrativeKey: *mut super::super::storage::streams::IBuffer, out: *mut *mut foundation::IAsyncAction) -> HRESULT }} -impl IPrintTaskConfigurationSaveRequestedEventArgs { - #[inline] pub fn get_request(&self) -> Result>> { unsafe { +impl ISmartCardChallengeContext { + #[cfg(feature="windows-storage")] #[inline] pub fn get_challenge(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Request)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_Challenge)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} + #[cfg(feature="windows-storage")] #[inline] pub fn verify_response_async(&self, response: &super::super::storage::streams::IBuffer) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).VerifyResponseAsync)(self as *const _ as *mut _, response as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[cfg(feature="windows-storage")] #[inline] pub fn provision_async(&self, response: &super::super::storage::streams::IBuffer, formatCard: bool) -> Result> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).ProvisionAsync)(self as *const _ as *mut _, response as *const _ as *mut _, formatCard, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[cfg(feature="windows-storage")] #[inline] pub fn provision_async_with_new_card_id(&self, response: &super::super::storage::streams::IBuffer, formatCard: bool, newCardId: Guid) -> Result> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).ProvisionAsyncWithNewCardId)(self as *const _ as *mut _, response as *const _ as *mut _, formatCard, newCardId, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[cfg(feature="windows-storage")] #[inline] pub fn change_administrative_key_async(&self, response: &super::super::storage::streams::IBuffer, newAdministrativeKey: &super::super::storage::streams::IBuffer) -> Result> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).ChangeAdministrativeKeyAsync)(self as *const _ as *mut _, response as *const _ as *mut _, newAdministrativeKey as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} } -RT_CLASS!{class PrintTaskConfigurationSaveRequestedEventArgs: IPrintTaskConfigurationSaveRequestedEventArgs} -} // Windows.Devices.Printers.Extensions -} // Windows.Devices.Printers -pub mod adc { // Windows.Devices.Adc -use ::prelude::*; -DEFINE_IID!(IID_IAdcChannel, 67892244, 9608, 19030, 171, 239, 115, 162, 96, 172, 198, 10); -RT_INTERFACE!{interface IAdcChannel(IAdcChannelVtbl): IInspectable(IInspectableVtbl) [IID_IAdcChannel] { - fn get_Controller(&self, out: *mut *mut AdcController) -> HRESULT, - fn ReadValue(&self, out: *mut i32) -> HRESULT, - fn ReadRatio(&self, out: *mut f64) -> HRESULT +RT_CLASS!{class SmartCardChallengeContext: ISmartCardChallengeContext} +DEFINE_IID!(IID_ISmartCardConnect, 803178469, 653, 18718, 160, 88, 51, 130, 195, 152, 111, 64); +RT_INTERFACE!{interface ISmartCardConnect(ISmartCardConnectVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardConnect] { + fn ConnectAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT }} -impl IAdcChannel { - #[inline] pub fn get_controller(&self) -> Result>> { unsafe { +impl ISmartCardConnect { + #[inline] pub fn connect_async(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Controller)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } - }} - #[inline] pub fn read_value(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).ReadValue)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } + let hr = ((*self.lpVtbl).ConnectAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn read_ratio(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).ReadRatio)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } +} +DEFINE_IID!(IID_ISmartCardConnection, 2128320794, 43034, 18364, 166, 73, 21, 107, 230, 183, 242, 49); +RT_INTERFACE!{interface ISmartCardConnection(ISmartCardConnectionVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardConnection] { + #[cfg(feature="windows-storage")] fn TransmitAsync(&self, command: *mut super::super::storage::streams::IBuffer, out: *mut *mut foundation::IAsyncOperation) -> HRESULT +}} +impl ISmartCardConnection { + #[cfg(feature="windows-storage")] #[inline] pub fn transmit_async(&self, command: &super::super::storage::streams::IBuffer) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).TransmitAsync)(self as *const _ as *mut _, command as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } -RT_CLASS!{class AdcChannel: IAdcChannel} -RT_ENUM! { enum AdcChannelMode: i32 { - SingleEnded (AdcChannelMode_SingleEnded) = 0, Differential (AdcChannelMode_Differential) = 1, +RT_CLASS!{class SmartCardConnection: ISmartCardConnection} +RT_ENUM! { enum SmartCardCryptogramAlgorithm: i32 { + None (SmartCardCryptogramAlgorithm_None) = 0, CbcMac (SmartCardCryptogramAlgorithm_CbcMac) = 1, Cvc3Umd (SmartCardCryptogramAlgorithm_Cvc3Umd) = 2, DecimalizedMsd (SmartCardCryptogramAlgorithm_DecimalizedMsd) = 3, Cvc3MD (SmartCardCryptogramAlgorithm_Cvc3MD) = 4, Sha1 (SmartCardCryptogramAlgorithm_Sha1) = 5, SignedDynamicApplicationData (SmartCardCryptogramAlgorithm_SignedDynamicApplicationData) = 6, RsaPkcs1 (SmartCardCryptogramAlgorithm_RsaPkcs1) = 7, Sha256Hmac (SmartCardCryptogramAlgorithm_Sha256Hmac) = 8, }} -DEFINE_IID!(IID_IAdcController, 712434864, 43158, 16921, 134, 182, 234, 140, 220, 233, 143, 86); -RT_INTERFACE!{interface IAdcController(IAdcControllerVtbl): IInspectable(IInspectableVtbl) [IID_IAdcController] { - fn get_ChannelCount(&self, out: *mut i32) -> HRESULT, - fn get_ResolutionInBits(&self, out: *mut i32) -> HRESULT, - fn get_MinValue(&self, out: *mut i32) -> HRESULT, - fn get_MaxValue(&self, out: *mut i32) -> HRESULT, - fn get_ChannelMode(&self, out: *mut AdcChannelMode) -> HRESULT, - fn put_ChannelMode(&self, value: AdcChannelMode) -> HRESULT, - fn IsChannelModeSupported(&self, channelMode: AdcChannelMode, out: *mut bool) -> HRESULT, - fn OpenChannel(&self, channelNumber: i32, out: *mut *mut AdcChannel) -> HRESULT +DEFINE_IID!(IID_ISmartCardCryptogramGenerator, 3818870907, 60883, 20041, 181, 148, 15, 245, 228, 208, 199, 111); +RT_INTERFACE!{interface ISmartCardCryptogramGenerator(ISmartCardCryptogramGeneratorVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardCryptogramGenerator] { + fn get_SupportedCryptogramMaterialTypes(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT, + fn get_SupportedCryptogramAlgorithms(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT, + fn get_SupportedCryptogramMaterialPackageFormats(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT, + fn get_SupportedCryptogramMaterialPackageConfirmationResponseFormats(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT, + fn get_SupportedSmartCardCryptogramStorageKeyCapabilities(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT, + fn DeleteCryptogramMaterialStorageKeyAsync(&self, storageKeyName: HSTRING, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn CreateCryptogramMaterialStorageKeyAsync(&self, promptingBehavior: SmartCardUnlockPromptingBehavior, storageKeyName: HSTRING, algorithm: SmartCardCryptogramStorageKeyAlgorithm, capabilities: SmartCardCryptogramStorageKeyCapabilities, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + #[cfg(not(feature="windows-security"))] fn __Dummy7(&self) -> (), + #[cfg(feature="windows-security")] fn RequestCryptogramMaterialStorageKeyInfoAsync(&self, promptingBehavior: SmartCardUnlockPromptingBehavior, storageKeyName: HSTRING, format: super::super::security::cryptography::core::CryptographicPublicKeyBlobType, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + #[cfg(not(feature="windows-storage"))] fn __Dummy8(&self) -> (), + #[cfg(feature="windows-storage")] fn ImportCryptogramMaterialPackageAsync(&self, format: SmartCardCryptogramMaterialPackageFormat, storageKeyName: HSTRING, materialPackageName: HSTRING, cryptogramMaterialPackage: *mut super::super::storage::streams::IBuffer, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + #[cfg(not(feature="windows-storage"))] fn __Dummy9(&self) -> (), + #[cfg(feature="windows-storage")] fn TryProvePossessionOfCryptogramMaterialPackageAsync(&self, promptingBehavior: SmartCardUnlockPromptingBehavior, responseFormat: SmartCardCryptogramMaterialPackageConfirmationResponseFormat, materialPackageName: HSTRING, materialName: HSTRING, challenge: *mut super::super::storage::streams::IBuffer, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn RequestUnlockCryptogramMaterialForUseAsync(&self, promptingBehavior: SmartCardUnlockPromptingBehavior, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn DeleteCryptogramMaterialPackageAsync(&self, materialPackageName: HSTRING, out: *mut *mut foundation::IAsyncOperation) -> HRESULT }} -impl IAdcController { - #[inline] pub fn get_channel_count(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_ChannelCount)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } +impl ISmartCardCryptogramGenerator { + #[inline] pub fn get_supported_cryptogram_material_types(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_SupportedCryptogramMaterialTypes)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn get_resolution_in_bits(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_ResolutionInBits)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } + #[inline] pub fn get_supported_cryptogram_algorithms(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_SupportedCryptogramAlgorithms)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn get_min_value(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_MinValue)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } + #[inline] pub fn get_supported_cryptogram_material_package_formats(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_SupportedCryptogramMaterialPackageFormats)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn get_max_value(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_MaxValue)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } + #[inline] pub fn get_supported_cryptogram_material_package_confirmation_response_formats(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_SupportedCryptogramMaterialPackageConfirmationResponseFormats)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn get_channel_mode(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_ChannelMode)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } + #[inline] pub fn get_supported_smart_card_cryptogram_storage_key_capabilities(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_SupportedSmartCardCryptogramStorageKeyCapabilities)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn set_channel_mode(&self, value: AdcChannelMode) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_ChannelMode)(self as *const _ as *mut _, value); - if hr == S_OK { Ok(()) } else { err(hr) } + #[inline] pub fn delete_cryptogram_material_storage_key_async(&self, storageKeyName: &HStringArg) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).DeleteCryptogramMaterialStorageKeyAsync)(self as *const _ as *mut _, storageKeyName.get(), &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn is_channel_mode_supported(&self, channelMode: AdcChannelMode) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).IsChannelModeSupported)(self as *const _ as *mut _, channelMode, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } + #[inline] pub fn create_cryptogram_material_storage_key_async(&self, promptingBehavior: SmartCardUnlockPromptingBehavior, storageKeyName: &HStringArg, algorithm: SmartCardCryptogramStorageKeyAlgorithm, capabilities: SmartCardCryptogramStorageKeyCapabilities) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreateCryptogramMaterialStorageKeyAsync)(self as *const _ as *mut _, promptingBehavior, storageKeyName.get(), algorithm, capabilities, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn open_channel(&self, channelNumber: i32) -> Result>> { unsafe { + #[cfg(feature="windows-security")] #[inline] pub fn request_cryptogram_material_storage_key_info_async(&self, promptingBehavior: SmartCardUnlockPromptingBehavior, storageKeyName: &HStringArg, format: super::super::security::cryptography::core::CryptographicPublicKeyBlobType) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).OpenChannel)(self as *const _ as *mut _, channelNumber, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).RequestCryptogramMaterialStorageKeyInfoAsync)(self as *const _ as *mut _, promptingBehavior, storageKeyName.get(), format, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[cfg(feature="windows-storage")] #[inline] pub fn import_cryptogram_material_package_async(&self, format: SmartCardCryptogramMaterialPackageFormat, storageKeyName: &HStringArg, materialPackageName: &HStringArg, cryptogramMaterialPackage: &super::super::storage::streams::IBuffer) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).ImportCryptogramMaterialPackageAsync)(self as *const _ as *mut _, format, storageKeyName.get(), materialPackageName.get(), cryptogramMaterialPackage as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[cfg(feature="windows-storage")] #[inline] pub fn try_prove_possession_of_cryptogram_material_package_async(&self, promptingBehavior: SmartCardUnlockPromptingBehavior, responseFormat: SmartCardCryptogramMaterialPackageConfirmationResponseFormat, materialPackageName: &HStringArg, materialName: &HStringArg, challenge: &super::super::storage::streams::IBuffer) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).TryProvePossessionOfCryptogramMaterialPackageAsync)(self as *const _ as *mut _, promptingBehavior, responseFormat, materialPackageName.get(), materialName.get(), challenge as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn request_unlock_cryptogram_material_for_use_async(&self, promptingBehavior: SmartCardUnlockPromptingBehavior) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).RequestUnlockCryptogramMaterialForUseAsync)(self as *const _ as *mut _, promptingBehavior, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn delete_cryptogram_material_package_async(&self, materialPackageName: &HStringArg) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).DeleteCryptogramMaterialPackageAsync)(self as *const _ as *mut _, materialPackageName.get(), &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } -RT_CLASS!{class AdcController: IAdcController} -impl RtActivatable for AdcController {} -impl RtActivatable for AdcController {} -impl AdcController { - #[inline] pub fn get_controllers_async(provider: &provider::IAdcProvider) -> Result>>> { - >::get_activation_factory().get_controllers_async(provider) +RT_CLASS!{class SmartCardCryptogramGenerator: ISmartCardCryptogramGenerator} +impl RtActivatable for SmartCardCryptogramGenerator {} +impl RtActivatable for SmartCardCryptogramGenerator {} +impl SmartCardCryptogramGenerator { + #[inline] pub fn get_smart_card_cryptogram_generator_async() -> Result>> { + >::get_activation_factory().get_smart_card_cryptogram_generator_async() } - #[inline] pub fn get_default_async() -> Result>> { - >::get_activation_factory().get_default_async() + #[inline] pub fn is_supported() -> Result { + >::get_activation_factory().is_supported() } } -DEFINE_CLSID!(AdcController(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,65,100,99,46,65,100,99,67,111,110,116,114,111,108,108,101,114,0]) [CLSID_AdcController]); -DEFINE_IID!(IID_IAdcControllerStatics, 3437858316, 504, 18577, 188, 59, 190, 83, 239, 39, 156, 164); -RT_INTERFACE!{static interface IAdcControllerStatics(IAdcControllerStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IAdcControllerStatics] { - fn GetControllersAsync(&self, provider: *mut provider::IAdcProvider, out: *mut *mut foundation::IAsyncOperation>) -> HRESULT +DEFINE_CLSID!(SmartCardCryptogramGenerator(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,83,109,97,114,116,67,97,114,100,115,46,83,109,97,114,116,67,97,114,100,67,114,121,112,116,111,103,114,97,109,71,101,110,101,114,97,116,111,114,0]) [CLSID_SmartCardCryptogramGenerator]); +DEFINE_IID!(IID_ISmartCardCryptogramGenerator2, 1897310772, 23917, 19274, 150, 163, 239, 164, 125, 42, 126, 37); +RT_INTERFACE!{interface ISmartCardCryptogramGenerator2(ISmartCardCryptogramGenerator2Vtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardCryptogramGenerator2] { + #[cfg(not(feature="windows-storage"))] fn __Dummy0(&self) -> (), + #[cfg(feature="windows-storage")] fn ValidateRequestApduAsync(&self, promptingBehavior: SmartCardUnlockPromptingBehavior, apduToValidate: *mut super::super::storage::streams::IBuffer, cryptogramPlacementSteps: *mut foundation::collections::IIterable, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn GetAllCryptogramStorageKeyCharacteristicsAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn GetAllCryptogramMaterialPackageCharacteristicsAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn GetAllCryptogramMaterialPackageCharacteristicsWithStorageKeyAsync(&self, storageKeyName: HSTRING, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn GetAllCryptogramMaterialCharacteristicsAsync(&self, promptingBehavior: SmartCardUnlockPromptingBehavior, materialPackageName: HSTRING, out: *mut *mut foundation::IAsyncOperation) -> HRESULT }} -impl IAdcControllerStatics { - #[inline] pub fn get_controllers_async(&self, provider: &provider::IAdcProvider) -> Result>>> { unsafe { +impl ISmartCardCryptogramGenerator2 { + #[cfg(feature="windows-storage")] #[inline] pub fn validate_request_apdu_async(&self, promptingBehavior: SmartCardUnlockPromptingBehavior, apduToValidate: &super::super::storage::streams::IBuffer, cryptogramPlacementSteps: &foundation::collections::IIterable) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetControllersAsync)(self as *const _ as *mut _, provider as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).ValidateRequestApduAsync)(self as *const _ as *mut _, promptingBehavior, apduToValidate as *const _ as *mut _, cryptogramPlacementSteps as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} -} -DEFINE_IID!(IID_IAdcControllerStatics2, 2730048285, 38779, 20314, 165, 254, 166, 171, 175, 254, 100, 132); -RT_INTERFACE!{static interface IAdcControllerStatics2(IAdcControllerStatics2Vtbl): IInspectable(IInspectableVtbl) [IID_IAdcControllerStatics2] { - fn GetDefaultAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT -}} -impl IAdcControllerStatics2 { - #[inline] pub fn get_default_async(&self) -> Result>> { unsafe { + #[inline] pub fn get_all_cryptogram_storage_key_characteristics_async(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetDefaultAsync)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).GetAllCryptogramStorageKeyCharacteristicsAsync)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} -} -pub mod provider { // Windows.Devices.Adc.Provider -use ::prelude::*; -DEFINE_IID!(IID_IAdcControllerProvider, 3193198632, 33133, 19941, 160, 72, 171, 160, 105, 88, 170, 168); -RT_INTERFACE!{interface IAdcControllerProvider(IAdcControllerProviderVtbl): IInspectable(IInspectableVtbl) [IID_IAdcControllerProvider] { - fn get_ChannelCount(&self, out: *mut i32) -> HRESULT, - fn get_ResolutionInBits(&self, out: *mut i32) -> HRESULT, - fn get_MinValue(&self, out: *mut i32) -> HRESULT, - fn get_MaxValue(&self, out: *mut i32) -> HRESULT, - fn get_ChannelMode(&self, out: *mut ProviderAdcChannelMode) -> HRESULT, - fn put_ChannelMode(&self, value: ProviderAdcChannelMode) -> HRESULT, - fn IsChannelModeSupported(&self, channelMode: ProviderAdcChannelMode, out: *mut bool) -> HRESULT, - fn AcquireChannel(&self, channel: i32) -> HRESULT, - fn ReleaseChannel(&self, channel: i32) -> HRESULT, - fn ReadValue(&self, channelNumber: i32, out: *mut i32) -> HRESULT -}} -impl IAdcControllerProvider { - #[inline] pub fn get_channel_count(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_ChannelCount)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } + #[inline] pub fn get_all_cryptogram_material_package_characteristics_async(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetAllCryptogramMaterialPackageCharacteristicsAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_resolution_in_bits(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_ResolutionInBits)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } + #[inline] pub fn get_all_cryptogram_material_package_characteristics_with_storage_key_async(&self, storageKeyName: &HStringArg) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetAllCryptogramMaterialPackageCharacteristicsWithStorageKeyAsync)(self as *const _ as *mut _, storageKeyName.get(), &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_min_value(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_MinValue)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } + #[inline] pub fn get_all_cryptogram_material_characteristics_async(&self, promptingBehavior: SmartCardUnlockPromptingBehavior, materialPackageName: &HStringArg) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetAllCryptogramMaterialCharacteristicsAsync)(self as *const _ as *mut _, promptingBehavior, materialPackageName.get(), &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_max_value(&self) -> Result { unsafe { +} +RT_ENUM! { enum SmartCardCryptogramGeneratorOperationStatus: i32 { + Success (SmartCardCryptogramGeneratorOperationStatus_Success) = 0, AuthorizationFailed (SmartCardCryptogramGeneratorOperationStatus_AuthorizationFailed) = 1, AuthorizationCanceled (SmartCardCryptogramGeneratorOperationStatus_AuthorizationCanceled) = 2, AuthorizationRequired (SmartCardCryptogramGeneratorOperationStatus_AuthorizationRequired) = 3, CryptogramMaterialPackageStorageKeyExists (SmartCardCryptogramGeneratorOperationStatus_CryptogramMaterialPackageStorageKeyExists) = 4, NoCryptogramMaterialPackageStorageKey (SmartCardCryptogramGeneratorOperationStatus_NoCryptogramMaterialPackageStorageKey) = 5, NoCryptogramMaterialPackage (SmartCardCryptogramGeneratorOperationStatus_NoCryptogramMaterialPackage) = 6, UnsupportedCryptogramMaterialPackage (SmartCardCryptogramGeneratorOperationStatus_UnsupportedCryptogramMaterialPackage) = 7, UnknownCryptogramMaterialName (SmartCardCryptogramGeneratorOperationStatus_UnknownCryptogramMaterialName) = 8, InvalidCryptogramMaterialUsage (SmartCardCryptogramGeneratorOperationStatus_InvalidCryptogramMaterialUsage) = 9, ApduResponseNotSent (SmartCardCryptogramGeneratorOperationStatus_ApduResponseNotSent) = 10, OtherError (SmartCardCryptogramGeneratorOperationStatus_OtherError) = 11, ValidationFailed (SmartCardCryptogramGeneratorOperationStatus_ValidationFailed) = 12, NotSupported (SmartCardCryptogramGeneratorOperationStatus_NotSupported) = 13, +}} +DEFINE_IID!(IID_ISmartCardCryptogramGeneratorStatics, 160643344, 52124, 16405, 150, 125, 82, 52, 243, 176, 41, 0); +RT_INTERFACE!{static interface ISmartCardCryptogramGeneratorStatics(ISmartCardCryptogramGeneratorStaticsVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardCryptogramGeneratorStatics] { + fn GetSmartCardCryptogramGeneratorAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT +}} +impl ISmartCardCryptogramGeneratorStatics { + #[inline] pub fn get_smart_card_cryptogram_generator_async(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetSmartCardCryptogramGeneratorAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} +} +DEFINE_IID!(IID_ISmartCardCryptogramGeneratorStatics2, 163444197, 46269, 20003, 165, 136, 116, 70, 146, 4, 193, 40); +RT_INTERFACE!{static interface ISmartCardCryptogramGeneratorStatics2(ISmartCardCryptogramGeneratorStatics2Vtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardCryptogramGeneratorStatics2] { + fn IsSupported(&self, out: *mut bool) -> HRESULT +}} +impl ISmartCardCryptogramGeneratorStatics2 { + #[inline] pub fn is_supported(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_MaxValue)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).IsSupported)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_channel_mode(&self) -> Result { unsafe { +} +DEFINE_IID!(IID_ISmartCardCryptogramGetAllCryptogramMaterialCharacteristicsResult, 664330281, 54919, 19602, 134, 198, 57, 158, 154, 14, 203, 9); +RT_INTERFACE!{interface ISmartCardCryptogramGetAllCryptogramMaterialCharacteristicsResult(ISmartCardCryptogramGetAllCryptogramMaterialCharacteristicsResultVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardCryptogramGetAllCryptogramMaterialCharacteristicsResult] { + fn get_OperationStatus(&self, out: *mut SmartCardCryptogramGeneratorOperationStatus) -> HRESULT, + fn get_Characteristics(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT +}} +impl ISmartCardCryptogramGetAllCryptogramMaterialCharacteristicsResult { + #[inline] pub fn get_operation_status(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_ChannelMode)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_OperationStatus)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn set_channel_mode(&self, value: ProviderAdcChannelMode) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_ChannelMode)(self as *const _ as *mut _, value); - if hr == S_OK { Ok(()) } else { err(hr) } + #[inline] pub fn get_characteristics(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Characteristics)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn is_channel_mode_supported(&self, channelMode: ProviderAdcChannelMode) -> Result { unsafe { +} +RT_CLASS!{class SmartCardCryptogramGetAllCryptogramMaterialCharacteristicsResult: ISmartCardCryptogramGetAllCryptogramMaterialCharacteristicsResult} +impl RtActivatable for SmartCardCryptogramGetAllCryptogramMaterialCharacteristicsResult {} +DEFINE_CLSID!(SmartCardCryptogramGetAllCryptogramMaterialCharacteristicsResult(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,83,109,97,114,116,67,97,114,100,115,46,83,109,97,114,116,67,97,114,100,67,114,121,112,116,111,103,114,97,109,71,101,116,65,108,108,67,114,121,112,116,111,103,114,97,109,77,97,116,101,114,105,97,108,67,104,97,114,97,99,116,101,114,105,115,116,105,99,115,82,101,115,117,108,116,0]) [CLSID_SmartCardCryptogramGetAllCryptogramMaterialCharacteristicsResult]); +DEFINE_IID!(IID_ISmartCardCryptogramGetAllCryptogramMaterialPackageCharacteristicsResult, 1315605084, 38771, 18116, 163, 47, 177, 229, 67, 21, 158, 4); +RT_INTERFACE!{interface ISmartCardCryptogramGetAllCryptogramMaterialPackageCharacteristicsResult(ISmartCardCryptogramGetAllCryptogramMaterialPackageCharacteristicsResultVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardCryptogramGetAllCryptogramMaterialPackageCharacteristicsResult] { + fn get_OperationStatus(&self, out: *mut SmartCardCryptogramGeneratorOperationStatus) -> HRESULT, + fn get_Characteristics(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT +}} +impl ISmartCardCryptogramGetAllCryptogramMaterialPackageCharacteristicsResult { + #[inline] pub fn get_operation_status(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).IsChannelModeSupported)(self as *const _ as *mut _, channelMode, &mut out); + let hr = ((*self.lpVtbl).get_OperationStatus)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn acquire_channel(&self, channel: i32) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).AcquireChannel)(self as *const _ as *mut _, channel); - if hr == S_OK { Ok(()) } else { err(hr) } - }} - #[inline] pub fn release_channel(&self, channel: i32) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).ReleaseChannel)(self as *const _ as *mut _, channel); - if hr == S_OK { Ok(()) } else { err(hr) } + #[inline] pub fn get_characteristics(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Characteristics)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn read_value(&self, channelNumber: i32) -> Result { unsafe { +} +RT_CLASS!{class SmartCardCryptogramGetAllCryptogramMaterialPackageCharacteristicsResult: ISmartCardCryptogramGetAllCryptogramMaterialPackageCharacteristicsResult} +impl RtActivatable for SmartCardCryptogramGetAllCryptogramMaterialPackageCharacteristicsResult {} +DEFINE_CLSID!(SmartCardCryptogramGetAllCryptogramMaterialPackageCharacteristicsResult(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,83,109,97,114,116,67,97,114,100,115,46,83,109,97,114,116,67,97,114,100,67,114,121,112,116,111,103,114,97,109,71,101,116,65,108,108,67,114,121,112,116,111,103,114,97,109,77,97,116,101,114,105,97,108,80,97,99,107,97,103,101,67,104,97,114,97,99,116,101,114,105,115,116,105,99,115,82,101,115,117,108,116,0]) [CLSID_SmartCardCryptogramGetAllCryptogramMaterialPackageCharacteristicsResult]); +DEFINE_IID!(IID_ISmartCardCryptogramGetAllCryptogramStorageKeyCharacteristicsResult, 2356996183, 42983, 18589, 185, 214, 54, 128, 97, 81, 80, 18); +RT_INTERFACE!{interface ISmartCardCryptogramGetAllCryptogramStorageKeyCharacteristicsResult(ISmartCardCryptogramGetAllCryptogramStorageKeyCharacteristicsResultVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardCryptogramGetAllCryptogramStorageKeyCharacteristicsResult] { + fn get_OperationStatus(&self, out: *mut SmartCardCryptogramGeneratorOperationStatus) -> HRESULT, + fn get_Characteristics(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT +}} +impl ISmartCardCryptogramGetAllCryptogramStorageKeyCharacteristicsResult { + #[inline] pub fn get_operation_status(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).ReadValue)(self as *const _ as *mut _, channelNumber, &mut out); + let hr = ((*self.lpVtbl).get_OperationStatus)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} -} -DEFINE_IID!(IID_IAdcProvider, 680867432, 37721, 19543, 188, 136, 226, 117, 232, 22, 56, 201); -RT_INTERFACE!{interface IAdcProvider(IAdcProviderVtbl): IInspectable(IInspectableVtbl) [IID_IAdcProvider] { - fn GetControllers(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT -}} -impl IAdcProvider { - #[inline] pub fn get_controllers(&self) -> Result>>> { unsafe { + #[inline] pub fn get_characteristics(&self) -> Result>>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetControllers)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_Characteristics)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } -RT_ENUM! { enum ProviderAdcChannelMode: i32 { - SingleEnded (ProviderAdcChannelMode_SingleEnded) = 0, Differential (ProviderAdcChannelMode_Differential) = 1, -}} -} // Windows.Devices.Adc.Provider -} // Windows.Devices.Adc -pub mod gpio { // Windows.Devices.Gpio -use ::prelude::*; -RT_STRUCT! { struct GpioChangeCount { - Count: u64, RelativeTime: foundation::TimeSpan, -}} -DEFINE_IID!(IID_IGpioChangeCounter, 3411984606, 26625, 17407, 128, 61, 69, 118, 98, 138, 139, 38); -RT_INTERFACE!{interface IGpioChangeCounter(IGpioChangeCounterVtbl): IInspectable(IInspectableVtbl) [IID_IGpioChangeCounter] { - fn put_Polarity(&self, value: GpioChangePolarity) -> HRESULT, - fn get_Polarity(&self, out: *mut GpioChangePolarity) -> HRESULT, - fn get_IsStarted(&self, out: *mut bool) -> HRESULT, - fn Start(&self) -> HRESULT, - fn Stop(&self) -> HRESULT, - fn Read(&self, out: *mut GpioChangeCount) -> HRESULT, - fn Reset(&self, out: *mut GpioChangeCount) -> HRESULT +RT_CLASS!{class SmartCardCryptogramGetAllCryptogramStorageKeyCharacteristicsResult: ISmartCardCryptogramGetAllCryptogramStorageKeyCharacteristicsResult} +impl RtActivatable for SmartCardCryptogramGetAllCryptogramStorageKeyCharacteristicsResult {} +DEFINE_CLSID!(SmartCardCryptogramGetAllCryptogramStorageKeyCharacteristicsResult(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,83,109,97,114,116,67,97,114,100,115,46,83,109,97,114,116,67,97,114,100,67,114,121,112,116,111,103,114,97,109,71,101,116,65,108,108,67,114,121,112,116,111,103,114,97,109,83,116,111,114,97,103,101,75,101,121,67,104,97,114,97,99,116,101,114,105,115,116,105,99,115,82,101,115,117,108,116,0]) [CLSID_SmartCardCryptogramGetAllCryptogramStorageKeyCharacteristicsResult]); +DEFINE_IID!(IID_ISmartCardCryptogramMaterialCharacteristics, 4238001612, 49623, 16723, 146, 59, 162, 212, 60, 108, 141, 73); +RT_INTERFACE!{interface ISmartCardCryptogramMaterialCharacteristics(ISmartCardCryptogramMaterialCharacteristicsVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardCryptogramMaterialCharacteristics] { + fn get_MaterialName(&self, out: *mut HSTRING) -> HRESULT, + fn get_AllowedAlgorithms(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT, + fn get_AllowedProofOfPossessionAlgorithms(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT, + fn get_AllowedValidations(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT, + fn get_MaterialType(&self, out: *mut SmartCardCryptogramMaterialType) -> HRESULT, + fn get_ProtectionMethod(&self, out: *mut SmartCardCryptogramMaterialProtectionMethod) -> HRESULT, + fn get_ProtectionVersion(&self, out: *mut i32) -> HRESULT, + fn get_MaterialLength(&self, out: *mut i32) -> HRESULT }} -impl IGpioChangeCounter { - #[inline] pub fn set_polarity(&self, value: GpioChangePolarity) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_Polarity)(self as *const _ as *mut _, value); - if hr == S_OK { Ok(()) } else { err(hr) } +impl ISmartCardCryptogramMaterialCharacteristics { + #[inline] pub fn get_material_name(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_MaterialName)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_polarity(&self) -> Result { unsafe { + #[inline] pub fn get_allowed_algorithms(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_AllowedAlgorithms)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_allowed_proof_of_possession_algorithms(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_AllowedProofOfPossessionAlgorithms)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_allowed_validations(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_AllowedValidations)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_material_type(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_Polarity)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_MaterialType)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_is_started(&self) -> Result { unsafe { + #[inline] pub fn get_protection_method(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_IsStarted)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_ProtectionMethod)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn start(&self) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).Start)(self as *const _ as *mut _); - if hr == S_OK { Ok(()) } else { err(hr) } - }} - #[inline] pub fn stop(&self) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).Stop)(self as *const _ as *mut _); - if hr == S_OK { Ok(()) } else { err(hr) } - }} - #[inline] pub fn read(&self) -> Result { unsafe { + #[inline] pub fn get_protection_version(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).Read)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_ProtectionVersion)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn reset(&self) -> Result { unsafe { + #[inline] pub fn get_material_length(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).Reset)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_MaterialLength)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} } -RT_CLASS!{class GpioChangeCounter: IGpioChangeCounter} -impl RtActivatable for GpioChangeCounter {} -impl GpioChangeCounter { - #[inline] pub fn create(pin: &GpioPin) -> Result> { - >::get_activation_factory().create(pin) - } -} -DEFINE_CLSID!(GpioChangeCounter(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,71,112,105,111,46,71,112,105,111,67,104,97,110,103,101,67,111,117,110,116,101,114,0]) [CLSID_GpioChangeCounter]); -DEFINE_IID!(IID_IGpioChangeCounterFactory, 343774390, 2718, 16652, 180, 250, 248, 159, 64, 82, 8, 77); -RT_INTERFACE!{static interface IGpioChangeCounterFactory(IGpioChangeCounterFactoryVtbl): IInspectable(IInspectableVtbl) [IID_IGpioChangeCounterFactory] { - fn Create(&self, pin: *mut GpioPin, out: *mut *mut GpioChangeCounter) -> HRESULT +RT_CLASS!{class SmartCardCryptogramMaterialCharacteristics: ISmartCardCryptogramMaterialCharacteristics} +impl RtActivatable for SmartCardCryptogramMaterialCharacteristics {} +DEFINE_CLSID!(SmartCardCryptogramMaterialCharacteristics(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,83,109,97,114,116,67,97,114,100,115,46,83,109,97,114,116,67,97,114,100,67,114,121,112,116,111,103,114,97,109,77,97,116,101,114,105,97,108,67,104,97,114,97,99,116,101,114,105,115,116,105,99,115,0]) [CLSID_SmartCardCryptogramMaterialCharacteristics]); +DEFINE_IID!(IID_ISmartCardCryptogramMaterialPackageCharacteristics, 4290088479, 1682, 19527, 147, 207, 52, 217, 31, 157, 205, 0); +RT_INTERFACE!{interface ISmartCardCryptogramMaterialPackageCharacteristics(ISmartCardCryptogramMaterialPackageCharacteristicsVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardCryptogramMaterialPackageCharacteristics] { + fn get_PackageName(&self, out: *mut HSTRING) -> HRESULT, + fn get_StorageKeyName(&self, out: *mut HSTRING) -> HRESULT, + fn get_DateImported(&self, out: *mut foundation::DateTime) -> HRESULT, + fn get_PackageFormat(&self, out: *mut SmartCardCryptogramMaterialPackageFormat) -> HRESULT }} -impl IGpioChangeCounterFactory { - #[inline] pub fn create(&self, pin: &GpioPin) -> Result> { unsafe { +impl ISmartCardCryptogramMaterialPackageCharacteristics { + #[inline] pub fn get_package_name(&self) -> Result { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, pin as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).get_PackageName)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_storage_key_name(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_StorageKeyName)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_date_imported(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_DateImported)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_package_format(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_PackageFormat)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} } -RT_ENUM! { enum GpioChangePolarity: i32 { - Falling (GpioChangePolarity_Falling) = 0, Rising (GpioChangePolarity_Rising) = 1, Both (GpioChangePolarity_Both) = 2, -}} -DEFINE_IID!(IID_IGpioChangeReader, 180127839, 57393, 18664, 133, 144, 112, 222, 120, 54, 60, 109); -RT_INTERFACE!{interface IGpioChangeReader(IGpioChangeReaderVtbl): IInspectable(IInspectableVtbl) [IID_IGpioChangeReader] { - fn get_Capacity(&self, out: *mut i32) -> HRESULT, - fn get_Length(&self, out: *mut i32) -> HRESULT, - fn get_IsEmpty(&self, out: *mut bool) -> HRESULT, - fn get_IsOverflowed(&self, out: *mut bool) -> HRESULT, - fn put_Polarity(&self, value: GpioChangePolarity) -> HRESULT, - fn get_Polarity(&self, out: *mut GpioChangePolarity) -> HRESULT, - fn get_IsStarted(&self, out: *mut bool) -> HRESULT, - fn Start(&self) -> HRESULT, - fn Stop(&self) -> HRESULT, - fn Clear(&self) -> HRESULT, - fn GetNextItem(&self, out: *mut GpioChangeRecord) -> HRESULT, - fn PeekNextItem(&self, out: *mut GpioChangeRecord) -> HRESULT, - fn GetAllItems(&self, out: *mut *mut foundation::collections::IVector) -> HRESULT, - fn WaitForItemsAsync(&self, count: i32, out: *mut *mut foundation::IAsyncAction) -> HRESULT +RT_CLASS!{class SmartCardCryptogramMaterialPackageCharacteristics: ISmartCardCryptogramMaterialPackageCharacteristics} +impl RtActivatable for SmartCardCryptogramMaterialPackageCharacteristics {} +DEFINE_CLSID!(SmartCardCryptogramMaterialPackageCharacteristics(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,83,109,97,114,116,67,97,114,100,115,46,83,109,97,114,116,67,97,114,100,67,114,121,112,116,111,103,114,97,109,77,97,116,101,114,105,97,108,80,97,99,107,97,103,101,67,104,97,114,97,99,116,101,114,105,115,116,105,99,115,0]) [CLSID_SmartCardCryptogramMaterialPackageCharacteristics]); +RT_ENUM! { enum SmartCardCryptogramMaterialPackageConfirmationResponseFormat: i32 { + None (SmartCardCryptogramMaterialPackageConfirmationResponseFormat_None) = 0, VisaHmac (SmartCardCryptogramMaterialPackageConfirmationResponseFormat_VisaHmac) = 1, }} -impl IGpioChangeReader { - #[inline] pub fn get_capacity(&self) -> Result { unsafe { +RT_ENUM! { enum SmartCardCryptogramMaterialPackageFormat: i32 { + None (SmartCardCryptogramMaterialPackageFormat_None) = 0, JweRsaPki (SmartCardCryptogramMaterialPackageFormat_JweRsaPki) = 1, +}} +DEFINE_IID!(IID_ISmartCardCryptogramMaterialPossessionProof, 3854150540, 41281, 16693, 154, 221, 176, 210, 227, 170, 31, 201); +RT_INTERFACE!{interface ISmartCardCryptogramMaterialPossessionProof(ISmartCardCryptogramMaterialPossessionProofVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardCryptogramMaterialPossessionProof] { + fn get_OperationStatus(&self, out: *mut SmartCardCryptogramGeneratorOperationStatus) -> HRESULT, + #[cfg(feature="windows-storage")] fn get_Proof(&self, out: *mut *mut super::super::storage::streams::IBuffer) -> HRESULT +}} +impl ISmartCardCryptogramMaterialPossessionProof { + #[inline] pub fn get_operation_status(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_Capacity)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_OperationStatus)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_length(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_Length)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } + #[cfg(feature="windows-storage")] #[inline] pub fn get_proof(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Proof)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn get_is_empty(&self) -> Result { unsafe { +} +RT_CLASS!{class SmartCardCryptogramMaterialPossessionProof: ISmartCardCryptogramMaterialPossessionProof} +RT_ENUM! { enum SmartCardCryptogramMaterialProtectionMethod: i32 { + None (SmartCardCryptogramMaterialProtectionMethod_None) = 0, WhiteBoxing (SmartCardCryptogramMaterialProtectionMethod_WhiteBoxing) = 1, +}} +RT_ENUM! { enum SmartCardCryptogramMaterialType: i32 { + None (SmartCardCryptogramMaterialType_None) = 0, StaticDataAuthentication (SmartCardCryptogramMaterialType_StaticDataAuthentication) = 1, TripleDes112 (SmartCardCryptogramMaterialType_TripleDes112) = 2, Aes (SmartCardCryptogramMaterialType_Aes) = 3, RsaPkcs1 (SmartCardCryptogramMaterialType_RsaPkcs1) = 4, +}} +RT_ENUM! { enum SmartCardCryptogramPlacementOptions: u32 { + None (SmartCardCryptogramPlacementOptions_None) = 0, UnitsAreInNibbles (SmartCardCryptogramPlacementOptions_UnitsAreInNibbles) = 1, ChainOutput (SmartCardCryptogramPlacementOptions_ChainOutput) = 2, +}} +DEFINE_IID!(IID_ISmartCardCryptogramPlacementStep, 2491089899, 33602, 18322, 162, 229, 146, 86, 54, 55, 138, 83); +RT_INTERFACE!{interface ISmartCardCryptogramPlacementStep(ISmartCardCryptogramPlacementStepVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardCryptogramPlacementStep] { + fn get_Algorithm(&self, out: *mut SmartCardCryptogramAlgorithm) -> HRESULT, + fn put_Algorithm(&self, value: SmartCardCryptogramAlgorithm) -> HRESULT, + #[cfg(not(feature="windows-storage"))] fn __Dummy2(&self) -> (), + #[cfg(feature="windows-storage")] fn get_SourceData(&self, out: *mut *mut super::super::storage::streams::IBuffer) -> HRESULT, + #[cfg(not(feature="windows-storage"))] fn __Dummy3(&self) -> (), + #[cfg(feature="windows-storage")] fn put_SourceData(&self, value: *mut super::super::storage::streams::IBuffer) -> HRESULT, + fn get_CryptogramMaterialPackageName(&self, out: *mut HSTRING) -> HRESULT, + fn put_CryptogramMaterialPackageName(&self, value: HSTRING) -> HRESULT, + fn get_CryptogramMaterialName(&self, out: *mut HSTRING) -> HRESULT, + fn put_CryptogramMaterialName(&self, value: HSTRING) -> HRESULT, + fn get_TemplateOffset(&self, out: *mut i32) -> HRESULT, + fn put_TemplateOffset(&self, value: i32) -> HRESULT, + fn get_CryptogramOffset(&self, out: *mut i32) -> HRESULT, + fn put_CryptogramOffset(&self, value: i32) -> HRESULT, + fn get_CryptogramLength(&self, out: *mut i32) -> HRESULT, + fn put_CryptogramLength(&self, value: i32) -> HRESULT, + fn get_CryptogramPlacementOptions(&self, out: *mut SmartCardCryptogramPlacementOptions) -> HRESULT, + fn put_CryptogramPlacementOptions(&self, value: SmartCardCryptogramPlacementOptions) -> HRESULT, + fn get_ChainedOutputStep(&self, out: *mut *mut SmartCardCryptogramPlacementStep) -> HRESULT, + fn put_ChainedOutputStep(&self, value: *mut SmartCardCryptogramPlacementStep) -> HRESULT +}} +impl ISmartCardCryptogramPlacementStep { + #[inline] pub fn get_algorithm(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_IsEmpty)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_Algorithm)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_is_overflowed(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_IsOverflowed)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } + #[inline] pub fn set_algorithm(&self, value: SmartCardCryptogramAlgorithm) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Algorithm)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn set_polarity(&self, value: GpioChangePolarity) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_Polarity)(self as *const _ as *mut _, value); + #[cfg(feature="windows-storage")] #[inline] pub fn get_source_data(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_SourceData)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[cfg(feature="windows-storage")] #[inline] pub fn set_source_data(&self, value: &super::super::storage::streams::IBuffer) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_SourceData)(self as *const _ as *mut _, value as *const _ as *mut _); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_polarity(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_Polarity)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } + #[inline] pub fn get_cryptogram_material_package_name(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_CryptogramMaterialPackageName)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_is_started(&self) -> Result { unsafe { + #[inline] pub fn set_cryptogram_material_package_name(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_CryptogramMaterialPackageName)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_cryptogram_material_name(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_CryptogramMaterialName)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn set_cryptogram_material_name(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_CryptogramMaterialName)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_template_offset(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_IsStarted)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_TemplateOffset)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn start(&self) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).Start)(self as *const _ as *mut _); + #[inline] pub fn set_template_offset(&self, value: i32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_TemplateOffset)(self as *const _ as *mut _, value); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn stop(&self) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).Stop)(self as *const _ as *mut _); - if hr == S_OK { Ok(()) } else { err(hr) } + #[inline] pub fn get_cryptogram_offset(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_CryptogramOffset)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn clear(&self) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).Clear)(self as *const _ as *mut _); + #[inline] pub fn set_cryptogram_offset(&self, value: i32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_CryptogramOffset)(self as *const _ as *mut _, value); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_next_item(&self) -> Result { unsafe { + #[inline] pub fn get_cryptogram_length(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).GetNextItem)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_CryptogramLength)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn peek_next_item(&self) -> Result { unsafe { + #[inline] pub fn set_cryptogram_length(&self, value: i32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_CryptogramLength)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_cryptogram_placement_options(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).PeekNextItem)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_CryptogramPlacementOptions)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_all_items(&self) -> Result>>> { unsafe { + #[inline] pub fn set_cryptogram_placement_options(&self, value: SmartCardCryptogramPlacementOptions) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_CryptogramPlacementOptions)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_chained_output_step(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetAllItems)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_ChainedOutputStep)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn wait_for_items_async(&self, count: i32) -> Result> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).WaitForItemsAsync)(self as *const _ as *mut _, count, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + #[inline] pub fn set_chained_output_step(&self, value: &SmartCardCryptogramPlacementStep) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_ChainedOutputStep)(self as *const _ as *mut _, value as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } }} } -RT_CLASS!{class GpioChangeReader: IGpioChangeReader} -impl RtActivatable for GpioChangeReader {} -impl GpioChangeReader { - #[inline] pub fn create(pin: &GpioPin) -> Result> { - >::get_activation_factory().create(pin) - } - #[inline] pub fn create_with_capacity(pin: &GpioPin, minCapacity: i32) -> Result> { - >::get_activation_factory().create_with_capacity(pin, minCapacity) - } -} -DEFINE_CLSID!(GpioChangeReader(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,71,112,105,111,46,71,112,105,111,67,104,97,110,103,101,82,101,97,100,101,114,0]) [CLSID_GpioChangeReader]); -DEFINE_IID!(IID_IGpioChangeReaderFactory, 2841218803, 14606, 17434, 157, 28, 232, 222, 11, 45, 240, 223); -RT_INTERFACE!{static interface IGpioChangeReaderFactory(IGpioChangeReaderFactoryVtbl): IInspectable(IInspectableVtbl) [IID_IGpioChangeReaderFactory] { - fn Create(&self, pin: *mut GpioPin, out: *mut *mut GpioChangeReader) -> HRESULT, - fn CreateWithCapacity(&self, pin: *mut GpioPin, minCapacity: i32, out: *mut *mut GpioChangeReader) -> HRESULT +RT_CLASS!{class SmartCardCryptogramPlacementStep: ISmartCardCryptogramPlacementStep} +impl RtActivatable for SmartCardCryptogramPlacementStep {} +DEFINE_CLSID!(SmartCardCryptogramPlacementStep(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,83,109,97,114,116,67,97,114,100,115,46,83,109,97,114,116,67,97,114,100,67,114,121,112,116,111,103,114,97,109,80,108,97,99,101,109,101,110,116,83,116,101,112,0]) [CLSID_SmartCardCryptogramPlacementStep]); +RT_ENUM! { enum SmartCardCryptogramStorageKeyAlgorithm: i32 { + None (SmartCardCryptogramStorageKeyAlgorithm_None) = 0, Rsa2048 (SmartCardCryptogramStorageKeyAlgorithm_Rsa2048) = 1, }} -impl IGpioChangeReaderFactory { - #[inline] pub fn create(&self, pin: &GpioPin) -> Result> { unsafe { +RT_ENUM! { enum SmartCardCryptogramStorageKeyCapabilities: u32 { + None (SmartCardCryptogramStorageKeyCapabilities_None) = 0, HardwareProtection (SmartCardCryptogramStorageKeyCapabilities_HardwareProtection) = 1, UnlockPrompt (SmartCardCryptogramStorageKeyCapabilities_UnlockPrompt) = 2, +}} +DEFINE_IID!(IID_ISmartCardCryptogramStorageKeyCharacteristics, 2236765294, 17495, 18469, 180, 100, 99, 84, 113, 163, 159, 92); +RT_INTERFACE!{interface ISmartCardCryptogramStorageKeyCharacteristics(ISmartCardCryptogramStorageKeyCharacteristicsVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardCryptogramStorageKeyCharacteristics] { + fn get_StorageKeyName(&self, out: *mut HSTRING) -> HRESULT, + fn get_DateCreated(&self, out: *mut foundation::DateTime) -> HRESULT, + fn get_Algorithm(&self, out: *mut SmartCardCryptogramStorageKeyAlgorithm) -> HRESULT, + fn get_Capabilities(&self, out: *mut SmartCardCryptogramStorageKeyCapabilities) -> HRESULT +}} +impl ISmartCardCryptogramStorageKeyCharacteristics { + #[inline] pub fn get_storage_key_name(&self) -> Result { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, pin as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).get_StorageKeyName)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} - #[inline] pub fn create_with_capacity(&self, pin: &GpioPin, minCapacity: i32) -> Result> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).CreateWithCapacity)(self as *const _ as *mut _, pin as *const _ as *mut _, minCapacity, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + #[inline] pub fn get_date_created(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_DateCreated)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_algorithm(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Algorithm)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_capabilities(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Capabilities)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} } -RT_STRUCT! { struct GpioChangeRecord { - RelativeTime: foundation::TimeSpan, Edge: GpioPinEdge, -}} -DEFINE_IID!(IID_IGpioController, 675287779, 29793, 18076, 168, 188, 97, 214, 157, 8, 165, 60); -RT_INTERFACE!{interface IGpioController(IGpioControllerVtbl): IInspectable(IInspectableVtbl) [IID_IGpioController] { - fn get_PinCount(&self, out: *mut i32) -> HRESULT, - fn OpenPin(&self, pinNumber: i32, out: *mut *mut GpioPin) -> HRESULT, - fn OpenPinWithSharingMode(&self, pinNumber: i32, sharingMode: GpioSharingMode, out: *mut *mut GpioPin) -> HRESULT, - fn TryOpenPin(&self, pinNumber: i32, sharingMode: GpioSharingMode, pin: *mut *mut GpioPin, openStatus: *mut GpioOpenStatus, out: *mut bool) -> HRESULT +RT_CLASS!{class SmartCardCryptogramStorageKeyCharacteristics: ISmartCardCryptogramStorageKeyCharacteristics} +impl RtActivatable for SmartCardCryptogramStorageKeyCharacteristics {} +DEFINE_CLSID!(SmartCardCryptogramStorageKeyCharacteristics(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,83,109,97,114,116,67,97,114,100,115,46,83,109,97,114,116,67,97,114,100,67,114,121,112,116,111,103,114,97,109,83,116,111,114,97,103,101,75,101,121,67,104,97,114,97,99,116,101,114,105,115,116,105,99,115,0]) [CLSID_SmartCardCryptogramStorageKeyCharacteristics]); +DEFINE_IID!(IID_ISmartCardCryptogramStorageKeyInfo, 2008084493, 45207, 20321, 162, 106, 149, 97, 99, 156, 156, 58); +RT_INTERFACE!{interface ISmartCardCryptogramStorageKeyInfo(ISmartCardCryptogramStorageKeyInfoVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardCryptogramStorageKeyInfo] { + fn get_OperationStatus(&self, out: *mut SmartCardCryptogramGeneratorOperationStatus) -> HRESULT, + #[cfg(not(feature="windows-security"))] fn __Dummy1(&self) -> (), + #[cfg(feature="windows-security")] fn get_PublicKeyBlobType(&self, out: *mut super::super::security::cryptography::core::CryptographicPublicKeyBlobType) -> HRESULT, + #[cfg(not(feature="windows-storage"))] fn __Dummy2(&self) -> (), + #[cfg(feature="windows-storage")] fn get_PublicKey(&self, out: *mut *mut super::super::storage::streams::IBuffer) -> HRESULT, + fn get_AttestationStatus(&self, out: *mut SmartCardCryptographicKeyAttestationStatus) -> HRESULT, + #[cfg(not(feature="windows-storage"))] fn __Dummy4(&self) -> (), + #[cfg(feature="windows-storage")] fn get_Attestation(&self, out: *mut *mut super::super::storage::streams::IBuffer) -> HRESULT, + #[cfg(not(feature="windows-storage"))] fn __Dummy5(&self) -> (), + #[cfg(feature="windows-storage")] fn get_AttestationCertificateChain(&self, out: *mut *mut super::super::storage::streams::IBuffer) -> HRESULT, + fn get_Capabilities(&self, out: *mut SmartCardCryptogramStorageKeyCapabilities) -> HRESULT }} -impl IGpioController { - #[inline] pub fn get_pin_count(&self) -> Result { unsafe { +impl ISmartCardCryptogramStorageKeyInfo { + #[inline] pub fn get_operation_status(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_PinCount)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_OperationStatus)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn open_pin(&self, pinNumber: i32) -> Result>> { unsafe { + #[cfg(feature="windows-security")] #[inline] pub fn get_public_key_blob_type(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_PublicKeyBlobType)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[cfg(feature="windows-storage")] #[inline] pub fn get_public_key(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).OpenPin)(self as *const _ as *mut _, pinNumber, &mut out); + let hr = ((*self.lpVtbl).get_PublicKey)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn open_pin_with_sharing_mode(&self, pinNumber: i32, sharingMode: GpioSharingMode) -> Result>> { unsafe { + #[inline] pub fn get_attestation_status(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_AttestationStatus)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[cfg(feature="windows-storage")] #[inline] pub fn get_attestation(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).OpenPinWithSharingMode)(self as *const _ as *mut _, pinNumber, sharingMode, &mut out); + let hr = ((*self.lpVtbl).get_Attestation)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn try_open_pin(&self, pinNumber: i32, sharingMode: GpioSharingMode) -> Result<(Option>, GpioOpenStatus, bool)> { unsafe { - let mut pin = null_mut(); let mut openStatus = zeroed(); let mut out = zeroed(); - let hr = ((*self.lpVtbl).TryOpenPin)(self as *const _ as *mut _, pinNumber, sharingMode, &mut pin, &mut openStatus, &mut out); - if hr == S_OK { Ok((ComPtr::wrap_optional(pin), openStatus, out)) } else { err(hr) } - }} -} -RT_CLASS!{class GpioController: IGpioController} -impl RtActivatable for GpioController {} -impl RtActivatable for GpioController {} -impl GpioController { - #[inline] pub fn get_default() -> Result>> { - >::get_activation_factory().get_default() - } - #[inline] pub fn get_controllers_async(provider: &provider::IGpioProvider) -> Result>>> { - >::get_activation_factory().get_controllers_async(provider) - } - #[inline] pub fn get_default_async() -> Result>> { - >::get_activation_factory().get_default_async() - } -} -DEFINE_CLSID!(GpioController(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,71,112,105,111,46,71,112,105,111,67,111,110,116,114,111,108,108,101,114,0]) [CLSID_GpioController]); -DEFINE_IID!(IID_IGpioControllerStatics, 785839150, 31479, 16662, 149, 51, 196, 61, 153, 161, 251, 100); -RT_INTERFACE!{static interface IGpioControllerStatics(IGpioControllerStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IGpioControllerStatics] { - fn GetDefault(&self, out: *mut *mut GpioController) -> HRESULT -}} -impl IGpioControllerStatics { - #[inline] pub fn get_default(&self) -> Result>> { unsafe { + #[cfg(feature="windows-storage")] #[inline] pub fn get_attestation_certificate_chain(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetDefault)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_AttestationCertificateChain)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} + #[inline] pub fn get_capabilities(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Capabilities)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} } -DEFINE_IID!(IID_IGpioControllerStatics2, 2435546400, 27812, 16646, 163, 115, 255, 253, 52, 107, 14, 91); -RT_INTERFACE!{static interface IGpioControllerStatics2(IGpioControllerStatics2Vtbl): IInspectable(IInspectableVtbl) [IID_IGpioControllerStatics2] { - fn GetControllersAsync(&self, provider: *mut provider::IGpioProvider, out: *mut *mut foundation::IAsyncOperation>) -> HRESULT, - fn GetDefaultAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT +RT_CLASS!{class SmartCardCryptogramStorageKeyInfo: ISmartCardCryptogramStorageKeyInfo} +DEFINE_IID!(IID_ISmartCardCryptogramStorageKeyInfo2, 278777, 63485, 16765, 137, 225, 251, 176, 56, 42, 220, 77); +RT_INTERFACE!{interface ISmartCardCryptogramStorageKeyInfo2(ISmartCardCryptogramStorageKeyInfo2Vtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardCryptogramStorageKeyInfo2] { + fn get_OperationalRequirements(&self, out: *mut HSTRING) -> HRESULT }} -impl IGpioControllerStatics2 { - #[inline] pub fn get_controllers_async(&self, provider: &provider::IGpioProvider) -> Result>>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetControllersAsync)(self as *const _ as *mut _, provider as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } - }} - #[inline] pub fn get_default_async(&self) -> Result>> { unsafe { +impl ISmartCardCryptogramStorageKeyInfo2 { + #[inline] pub fn get_operational_requirements(&self) -> Result { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetDefaultAsync)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).get_OperationalRequirements)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} } -RT_ENUM! { enum GpioOpenStatus: i32 { - PinOpened (GpioOpenStatus_PinOpened) = 0, PinUnavailable (GpioOpenStatus_PinUnavailable) = 1, SharingViolation (GpioOpenStatus_SharingViolation) = 2, MuxingConflict (GpioOpenStatus_MuxingConflict) = 3, UnknownError (GpioOpenStatus_UnknownError) = 4, +RT_ENUM! { enum SmartCardCryptographicKeyAttestationStatus: i32 { + NoAttestation (SmartCardCryptographicKeyAttestationStatus_NoAttestation) = 0, SoftwareKeyWithoutTpm (SmartCardCryptographicKeyAttestationStatus_SoftwareKeyWithoutTpm) = 1, SoftwareKeyWithTpm (SmartCardCryptographicKeyAttestationStatus_SoftwareKeyWithTpm) = 2, TpmKeyUnknownAttestationStatus (SmartCardCryptographicKeyAttestationStatus_TpmKeyUnknownAttestationStatus) = 3, TpmKeyWithoutAttestationCapability (SmartCardCryptographicKeyAttestationStatus_TpmKeyWithoutAttestationCapability) = 4, TpmKeyWithTemporaryAttestationFailure (SmartCardCryptographicKeyAttestationStatus_TpmKeyWithTemporaryAttestationFailure) = 5, TpmKeyWithLongTermAttestationFailure (SmartCardCryptographicKeyAttestationStatus_TpmKeyWithLongTermAttestationFailure) = 6, TpmKeyWithAttestation (SmartCardCryptographicKeyAttestationStatus_TpmKeyWithAttestation) = 7, }} -DEFINE_IID!(IID_IGpioPin, 299479175, 44974, 18320, 158, 233, 224, 234, 201, 66, 210, 1); -RT_INTERFACE!{interface IGpioPin(IGpioPinVtbl): IInspectable(IInspectableVtbl) [IID_IGpioPin] { - fn add_ValueChanged(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, - fn remove_ValueChanged(&self, token: foundation::EventRegistrationToken) -> HRESULT, - fn get_DebounceTimeout(&self, out: *mut foundation::TimeSpan) -> HRESULT, - fn put_DebounceTimeout(&self, value: foundation::TimeSpan) -> HRESULT, - fn get_PinNumber(&self, out: *mut i32) -> HRESULT, - fn get_SharingMode(&self, out: *mut GpioSharingMode) -> HRESULT, - fn IsDriveModeSupported(&self, driveMode: GpioPinDriveMode, out: *mut bool) -> HRESULT, - fn GetDriveMode(&self, out: *mut GpioPinDriveMode) -> HRESULT, - fn SetDriveMode(&self, value: GpioPinDriveMode) -> HRESULT, - fn Write(&self, value: GpioPinValue) -> HRESULT, - fn Read(&self, out: *mut GpioPinValue) -> HRESULT +RT_ENUM! { enum SmartCardEmulationCategory: i32 { + Other (SmartCardEmulationCategory_Other) = 0, Payment (SmartCardEmulationCategory_Payment) = 1, }} -impl IGpioPin { - #[inline] pub fn add_value_changed(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { +RT_ENUM! { enum SmartCardEmulationType: i32 { + Host (SmartCardEmulationType_Host) = 0, Uicc (SmartCardEmulationType_Uicc) = 1, EmbeddedSE (SmartCardEmulationType_EmbeddedSE) = 2, +}} +DEFINE_IID!(IID_ISmartCardEmulator, 3753445042, 34654, 18405, 128, 119, 232, 191, 241, 177, 198, 251); +RT_INTERFACE!{interface ISmartCardEmulator(ISmartCardEmulatorVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardEmulator] { + fn get_EnablementPolicy(&self, out: *mut SmartCardEmulatorEnablementPolicy) -> HRESULT +}} +impl ISmartCardEmulator { + #[inline] pub fn get_enablement_policy(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).add_ValueChanged)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_EnablementPolicy)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn remove_value_changed(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).remove_ValueChanged)(self as *const _ as *mut _, token); - if hr == S_OK { Ok(()) } else { err(hr) } - }} - #[inline] pub fn get_debounce_timeout(&self) -> Result { unsafe { +} +RT_CLASS!{class SmartCardEmulator: ISmartCardEmulator} +impl RtActivatable for SmartCardEmulator {} +impl RtActivatable for SmartCardEmulator {} +impl RtActivatable for SmartCardEmulator {} +impl SmartCardEmulator { + #[inline] pub fn get_default_async() -> Result>> { + >::get_activation_factory().get_default_async() + } + #[inline] pub fn get_applet_id_group_registrations_async() -> Result>>> { + >::get_activation_factory().get_applet_id_group_registrations_async() + } + #[inline] pub fn register_applet_id_group_async(appletIdGroup: &SmartCardAppletIdGroup) -> Result>> { + >::get_activation_factory().register_applet_id_group_async(appletIdGroup) + } + #[inline] pub fn unregister_applet_id_group_async(registration: &SmartCardAppletIdGroupRegistration) -> Result> { + >::get_activation_factory().unregister_applet_id_group_async(registration) + } + #[inline] pub fn get_max_applet_id_group_registrations() -> Result { + >::get_activation_factory().get_max_applet_id_group_registrations() + } + #[inline] pub fn is_supported() -> Result { + >::get_activation_factory().is_supported() + } +} +DEFINE_CLSID!(SmartCardEmulator(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,83,109,97,114,116,67,97,114,100,115,46,83,109,97,114,116,67,97,114,100,69,109,117,108,97,116,111,114,0]) [CLSID_SmartCardEmulator]); +DEFINE_IID!(IID_ISmartCardEmulator2, 4265590968, 34089, 16666, 128, 123, 72, 237, 194, 160, 171, 68); +RT_INTERFACE!{interface ISmartCardEmulator2(ISmartCardEmulator2Vtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardEmulator2] { + fn add_ApduReceived(&self, value: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_ApduReceived(&self, value: foundation::EventRegistrationToken) -> HRESULT, + fn add_ConnectionDeactivated(&self, value: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_ConnectionDeactivated(&self, value: foundation::EventRegistrationToken) -> HRESULT, + fn Start(&self) -> HRESULT, + fn IsHostCardEmulationSupported(&self, out: *mut bool) -> HRESULT +}} +impl ISmartCardEmulator2 { + #[inline] pub fn add_apdu_received(&self, value: &foundation::TypedEventHandler) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_DebounceTimeout)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).add_ApduReceived)(self as *const _ as *mut _, value as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn set_debounce_timeout(&self, value: foundation::TimeSpan) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_DebounceTimeout)(self as *const _ as *mut _, value); + #[inline] pub fn remove_apdu_received(&self, value: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_ApduReceived)(self as *const _ as *mut _, value); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_pin_number(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_PinNumber)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } - }} - #[inline] pub fn get_sharing_mode(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_SharingMode)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } - }} - #[inline] pub fn is_drive_mode_supported(&self, driveMode: GpioPinDriveMode) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).IsDriveModeSupported)(self as *const _ as *mut _, driveMode, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } - }} - #[inline] pub fn get_drive_mode(&self) -> Result { unsafe { + #[inline] pub fn add_connection_deactivated(&self, value: &foundation::TypedEventHandler) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).GetDriveMode)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).add_ConnectionDeactivated)(self as *const _ as *mut _, value as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn set_drive_mode(&self, value: GpioPinDriveMode) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).SetDriveMode)(self as *const _ as *mut _, value); + #[inline] pub fn remove_connection_deactivated(&self, value: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_ConnectionDeactivated)(self as *const _ as *mut _, value); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn write(&self, value: GpioPinValue) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).Write)(self as *const _ as *mut _, value); + #[inline] pub fn start(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).Start)(self as *const _ as *mut _); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn read(&self) -> Result { unsafe { + #[inline] pub fn is_host_card_emulation_supported(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).Read)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).IsHostCardEmulationSupported)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} } -RT_CLASS!{class GpioPin: IGpioPin} -RT_ENUM! { enum GpioPinDriveMode: i32 { - Input (GpioPinDriveMode_Input) = 0, Output (GpioPinDriveMode_Output) = 1, InputPullUp (GpioPinDriveMode_InputPullUp) = 2, InputPullDown (GpioPinDriveMode_InputPullDown) = 3, OutputOpenDrain (GpioPinDriveMode_OutputOpenDrain) = 4, OutputOpenDrainPullUp (GpioPinDriveMode_OutputOpenDrainPullUp) = 5, OutputOpenSource (GpioPinDriveMode_OutputOpenSource) = 6, OutputOpenSourcePullDown (GpioPinDriveMode_OutputOpenSourcePullDown) = 7, -}} -RT_ENUM! { enum GpioPinEdge: i32 { - FallingEdge (GpioPinEdge_FallingEdge) = 0, RisingEdge (GpioPinEdge_RisingEdge) = 1, -}} -RT_ENUM! { enum GpioPinValue: i32 { - Low (GpioPinValue_Low) = 0, High (GpioPinValue_High) = 1, -}} -DEFINE_IID!(IID_IGpioPinValueChangedEventArgs, 825731809, 28733, 16473, 189, 36, 181, 178, 93, 255, 184, 78); -RT_INTERFACE!{interface IGpioPinValueChangedEventArgs(IGpioPinValueChangedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IGpioPinValueChangedEventArgs] { - fn get_Edge(&self, out: *mut GpioPinEdge) -> HRESULT +DEFINE_IID!(IID_ISmartCardEmulatorApduReceivedEventArgs, 3579647350, 27090, 21299, 91, 95, 248, 192, 214, 233, 240, 159); +RT_INTERFACE!{interface ISmartCardEmulatorApduReceivedEventArgs(ISmartCardEmulatorApduReceivedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardEmulatorApduReceivedEventArgs] { + #[cfg(not(feature="windows-storage"))] fn __Dummy0(&self) -> (), + #[cfg(feature="windows-storage")] fn get_CommandApdu(&self, out: *mut *mut super::super::storage::streams::IBuffer) -> HRESULT, + fn get_ConnectionProperties(&self, out: *mut *mut SmartCardEmulatorConnectionProperties) -> HRESULT, + #[cfg(not(feature="windows-storage"))] fn __Dummy2(&self) -> (), + #[cfg(feature="windows-storage")] fn TryRespondAsync(&self, responseApdu: *mut super::super::storage::streams::IBuffer, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn get_AutomaticResponseStatus(&self, out: *mut SmartCardAutomaticResponseStatus) -> HRESULT }} -impl IGpioPinValueChangedEventArgs { - #[inline] pub fn get_edge(&self) -> Result { unsafe { +impl ISmartCardEmulatorApduReceivedEventArgs { + #[cfg(feature="windows-storage")] #[inline] pub fn get_command_apdu(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_CommandApdu)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_connection_properties(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ConnectionProperties)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[cfg(feature="windows-storage")] #[inline] pub fn try_respond_async(&self, responseApdu: &super::super::storage::streams::IBuffer) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).TryRespondAsync)(self as *const _ as *mut _, responseApdu as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_automatic_response_status(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_Edge)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_AutomaticResponseStatus)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} } -RT_CLASS!{class GpioPinValueChangedEventArgs: IGpioPinValueChangedEventArgs} -RT_ENUM! { enum GpioSharingMode: i32 { - Exclusive (GpioSharingMode_Exclusive) = 0, SharedReadOnly (GpioSharingMode_SharedReadOnly) = 1, -}} -pub mod provider { // Windows.Devices.Gpio.Provider -use ::prelude::*; -DEFINE_IID!(IID_IGpioControllerProvider, 2903625415, 6634, 19233, 135, 79, 185, 26, 237, 74, 37, 219); -RT_INTERFACE!{interface IGpioControllerProvider(IGpioControllerProviderVtbl): IInspectable(IInspectableVtbl) [IID_IGpioControllerProvider] { - fn get_PinCount(&self, out: *mut i32) -> HRESULT, - fn OpenPinProvider(&self, pin: i32, sharingMode: ProviderGpioSharingMode, out: *mut *mut IGpioPinProvider) -> HRESULT +RT_CLASS!{class SmartCardEmulatorApduReceivedEventArgs: ISmartCardEmulatorApduReceivedEventArgs} +DEFINE_IID!(IID_ISmartCardEmulatorApduReceivedEventArgs2, 2348367344, 8929, 16952, 134, 16, 148, 206, 74, 150, 84, 37); +RT_INTERFACE!{interface ISmartCardEmulatorApduReceivedEventArgs2(ISmartCardEmulatorApduReceivedEventArgs2Vtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardEmulatorApduReceivedEventArgs2] { + fn get_State(&self, out: *mut u32) -> HRESULT, + #[cfg(feature="windows-storage")] fn TryRespondWithStateAsync(&self, responseApdu: *mut super::super::storage::streams::IBuffer, nextState: *mut foundation::IReference, out: *mut *mut foundation::IAsyncOperation) -> HRESULT }} -impl IGpioControllerProvider { - #[inline] pub fn get_pin_count(&self) -> Result { unsafe { +impl ISmartCardEmulatorApduReceivedEventArgs2 { + #[inline] pub fn get_state(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_PinCount)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_State)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn open_pin_provider(&self, pin: i32, sharingMode: ProviderGpioSharingMode) -> Result>> { unsafe { + #[cfg(feature="windows-storage")] #[inline] pub fn try_respond_with_state_async(&self, responseApdu: &super::super::storage::streams::IBuffer, nextState: &foundation::IReference) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).OpenPinProvider)(self as *const _ as *mut _, pin, sharingMode, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).TryRespondWithStateAsync)(self as *const _ as *mut _, responseApdu as *const _ as *mut _, nextState as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } -DEFINE_IID!(IID_IGpioPinProvider, 1110723767, 27324, 16639, 156, 231, 115, 184, 83, 1, 185, 0); -RT_INTERFACE!{interface IGpioPinProvider(IGpioPinProviderVtbl): IInspectable(IInspectableVtbl) [IID_IGpioPinProvider] { - fn add_ValueChanged(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, - fn remove_ValueChanged(&self, token: foundation::EventRegistrationToken) -> HRESULT, - fn get_DebounceTimeout(&self, out: *mut foundation::TimeSpan) -> HRESULT, - fn put_DebounceTimeout(&self, value: foundation::TimeSpan) -> HRESULT, - fn get_PinNumber(&self, out: *mut i32) -> HRESULT, - fn get_SharingMode(&self, out: *mut ProviderGpioSharingMode) -> HRESULT, - fn IsDriveModeSupported(&self, driveMode: ProviderGpioPinDriveMode, out: *mut bool) -> HRESULT, - fn GetDriveMode(&self, out: *mut ProviderGpioPinDriveMode) -> HRESULT, - fn SetDriveMode(&self, value: ProviderGpioPinDriveMode) -> HRESULT, - fn Write(&self, value: ProviderGpioPinValue) -> HRESULT, - fn Read(&self, out: *mut ProviderGpioPinValue) -> HRESULT +DEFINE_IID!(IID_ISmartCardEmulatorApduReceivedEventArgsWithCryptograms, 3578837703, 47039, 20009, 146, 148, 12, 74, 195, 201, 65, 189); +RT_INTERFACE!{interface ISmartCardEmulatorApduReceivedEventArgsWithCryptograms(ISmartCardEmulatorApduReceivedEventArgsWithCryptogramsVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardEmulatorApduReceivedEventArgsWithCryptograms] { + #[cfg(feature="windows-storage")] fn TryRespondWithCryptogramsAsync(&self, responseTemplate: *mut super::super::storage::streams::IBuffer, cryptogramPlacementSteps: *mut foundation::collections::IIterable, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + #[cfg(feature="windows-storage")] fn TryRespondWithCryptogramsAndStateAsync(&self, responseTemplate: *mut super::super::storage::streams::IBuffer, cryptogramPlacementSteps: *mut foundation::collections::IIterable, nextState: *mut foundation::IReference, out: *mut *mut foundation::IAsyncOperation) -> HRESULT }} -impl IGpioPinProvider { - #[inline] pub fn add_value_changed(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).add_ValueChanged)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } - }} - #[inline] pub fn remove_value_changed(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).remove_ValueChanged)(self as *const _ as *mut _, token); - if hr == S_OK { Ok(()) } else { err(hr) } - }} - #[inline] pub fn get_debounce_timeout(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_DebounceTimeout)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } - }} - #[inline] pub fn set_debounce_timeout(&self, value: foundation::TimeSpan) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_DebounceTimeout)(self as *const _ as *mut _, value); - if hr == S_OK { Ok(()) } else { err(hr) } +impl ISmartCardEmulatorApduReceivedEventArgsWithCryptograms { + #[cfg(feature="windows-storage")] #[inline] pub fn try_respond_with_cryptograms_async(&self, responseTemplate: &super::super::storage::streams::IBuffer, cryptogramPlacementSteps: &foundation::collections::IIterable) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).TryRespondWithCryptogramsAsync)(self as *const _ as *mut _, responseTemplate as *const _ as *mut _, cryptogramPlacementSteps as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_pin_number(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_PinNumber)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } + #[cfg(feature="windows-storage")] #[inline] pub fn try_respond_with_cryptograms_and_state_async(&self, responseTemplate: &super::super::storage::streams::IBuffer, cryptogramPlacementSteps: &foundation::collections::IIterable, nextState: &foundation::IReference) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).TryRespondWithCryptogramsAndStateAsync)(self as *const _ as *mut _, responseTemplate as *const _ as *mut _, cryptogramPlacementSteps as *const _ as *mut _, nextState as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_sharing_mode(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_SharingMode)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } +} +DEFINE_IID!(IID_ISmartCardEmulatorConnectionDeactivatedEventArgs, 562485459, 50667, 21090, 67, 223, 98, 160, 161, 181, 85, 87); +RT_INTERFACE!{interface ISmartCardEmulatorConnectionDeactivatedEventArgs(ISmartCardEmulatorConnectionDeactivatedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardEmulatorConnectionDeactivatedEventArgs] { + fn get_ConnectionProperties(&self, out: *mut *mut SmartCardEmulatorConnectionProperties) -> HRESULT, + fn get_Reason(&self, out: *mut SmartCardEmulatorConnectionDeactivatedReason) -> HRESULT +}} +impl ISmartCardEmulatorConnectionDeactivatedEventArgs { + #[inline] pub fn get_connection_properties(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ConnectionProperties)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn is_drive_mode_supported(&self, driveMode: ProviderGpioPinDriveMode) -> Result { unsafe { + #[inline] pub fn get_reason(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).IsDriveModeSupported)(self as *const _ as *mut _, driveMode, &mut out); + let hr = ((*self.lpVtbl).get_Reason)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_drive_mode(&self) -> Result { unsafe { +} +RT_CLASS!{class SmartCardEmulatorConnectionDeactivatedEventArgs: ISmartCardEmulatorConnectionDeactivatedEventArgs} +RT_ENUM! { enum SmartCardEmulatorConnectionDeactivatedReason: i32 { + ConnectionLost (SmartCardEmulatorConnectionDeactivatedReason_ConnectionLost) = 0, ConnectionRedirected (SmartCardEmulatorConnectionDeactivatedReason_ConnectionRedirected) = 1, +}} +DEFINE_IID!(IID_ISmartCardEmulatorConnectionProperties, 1311548910, 63849, 20605, 108, 249, 52, 226, 209, 141, 243, 17); +RT_INTERFACE!{interface ISmartCardEmulatorConnectionProperties(ISmartCardEmulatorConnectionPropertiesVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardEmulatorConnectionProperties] { + fn get_Id(&self, out: *mut Guid) -> HRESULT, + fn get_Source(&self, out: *mut SmartCardEmulatorConnectionSource) -> HRESULT +}} +impl ISmartCardEmulatorConnectionProperties { + #[inline] pub fn get_id(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).GetDriveMode)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_Id)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn set_drive_mode(&self, value: ProviderGpioPinDriveMode) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).SetDriveMode)(self as *const _ as *mut _, value); - if hr == S_OK { Ok(()) } else { err(hr) } - }} - #[inline] pub fn write(&self, value: ProviderGpioPinValue) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).Write)(self as *const _ as *mut _, value); - if hr == S_OK { Ok(()) } else { err(hr) } - }} - #[inline] pub fn read(&self) -> Result { unsafe { + #[inline] pub fn get_source(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).Read)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_Source)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} } -DEFINE_IID!(IID_IGpioPinProviderValueChangedEventArgs, 849794802, 15707, 17613, 143, 190, 19, 166, 159, 46, 219, 36); -RT_INTERFACE!{interface IGpioPinProviderValueChangedEventArgs(IGpioPinProviderValueChangedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IGpioPinProviderValueChangedEventArgs] { - fn get_Edge(&self, out: *mut ProviderGpioPinEdge) -> HRESULT +RT_CLASS!{class SmartCardEmulatorConnectionProperties: ISmartCardEmulatorConnectionProperties} +RT_ENUM! { enum SmartCardEmulatorConnectionSource: i32 { + Unknown (SmartCardEmulatorConnectionSource_Unknown) = 0, NfcReader (SmartCardEmulatorConnectionSource_NfcReader) = 1, }} -impl IGpioPinProviderValueChangedEventArgs { - #[inline] pub fn get_edge(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_Edge)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } - }} -} -RT_CLASS!{class GpioPinProviderValueChangedEventArgs: IGpioPinProviderValueChangedEventArgs} -impl RtActivatable for GpioPinProviderValueChangedEventArgs {} -impl GpioPinProviderValueChangedEventArgs { - #[inline] pub fn create(edge: ProviderGpioPinEdge) -> Result> { - >::get_activation_factory().create(edge) - } -} -DEFINE_CLSID!(GpioPinProviderValueChangedEventArgs(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,71,112,105,111,46,80,114,111,118,105,100,101,114,46,71,112,105,111,80,105,110,80,114,111,118,105,100,101,114,86,97,108,117,101,67,104,97,110,103,101,100,69,118,101,110,116,65,114,103,115,0]) [CLSID_GpioPinProviderValueChangedEventArgs]); -DEFINE_IID!(IID_IGpioPinProviderValueChangedEventArgsFactory, 1053494105, 22156, 17298, 178, 74, 138, 89, 169, 2, 177, 241); -RT_INTERFACE!{static interface IGpioPinProviderValueChangedEventArgsFactory(IGpioPinProviderValueChangedEventArgsFactoryVtbl): IInspectable(IInspectableVtbl) [IID_IGpioPinProviderValueChangedEventArgsFactory] { - fn Create(&self, edge: ProviderGpioPinEdge, out: *mut *mut GpioPinProviderValueChangedEventArgs) -> HRESULT +RT_ENUM! { enum SmartCardEmulatorEnablementPolicy: i32 { + Never (SmartCardEmulatorEnablementPolicy_Never) = 0, Always (SmartCardEmulatorEnablementPolicy_Always) = 1, ScreenOn (SmartCardEmulatorEnablementPolicy_ScreenOn) = 2, ScreenUnlocked (SmartCardEmulatorEnablementPolicy_ScreenUnlocked) = 3, }} -impl IGpioPinProviderValueChangedEventArgsFactory { - #[inline] pub fn create(&self, edge: ProviderGpioPinEdge) -> Result> { unsafe { +DEFINE_IID!(IID_ISmartCardEmulatorStatics, 2057043019, 50387, 18767, 184, 162, 98, 21, 216, 30, 133, 178); +RT_INTERFACE!{static interface ISmartCardEmulatorStatics(ISmartCardEmulatorStaticsVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardEmulatorStatics] { + fn GetDefaultAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT +}} +impl ISmartCardEmulatorStatics { + #[inline] pub fn get_default_async(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, edge, &mut out); + let hr = ((*self.lpVtbl).GetDefaultAsync)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } -DEFINE_IID!(IID_IGpioProvider, 1156065031, 2250, 17226, 175, 224, 214, 21, 128, 68, 111, 126); -RT_INTERFACE!{interface IGpioProvider(IGpioProviderVtbl): IInspectable(IInspectableVtbl) [IID_IGpioProvider] { - fn GetControllers(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT +DEFINE_IID!(IID_ISmartCardEmulatorStatics2, 1773051786, 46965, 18571, 132, 54, 108, 30, 40, 237, 115, 31); +RT_INTERFACE!{static interface ISmartCardEmulatorStatics2(ISmartCardEmulatorStatics2Vtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardEmulatorStatics2] { + fn GetAppletIdGroupRegistrationsAsync(&self, out: *mut *mut foundation::IAsyncOperation>) -> HRESULT, + fn RegisterAppletIdGroupAsync(&self, appletIdGroup: *mut SmartCardAppletIdGroup, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn UnregisterAppletIdGroupAsync(&self, registration: *mut SmartCardAppletIdGroupRegistration, out: *mut *mut foundation::IAsyncAction) -> HRESULT, + fn get_MaxAppletIdGroupRegistrations(&self, out: *mut u16) -> HRESULT }} -impl IGpioProvider { - #[inline] pub fn get_controllers(&self) -> Result>>> { unsafe { +impl ISmartCardEmulatorStatics2 { + #[inline] pub fn get_applet_id_group_registrations_async(&self) -> Result>>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetControllers)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).GetAppletIdGroupRegistrationsAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn register_applet_id_group_async(&self, appletIdGroup: &SmartCardAppletIdGroup) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).RegisterAppletIdGroupAsync)(self as *const _ as *mut _, appletIdGroup as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn unregister_applet_id_group_async(&self, registration: &SmartCardAppletIdGroupRegistration) -> Result> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).UnregisterAppletIdGroupAsync)(self as *const _ as *mut _, registration as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_max_applet_id_group_registrations(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_MaxAppletIdGroupRegistrations)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} } -RT_ENUM! { enum ProviderGpioPinDriveMode: i32 { - Input (ProviderGpioPinDriveMode_Input) = 0, Output (ProviderGpioPinDriveMode_Output) = 1, InputPullUp (ProviderGpioPinDriveMode_InputPullUp) = 2, InputPullDown (ProviderGpioPinDriveMode_InputPullDown) = 3, OutputOpenDrain (ProviderGpioPinDriveMode_OutputOpenDrain) = 4, OutputOpenDrainPullUp (ProviderGpioPinDriveMode_OutputOpenDrainPullUp) = 5, OutputOpenSource (ProviderGpioPinDriveMode_OutputOpenSource) = 6, OutputOpenSourcePullDown (ProviderGpioPinDriveMode_OutputOpenSourcePullDown) = 7, -}} -RT_ENUM! { enum ProviderGpioPinEdge: i32 { - FallingEdge (ProviderGpioPinEdge_FallingEdge) = 0, RisingEdge (ProviderGpioPinEdge_RisingEdge) = 1, -}} -RT_ENUM! { enum ProviderGpioPinValue: i32 { - Low (ProviderGpioPinValue_Low) = 0, High (ProviderGpioPinValue_High) = 1, +DEFINE_IID!(IID_ISmartCardEmulatorStatics3, 1508512810, 40713, 17397, 133, 101, 207, 168, 20, 142, 76, 178); +RT_INTERFACE!{static interface ISmartCardEmulatorStatics3(ISmartCardEmulatorStatics3Vtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardEmulatorStatics3] { + fn IsSupported(&self, out: *mut bool) -> HRESULT }} -RT_ENUM! { enum ProviderGpioSharingMode: i32 { - Exclusive (ProviderGpioSharingMode_Exclusive) = 0, SharedReadOnly (ProviderGpioSharingMode_SharedReadOnly) = 1, +impl ISmartCardEmulatorStatics3 { + #[inline] pub fn is_supported(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).IsSupported)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} +RT_ENUM! { enum SmartCardLaunchBehavior: i32 { + Default (SmartCardLaunchBehavior_Default) = 0, AboveLock (SmartCardLaunchBehavior_AboveLock) = 1, }} -} // Windows.Devices.Gpio.Provider -} // Windows.Devices.Gpio -pub mod i2c { // Windows.Devices.I2c -use ::prelude::*; -RT_ENUM! { enum I2cBusSpeed: i32 { - StandardMode (I2cBusSpeed_StandardMode) = 0, FastMode (I2cBusSpeed_FastMode) = 1, +RT_ENUM! { enum SmartCardPinCharacterPolicyOption: i32 { + Allow (SmartCardPinCharacterPolicyOption_Allow) = 0, RequireAtLeastOne (SmartCardPinCharacterPolicyOption_RequireAtLeastOne) = 1, Disallow (SmartCardPinCharacterPolicyOption_Disallow) = 2, }} -DEFINE_IID!(IID_II2cConnectionSettings, 4074443527, 43887, 17977, 167, 103, 84, 83, 109, 195, 70, 15); -RT_INTERFACE!{interface II2cConnectionSettings(II2cConnectionSettingsVtbl): IInspectable(IInspectableVtbl) [IID_II2cConnectionSettings] { - fn get_SlaveAddress(&self, out: *mut i32) -> HRESULT, - fn put_SlaveAddress(&self, value: i32) -> HRESULT, - fn get_BusSpeed(&self, out: *mut I2cBusSpeed) -> HRESULT, - fn put_BusSpeed(&self, value: I2cBusSpeed) -> HRESULT, - fn get_SharingMode(&self, out: *mut I2cSharingMode) -> HRESULT, - fn put_SharingMode(&self, value: I2cSharingMode) -> HRESULT +DEFINE_IID!(IID_ISmartCardPinPolicy, 406643076, 19894, 18497, 172, 158, 42, 193, 243, 155, 115, 4); +RT_INTERFACE!{interface ISmartCardPinPolicy(ISmartCardPinPolicyVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardPinPolicy] { + fn get_MinLength(&self, out: *mut u32) -> HRESULT, + fn put_MinLength(&self, value: u32) -> HRESULT, + fn get_MaxLength(&self, out: *mut u32) -> HRESULT, + fn put_MaxLength(&self, value: u32) -> HRESULT, + fn get_UppercaseLetters(&self, out: *mut SmartCardPinCharacterPolicyOption) -> HRESULT, + fn put_UppercaseLetters(&self, value: SmartCardPinCharacterPolicyOption) -> HRESULT, + fn get_LowercaseLetters(&self, out: *mut SmartCardPinCharacterPolicyOption) -> HRESULT, + fn put_LowercaseLetters(&self, value: SmartCardPinCharacterPolicyOption) -> HRESULT, + fn get_Digits(&self, out: *mut SmartCardPinCharacterPolicyOption) -> HRESULT, + fn put_Digits(&self, value: SmartCardPinCharacterPolicyOption) -> HRESULT, + fn get_SpecialCharacters(&self, out: *mut SmartCardPinCharacterPolicyOption) -> HRESULT, + fn put_SpecialCharacters(&self, value: SmartCardPinCharacterPolicyOption) -> HRESULT }} -impl II2cConnectionSettings { - #[inline] pub fn get_slave_address(&self) -> Result { unsafe { +impl ISmartCardPinPolicy { + #[inline] pub fn get_min_length(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_SlaveAddress)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_MinLength)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn set_slave_address(&self, value: i32) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_SlaveAddress)(self as *const _ as *mut _, value); + #[inline] pub fn set_min_length(&self, value: u32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_MinLength)(self as *const _ as *mut _, value); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_bus_speed(&self) -> Result { unsafe { + #[inline] pub fn get_max_length(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_BusSpeed)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_MaxLength)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn set_bus_speed(&self, value: I2cBusSpeed) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_BusSpeed)(self as *const _ as *mut _, value); + #[inline] pub fn set_max_length(&self, value: u32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_MaxLength)(self as *const _ as *mut _, value); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_sharing_mode(&self) -> Result { unsafe { + #[inline] pub fn get_uppercase_letters(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_SharingMode)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_UppercaseLetters)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn set_sharing_mode(&self, value: I2cSharingMode) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_SharingMode)(self as *const _ as *mut _, value); + #[inline] pub fn set_uppercase_letters(&self, value: SmartCardPinCharacterPolicyOption) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_UppercaseLetters)(self as *const _ as *mut _, value); if hr == S_OK { Ok(()) } else { err(hr) } }} -} -RT_CLASS!{class I2cConnectionSettings: II2cConnectionSettings} -impl RtActivatable for I2cConnectionSettings {} -impl I2cConnectionSettings { - #[inline] pub fn create(slaveAddress: i32) -> Result> { - >::get_activation_factory().create(slaveAddress) - } -} -DEFINE_CLSID!(I2cConnectionSettings(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,73,50,99,46,73,50,99,67,111,110,110,101,99,116,105,111,110,83,101,116,116,105,110,103,115,0]) [CLSID_I2cConnectionSettings]); -DEFINE_IID!(IID_II2cConnectionSettingsFactory, 2176157363, 38547, 16817, 162, 67, 222, 212, 246, 230, 105, 38); -RT_INTERFACE!{static interface II2cConnectionSettingsFactory(II2cConnectionSettingsFactoryVtbl): IInspectable(IInspectableVtbl) [IID_II2cConnectionSettingsFactory] { - fn Create(&self, slaveAddress: i32, out: *mut *mut I2cConnectionSettings) -> HRESULT -}} -impl II2cConnectionSettingsFactory { - #[inline] pub fn create(&self, slaveAddress: i32) -> Result> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, slaveAddress, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + #[inline] pub fn get_lowercase_letters(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_LowercaseLetters)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} -} -DEFINE_IID!(IID_II2cController, 3297423794, 34720, 16742, 142, 62, 180, 184, 249, 124, 215, 41); -RT_INTERFACE!{interface II2cController(II2cControllerVtbl): IInspectable(IInspectableVtbl) [IID_II2cController] { - fn GetDevice(&self, settings: *mut I2cConnectionSettings, out: *mut *mut I2cDevice) -> HRESULT -}} -impl II2cController { - #[inline] pub fn get_device(&self, settings: &I2cConnectionSettings) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetDevice)(self as *const _ as *mut _, settings as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } - }} -} -RT_CLASS!{class I2cController: II2cController} -impl RtActivatable for I2cController {} -impl I2cController { - #[inline] pub fn get_controllers_async(provider: &provider::II2cProvider) -> Result>>> { - >::get_activation_factory().get_controllers_async(provider) - } - #[inline] pub fn get_default_async() -> Result>> { - >::get_activation_factory().get_default_async() - } -} -DEFINE_CLSID!(I2cController(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,73,50,99,46,73,50,99,67,111,110,116,114,111,108,108,101,114,0]) [CLSID_I2cController]); -DEFINE_IID!(IID_II2cControllerStatics, 1090257765, 24325, 20094, 132, 189, 16, 13, 184, 224, 174, 197); -RT_INTERFACE!{static interface II2cControllerStatics(II2cControllerStaticsVtbl): IInspectable(IInspectableVtbl) [IID_II2cControllerStatics] { - fn GetControllersAsync(&self, provider: *mut provider::II2cProvider, out: *mut *mut foundation::IAsyncOperation>) -> HRESULT, - fn GetDefaultAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT -}} -impl II2cControllerStatics { - #[inline] pub fn get_controllers_async(&self, provider: &provider::II2cProvider) -> Result>>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetControllersAsync)(self as *const _ as *mut _, provider as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } - }} - #[inline] pub fn get_default_async(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetDefaultAsync)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } - }} -} -DEFINE_IID!(IID_II2cDevice, 2251735350, 47557, 20336, 148, 73, 204, 70, 220, 111, 87, 235); -RT_INTERFACE!{interface II2cDevice(II2cDeviceVtbl): IInspectable(IInspectableVtbl) [IID_II2cDevice] { - fn get_DeviceId(&self, out: *mut HSTRING) -> HRESULT, - fn get_ConnectionSettings(&self, out: *mut *mut I2cConnectionSettings) -> HRESULT, - fn Write(&self, bufferSize: u32, buffer: *mut u8) -> HRESULT, - fn WritePartial(&self, bufferSize: u32, buffer: *mut u8, out: *mut I2cTransferResult) -> HRESULT, - fn Read(&self, bufferSize: u32, buffer: *mut u8) -> HRESULT, - fn ReadPartial(&self, bufferSize: u32, buffer: *mut u8, out: *mut I2cTransferResult) -> HRESULT, - fn WriteRead(&self, writeBufferSize: u32, writeBuffer: *mut u8, readBufferSize: u32, readBuffer: *mut u8) -> HRESULT, - fn WriteReadPartial(&self, writeBufferSize: u32, writeBuffer: *mut u8, readBufferSize: u32, readBuffer: *mut u8, out: *mut I2cTransferResult) -> HRESULT -}} -impl II2cDevice { - #[inline] pub fn get_device_id(&self) -> Result { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_DeviceId)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } - }} - #[inline] pub fn get_connection_settings(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_ConnectionSettings)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } - }} - #[inline] pub fn write(&self, buffer: &[u8]) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).Write)(self as *const _ as *mut _, buffer.len() as u32, buffer.as_ptr() as *mut _); + #[inline] pub fn set_lowercase_letters(&self, value: SmartCardPinCharacterPolicyOption) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_LowercaseLetters)(self as *const _ as *mut _, value); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn write_partial(&self, buffer: &[u8]) -> Result { unsafe { + #[inline] pub fn get_digits(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).WritePartial)(self as *const _ as *mut _, buffer.len() as u32, buffer.as_ptr() as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_Digits)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn read(&self, buffer: &mut [u8]) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).Read)(self as *const _ as *mut _, buffer.len() as u32, buffer.as_mut_ptr() as *mut _); + #[inline] pub fn set_digits(&self, value: SmartCardPinCharacterPolicyOption) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Digits)(self as *const _ as *mut _, value); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn read_partial(&self, buffer: &mut [u8]) -> Result { unsafe { + #[inline] pub fn get_special_characters(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).ReadPartial)(self as *const _ as *mut _, buffer.len() as u32, buffer.as_mut_ptr() as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_SpecialCharacters)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn write_read(&self, writeBuffer: &[u8], readBuffer: &mut [u8]) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).WriteRead)(self as *const _ as *mut _, writeBuffer.len() as u32, writeBuffer.as_ptr() as *mut _, readBuffer.len() as u32, readBuffer.as_mut_ptr() as *mut _); + #[inline] pub fn set_special_characters(&self, value: SmartCardPinCharacterPolicyOption) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_SpecialCharacters)(self as *const _ as *mut _, value); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn write_read_partial(&self, writeBuffer: &[u8], readBuffer: &mut [u8]) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).WriteReadPartial)(self as *const _ as *mut _, writeBuffer.len() as u32, writeBuffer.as_ptr() as *mut _, readBuffer.len() as u32, readBuffer.as_mut_ptr() as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } +} +RT_CLASS!{class SmartCardPinPolicy: ISmartCardPinPolicy} +impl RtActivatable for SmartCardPinPolicy {} +DEFINE_CLSID!(SmartCardPinPolicy(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,83,109,97,114,116,67,97,114,100,115,46,83,109,97,114,116,67,97,114,100,80,105,110,80,111,108,105,99,121,0]) [CLSID_SmartCardPinPolicy]); +DEFINE_IID!(IID_ISmartCardPinResetDeferral, 415845036, 30725, 16388, 133, 228, 187, 239, 172, 143, 104, 132); +RT_INTERFACE!{interface ISmartCardPinResetDeferral(ISmartCardPinResetDeferralVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardPinResetDeferral] { + fn Complete(&self) -> HRESULT +}} +impl ISmartCardPinResetDeferral { + #[inline] pub fn complete(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).Complete)(self as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } }} } -RT_CLASS!{class I2cDevice: II2cDevice} -impl RtActivatable for I2cDevice {} -impl I2cDevice { - #[inline] pub fn get_device_selector() -> Result { - >::get_activation_factory().get_device_selector() - } - #[inline] pub fn get_device_selector_from_friendly_name(friendlyName: &HStringArg) -> Result { - >::get_activation_factory().get_device_selector_from_friendly_name(friendlyName) - } - #[inline] pub fn from_id_async(deviceId: &HStringArg, settings: &I2cConnectionSettings) -> Result>> { - >::get_activation_factory().from_id_async(deviceId, settings) - } +RT_CLASS!{class SmartCardPinResetDeferral: ISmartCardPinResetDeferral} +DEFINE_IID!(IID_SmartCardPinResetHandler, 328031808, 62396, 19036, 180, 29, 75, 78, 246, 132, 226, 55); +RT_DELEGATE!{delegate SmartCardPinResetHandler(SmartCardPinResetHandlerVtbl, SmartCardPinResetHandlerImpl) [IID_SmartCardPinResetHandler] { + fn Invoke(&self, sender: *mut SmartCardProvisioning, request: *mut SmartCardPinResetRequest) -> HRESULT +}} +impl SmartCardPinResetHandler { + #[inline] pub fn invoke(&self, sender: &SmartCardProvisioning, request: &SmartCardPinResetRequest) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).Invoke)(self as *const _ as *mut _, sender as *const _ as *mut _, request as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} } -DEFINE_CLSID!(I2cDevice(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,73,50,99,46,73,50,99,68,101,118,105,99,101,0]) [CLSID_I2cDevice]); -DEFINE_IID!(IID_II2cDeviceStatics, 2443394019, 29492, 17682, 150, 188, 251, 174, 148, 89, 245, 246); -RT_INTERFACE!{static interface II2cDeviceStatics(II2cDeviceStaticsVtbl): IInspectable(IInspectableVtbl) [IID_II2cDeviceStatics] { - fn GetDeviceSelector(&self, out: *mut HSTRING) -> HRESULT, - fn GetDeviceSelectorFromFriendlyName(&self, friendlyName: HSTRING, out: *mut HSTRING) -> HRESULT, - fn FromIdAsync(&self, deviceId: HSTRING, settings: *mut I2cConnectionSettings, out: *mut *mut foundation::IAsyncOperation) -> HRESULT +DEFINE_IID!(IID_ISmartCardPinResetRequest, 318651469, 24505, 20110, 159, 246, 97, 244, 117, 18, 79, 239); +RT_INTERFACE!{interface ISmartCardPinResetRequest(ISmartCardPinResetRequestVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardPinResetRequest] { + #[cfg(feature="windows-storage")] fn get_Challenge(&self, out: *mut *mut super::super::storage::streams::IBuffer) -> HRESULT, + fn get_Deadline(&self, out: *mut foundation::DateTime) -> HRESULT, + fn GetDeferral(&self, out: *mut *mut SmartCardPinResetDeferral) -> HRESULT, + #[cfg(feature="windows-storage")] fn SetResponse(&self, response: *mut super::super::storage::streams::IBuffer) -> HRESULT }} -impl II2cDeviceStatics { - #[inline] pub fn get_device_selector(&self) -> Result { unsafe { +impl ISmartCardPinResetRequest { + #[cfg(feature="windows-storage")] #[inline] pub fn get_challenge(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetDeviceSelector)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).get_Challenge)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn get_device_selector_from_friendly_name(&self, friendlyName: &HStringArg) -> Result { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetDeviceSelectorFromFriendlyName)(self as *const _ as *mut _, friendlyName.get(), &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + #[inline] pub fn get_deadline(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Deadline)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn from_id_async(&self, deviceId: &HStringArg, settings: &I2cConnectionSettings) -> Result>> { unsafe { + #[inline] pub fn get_deferral(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).FromIdAsync)(self as *const _ as *mut _, deviceId.get(), settings as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).GetDeferral)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[cfg(feature="windows-storage")] #[inline] pub fn set_response(&self, response: &super::super::storage::streams::IBuffer) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).SetResponse)(self as *const _ as *mut _, response as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } }} } -RT_ENUM! { enum I2cSharingMode: i32 { - Exclusive (I2cSharingMode_Exclusive) = 0, Shared (I2cSharingMode_Shared) = 1, -}} -RT_STRUCT! { struct I2cTransferResult { - Status: I2cTransferStatus, BytesTransferred: u32, -}} -RT_ENUM! { enum I2cTransferStatus: i32 { - FullTransfer (I2cTransferStatus_FullTransfer) = 0, PartialTransfer (I2cTransferStatus_PartialTransfer) = 1, SlaveAddressNotAcknowledged (I2cTransferStatus_SlaveAddressNotAcknowledged) = 2, ClockStretchTimeout (I2cTransferStatus_ClockStretchTimeout) = 3, UnknownError (I2cTransferStatus_UnknownError) = 4, -}} -pub mod provider { // Windows.Devices.I2c.Provider -use ::prelude::*; -DEFINE_IID!(IID_II2cControllerProvider, 1640151938, 17680, 16739, 168, 124, 78, 21, 169, 85, 137, 128); -RT_INTERFACE!{interface II2cControllerProvider(II2cControllerProviderVtbl): IInspectable(IInspectableVtbl) [IID_II2cControllerProvider] { - fn GetDeviceProvider(&self, settings: *mut ProviderI2cConnectionSettings, out: *mut *mut II2cDeviceProvider) -> HRESULT +RT_CLASS!{class SmartCardPinResetRequest: ISmartCardPinResetRequest} +DEFINE_IID!(IID_ISmartCardProvisioning, 435088829, 8107, 18300, 183, 18, 26, 44, 90, 241, 253, 110); +RT_INTERFACE!{interface ISmartCardProvisioning(ISmartCardProvisioningVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardProvisioning] { + fn get_SmartCard(&self, out: *mut *mut SmartCard) -> HRESULT, + fn GetIdAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn GetNameAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn GetChallengeContextAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn RequestPinChangeAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn RequestPinResetAsync(&self, handler: *mut SmartCardPinResetHandler, out: *mut *mut foundation::IAsyncOperation) -> HRESULT }} -impl II2cControllerProvider { - #[inline] pub fn get_device_provider(&self, settings: &ProviderI2cConnectionSettings) -> Result>> { unsafe { +impl ISmartCardProvisioning { + #[inline] pub fn get_smart_card(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetDeviceProvider)(self as *const _ as *mut _, settings as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_SmartCard)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} -} -DEFINE_IID!(IID_II2cDeviceProvider, 2905876052, 22504, 17726, 131, 41, 209, 228, 71, 209, 3, 169); -RT_INTERFACE!{interface II2cDeviceProvider(II2cDeviceProviderVtbl): IInspectable(IInspectableVtbl) [IID_II2cDeviceProvider] { - fn get_DeviceId(&self, out: *mut HSTRING) -> HRESULT, - fn Write(&self, bufferSize: u32, buffer: *mut u8) -> HRESULT, - fn WritePartial(&self, bufferSize: u32, buffer: *mut u8, out: *mut ProviderI2cTransferResult) -> HRESULT, - fn Read(&self, bufferSize: u32, buffer: *mut u8) -> HRESULT, - fn ReadPartial(&self, bufferSize: u32, buffer: *mut u8, out: *mut ProviderI2cTransferResult) -> HRESULT, - fn WriteRead(&self, writeBufferSize: u32, writeBuffer: *mut u8, readBufferSize: u32, readBuffer: *mut u8) -> HRESULT, - fn WriteReadPartial(&self, writeBufferSize: u32, writeBuffer: *mut u8, readBufferSize: u32, readBuffer: *mut u8, out: *mut ProviderI2cTransferResult) -> HRESULT -}} -impl II2cDeviceProvider { - #[inline] pub fn get_device_id(&self) -> Result { unsafe { + #[inline] pub fn get_id_async(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_DeviceId)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } - }} - #[inline] pub fn write(&self, buffer: &[u8]) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).Write)(self as *const _ as *mut _, buffer.len() as u32, buffer.as_ptr() as *mut _); - if hr == S_OK { Ok(()) } else { err(hr) } - }} - #[inline] pub fn write_partial(&self, buffer: &[u8]) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).WritePartial)(self as *const _ as *mut _, buffer.len() as u32, buffer.as_ptr() as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } - }} - #[inline] pub fn read(&self, buffer: &mut [u8]) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).Read)(self as *const _ as *mut _, buffer.len() as u32, buffer.as_mut_ptr() as *mut _); - if hr == S_OK { Ok(()) } else { err(hr) } + let hr = ((*self.lpVtbl).GetIdAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn read_partial(&self, buffer: &mut [u8]) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).ReadPartial)(self as *const _ as *mut _, buffer.len() as u32, buffer.as_mut_ptr() as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } + #[inline] pub fn get_name_async(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetNameAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn write_read(&self, writeBuffer: &[u8], readBuffer: &mut [u8]) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).WriteRead)(self as *const _ as *mut _, writeBuffer.len() as u32, writeBuffer.as_ptr() as *mut _, readBuffer.len() as u32, readBuffer.as_mut_ptr() as *mut _); - if hr == S_OK { Ok(()) } else { err(hr) } + #[inline] pub fn get_challenge_context_async(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetChallengeContextAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn write_read_partial(&self, writeBuffer: &[u8], readBuffer: &mut [u8]) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).WriteReadPartial)(self as *const _ as *mut _, writeBuffer.len() as u32, writeBuffer.as_ptr() as *mut _, readBuffer.len() as u32, readBuffer.as_mut_ptr() as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } + #[inline] pub fn request_pin_change_async(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).RequestPinChangeAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} -} -DEFINE_IID!(IID_II2cProvider, 1863518270, 48994, 20450, 169, 90, 240, 137, 153, 102, 152, 24); -RT_INTERFACE!{interface II2cProvider(II2cProviderVtbl): IInspectable(IInspectableVtbl) [IID_II2cProvider] { - fn GetControllersAsync(&self, out: *mut *mut foundation::IAsyncOperation>) -> HRESULT -}} -impl II2cProvider { - #[inline] pub fn get_controllers_async(&self) -> Result>>> { unsafe { + #[inline] pub fn request_pin_reset_async(&self, handler: &SmartCardPinResetHandler) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetControllersAsync)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).RequestPinResetAsync)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } -RT_ENUM! { enum ProviderI2cBusSpeed: i32 { - StandardMode (ProviderI2cBusSpeed_StandardMode) = 0, FastMode (ProviderI2cBusSpeed_FastMode) = 1, -}} -DEFINE_IID!(IID_IProviderI2cConnectionSettings, 3923463732, 58640, 17591, 128, 157, 242, 248, 91, 85, 83, 57); -RT_INTERFACE!{interface IProviderI2cConnectionSettings(IProviderI2cConnectionSettingsVtbl): IInspectable(IInspectableVtbl) [IID_IProviderI2cConnectionSettings] { - fn get_SlaveAddress(&self, out: *mut i32) -> HRESULT, - fn put_SlaveAddress(&self, value: i32) -> HRESULT, - fn get_BusSpeed(&self, out: *mut ProviderI2cBusSpeed) -> HRESULT, - fn put_BusSpeed(&self, value: ProviderI2cBusSpeed) -> HRESULT, - fn get_SharingMode(&self, out: *mut ProviderI2cSharingMode) -> HRESULT, - fn put_SharingMode(&self, value: ProviderI2cSharingMode) -> HRESULT +RT_CLASS!{class SmartCardProvisioning: ISmartCardProvisioning} +impl RtActivatable for SmartCardProvisioning {} +impl RtActivatable for SmartCardProvisioning {} +impl SmartCardProvisioning { + #[inline] pub fn from_smart_card_async(card: &SmartCard) -> Result>> { + >::get_activation_factory().from_smart_card_async(card) + } + #[cfg(feature="windows-storage")] #[inline] pub fn request_virtual_smart_card_creation_async(friendlyName: &HStringArg, administrativeKey: &super::super::storage::streams::IBuffer, pinPolicy: &SmartCardPinPolicy) -> Result>> { + >::get_activation_factory().request_virtual_smart_card_creation_async(friendlyName, administrativeKey, pinPolicy) + } + #[cfg(feature="windows-storage")] #[inline] pub fn request_virtual_smart_card_creation_async_with_card_id(friendlyName: &HStringArg, administrativeKey: &super::super::storage::streams::IBuffer, pinPolicy: &SmartCardPinPolicy, cardId: Guid) -> Result>> { + >::get_activation_factory().request_virtual_smart_card_creation_async_with_card_id(friendlyName, administrativeKey, pinPolicy, cardId) + } + #[inline] pub fn request_virtual_smart_card_deletion_async(card: &SmartCard) -> Result>> { + >::get_activation_factory().request_virtual_smart_card_deletion_async(card) + } + #[cfg(feature="windows-storage")] #[inline] pub fn request_attested_virtual_smart_card_creation_async(friendlyName: &HStringArg, administrativeKey: &super::super::storage::streams::IBuffer, pinPolicy: &SmartCardPinPolicy) -> Result>> { + >::get_activation_factory().request_attested_virtual_smart_card_creation_async(friendlyName, administrativeKey, pinPolicy) + } + #[cfg(feature="windows-storage")] #[inline] pub fn request_attested_virtual_smart_card_creation_async_with_card_id(friendlyName: &HStringArg, administrativeKey: &super::super::storage::streams::IBuffer, pinPolicy: &SmartCardPinPolicy, cardId: Guid) -> Result>> { + >::get_activation_factory().request_attested_virtual_smart_card_creation_async_with_card_id(friendlyName, administrativeKey, pinPolicy, cardId) + } +} +DEFINE_CLSID!(SmartCardProvisioning(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,83,109,97,114,116,67,97,114,100,115,46,83,109,97,114,116,67,97,114,100,80,114,111,118,105,115,105,111,110,105,110,103,0]) [CLSID_SmartCardProvisioning]); +DEFINE_IID!(IID_ISmartCardProvisioning2, 285026539, 16249, 19302, 155, 124, 17, 193, 73, 183, 208, 188); +RT_INTERFACE!{interface ISmartCardProvisioning2(ISmartCardProvisioning2Vtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardProvisioning2] { + fn GetAuthorityKeyContainerNameAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT }} -impl IProviderI2cConnectionSettings { - #[inline] pub fn get_slave_address(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_SlaveAddress)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } - }} - #[inline] pub fn set_slave_address(&self, value: i32) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_SlaveAddress)(self as *const _ as *mut _, value); - if hr == S_OK { Ok(()) } else { err(hr) } +impl ISmartCardProvisioning2 { + #[inline] pub fn get_authority_key_container_name_async(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetAuthorityKeyContainerNameAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_bus_speed(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_BusSpeed)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } +} +DEFINE_IID!(IID_ISmartCardProvisioningStatics, 327690312, 3347, 20080, 151, 53, 81, 218, 236, 165, 37, 79); +RT_INTERFACE!{static interface ISmartCardProvisioningStatics(ISmartCardProvisioningStaticsVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardProvisioningStatics] { + fn FromSmartCardAsync(&self, card: *mut SmartCard, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + #[cfg(not(feature="windows-storage"))] fn __Dummy1(&self) -> (), + #[cfg(feature="windows-storage")] fn RequestVirtualSmartCardCreationAsync(&self, friendlyName: HSTRING, administrativeKey: *mut super::super::storage::streams::IBuffer, pinPolicy: *mut SmartCardPinPolicy, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + #[cfg(not(feature="windows-storage"))] fn __Dummy2(&self) -> (), + #[cfg(feature="windows-storage")] fn RequestVirtualSmartCardCreationAsyncWithCardId(&self, friendlyName: HSTRING, administrativeKey: *mut super::super::storage::streams::IBuffer, pinPolicy: *mut SmartCardPinPolicy, cardId: Guid, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn RequestVirtualSmartCardDeletionAsync(&self, card: *mut SmartCard, out: *mut *mut foundation::IAsyncOperation) -> HRESULT +}} +impl ISmartCardProvisioningStatics { + #[inline] pub fn from_smart_card_async(&self, card: &SmartCard) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).FromSmartCardAsync)(self as *const _ as *mut _, card as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn set_bus_speed(&self, value: ProviderI2cBusSpeed) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_BusSpeed)(self as *const _ as *mut _, value); - if hr == S_OK { Ok(()) } else { err(hr) } + #[cfg(feature="windows-storage")] #[inline] pub fn request_virtual_smart_card_creation_async(&self, friendlyName: &HStringArg, administrativeKey: &super::super::storage::streams::IBuffer, pinPolicy: &SmartCardPinPolicy) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).RequestVirtualSmartCardCreationAsync)(self as *const _ as *mut _, friendlyName.get(), administrativeKey as *const _ as *mut _, pinPolicy as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_sharing_mode(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_SharingMode)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } + #[cfg(feature="windows-storage")] #[inline] pub fn request_virtual_smart_card_creation_async_with_card_id(&self, friendlyName: &HStringArg, administrativeKey: &super::super::storage::streams::IBuffer, pinPolicy: &SmartCardPinPolicy, cardId: Guid) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).RequestVirtualSmartCardCreationAsyncWithCardId)(self as *const _ as *mut _, friendlyName.get(), administrativeKey as *const _ as *mut _, pinPolicy as *const _ as *mut _, cardId, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn set_sharing_mode(&self, value: ProviderI2cSharingMode) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_SharingMode)(self as *const _ as *mut _, value); - if hr == S_OK { Ok(()) } else { err(hr) } + #[inline] pub fn request_virtual_smart_card_deletion_async(&self, card: &SmartCard) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).RequestVirtualSmartCardDeletionAsync)(self as *const _ as *mut _, card as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } -RT_CLASS!{class ProviderI2cConnectionSettings: IProviderI2cConnectionSettings} -RT_ENUM! { enum ProviderI2cSharingMode: i32 { - Exclusive (ProviderI2cSharingMode_Exclusive) = 0, Shared (ProviderI2cSharingMode_Shared) = 1, -}} -RT_STRUCT! { struct ProviderI2cTransferResult { - Status: ProviderI2cTransferStatus, BytesTransferred: u32, -}} -RT_ENUM! { enum ProviderI2cTransferStatus: i32 { - FullTransfer (ProviderI2cTransferStatus_FullTransfer) = 0, PartialTransfer (ProviderI2cTransferStatus_PartialTransfer) = 1, SlaveAddressNotAcknowledged (ProviderI2cTransferStatus_SlaveAddressNotAcknowledged) = 2, +DEFINE_IID!(IID_ISmartCardProvisioningStatics2, 877119144, 51616, 19414, 181, 13, 37, 31, 78, 141, 58, 98); +RT_INTERFACE!{static interface ISmartCardProvisioningStatics2(ISmartCardProvisioningStatics2Vtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardProvisioningStatics2] { + #[cfg(feature="windows-storage")] fn RequestAttestedVirtualSmartCardCreationAsync(&self, friendlyName: HSTRING, administrativeKey: *mut super::super::storage::streams::IBuffer, pinPolicy: *mut SmartCardPinPolicy, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + #[cfg(feature="windows-storage")] fn RequestAttestedVirtualSmartCardCreationAsyncWithCardId(&self, friendlyName: HSTRING, administrativeKey: *mut super::super::storage::streams::IBuffer, pinPolicy: *mut SmartCardPinPolicy, cardId: Guid, out: *mut *mut foundation::IAsyncOperation) -> HRESULT }} -} // Windows.Devices.I2c.Provider -} // Windows.Devices.I2c -pub mod pwm { // Windows.Devices.Pwm -use ::prelude::*; -DEFINE_IID!(IID_IPwmController, 3294583941, 53992, 17103, 155, 214, 207, 94, 208, 41, 230, 167); -RT_INTERFACE!{interface IPwmController(IPwmControllerVtbl): IInspectable(IInspectableVtbl) [IID_IPwmController] { - fn get_PinCount(&self, out: *mut i32) -> HRESULT, - fn get_ActualFrequency(&self, out: *mut f64) -> HRESULT, - fn SetDesiredFrequency(&self, desiredFrequency: f64, out: *mut f64) -> HRESULT, - fn get_MinFrequency(&self, out: *mut f64) -> HRESULT, - fn get_MaxFrequency(&self, out: *mut f64) -> HRESULT, - fn OpenPin(&self, pinNumber: i32, out: *mut *mut PwmPin) -> HRESULT +impl ISmartCardProvisioningStatics2 { + #[cfg(feature="windows-storage")] #[inline] pub fn request_attested_virtual_smart_card_creation_async(&self, friendlyName: &HStringArg, administrativeKey: &super::super::storage::streams::IBuffer, pinPolicy: &SmartCardPinPolicy) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).RequestAttestedVirtualSmartCardCreationAsync)(self as *const _ as *mut _, friendlyName.get(), administrativeKey as *const _ as *mut _, pinPolicy as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[cfg(feature="windows-storage")] #[inline] pub fn request_attested_virtual_smart_card_creation_async_with_card_id(&self, friendlyName: &HStringArg, administrativeKey: &super::super::storage::streams::IBuffer, pinPolicy: &SmartCardPinPolicy, cardId: Guid) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).RequestAttestedVirtualSmartCardCreationAsyncWithCardId)(self as *const _ as *mut _, friendlyName.get(), administrativeKey as *const _ as *mut _, pinPolicy as *const _ as *mut _, cardId, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} +} +DEFINE_IID!(IID_ISmartCardReader, 276083936, 21698, 19952, 129, 122, 20, 193, 67, 120, 240, 108); +RT_INTERFACE!{interface ISmartCardReader(ISmartCardReaderVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardReader] { + fn get_DeviceId(&self, out: *mut HSTRING) -> HRESULT, + fn get_Name(&self, out: *mut HSTRING) -> HRESULT, + fn get_Kind(&self, out: *mut SmartCardReaderKind) -> HRESULT, + fn GetStatusAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn FindAllCardsAsync(&self, out: *mut *mut foundation::IAsyncOperation>) -> HRESULT, + fn add_CardAdded(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_CardAdded(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn add_CardRemoved(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_CardRemoved(&self, token: foundation::EventRegistrationToken) -> HRESULT }} -impl IPwmController { - #[inline] pub fn get_pin_count(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_PinCount)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } +impl ISmartCardReader { + #[inline] pub fn get_device_id(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_DeviceId)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_actual_frequency(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_ActualFrequency)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } + #[inline] pub fn get_name(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Name)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} - #[inline] pub fn set_desired_frequency(&self, desiredFrequency: f64) -> Result { unsafe { + #[inline] pub fn get_kind(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).SetDesiredFrequency)(self as *const _ as *mut _, desiredFrequency, &mut out); + let hr = ((*self.lpVtbl).get_Kind)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_min_frequency(&self) -> Result { unsafe { + #[inline] pub fn get_status_async(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetStatusAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn find_all_cards_async(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).FindAllCardsAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn add_card_added(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_MinFrequency)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).add_CardAdded)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_max_frequency(&self) -> Result { unsafe { + #[inline] pub fn remove_card_added(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_CardAdded)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_card_removed(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_MaxFrequency)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).add_CardRemoved)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn open_pin(&self, pinNumber: i32) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).OpenPin)(self as *const _ as *mut _, pinNumber, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + #[inline] pub fn remove_card_removed(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_CardRemoved)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } }} } -RT_CLASS!{class PwmController: IPwmController} -impl RtActivatable for PwmController {} -impl RtActivatable for PwmController {} -impl RtActivatable for PwmController {} -impl PwmController { - #[inline] pub fn get_controllers_async(provider: &provider::IPwmProvider) -> Result>>> { - >::get_activation_factory().get_controllers_async(provider) - } - #[inline] pub fn get_default_async() -> Result>> { - >::get_activation_factory().get_default_async() - } +RT_CLASS!{class SmartCardReader: ISmartCardReader} +impl RtActivatable for SmartCardReader {} +impl SmartCardReader { #[inline] pub fn get_device_selector() -> Result { - >::get_activation_factory().get_device_selector() + >::get_activation_factory().get_device_selector() } - #[inline] pub fn get_device_selector_from_friendly_name(friendlyName: &HStringArg) -> Result { - >::get_activation_factory().get_device_selector_from_friendly_name(friendlyName) + #[inline] pub fn get_device_selector_with_kind(kind: SmartCardReaderKind) -> Result { + >::get_activation_factory().get_device_selector_with_kind(kind) } - #[inline] pub fn from_id_async(deviceId: &HStringArg) -> Result>> { - >::get_activation_factory().from_id_async(deviceId) + #[inline] pub fn from_id_async(deviceId: &HStringArg) -> Result>> { + >::get_activation_factory().from_id_async(deviceId) } } -DEFINE_CLSID!(PwmController(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,80,119,109,46,80,119,109,67,111,110,116,114,111,108,108,101,114,0]) [CLSID_PwmController]); -DEFINE_IID!(IID_IPwmControllerStatics, 1113832865, 35142, 17412, 189, 72, 129, 221, 18, 74, 244, 217); -RT_INTERFACE!{static interface IPwmControllerStatics(IPwmControllerStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IPwmControllerStatics] { - fn GetControllersAsync(&self, provider: *mut provider::IPwmProvider, out: *mut *mut foundation::IAsyncOperation>) -> HRESULT -}} -impl IPwmControllerStatics { - #[inline] pub fn get_controllers_async(&self, provider: &provider::IPwmProvider) -> Result>>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetControllersAsync)(self as *const _ as *mut _, provider as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } - }} -} -DEFINE_IID!(IID_IPwmControllerStatics2, 1157389087, 61721, 19421, 151, 173, 247, 110, 249, 134, 115, 109); -RT_INTERFACE!{static interface IPwmControllerStatics2(IPwmControllerStatics2Vtbl): IInspectable(IInspectableVtbl) [IID_IPwmControllerStatics2] { - fn GetDefaultAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT +DEFINE_CLSID!(SmartCardReader(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,83,109,97,114,116,67,97,114,100,115,46,83,109,97,114,116,67,97,114,100,82,101,97,100,101,114,0]) [CLSID_SmartCardReader]); +RT_ENUM! { enum SmartCardReaderKind: i32 { + Any (SmartCardReaderKind_Any) = 0, Generic (SmartCardReaderKind_Generic) = 1, Tpm (SmartCardReaderKind_Tpm) = 2, Nfc (SmartCardReaderKind_Nfc) = 3, Uicc (SmartCardReaderKind_Uicc) = 4, EmbeddedSE (SmartCardReaderKind_EmbeddedSE) = 5, }} -impl IPwmControllerStatics2 { - #[inline] pub fn get_default_async(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetDefaultAsync)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } - }} -} -DEFINE_IID!(IID_IPwmControllerStatics3, 2992117873, 553, 17220, 174, 63, 155, 124, 208, 230, 107, 148); -RT_INTERFACE!{static interface IPwmControllerStatics3(IPwmControllerStatics3Vtbl): IInspectable(IInspectableVtbl) [IID_IPwmControllerStatics3] { +DEFINE_IID!(IID_ISmartCardReaderStatics, 272368865, 41418, 18674, 162, 129, 91, 111, 102, 154, 241, 7); +RT_INTERFACE!{static interface ISmartCardReaderStatics(ISmartCardReaderStaticsVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardReaderStatics] { fn GetDeviceSelector(&self, out: *mut HSTRING) -> HRESULT, - fn GetDeviceSelectorFromFriendlyName(&self, friendlyName: HSTRING, out: *mut HSTRING) -> HRESULT, - fn FromIdAsync(&self, deviceId: HSTRING, out: *mut *mut foundation::IAsyncOperation) -> HRESULT + fn GetDeviceSelectorWithKind(&self, kind: SmartCardReaderKind, out: *mut HSTRING) -> HRESULT, + fn FromIdAsync(&self, deviceId: HSTRING, out: *mut *mut foundation::IAsyncOperation) -> HRESULT }} -impl IPwmControllerStatics3 { +impl ISmartCardReaderStatics { #[inline] pub fn get_device_selector(&self) -> Result { unsafe { let mut out = null_mut(); let hr = ((*self.lpVtbl).GetDeviceSelector)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_device_selector_from_friendly_name(&self, friendlyName: &HStringArg) -> Result { unsafe { + #[inline] pub fn get_device_selector_with_kind(&self, kind: SmartCardReaderKind) -> Result { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetDeviceSelectorFromFriendlyName)(self as *const _ as *mut _, friendlyName.get(), &mut out); + let hr = ((*self.lpVtbl).GetDeviceSelectorWithKind)(self as *const _ as *mut _, kind, &mut out); if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} - #[inline] pub fn from_id_async(&self, deviceId: &HStringArg) -> Result>> { unsafe { + #[inline] pub fn from_id_async(&self, deviceId: &HStringArg) -> Result>> { unsafe { let mut out = null_mut(); let hr = ((*self.lpVtbl).FromIdAsync)(self as *const _ as *mut _, deviceId.get(), &mut out); if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } -DEFINE_IID!(IID_IPwmPin, 580333000, 50895, 18465, 183, 249, 198, 69, 79, 182, 175, 121); -RT_INTERFACE!{interface IPwmPin(IPwmPinVtbl): IInspectable(IInspectableVtbl) [IID_IPwmPin] { - fn get_Controller(&self, out: *mut *mut PwmController) -> HRESULT, - fn GetActiveDutyCyclePercentage(&self, out: *mut f64) -> HRESULT, - fn SetActiveDutyCyclePercentage(&self, dutyCyclePercentage: f64) -> HRESULT, - fn get_Polarity(&self, out: *mut PwmPulsePolarity) -> HRESULT, - fn put_Polarity(&self, value: PwmPulsePolarity) -> HRESULT, - fn Start(&self) -> HRESULT, - fn Stop(&self) -> HRESULT, - fn get_IsStarted(&self, out: *mut bool) -> HRESULT +RT_ENUM! { enum SmartCardReaderStatus: i32 { + Disconnected (SmartCardReaderStatus_Disconnected) = 0, Ready (SmartCardReaderStatus_Ready) = 1, Exclusive (SmartCardReaderStatus_Exclusive) = 2, }} -impl IPwmPin { - #[inline] pub fn get_controller(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Controller)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } - }} - #[inline] pub fn get_active_duty_cycle_percentage(&self) -> Result { unsafe { +RT_ENUM! { enum SmartCardStatus: i32 { + Disconnected (SmartCardStatus_Disconnected) = 0, Ready (SmartCardStatus_Ready) = 1, Shared (SmartCardStatus_Shared) = 2, Exclusive (SmartCardStatus_Exclusive) = 3, Unresponsive (SmartCardStatus_Unresponsive) = 4, +}} +DEFINE_IID!(IID_ISmartCardTriggerDetails, 1604055326, 14831, 20267, 180, 79, 10, 145, 85, 177, 119, 188); +RT_INTERFACE!{interface ISmartCardTriggerDetails(ISmartCardTriggerDetailsVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardTriggerDetails] { + fn get_TriggerType(&self, out: *mut SmartCardTriggerType) -> HRESULT, + #[cfg(feature="windows-storage")] fn get_SourceAppletId(&self, out: *mut *mut super::super::storage::streams::IBuffer) -> HRESULT, + #[cfg(feature="windows-storage")] fn get_TriggerData(&self, out: *mut *mut super::super::storage::streams::IBuffer) -> HRESULT +}} +impl ISmartCardTriggerDetails { + #[inline] pub fn get_trigger_type(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).GetActiveDutyCyclePercentage)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_TriggerType)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn set_active_duty_cycle_percentage(&self, dutyCyclePercentage: f64) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).SetActiveDutyCyclePercentage)(self as *const _ as *mut _, dutyCyclePercentage); - if hr == S_OK { Ok(()) } else { err(hr) } + #[cfg(feature="windows-storage")] #[inline] pub fn get_source_applet_id(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_SourceAppletId)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn get_polarity(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_Polarity)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } + #[cfg(feature="windows-storage")] #[inline] pub fn get_trigger_data(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_TriggerData)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn set_polarity(&self, value: PwmPulsePolarity) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_Polarity)(self as *const _ as *mut _, value); - if hr == S_OK { Ok(()) } else { err(hr) } +} +RT_CLASS!{class SmartCardTriggerDetails: ISmartCardTriggerDetails} +DEFINE_IID!(IID_ISmartCardTriggerDetails2, 692438377, 35189, 19025, 158, 26, 95, 138, 118, 238, 81, 175); +RT_INTERFACE!{interface ISmartCardTriggerDetails2(ISmartCardTriggerDetails2Vtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardTriggerDetails2] { + fn get_Emulator(&self, out: *mut *mut SmartCardEmulator) -> HRESULT, + fn TryLaunchCurrentAppAsync(&self, arguments: HSTRING, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn TryLaunchCurrentAppWithBehaviorAsync(&self, arguments: HSTRING, behavior: SmartCardLaunchBehavior, out: *mut *mut foundation::IAsyncOperation) -> HRESULT +}} +impl ISmartCardTriggerDetails2 { + #[inline] pub fn get_emulator(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Emulator)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn start(&self) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).Start)(self as *const _ as *mut _); - if hr == S_OK { Ok(()) } else { err(hr) } + #[inline] pub fn try_launch_current_app_async(&self, arguments: &HStringArg) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).TryLaunchCurrentAppAsync)(self as *const _ as *mut _, arguments.get(), &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn stop(&self) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).Stop)(self as *const _ as *mut _); - if hr == S_OK { Ok(()) } else { err(hr) } + #[inline] pub fn try_launch_current_app_with_behavior_async(&self, arguments: &HStringArg, behavior: SmartCardLaunchBehavior) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).TryLaunchCurrentAppWithBehaviorAsync)(self as *const _ as *mut _, arguments.get(), behavior, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_is_started(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_IsStarted)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } +} +DEFINE_IID!(IID_ISmartCardTriggerDetails3, 3017982589, 6342, 19368, 131, 118, 239, 3, 212, 145, 38, 102); +RT_INTERFACE!{interface ISmartCardTriggerDetails3(ISmartCardTriggerDetails3Vtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardTriggerDetails3] { + fn get_SmartCard(&self, out: *mut *mut SmartCard) -> HRESULT +}} +impl ISmartCardTriggerDetails3 { + #[inline] pub fn get_smart_card(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_SmartCard)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } -RT_CLASS!{class PwmPin: IPwmPin} -RT_ENUM! { enum PwmPulsePolarity: i32 { - ActiveHigh (PwmPulsePolarity_ActiveHigh) = 0, ActiveLow (PwmPulsePolarity_ActiveLow) = 1, +RT_ENUM! { enum SmartCardTriggerType: i32 { + EmulatorTransaction (SmartCardTriggerType_EmulatorTransaction) = 0, EmulatorNearFieldEntry (SmartCardTriggerType_EmulatorNearFieldEntry) = 1, EmulatorNearFieldExit (SmartCardTriggerType_EmulatorNearFieldExit) = 2, EmulatorHostApplicationActivated (SmartCardTriggerType_EmulatorHostApplicationActivated) = 3, EmulatorAppletIdGroupRegistrationChanged (SmartCardTriggerType_EmulatorAppletIdGroupRegistrationChanged) = 4, ReaderCardAdded (SmartCardTriggerType_ReaderCardAdded) = 5, }} -pub mod provider { // Windows.Devices.Pwm.Provider +RT_ENUM! { enum SmartCardUnlockPromptingBehavior: i32 { + AllowUnlockPrompt (SmartCardUnlockPromptingBehavior_AllowUnlockPrompt) = 0, RequireUnlockPrompt (SmartCardUnlockPromptingBehavior_RequireUnlockPrompt) = 1, PreventUnlockPrompt (SmartCardUnlockPromptingBehavior_PreventUnlockPrompt) = 2, +}} +} // Windows.Devices.SmartCards +pub mod custom { // Windows.Devices.Custom use ::prelude::*; -DEFINE_IID!(IID_IPwmControllerProvider, 318789947, 58083, 16548, 183, 217, 72, 223, 240, 55, 122, 82); -RT_INTERFACE!{interface IPwmControllerProvider(IPwmControllerProviderVtbl): IInspectable(IInspectableVtbl) [IID_IPwmControllerProvider] { - fn get_PinCount(&self, out: *mut i32) -> HRESULT, - fn get_ActualFrequency(&self, out: *mut f64) -> HRESULT, - fn SetDesiredFrequency(&self, frequency: f64, out: *mut f64) -> HRESULT, - fn get_MaxFrequency(&self, out: *mut f64) -> HRESULT, - fn get_MinFrequency(&self, out: *mut f64) -> HRESULT, - fn AcquirePin(&self, pin: i32) -> HRESULT, - fn ReleasePin(&self, pin: i32) -> HRESULT, - fn EnablePin(&self, pin: i32) -> HRESULT, - fn DisablePin(&self, pin: i32) -> HRESULT, - fn SetPulseParameters(&self, pin: i32, dutyCycle: f64, invertPolarity: bool) -> HRESULT +DEFINE_IID!(IID_ICustomDevice, 3710919967, 50315, 17341, 188, 177, 222, 200, 143, 21, 20, 62); +RT_INTERFACE!{interface ICustomDevice(ICustomDeviceVtbl): IInspectable(IInspectableVtbl) [IID_ICustomDevice] { + #[cfg(feature="windows-storage")] fn get_InputStream(&self, out: *mut *mut super::super::storage::streams::IInputStream) -> HRESULT, + #[cfg(feature="windows-storage")] fn get_OutputStream(&self, out: *mut *mut super::super::storage::streams::IOutputStream) -> HRESULT, + #[cfg(feature="windows-storage")] fn SendIOControlAsync(&self, ioControlCode: *mut IIOControlCode, inputBuffer: *mut super::super::storage::streams::IBuffer, outputBuffer: *mut super::super::storage::streams::IBuffer, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + #[cfg(feature="windows-storage")] fn TrySendIOControlAsync(&self, ioControlCode: *mut IIOControlCode, inputBuffer: *mut super::super::storage::streams::IBuffer, outputBuffer: *mut super::super::storage::streams::IBuffer, out: *mut *mut foundation::IAsyncOperation) -> HRESULT }} -impl IPwmControllerProvider { - #[inline] pub fn get_pin_count(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_PinCount)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } - }} - #[inline] pub fn get_actual_frequency(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_ActualFrequency)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } - }} - #[inline] pub fn set_desired_frequency(&self, frequency: f64) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).SetDesiredFrequency)(self as *const _ as *mut _, frequency, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } - }} - #[inline] pub fn get_max_frequency(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_MaxFrequency)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } - }} - #[inline] pub fn get_min_frequency(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_MinFrequency)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } - }} - #[inline] pub fn acquire_pin(&self, pin: i32) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).AcquirePin)(self as *const _ as *mut _, pin); - if hr == S_OK { Ok(()) } else { err(hr) } - }} - #[inline] pub fn release_pin(&self, pin: i32) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).ReleasePin)(self as *const _ as *mut _, pin); - if hr == S_OK { Ok(()) } else { err(hr) } +impl ICustomDevice { + #[cfg(feature="windows-storage")] #[inline] pub fn get_input_stream(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_InputStream)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn enable_pin(&self, pin: i32) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).EnablePin)(self as *const _ as *mut _, pin); - if hr == S_OK { Ok(()) } else { err(hr) } + #[cfg(feature="windows-storage")] #[inline] pub fn get_output_stream(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_OutputStream)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn disable_pin(&self, pin: i32) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).DisablePin)(self as *const _ as *mut _, pin); - if hr == S_OK { Ok(()) } else { err(hr) } + #[cfg(feature="windows-storage")] #[inline] pub fn send_iocontrol_async(&self, ioControlCode: &IIOControlCode, inputBuffer: &super::super::storage::streams::IBuffer, outputBuffer: &super::super::storage::streams::IBuffer) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).SendIOControlAsync)(self as *const _ as *mut _, ioControlCode as *const _ as *mut _, inputBuffer as *const _ as *mut _, outputBuffer as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn set_pulse_parameters(&self, pin: i32, dutyCycle: f64, invertPolarity: bool) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).SetPulseParameters)(self as *const _ as *mut _, pin, dutyCycle, invertPolarity); - if hr == S_OK { Ok(()) } else { err(hr) } + #[cfg(feature="windows-storage")] #[inline] pub fn try_send_iocontrol_async(&self, ioControlCode: &IIOControlCode, inputBuffer: &super::super::storage::streams::IBuffer, outputBuffer: &super::super::storage::streams::IBuffer) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).TrySendIOControlAsync)(self as *const _ as *mut _, ioControlCode as *const _ as *mut _, inputBuffer as *const _ as *mut _, outputBuffer as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } -DEFINE_IID!(IID_IPwmProvider, 2737836584, 21233, 18352, 147, 73, 102, 186, 67, 210, 89, 2); -RT_INTERFACE!{interface IPwmProvider(IPwmProviderVtbl): IInspectable(IInspectableVtbl) [IID_IPwmProvider] { - fn GetControllers(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT +RT_CLASS!{class CustomDevice: ICustomDevice} +impl RtActivatable for CustomDevice {} +impl CustomDevice { + #[inline] pub fn get_device_selector(classGuid: Guid) -> Result { + >::get_activation_factory().get_device_selector(classGuid) + } + #[inline] pub fn from_id_async(deviceId: &HStringArg, desiredAccess: DeviceAccessMode, sharingMode: DeviceSharingMode) -> Result>> { + >::get_activation_factory().from_id_async(deviceId, desiredAccess, sharingMode) + } +} +DEFINE_CLSID!(CustomDevice(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,67,117,115,116,111,109,46,67,117,115,116,111,109,68,101,118,105,99,101,0]) [CLSID_CustomDevice]); +DEFINE_IID!(IID_ICustomDeviceStatics, 3357672210, 61260, 18097, 165, 142, 238, 179, 8, 220, 137, 23); +RT_INTERFACE!{static interface ICustomDeviceStatics(ICustomDeviceStaticsVtbl): IInspectable(IInspectableVtbl) [IID_ICustomDeviceStatics] { + fn GetDeviceSelector(&self, classGuid: Guid, out: *mut HSTRING) -> HRESULT, + fn FromIdAsync(&self, deviceId: HSTRING, desiredAccess: DeviceAccessMode, sharingMode: DeviceSharingMode, out: *mut *mut foundation::IAsyncOperation) -> HRESULT }} -impl IPwmProvider { - #[inline] pub fn get_controllers(&self) -> Result>>> { unsafe { +impl ICustomDeviceStatics { + #[inline] pub fn get_device_selector(&self, classGuid: Guid) -> Result { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetControllers)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).GetDeviceSelector)(self as *const _ as *mut _, classGuid, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn from_id_async(&self, deviceId: &HStringArg, desiredAccess: DeviceAccessMode, sharingMode: DeviceSharingMode) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).FromIdAsync)(self as *const _ as *mut _, deviceId.get(), desiredAccess, sharingMode, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } -} // Windows.Devices.Pwm.Provider -} // Windows.Devices.Pwm -pub mod spi { // Windows.Devices.Spi -use ::prelude::*; -DEFINE_IID!(IID_ISpiBusInfo, 2569618506, 21746, 18630, 185, 82, 156, 50, 252, 2, 198, 105); -RT_INTERFACE!{interface ISpiBusInfo(ISpiBusInfoVtbl): IInspectable(IInspectableVtbl) [IID_ISpiBusInfo] { - fn get_ChipSelectLineCount(&self, out: *mut i32) -> HRESULT, - fn get_MinClockFrequency(&self, out: *mut i32) -> HRESULT, - fn get_MaxClockFrequency(&self, out: *mut i32) -> HRESULT, - fn get_SupportedDataBitLengths(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT +RT_ENUM! { enum DeviceAccessMode: i32 { + Read (DeviceAccessMode_Read) = 0, Write (DeviceAccessMode_Write) = 1, ReadWrite (DeviceAccessMode_ReadWrite) = 2, }} -impl ISpiBusInfo { - #[inline] pub fn get_chip_select_line_count(&self) -> Result { unsafe { +RT_ENUM! { enum DeviceSharingMode: i32 { + Shared (DeviceSharingMode_Shared) = 0, Exclusive (DeviceSharingMode_Exclusive) = 1, +}} +DEFINE_IID!(IID_IIOControlCode, 244668903, 24776, 17269, 167, 97, 127, 136, 8, 6, 108, 96); +RT_INTERFACE!{interface IIOControlCode(IIOControlCodeVtbl): IInspectable(IInspectableVtbl) [IID_IIOControlCode] { + fn get_AccessMode(&self, out: *mut IOControlAccessMode) -> HRESULT, + fn get_BufferingMethod(&self, out: *mut IOControlBufferingMethod) -> HRESULT, + fn get_Function(&self, out: *mut u16) -> HRESULT, + fn get_DeviceType(&self, out: *mut u16) -> HRESULT, + fn get_ControlCode(&self, out: *mut u32) -> HRESULT +}} +impl IIOControlCode { + #[inline] pub fn get_access_mode(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_ChipSelectLineCount)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_AccessMode)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_min_clock_frequency(&self) -> Result { unsafe { + #[inline] pub fn get_buffering_method(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_MinClockFrequency)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_BufferingMethod)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_max_clock_frequency(&self) -> Result { unsafe { + #[inline] pub fn get_function(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_MaxClockFrequency)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_Function)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_supported_data_bit_lengths(&self) -> Result>>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_SupportedDataBitLengths)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + #[inline] pub fn get_device_type(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_DeviceType)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_control_code(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_ControlCode)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} } -RT_CLASS!{class SpiBusInfo: ISpiBusInfo} -DEFINE_IID!(IID_ISpiConnectionSettings, 1384358783, 63797, 19359, 167, 167, 58, 120, 144, 175, 165, 206); -RT_INTERFACE!{interface ISpiConnectionSettings(ISpiConnectionSettingsVtbl): IInspectable(IInspectableVtbl) [IID_ISpiConnectionSettings] { - fn get_ChipSelectLine(&self, out: *mut i32) -> HRESULT, - fn put_ChipSelectLine(&self, value: i32) -> HRESULT, - fn get_Mode(&self, out: *mut SpiMode) -> HRESULT, - fn put_Mode(&self, value: SpiMode) -> HRESULT, - fn get_DataBitLength(&self, out: *mut i32) -> HRESULT, - fn put_DataBitLength(&self, value: i32) -> HRESULT, - fn get_ClockFrequency(&self, out: *mut i32) -> HRESULT, - fn put_ClockFrequency(&self, value: i32) -> HRESULT, - fn get_SharingMode(&self, out: *mut SpiSharingMode) -> HRESULT, - fn put_SharingMode(&self, value: SpiSharingMode) -> HRESULT +DEFINE_IID!(IID_IIOControlCodeFactory, 2238348528, 19473, 17582, 175, 198, 184, 212, 162, 18, 120, 143); +RT_INTERFACE!{static interface IIOControlCodeFactory(IIOControlCodeFactoryVtbl): IInspectable(IInspectableVtbl) [IID_IIOControlCodeFactory] { + fn CreateIOControlCode(&self, deviceType: u16, function: u16, accessMode: IOControlAccessMode, bufferingMethod: IOControlBufferingMethod, out: *mut *mut IOControlCode) -> HRESULT }} -impl ISpiConnectionSettings { - #[inline] pub fn get_chip_select_line(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_ChipSelectLine)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } - }} - #[inline] pub fn set_chip_select_line(&self, value: i32) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_ChipSelectLine)(self as *const _ as *mut _, value); - if hr == S_OK { Ok(()) } else { err(hr) } - }} - #[inline] pub fn get_mode(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_Mode)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } - }} - #[inline] pub fn set_mode(&self, value: SpiMode) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_Mode)(self as *const _ as *mut _, value); - if hr == S_OK { Ok(()) } else { err(hr) } - }} - #[inline] pub fn get_data_bit_length(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_DataBitLength)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } - }} - #[inline] pub fn set_data_bit_length(&self, value: i32) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_DataBitLength)(self as *const _ as *mut _, value); - if hr == S_OK { Ok(()) } else { err(hr) } - }} - #[inline] pub fn get_clock_frequency(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_ClockFrequency)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } - }} - #[inline] pub fn set_clock_frequency(&self, value: i32) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_ClockFrequency)(self as *const _ as *mut _, value); - if hr == S_OK { Ok(()) } else { err(hr) } - }} - #[inline] pub fn get_sharing_mode(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_SharingMode)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } - }} - #[inline] pub fn set_sharing_mode(&self, value: SpiSharingMode) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_SharingMode)(self as *const _ as *mut _, value); - if hr == S_OK { Ok(()) } else { err(hr) } +impl IIOControlCodeFactory { + #[inline] pub fn create_iocontrol_code(&self, deviceType: u16, function: u16, accessMode: IOControlAccessMode, bufferingMethod: IOControlBufferingMethod) -> Result> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreateIOControlCode)(self as *const _ as *mut _, deviceType, function, accessMode, bufferingMethod, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } -RT_CLASS!{class SpiConnectionSettings: ISpiConnectionSettings} -impl RtActivatable for SpiConnectionSettings {} -impl SpiConnectionSettings { - #[inline] pub fn create(chipSelectLine: i32) -> Result> { - >::get_activation_factory().create(chipSelectLine) +RT_CLASS!{static class KnownDeviceTypes} +impl RtActivatable for KnownDeviceTypes {} +impl KnownDeviceTypes { + #[inline] pub fn get_unknown() -> Result { + >::get_activation_factory().get_unknown() } } -DEFINE_CLSID!(SpiConnectionSettings(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,83,112,105,46,83,112,105,67,111,110,110,101,99,116,105,111,110,83,101,116,116,105,110,103,115,0]) [CLSID_SpiConnectionSettings]); -DEFINE_IID!(IID_ISpiConnectionSettingsFactory, 4288219166, 4292, 17591, 159, 234, 167, 72, 181, 164, 111, 49); -RT_INTERFACE!{static interface ISpiConnectionSettingsFactory(ISpiConnectionSettingsFactoryVtbl): IInspectable(IInspectableVtbl) [IID_ISpiConnectionSettingsFactory] { - fn Create(&self, chipSelectLine: i32, out: *mut *mut SpiConnectionSettings) -> HRESULT +DEFINE_CLSID!(KnownDeviceTypes(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,67,117,115,116,111,109,46,75,110,111,119,110,68,101,118,105,99,101,84,121,112,101,115,0]) [CLSID_KnownDeviceTypes]); +DEFINE_IID!(IID_IKnownDeviceTypesStatics, 3998513602, 21576, 17882, 173, 27, 36, 148, 140, 35, 144, 148); +RT_INTERFACE!{static interface IKnownDeviceTypesStatics(IKnownDeviceTypesStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IKnownDeviceTypesStatics] { + fn get_Unknown(&self, out: *mut u16) -> HRESULT }} -impl ISpiConnectionSettingsFactory { - #[inline] pub fn create(&self, chipSelectLine: i32) -> Result> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, chipSelectLine, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } +impl IKnownDeviceTypesStatics { + #[inline] pub fn get_unknown(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Unknown)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} } -DEFINE_IID!(IID_ISpiController, 2832451625, 39061, 16729, 169, 52, 135, 65, 241, 238, 109, 39); -RT_INTERFACE!{interface ISpiController(ISpiControllerVtbl): IInspectable(IInspectableVtbl) [IID_ISpiController] { - fn GetDevice(&self, settings: *mut SpiConnectionSettings, out: *mut *mut SpiDevice) -> HRESULT +RT_ENUM! { enum IOControlAccessMode: i32 { + Any (IOControlAccessMode_Any) = 0, Read (IOControlAccessMode_Read) = 1, Write (IOControlAccessMode_Write) = 2, ReadWrite (IOControlAccessMode_ReadWrite) = 3, }} -impl ISpiController { - #[inline] pub fn get_device(&self, settings: &SpiConnectionSettings) -> Result>> { unsafe { +RT_ENUM! { enum IOControlBufferingMethod: i32 { + Buffered (IOControlBufferingMethod_Buffered) = 0, DirectInput (IOControlBufferingMethod_DirectInput) = 1, DirectOutput (IOControlBufferingMethod_DirectOutput) = 2, Neither (IOControlBufferingMethod_Neither) = 3, +}} +RT_CLASS!{class IOControlCode: IIOControlCode} +impl RtActivatable for IOControlCode {} +impl IOControlCode { + #[inline] pub fn create_iocontrol_code(deviceType: u16, function: u16, accessMode: IOControlAccessMode, bufferingMethod: IOControlBufferingMethod) -> Result> { + >::get_activation_factory().create_iocontrol_code(deviceType, function, accessMode, bufferingMethod) + } +} +DEFINE_CLSID!(IOControlCode(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,67,117,115,116,111,109,46,73,79,67,111,110,116,114,111,108,67,111,100,101,0]) [CLSID_IOControlCode]); +} // Windows.Devices.Custom +pub mod printers { // Windows.Devices.Printers +use ::prelude::*; +DEFINE_IID!(IID_IPrint3DDevice, 68959513, 38675, 17058, 152, 19, 125, 195, 51, 116, 40, 211); +RT_INTERFACE!{interface IPrint3DDevice(IPrint3DDeviceVtbl): IInspectable(IInspectableVtbl) [IID_IPrint3DDevice] { + fn get_PrintSchema(&self, out: *mut *mut PrintSchema) -> HRESULT +}} +impl IPrint3DDevice { + #[inline] pub fn get_print_schema(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetDevice)(self as *const _ as *mut _, settings as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_PrintSchema)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } -RT_CLASS!{class SpiController: ISpiController} -impl RtActivatable for SpiController {} -impl SpiController { - #[inline] pub fn get_default_async() -> Result>> { - >::get_activation_factory().get_default_async() +RT_CLASS!{class Print3DDevice: IPrint3DDevice} +impl RtActivatable for Print3DDevice {} +impl Print3DDevice { + #[inline] pub fn from_id_async(deviceId: &HStringArg) -> Result>> { + >::get_activation_factory().from_id_async(deviceId) } - #[inline] pub fn get_controllers_async(provider: &provider::ISpiProvider) -> Result>>> { - >::get_activation_factory().get_controllers_async(provider) + #[inline] pub fn get_device_selector() -> Result { + >::get_activation_factory().get_device_selector() } } -DEFINE_CLSID!(SpiController(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,83,112,105,46,83,112,105,67,111,110,116,114,111,108,108,101,114,0]) [CLSID_SpiController]); -DEFINE_IID!(IID_ISpiControllerStatics, 223488482, 5003, 20040, 185, 100, 79, 47, 121, 185, 197, 162); -RT_INTERFACE!{static interface ISpiControllerStatics(ISpiControllerStaticsVtbl): IInspectable(IInspectableVtbl) [IID_ISpiControllerStatics] { - fn GetDefaultAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, - fn GetControllersAsync(&self, provider: *mut provider::ISpiProvider, out: *mut *mut foundation::IAsyncOperation>) -> HRESULT +DEFINE_CLSID!(Print3DDevice(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,80,114,105,110,116,101,114,115,46,80,114,105,110,116,51,68,68,101,118,105,99,101,0]) [CLSID_Print3DDevice]); +DEFINE_IID!(IID_IPrint3DDeviceStatics, 4259537418, 26573, 16823, 163, 68, 81, 80, 161, 253, 117, 181); +RT_INTERFACE!{static interface IPrint3DDeviceStatics(IPrint3DDeviceStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IPrint3DDeviceStatics] { + fn FromIdAsync(&self, deviceId: HSTRING, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn GetDeviceSelector(&self, out: *mut HSTRING) -> HRESULT }} -impl ISpiControllerStatics { - #[inline] pub fn get_default_async(&self) -> Result>> { unsafe { +impl IPrint3DDeviceStatics { + #[inline] pub fn from_id_async(&self, deviceId: &HStringArg) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetDefaultAsync)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).FromIdAsync)(self as *const _ as *mut _, deviceId.get(), &mut out); if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_controllers_async(&self, provider: &provider::ISpiProvider) -> Result>>> { unsafe { + #[inline] pub fn get_device_selector(&self) -> Result { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetControllersAsync)(self as *const _ as *mut _, provider as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).GetDeviceSelector)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} +} +DEFINE_IID!(IID_IPrintSchema, 3266937622, 9912, 19451, 129, 56, 159, 150, 44, 34, 163, 91); +RT_INTERFACE!{interface IPrintSchema(IPrintSchemaVtbl): IInspectable(IInspectableVtbl) [IID_IPrintSchema] { + #[cfg(feature="windows-storage")] fn GetDefaultPrintTicketAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + #[cfg(feature="windows-storage")] fn GetCapabilitiesAsync(&self, constrainTicket: *mut super::super::storage::streams::IRandomAccessStreamWithContentType, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + #[cfg(feature="windows-storage")] fn MergeAndValidateWithDefaultPrintTicketAsync(&self, deltaTicket: *mut super::super::storage::streams::IRandomAccessStreamWithContentType, out: *mut *mut foundation::IAsyncOperation) -> HRESULT +}} +impl IPrintSchema { + #[cfg(feature="windows-storage")] #[inline] pub fn get_default_print_ticket_async(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetDefaultPrintTicketAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[cfg(feature="windows-storage")] #[inline] pub fn get_capabilities_async(&self, constrainTicket: &super::super::storage::streams::IRandomAccessStreamWithContentType) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetCapabilitiesAsync)(self as *const _ as *mut _, constrainTicket as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[cfg(feature="windows-storage")] #[inline] pub fn merge_and_validate_with_default_print_ticket_async(&self, deltaTicket: &super::super::storage::streams::IRandomAccessStreamWithContentType) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).MergeAndValidateWithDefaultPrintTicketAsync)(self as *const _ as *mut _, deltaTicket as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } -DEFINE_IID!(IID_ISpiDevice, 97858925, 4534, 19769, 132, 213, 149, 223, 180, 201, 242, 206); -RT_INTERFACE!{interface ISpiDevice(ISpiDeviceVtbl): IInspectable(IInspectableVtbl) [IID_ISpiDevice] { - fn get_DeviceId(&self, out: *mut HSTRING) -> HRESULT, - fn get_ConnectionSettings(&self, out: *mut *mut SpiConnectionSettings) -> HRESULT, - fn Write(&self, bufferSize: u32, buffer: *mut u8) -> HRESULT, - fn Read(&self, bufferSize: u32, buffer: *mut u8) -> HRESULT, - fn TransferSequential(&self, writeBufferSize: u32, writeBuffer: *mut u8, readBufferSize: u32, readBuffer: *mut u8) -> HRESULT, - fn TransferFullDuplex(&self, writeBufferSize: u32, writeBuffer: *mut u8, readBufferSize: u32, readBuffer: *mut u8) -> HRESULT +RT_CLASS!{class PrintSchema: IPrintSchema} +pub mod extensions { // Windows.Devices.Printers.Extensions +use ::prelude::*; +DEFINE_IID!(IID_IPrint3DWorkflow, 3312415933, 13929, 19046, 171, 66, 200, 21, 25, 48, 205, 52); +RT_INTERFACE!{interface IPrint3DWorkflow(IPrint3DWorkflowVtbl): IInspectable(IInspectableVtbl) [IID_IPrint3DWorkflow] { + fn get_DeviceID(&self, out: *mut HSTRING) -> HRESULT, + fn GetPrintModelPackage(&self, out: *mut *mut IInspectable) -> HRESULT, + fn get_IsPrintReady(&self, out: *mut bool) -> HRESULT, + fn put_IsPrintReady(&self, value: bool) -> HRESULT, + fn add_PrintRequested(&self, eventHandler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_PrintRequested(&self, eventCookie: foundation::EventRegistrationToken) -> HRESULT }} -impl ISpiDevice { +impl IPrint3DWorkflow { #[inline] pub fn get_device_id(&self) -> Result { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_DeviceId)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_DeviceID)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_connection_settings(&self) -> Result>> { unsafe { + #[inline] pub fn get_print_model_package(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_ConnectionSettings)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).GetPrintModelPackage)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn write(&self, buffer: &[u8]) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).Write)(self as *const _ as *mut _, buffer.len() as u32, buffer.as_ptr() as *mut _); - if hr == S_OK { Ok(()) } else { err(hr) } + #[inline] pub fn get_is_print_ready(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_IsPrintReady)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn read(&self, buffer: &mut [u8]) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).Read)(self as *const _ as *mut _, buffer.len() as u32, buffer.as_mut_ptr() as *mut _); + #[inline] pub fn set_is_print_ready(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_IsPrintReady)(self as *const _ as *mut _, value); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn transfer_sequential(&self, writeBuffer: &[u8], readBuffer: &mut [u8]) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).TransferSequential)(self as *const _ as *mut _, writeBuffer.len() as u32, writeBuffer.as_ptr() as *mut _, readBuffer.len() as u32, readBuffer.as_mut_ptr() as *mut _); - if hr == S_OK { Ok(()) } else { err(hr) } + #[inline] pub fn add_print_requested(&self, eventHandler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_PrintRequested)(self as *const _ as *mut _, eventHandler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn transfer_full_duplex(&self, writeBuffer: &[u8], readBuffer: &mut [u8]) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).TransferFullDuplex)(self as *const _ as *mut _, writeBuffer.len() as u32, writeBuffer.as_ptr() as *mut _, readBuffer.len() as u32, readBuffer.as_mut_ptr() as *mut _); + #[inline] pub fn remove_print_requested(&self, eventCookie: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_PrintRequested)(self as *const _ as *mut _, eventCookie); if hr == S_OK { Ok(()) } else { err(hr) } }} } -RT_CLASS!{class SpiDevice: ISpiDevice} -impl RtActivatable for SpiDevice {} -impl SpiDevice { - #[inline] pub fn get_device_selector() -> Result { - >::get_activation_factory().get_device_selector() - } - #[inline] pub fn get_device_selector_from_friendly_name(friendlyName: &HStringArg) -> Result { - >::get_activation_factory().get_device_selector_from_friendly_name(friendlyName) - } - #[inline] pub fn get_bus_info(busId: &HStringArg) -> Result>> { - >::get_activation_factory().get_bus_info(busId) - } - #[inline] pub fn from_id_async(busId: &HStringArg, settings: &SpiConnectionSettings) -> Result>> { - >::get_activation_factory().from_id_async(busId, settings) - } -} -DEFINE_CLSID!(SpiDevice(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,83,112,105,46,83,112,105,68,101,118,105,99,101,0]) [CLSID_SpiDevice]); -DEFINE_IID!(IID_ISpiDeviceStatics, 2725832025, 22304, 19775, 189, 147, 86, 245, 255, 90, 88, 121); -RT_INTERFACE!{static interface ISpiDeviceStatics(ISpiDeviceStaticsVtbl): IInspectable(IInspectableVtbl) [IID_ISpiDeviceStatics] { - fn GetDeviceSelector(&self, out: *mut HSTRING) -> HRESULT, - fn GetDeviceSelectorFromFriendlyName(&self, friendlyName: HSTRING, out: *mut HSTRING) -> HRESULT, - fn GetBusInfo(&self, busId: HSTRING, out: *mut *mut SpiBusInfo) -> HRESULT, - fn FromIdAsync(&self, busId: HSTRING, settings: *mut SpiConnectionSettings, out: *mut *mut foundation::IAsyncOperation) -> HRESULT +RT_CLASS!{class Print3DWorkflow: IPrint3DWorkflow} +DEFINE_IID!(IID_IPrint3DWorkflow2, 2728838479, 35521, 18712, 151, 65, 227, 79, 48, 4, 35, 158); +RT_INTERFACE!{interface IPrint3DWorkflow2(IPrint3DWorkflow2Vtbl): IInspectable(IInspectableVtbl) [IID_IPrint3DWorkflow2] { + fn add_PrinterChanged(&self, eventHandler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_PrinterChanged(&self, eventCookie: foundation::EventRegistrationToken) -> HRESULT }} -impl ISpiDeviceStatics { - #[inline] pub fn get_device_selector(&self) -> Result { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetDeviceSelector)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } - }} - #[inline] pub fn get_device_selector_from_friendly_name(&self, friendlyName: &HStringArg) -> Result { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetDeviceSelectorFromFriendlyName)(self as *const _ as *mut _, friendlyName.get(), &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } - }} - #[inline] pub fn get_bus_info(&self, busId: &HStringArg) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetBusInfo)(self as *const _ as *mut _, busId.get(), &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } - }} - #[inline] pub fn from_id_async(&self, busId: &HStringArg, settings: &SpiConnectionSettings) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).FromIdAsync)(self as *const _ as *mut _, busId.get(), settings as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } - }} -} -RT_ENUM! { enum SpiMode: i32 { - Mode0 (SpiMode_Mode0) = 0, Mode1 (SpiMode_Mode1) = 1, Mode2 (SpiMode_Mode2) = 2, Mode3 (SpiMode_Mode3) = 3, -}} -RT_ENUM! { enum SpiSharingMode: i32 { - Exclusive (SpiSharingMode_Exclusive) = 0, Shared (SpiSharingMode_Shared) = 1, -}} -pub mod provider { // Windows.Devices.Spi.Provider -use ::prelude::*; -DEFINE_IID!(IID_IProviderSpiConnectionSettings, 4127409488, 42306, 20160, 150, 1, 164, 221, 104, 248, 105, 123); -RT_INTERFACE!{interface IProviderSpiConnectionSettings(IProviderSpiConnectionSettingsVtbl): IInspectable(IInspectableVtbl) [IID_IProviderSpiConnectionSettings] { - fn get_ChipSelectLine(&self, out: *mut i32) -> HRESULT, - fn put_ChipSelectLine(&self, value: i32) -> HRESULT, - fn get_Mode(&self, out: *mut ProviderSpiMode) -> HRESULT, - fn put_Mode(&self, value: ProviderSpiMode) -> HRESULT, - fn get_DataBitLength(&self, out: *mut i32) -> HRESULT, - fn put_DataBitLength(&self, value: i32) -> HRESULT, - fn get_ClockFrequency(&self, out: *mut i32) -> HRESULT, - fn put_ClockFrequency(&self, value: i32) -> HRESULT, - fn get_SharingMode(&self, out: *mut ProviderSpiSharingMode) -> HRESULT, - fn put_SharingMode(&self, value: ProviderSpiSharingMode) -> HRESULT -}} -impl IProviderSpiConnectionSettings { - #[inline] pub fn get_chip_select_line(&self) -> Result { unsafe { +impl IPrint3DWorkflow2 { + #[inline] pub fn add_printer_changed(&self, eventHandler: &foundation::TypedEventHandler) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_ChipSelectLine)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).add_PrinterChanged)(self as *const _ as *mut _, eventHandler as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn set_chip_select_line(&self, value: i32) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_ChipSelectLine)(self as *const _ as *mut _, value); + #[inline] pub fn remove_printer_changed(&self, eventCookie: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_PrinterChanged)(self as *const _ as *mut _, eventCookie); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_mode(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_Mode)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } - }} - #[inline] pub fn set_mode(&self, value: ProviderSpiMode) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_Mode)(self as *const _ as *mut _, value); - if hr == S_OK { Ok(()) } else { err(hr) } +} +RT_ENUM! { enum Print3DWorkflowDetail: i32 { + Unknown (Print3DWorkflowDetail_Unknown) = 0, ModelExceedsPrintBed (Print3DWorkflowDetail_ModelExceedsPrintBed) = 1, UploadFailed (Print3DWorkflowDetail_UploadFailed) = 2, InvalidMaterialSelection (Print3DWorkflowDetail_InvalidMaterialSelection) = 3, InvalidModel (Print3DWorkflowDetail_InvalidModel) = 4, ModelNotManifold (Print3DWorkflowDetail_ModelNotManifold) = 5, InvalidPrintTicket (Print3DWorkflowDetail_InvalidPrintTicket) = 6, +}} +DEFINE_IID!(IID_IPrint3DWorkflowPrinterChangedEventArgs, 1159881730, 38396, 18503, 147, 179, 19, 77, 191, 92, 96, 247); +RT_INTERFACE!{interface IPrint3DWorkflowPrinterChangedEventArgs(IPrint3DWorkflowPrinterChangedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IPrint3DWorkflowPrinterChangedEventArgs] { + fn get_NewDeviceId(&self, out: *mut HSTRING) -> HRESULT +}} +impl IPrint3DWorkflowPrinterChangedEventArgs { + #[inline] pub fn get_new_device_id(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_NewDeviceId)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_data_bit_length(&self) -> Result { unsafe { +} +RT_CLASS!{class Print3DWorkflowPrinterChangedEventArgs: IPrint3DWorkflowPrinterChangedEventArgs} +DEFINE_IID!(IID_IPrint3DWorkflowPrintRequestedEventArgs, 435734616, 23240, 19285, 138, 95, 230, 21, 103, 218, 251, 77); +RT_INTERFACE!{interface IPrint3DWorkflowPrintRequestedEventArgs(IPrint3DWorkflowPrintRequestedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IPrint3DWorkflowPrintRequestedEventArgs] { + fn get_Status(&self, out: *mut Print3DWorkflowStatus) -> HRESULT, + fn SetExtendedStatus(&self, value: Print3DWorkflowDetail) -> HRESULT, + fn SetSource(&self, source: *mut IInspectable) -> HRESULT, + fn SetSourceChanged(&self, value: bool) -> HRESULT +}} +impl IPrint3DWorkflowPrintRequestedEventArgs { + #[inline] pub fn get_status(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_DataBitLength)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_Status)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn set_data_bit_length(&self, value: i32) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_DataBitLength)(self as *const _ as *mut _, value); + #[inline] pub fn set_extended_status(&self, value: Print3DWorkflowDetail) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).SetExtendedStatus)(self as *const _ as *mut _, value); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_clock_frequency(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_ClockFrequency)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } - }} - #[inline] pub fn set_clock_frequency(&self, value: i32) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_ClockFrequency)(self as *const _ as *mut _, value); + #[inline] pub fn set_source(&self, source: &IInspectable) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).SetSource)(self as *const _ as *mut _, source as *const _ as *mut _); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_sharing_mode(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_SharingMode)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } - }} - #[inline] pub fn set_sharing_mode(&self, value: ProviderSpiSharingMode) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_SharingMode)(self as *const _ as *mut _, value); + #[inline] pub fn set_source_changed(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).SetSourceChanged)(self as *const _ as *mut _, value); if hr == S_OK { Ok(()) } else { err(hr) } }} } -RT_CLASS!{class ProviderSpiConnectionSettings: IProviderSpiConnectionSettings} -impl RtActivatable for ProviderSpiConnectionSettings {} -impl ProviderSpiConnectionSettings { - #[inline] pub fn create(chipSelectLine: i32) -> Result> { - >::get_activation_factory().create(chipSelectLine) +RT_CLASS!{class Print3DWorkflowPrintRequestedEventArgs: IPrint3DWorkflowPrintRequestedEventArgs} +RT_ENUM! { enum Print3DWorkflowStatus: i32 { + Abandoned (Print3DWorkflowStatus_Abandoned) = 0, Canceled (Print3DWorkflowStatus_Canceled) = 1, Failed (Print3DWorkflowStatus_Failed) = 2, Slicing (Print3DWorkflowStatus_Slicing) = 3, Submitted (Print3DWorkflowStatus_Submitted) = 4, +}} +RT_CLASS!{static class PrintExtensionContext} +impl RtActivatable for PrintExtensionContext {} +impl PrintExtensionContext { + #[inline] pub fn from_device_id(deviceId: &HStringArg) -> Result>> { + >::get_activation_factory().from_device_id(deviceId) } } -DEFINE_CLSID!(ProviderSpiConnectionSettings(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,83,112,105,46,80,114,111,118,105,100,101,114,46,80,114,111,118,105,100,101,114,83,112,105,67,111,110,110,101,99,116,105,111,110,83,101,116,116,105,110,103,115,0]) [CLSID_ProviderSpiConnectionSettings]); -DEFINE_IID!(IID_IProviderSpiConnectionSettingsFactory, 1715825498, 3193, 17379, 159, 60, 229, 151, 128, 172, 24, 250); -RT_INTERFACE!{static interface IProviderSpiConnectionSettingsFactory(IProviderSpiConnectionSettingsFactoryVtbl): IInspectable(IInspectableVtbl) [IID_IProviderSpiConnectionSettingsFactory] { - fn Create(&self, chipSelectLine: i32, out: *mut *mut ProviderSpiConnectionSettings) -> HRESULT +DEFINE_CLSID!(PrintExtensionContext(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,80,114,105,110,116,101,114,115,46,69,120,116,101,110,115,105,111,110,115,46,80,114,105,110,116,69,120,116,101,110,115,105,111,110,67,111,110,116,101,120,116,0]) [CLSID_PrintExtensionContext]); +DEFINE_IID!(IID_IPrintExtensionContextStatic, 3876429761, 65401, 19108, 140, 155, 12, 147, 174, 223, 222, 138); +RT_INTERFACE!{static interface IPrintExtensionContextStatic(IPrintExtensionContextStaticVtbl): IInspectable(IInspectableVtbl) [IID_IPrintExtensionContextStatic] { + fn FromDeviceId(&self, deviceId: HSTRING, out: *mut *mut IInspectable) -> HRESULT }} -impl IProviderSpiConnectionSettingsFactory { - #[inline] pub fn create(&self, chipSelectLine: i32) -> Result> { unsafe { +impl IPrintExtensionContextStatic { + #[inline] pub fn from_device_id(&self, deviceId: &HStringArg) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, chipSelectLine, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).FromDeviceId)(self as *const _ as *mut _, deviceId.get(), &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } -RT_ENUM! { enum ProviderSpiMode: i32 { - Mode0 (ProviderSpiMode_Mode0) = 0, Mode1 (ProviderSpiMode_Mode1) = 1, Mode2 (ProviderSpiMode_Mode2) = 2, Mode3 (ProviderSpiMode_Mode3) = 3, -}} -RT_ENUM! { enum ProviderSpiSharingMode: i32 { - Exclusive (ProviderSpiSharingMode_Exclusive) = 0, Shared (ProviderSpiSharingMode_Shared) = 1, -}} -DEFINE_IID!(IID_ISpiControllerProvider, 3244844292, 718, 16934, 163, 133, 79, 17, 251, 4, 180, 27); -RT_INTERFACE!{interface ISpiControllerProvider(ISpiControllerProviderVtbl): IInspectable(IInspectableVtbl) [IID_ISpiControllerProvider] { - fn GetDeviceProvider(&self, settings: *mut ProviderSpiConnectionSettings, out: *mut *mut ISpiDeviceProvider) -> HRESULT +DEFINE_IID!(IID_IPrintNotificationEventDetails, 3759033482, 18472, 19873, 139, 184, 134, 114, 223, 133, 21, 231); +RT_INTERFACE!{interface IPrintNotificationEventDetails(IPrintNotificationEventDetailsVtbl): IInspectable(IInspectableVtbl) [IID_IPrintNotificationEventDetails] { + fn get_PrinterName(&self, out: *mut HSTRING) -> HRESULT, + fn get_EventData(&self, out: *mut HSTRING) -> HRESULT, + fn put_EventData(&self, value: HSTRING) -> HRESULT }} -impl ISpiControllerProvider { - #[inline] pub fn get_device_provider(&self, settings: &ProviderSpiConnectionSettings) -> Result>> { unsafe { +impl IPrintNotificationEventDetails { + #[inline] pub fn get_printer_name(&self) -> Result { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetDeviceProvider)(self as *const _ as *mut _, settings as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).get_PrinterName)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} -} -DEFINE_IID!(IID_ISpiDeviceProvider, 219952195, 12363, 16476, 180, 247, 245, 171, 16, 116, 70, 30); -RT_INTERFACE!{interface ISpiDeviceProvider(ISpiDeviceProviderVtbl): IInspectable(IInspectableVtbl) [IID_ISpiDeviceProvider] { - fn get_DeviceId(&self, out: *mut HSTRING) -> HRESULT, - fn get_ConnectionSettings(&self, out: *mut *mut ProviderSpiConnectionSettings) -> HRESULT, - fn Write(&self, bufferSize: u32, buffer: *mut u8) -> HRESULT, - fn Read(&self, bufferSize: u32, buffer: *mut u8) -> HRESULT, - fn TransferSequential(&self, writeBufferSize: u32, writeBuffer: *mut u8, readBufferSize: u32, readBuffer: *mut u8) -> HRESULT, - fn TransferFullDuplex(&self, writeBufferSize: u32, writeBuffer: *mut u8, readBufferSize: u32, readBuffer: *mut u8) -> HRESULT -}} -impl ISpiDeviceProvider { - #[inline] pub fn get_device_id(&self) -> Result { unsafe { + #[inline] pub fn get_event_data(&self) -> Result { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_DeviceId)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_EventData)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_connection_settings(&self) -> Result>> { unsafe { + #[inline] pub fn set_event_data(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_EventData)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class PrintNotificationEventDetails: IPrintNotificationEventDetails} +DEFINE_IID!(IID_IPrintTaskConfiguration, 3821151313, 15012, 18565, 146, 64, 49, 31, 95, 143, 190, 157); +RT_INTERFACE!{interface IPrintTaskConfiguration(IPrintTaskConfigurationVtbl): IInspectable(IInspectableVtbl) [IID_IPrintTaskConfiguration] { + fn get_PrinterExtensionContext(&self, out: *mut *mut IInspectable) -> HRESULT, + fn add_SaveRequested(&self, eventHandler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_SaveRequested(&self, eventCookie: foundation::EventRegistrationToken) -> HRESULT +}} +impl IPrintTaskConfiguration { + #[inline] pub fn get_printer_extension_context(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_ConnectionSettings)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_PrinterExtensionContext)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn write(&self, buffer: &[u8]) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).Write)(self as *const _ as *mut _, buffer.len() as u32, buffer.as_ptr() as *mut _); + #[inline] pub fn add_save_requested(&self, eventHandler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_SaveRequested)(self as *const _ as *mut _, eventHandler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_save_requested(&self, eventCookie: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_SaveRequested)(self as *const _ as *mut _, eventCookie); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn read(&self, buffer: &mut [u8]) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).Read)(self as *const _ as *mut _, buffer.len() as u32, buffer.as_mut_ptr() as *mut _); +} +RT_CLASS!{class PrintTaskConfiguration: IPrintTaskConfiguration} +DEFINE_IID!(IID_IPrintTaskConfigurationSaveRequest, 4004458443, 25118, 19298, 172, 119, 178, 129, 204, 224, 141, 96); +RT_INTERFACE!{interface IPrintTaskConfigurationSaveRequest(IPrintTaskConfigurationSaveRequestVtbl): IInspectable(IInspectableVtbl) [IID_IPrintTaskConfigurationSaveRequest] { + fn Cancel(&self) -> HRESULT, + fn Save(&self, printerExtensionContext: *mut IInspectable) -> HRESULT, + fn GetDeferral(&self, out: *mut *mut PrintTaskConfigurationSaveRequestedDeferral) -> HRESULT, + fn get_Deadline(&self, out: *mut foundation::DateTime) -> HRESULT +}} +impl IPrintTaskConfigurationSaveRequest { + #[inline] pub fn cancel(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).Cancel)(self as *const _ as *mut _); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn transfer_sequential(&self, writeBuffer: &[u8], readBuffer: &mut [u8]) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).TransferSequential)(self as *const _ as *mut _, writeBuffer.len() as u32, writeBuffer.as_ptr() as *mut _, readBuffer.len() as u32, readBuffer.as_mut_ptr() as *mut _); + #[inline] pub fn save(&self, printerExtensionContext: &IInspectable) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).Save)(self as *const _ as *mut _, printerExtensionContext as *const _ as *mut _); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn transfer_full_duplex(&self, writeBuffer: &[u8], readBuffer: &mut [u8]) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).TransferFullDuplex)(self as *const _ as *mut _, writeBuffer.len() as u32, writeBuffer.as_ptr() as *mut _, readBuffer.len() as u32, readBuffer.as_mut_ptr() as *mut _); + #[inline] pub fn get_deferral(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetDeferral)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_deadline(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Deadline)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} +RT_CLASS!{class PrintTaskConfigurationSaveRequest: IPrintTaskConfigurationSaveRequest} +DEFINE_IID!(IID_IPrintTaskConfigurationSaveRequestedDeferral, 3914978664, 63273, 17572, 135, 29, 189, 6, 40, 105, 106, 51); +RT_INTERFACE!{interface IPrintTaskConfigurationSaveRequestedDeferral(IPrintTaskConfigurationSaveRequestedDeferralVtbl): IInspectable(IInspectableVtbl) [IID_IPrintTaskConfigurationSaveRequestedDeferral] { + fn Complete(&self) -> HRESULT +}} +impl IPrintTaskConfigurationSaveRequestedDeferral { + #[inline] pub fn complete(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).Complete)(self as *const _ as *mut _); if hr == S_OK { Ok(()) } else { err(hr) } }} } -DEFINE_IID!(IID_ISpiProvider, 2528403938, 30676, 18638, 170, 160, 117, 113, 90, 131, 98, 207); -RT_INTERFACE!{interface ISpiProvider(ISpiProviderVtbl): IInspectable(IInspectableVtbl) [IID_ISpiProvider] { - fn GetControllersAsync(&self, out: *mut *mut foundation::IAsyncOperation>) -> HRESULT +RT_CLASS!{class PrintTaskConfigurationSaveRequestedDeferral: IPrintTaskConfigurationSaveRequestedDeferral} +DEFINE_IID!(IID_IPrintTaskConfigurationSaveRequestedEventArgs, 3765184633, 3425, 18744, 145, 208, 150, 164, 91, 238, 132, 121); +RT_INTERFACE!{interface IPrintTaskConfigurationSaveRequestedEventArgs(IPrintTaskConfigurationSaveRequestedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IPrintTaskConfigurationSaveRequestedEventArgs] { + fn get_Request(&self, out: *mut *mut PrintTaskConfigurationSaveRequest) -> HRESULT }} -impl ISpiProvider { - #[inline] pub fn get_controllers_async(&self) -> Result>>> { unsafe { +impl IPrintTaskConfigurationSaveRequestedEventArgs { + #[inline] pub fn get_request(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetControllersAsync)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).get_Request)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } -} // Windows.Devices.Spi.Provider -} // Windows.Devices.Spi -pub mod smartcards { // Windows.Devices.SmartCards +RT_CLASS!{class PrintTaskConfigurationSaveRequestedEventArgs: IPrintTaskConfigurationSaveRequestedEventArgs} +} // Windows.Devices.Printers.Extensions +} // Windows.Devices.Printers +pub mod adc { // Windows.Devices.Adc use ::prelude::*; -DEFINE_IID!(IID_ICardAddedEventArgs, 414969752, 61835, 19923, 177, 24, 223, 178, 200, 226, 60, 198); -RT_INTERFACE!{interface ICardAddedEventArgs(ICardAddedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_ICardAddedEventArgs] { - fn get_SmartCard(&self, out: *mut *mut SmartCard) -> HRESULT -}} -impl ICardAddedEventArgs { - #[inline] pub fn get_smart_card(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_SmartCard)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } - }} -} -RT_CLASS!{class CardAddedEventArgs: ICardAddedEventArgs} -DEFINE_IID!(IID_ICardRemovedEventArgs, 355670703, 8919, 18757, 175, 201, 3, 180, 111, 66, 166, 205); -RT_INTERFACE!{interface ICardRemovedEventArgs(ICardRemovedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_ICardRemovedEventArgs] { - fn get_SmartCard(&self, out: *mut *mut SmartCard) -> HRESULT -}} -impl ICardRemovedEventArgs { - #[inline] pub fn get_smart_card(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_SmartCard)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } - }} -} -RT_CLASS!{class CardRemovedEventArgs: ICardRemovedEventArgs} -DEFINE_IID!(IID_ISmartCard, 460425329, 25652, 17396, 181, 90, 106, 41, 98, 56, 112, 170); -RT_INTERFACE!{interface ISmartCard(ISmartCardVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCard] { - fn get_Reader(&self, out: *mut *mut SmartCardReader) -> HRESULT, - fn GetStatusAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, - #[cfg(feature="windows-storage")] fn GetAnswerToResetAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT +DEFINE_IID!(IID_IAdcChannel, 67892244, 9608, 19030, 171, 239, 115, 162, 96, 172, 198, 10); +RT_INTERFACE!{interface IAdcChannel(IAdcChannelVtbl): IInspectable(IInspectableVtbl) [IID_IAdcChannel] { + fn get_Controller(&self, out: *mut *mut AdcController) -> HRESULT, + fn ReadValue(&self, out: *mut i32) -> HRESULT, + fn ReadRatio(&self, out: *mut f64) -> HRESULT }} -impl ISmartCard { - #[inline] pub fn get_reader(&self) -> Result>> { unsafe { +impl IAdcChannel { + #[inline] pub fn get_controller(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Reader)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_Controller)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn get_status_async(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetStatusAsync)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + #[inline] pub fn read_value(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).ReadValue)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} - #[cfg(feature="windows-storage")] #[inline] pub fn get_answer_to_reset_async(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetAnswerToResetAsync)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + #[inline] pub fn read_ratio(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).ReadRatio)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} } -RT_CLASS!{class SmartCard: ISmartCard} -RT_ENUM! { enum SmartCardActivationPolicyChangeResult: i32 { - Denied (SmartCardActivationPolicyChangeResult_Denied) = 0, Allowed (SmartCardActivationPolicyChangeResult_Allowed) = 1, +RT_CLASS!{class AdcChannel: IAdcChannel} +RT_ENUM! { enum AdcChannelMode: i32 { + SingleEnded (AdcChannelMode_SingleEnded) = 0, Differential (AdcChannelMode_Differential) = 1, }} -DEFINE_IID!(IID_ISmartCardAppletIdGroup, 2108777958, 25188, 22260, 94, 3, 200, 99, 133, 57, 94, 177); -RT_INTERFACE!{interface ISmartCardAppletIdGroup(ISmartCardAppletIdGroupVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardAppletIdGroup] { - fn get_DisplayName(&self, out: *mut HSTRING) -> HRESULT, - fn put_DisplayName(&self, value: HSTRING) -> HRESULT, - #[cfg(not(feature="windows-storage"))] fn __Dummy2(&self) -> (), - #[cfg(feature="windows-storage")] fn get_AppletIds(&self, out: *mut *mut foundation::collections::IVector) -> HRESULT, - fn get_SmartCardEmulationCategory(&self, out: *mut SmartCardEmulationCategory) -> HRESULT, - fn put_SmartCardEmulationCategory(&self, value: SmartCardEmulationCategory) -> HRESULT, - fn get_SmartCardEmulationType(&self, out: *mut SmartCardEmulationType) -> HRESULT, - fn put_SmartCardEmulationType(&self, value: SmartCardEmulationType) -> HRESULT, - fn get_AutomaticEnablement(&self, out: *mut bool) -> HRESULT, - fn put_AutomaticEnablement(&self, value: bool) -> HRESULT +DEFINE_IID!(IID_IAdcController, 712434864, 43158, 16921, 134, 182, 234, 140, 220, 233, 143, 86); +RT_INTERFACE!{interface IAdcController(IAdcControllerVtbl): IInspectable(IInspectableVtbl) [IID_IAdcController] { + fn get_ChannelCount(&self, out: *mut i32) -> HRESULT, + fn get_ResolutionInBits(&self, out: *mut i32) -> HRESULT, + fn get_MinValue(&self, out: *mut i32) -> HRESULT, + fn get_MaxValue(&self, out: *mut i32) -> HRESULT, + fn get_ChannelMode(&self, out: *mut AdcChannelMode) -> HRESULT, + fn put_ChannelMode(&self, value: AdcChannelMode) -> HRESULT, + fn IsChannelModeSupported(&self, channelMode: AdcChannelMode, out: *mut bool) -> HRESULT, + fn OpenChannel(&self, channelNumber: i32, out: *mut *mut AdcChannel) -> HRESULT }} -impl ISmartCardAppletIdGroup { - #[inline] pub fn get_display_name(&self) -> Result { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_DisplayName)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } - }} - #[inline] pub fn set_display_name(&self, value: &HStringArg) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_DisplayName)(self as *const _ as *mut _, value.get()); - if hr == S_OK { Ok(()) } else { err(hr) } +impl IAdcController { + #[inline] pub fn get_channel_count(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_ChannelCount)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} - #[cfg(feature="windows-storage")] #[inline] pub fn get_applet_ids(&self) -> Result>>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_AppletIds)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + #[inline] pub fn get_resolution_in_bits(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_ResolutionInBits)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_smart_card_emulation_category(&self) -> Result { unsafe { + #[inline] pub fn get_min_value(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_SmartCardEmulationCategory)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_MinValue)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn set_smart_card_emulation_category(&self, value: SmartCardEmulationCategory) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_SmartCardEmulationCategory)(self as *const _ as *mut _, value); - if hr == S_OK { Ok(()) } else { err(hr) } + #[inline] pub fn get_max_value(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_MaxValue)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_smart_card_emulation_type(&self) -> Result { unsafe { + #[inline] pub fn get_channel_mode(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_SmartCardEmulationType)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_ChannelMode)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn set_smart_card_emulation_type(&self, value: SmartCardEmulationType) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_SmartCardEmulationType)(self as *const _ as *mut _, value); + #[inline] pub fn set_channel_mode(&self, value: AdcChannelMode) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_ChannelMode)(self as *const _ as *mut _, value); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_automatic_enablement(&self) -> Result { unsafe { + #[inline] pub fn is_channel_mode_supported(&self, channelMode: AdcChannelMode) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_AutomaticEnablement)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).IsChannelModeSupported)(self as *const _ as *mut _, channelMode, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn set_automatic_enablement(&self, value: bool) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_AutomaticEnablement)(self as *const _ as *mut _, value); - if hr == S_OK { Ok(()) } else { err(hr) } + #[inline] pub fn open_channel(&self, channelNumber: i32) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).OpenChannel)(self as *const _ as *mut _, channelNumber, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } -RT_CLASS!{class SmartCardAppletIdGroup: ISmartCardAppletIdGroup} -impl RtActivatable for SmartCardAppletIdGroup {} -impl RtActivatable for SmartCardAppletIdGroup {} -impl RtActivatable for SmartCardAppletIdGroup {} -impl SmartCardAppletIdGroup { - #[cfg(feature="windows-storage")] #[inline] pub fn create(displayName: &HStringArg, appletIds: &foundation::collections::IVector, emulationCategory: SmartCardEmulationCategory, emulationType: SmartCardEmulationType) -> Result> { - >::get_activation_factory().create(displayName, appletIds, emulationCategory, emulationType) +RT_CLASS!{class AdcController: IAdcController} +impl RtActivatable for AdcController {} +impl RtActivatable for AdcController {} +impl AdcController { + #[inline] pub fn get_controllers_async(provider: &provider::IAdcProvider) -> Result>>> { + >::get_activation_factory().get_controllers_async(provider) } - #[inline] pub fn get_max_applet_ids() -> Result { - >::get_activation_factory().get_max_applet_ids() + #[inline] pub fn get_default_async() -> Result>> { + >::get_activation_factory().get_default_async() } } -DEFINE_CLSID!(SmartCardAppletIdGroup(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,83,109,97,114,116,67,97,114,100,115,46,83,109,97,114,116,67,97,114,100,65,112,112,108,101,116,73,100,71,114,111,117,112,0]) [CLSID_SmartCardAppletIdGroup]); -RT_ENUM! { enum SmartCardAppletIdGroupActivationPolicy: i32 { - Disabled (SmartCardAppletIdGroupActivationPolicy_Disabled) = 0, ForegroundOverride (SmartCardAppletIdGroupActivationPolicy_ForegroundOverride) = 1, Enabled (SmartCardAppletIdGroupActivationPolicy_Enabled) = 2, +DEFINE_CLSID!(AdcController(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,65,100,99,46,65,100,99,67,111,110,116,114,111,108,108,101,114,0]) [CLSID_AdcController]); +DEFINE_IID!(IID_IAdcControllerStatics, 3437858316, 504, 18577, 188, 59, 190, 83, 239, 39, 156, 164); +RT_INTERFACE!{static interface IAdcControllerStatics(IAdcControllerStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IAdcControllerStatics] { + fn GetControllersAsync(&self, provider: *mut provider::IAdcProvider, out: *mut *mut foundation::IAsyncOperation>) -> HRESULT }} -DEFINE_IID!(IID_ISmartCardAppletIdGroupFactory, 2433084237, 19045, 20033, 128, 97, 203, 232, 63, 54, 149, 229); -RT_INTERFACE!{static interface ISmartCardAppletIdGroupFactory(ISmartCardAppletIdGroupFactoryVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardAppletIdGroupFactory] { - #[cfg(feature="windows-storage")] fn Create(&self, displayName: HSTRING, appletIds: *mut foundation::collections::IVector, emulationCategory: SmartCardEmulationCategory, emulationType: SmartCardEmulationType, out: *mut *mut SmartCardAppletIdGroup) -> HRESULT +impl IAdcControllerStatics { + #[inline] pub fn get_controllers_async(&self, provider: &provider::IAdcProvider) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetControllersAsync)(self as *const _ as *mut _, provider as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} +} +DEFINE_IID!(IID_IAdcControllerStatics2, 2730048285, 38779, 20314, 165, 254, 166, 171, 175, 254, 100, 132); +RT_INTERFACE!{static interface IAdcControllerStatics2(IAdcControllerStatics2Vtbl): IInspectable(IInspectableVtbl) [IID_IAdcControllerStatics2] { + fn GetDefaultAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT }} -impl ISmartCardAppletIdGroupFactory { - #[cfg(feature="windows-storage")] #[inline] pub fn create(&self, displayName: &HStringArg, appletIds: &foundation::collections::IVector, emulationCategory: SmartCardEmulationCategory, emulationType: SmartCardEmulationType) -> Result> { unsafe { +impl IAdcControllerStatics2 { + #[inline] pub fn get_default_async(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, displayName.get(), appletIds as *const _ as *mut _, emulationCategory, emulationType, &mut out); + let hr = ((*self.lpVtbl).GetDefaultAsync)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } -DEFINE_IID!(IID_ISmartCardAppletIdGroupRegistration, 3742501073, 12731, 21910, 67, 177, 109, 105, 160, 37, 123, 58); -RT_INTERFACE!{interface ISmartCardAppletIdGroupRegistration(ISmartCardAppletIdGroupRegistrationVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardAppletIdGroupRegistration] { - fn get_ActivationPolicy(&self, out: *mut SmartCardAppletIdGroupActivationPolicy) -> HRESULT, - fn get_AppletIdGroup(&self, out: *mut *mut SmartCardAppletIdGroup) -> HRESULT, - fn RequestActivationPolicyChangeAsync(&self, policy: SmartCardAppletIdGroupActivationPolicy, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, - fn get_Id(&self, out: *mut Guid) -> HRESULT, - fn SetAutomaticResponseApdusAsync(&self, apdus: *mut foundation::collections::IIterable, out: *mut *mut foundation::IAsyncAction) -> HRESULT +pub mod provider { // Windows.Devices.Adc.Provider +use ::prelude::*; +DEFINE_IID!(IID_IAdcControllerProvider, 3193198632, 33133, 19941, 160, 72, 171, 160, 105, 88, 170, 168); +RT_INTERFACE!{interface IAdcControllerProvider(IAdcControllerProviderVtbl): IInspectable(IInspectableVtbl) [IID_IAdcControllerProvider] { + fn get_ChannelCount(&self, out: *mut i32) -> HRESULT, + fn get_ResolutionInBits(&self, out: *mut i32) -> HRESULT, + fn get_MinValue(&self, out: *mut i32) -> HRESULT, + fn get_MaxValue(&self, out: *mut i32) -> HRESULT, + fn get_ChannelMode(&self, out: *mut ProviderAdcChannelMode) -> HRESULT, + fn put_ChannelMode(&self, value: ProviderAdcChannelMode) -> HRESULT, + fn IsChannelModeSupported(&self, channelMode: ProviderAdcChannelMode, out: *mut bool) -> HRESULT, + fn AcquireChannel(&self, channel: i32) -> HRESULT, + fn ReleaseChannel(&self, channel: i32) -> HRESULT, + fn ReadValue(&self, channelNumber: i32, out: *mut i32) -> HRESULT }} -impl ISmartCardAppletIdGroupRegistration { - #[inline] pub fn get_activation_policy(&self) -> Result { unsafe { +impl IAdcControllerProvider { + #[inline] pub fn get_channel_count(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_ActivationPolicy)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_ChannelCount)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_applet_id_group(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_AppletIdGroup)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + #[inline] pub fn get_resolution_in_bits(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_ResolutionInBits)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn request_activation_policy_change_async(&self, policy: SmartCardAppletIdGroupActivationPolicy) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).RequestActivationPolicyChangeAsync)(self as *const _ as *mut _, policy, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + #[inline] pub fn get_min_value(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_MinValue)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_id(&self) -> Result { unsafe { + #[inline] pub fn get_max_value(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_Id)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_MaxValue)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn set_automatic_response_apdus_async(&self, apdus: &foundation::collections::IIterable) -> Result> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).SetAutomaticResponseApdusAsync)(self as *const _ as *mut _, apdus as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + #[inline] pub fn get_channel_mode(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_ChannelMode)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} -} -RT_CLASS!{class SmartCardAppletIdGroupRegistration: ISmartCardAppletIdGroupRegistration} -DEFINE_IID!(IID_ISmartCardAppletIdGroupStatics, 2871564713, 59244, 17871, 191, 29, 144, 234, 166, 32, 89, 39); -RT_INTERFACE!{static interface ISmartCardAppletIdGroupStatics(ISmartCardAppletIdGroupStaticsVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardAppletIdGroupStatics] { - fn get_MaxAppletIds(&self, out: *mut u16) -> HRESULT -}} -impl ISmartCardAppletIdGroupStatics { - #[inline] pub fn get_max_applet_ids(&self) -> Result { unsafe { + #[inline] pub fn set_channel_mode(&self, value: ProviderAdcChannelMode) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_ChannelMode)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn is_channel_mode_supported(&self, channelMode: ProviderAdcChannelMode) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_MaxAppletIds)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).IsChannelModeSupported)(self as *const _ as *mut _, channelMode, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} -} -DEFINE_IID!(IID_ISmartCardAutomaticResponseApdu, 1377119147, 50750, 17713, 168, 87, 215, 86, 217, 155, 152, 106); -RT_INTERFACE!{interface ISmartCardAutomaticResponseApdu(ISmartCardAutomaticResponseApduVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardAutomaticResponseApdu] { - #[cfg(feature="windows-storage")] fn get_CommandApdu(&self, out: *mut *mut super::super::storage::streams::IBuffer) -> HRESULT, - #[cfg(feature="windows-storage")] fn put_CommandApdu(&self, value: *mut super::super::storage::streams::IBuffer) -> HRESULT, - #[cfg(feature="windows-storage")] fn get_CommandApduBitMask(&self, out: *mut *mut super::super::storage::streams::IBuffer) -> HRESULT, - #[cfg(feature="windows-storage")] fn put_CommandApduBitMask(&self, value: *mut super::super::storage::streams::IBuffer) -> HRESULT, - fn get_ShouldMatchLength(&self, out: *mut bool) -> HRESULT, - fn put_ShouldMatchLength(&self, value: bool) -> HRESULT, - #[cfg(feature="windows-storage")] fn get_AppletId(&self, out: *mut *mut super::super::storage::streams::IBuffer) -> HRESULT, - #[cfg(feature="windows-storage")] fn put_AppletId(&self, value: *mut super::super::storage::streams::IBuffer) -> HRESULT, - #[cfg(feature="windows-storage")] fn get_ResponseApdu(&self, out: *mut *mut super::super::storage::streams::IBuffer) -> HRESULT, - #[cfg(feature="windows-storage")] fn put_ResponseApdu(&self, value: *mut super::super::storage::streams::IBuffer) -> HRESULT -}} -impl ISmartCardAutomaticResponseApdu { - #[cfg(feature="windows-storage")] #[inline] pub fn get_command_apdu(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_CommandApdu)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + #[inline] pub fn acquire_channel(&self, channel: i32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).AcquireChannel)(self as *const _ as *mut _, channel); + if hr == S_OK { Ok(()) } else { err(hr) } }} - #[cfg(feature="windows-storage")] #[inline] pub fn set_command_apdu(&self, value: &super::super::storage::streams::IBuffer) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_CommandApdu)(self as *const _ as *mut _, value as *const _ as *mut _); + #[inline] pub fn release_channel(&self, channel: i32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).ReleaseChannel)(self as *const _ as *mut _, channel); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[cfg(feature="windows-storage")] #[inline] pub fn get_command_apdu_bit_mask(&self) -> Result>> { unsafe { + #[inline] pub fn read_value(&self, channelNumber: i32) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).ReadValue)(self as *const _ as *mut _, channelNumber, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} +DEFINE_IID!(IID_IAdcProvider, 680867432, 37721, 19543, 188, 136, 226, 117, 232, 22, 56, 201); +RT_INTERFACE!{interface IAdcProvider(IAdcProviderVtbl): IInspectable(IInspectableVtbl) [IID_IAdcProvider] { + fn GetControllers(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT +}} +impl IAdcProvider { + #[inline] pub fn get_controllers(&self) -> Result>>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_CommandApduBitMask)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).GetControllers)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[cfg(feature="windows-storage")] #[inline] pub fn set_command_apdu_bit_mask(&self, value: &super::super::storage::streams::IBuffer) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_CommandApduBitMask)(self as *const _ as *mut _, value as *const _ as *mut _); +} +RT_ENUM! { enum ProviderAdcChannelMode: i32 { + SingleEnded (ProviderAdcChannelMode_SingleEnded) = 0, Differential (ProviderAdcChannelMode_Differential) = 1, +}} +} // Windows.Devices.Adc.Provider +} // Windows.Devices.Adc +pub mod gpio { // Windows.Devices.Gpio +use ::prelude::*; +RT_STRUCT! { struct GpioChangeCount { + Count: u64, RelativeTime: foundation::TimeSpan, +}} +DEFINE_IID!(IID_IGpioChangeCounter, 3411984606, 26625, 17407, 128, 61, 69, 118, 98, 138, 139, 38); +RT_INTERFACE!{interface IGpioChangeCounter(IGpioChangeCounterVtbl): IInspectable(IInspectableVtbl) [IID_IGpioChangeCounter] { + fn put_Polarity(&self, value: GpioChangePolarity) -> HRESULT, + fn get_Polarity(&self, out: *mut GpioChangePolarity) -> HRESULT, + fn get_IsStarted(&self, out: *mut bool) -> HRESULT, + fn Start(&self) -> HRESULT, + fn Stop(&self) -> HRESULT, + fn Read(&self, out: *mut GpioChangeCount) -> HRESULT, + fn Reset(&self, out: *mut GpioChangeCount) -> HRESULT +}} +impl IGpioChangeCounter { + #[inline] pub fn set_polarity(&self, value: GpioChangePolarity) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Polarity)(self as *const _ as *mut _, value); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_should_match_length(&self) -> Result { unsafe { + #[inline] pub fn get_polarity(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_ShouldMatchLength)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_Polarity)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn set_should_match_length(&self, value: bool) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_ShouldMatchLength)(self as *const _ as *mut _, value); - if hr == S_OK { Ok(()) } else { err(hr) } + #[inline] pub fn get_is_started(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_IsStarted)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} - #[cfg(feature="windows-storage")] #[inline] pub fn get_applet_id(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_AppletId)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + #[inline] pub fn start(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).Start)(self as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } }} - #[cfg(feature="windows-storage")] #[inline] pub fn set_applet_id(&self, value: &super::super::storage::streams::IBuffer) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_AppletId)(self as *const _ as *mut _, value as *const _ as *mut _); + #[inline] pub fn stop(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).Stop)(self as *const _ as *mut _); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[cfg(feature="windows-storage")] #[inline] pub fn get_response_apdu(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_ResponseApdu)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + #[inline] pub fn read(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).Read)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} - #[cfg(feature="windows-storage")] #[inline] pub fn set_response_apdu(&self, value: &super::super::storage::streams::IBuffer) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_ResponseApdu)(self as *const _ as *mut _, value as *const _ as *mut _); - if hr == S_OK { Ok(()) } else { err(hr) } + #[inline] pub fn reset(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).Reset)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} } -RT_CLASS!{class SmartCardAutomaticResponseApdu: ISmartCardAutomaticResponseApdu} -impl RtActivatable for SmartCardAutomaticResponseApdu {} -impl SmartCardAutomaticResponseApdu { - #[cfg(feature="windows-storage")] #[inline] pub fn create(commandApdu: &super::super::storage::streams::IBuffer, responseApdu: &super::super::storage::streams::IBuffer) -> Result> { - >::get_activation_factory().create(commandApdu, responseApdu) +RT_CLASS!{class GpioChangeCounter: IGpioChangeCounter} +impl RtActivatable for GpioChangeCounter {} +impl GpioChangeCounter { + #[inline] pub fn create(pin: &GpioPin) -> Result> { + >::get_activation_factory().create(pin) } } -DEFINE_CLSID!(SmartCardAutomaticResponseApdu(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,83,109,97,114,116,67,97,114,100,115,46,83,109,97,114,116,67,97,114,100,65,117,116,111,109,97,116,105,99,82,101,115,112,111,110,115,101,65,112,100,117,0]) [CLSID_SmartCardAutomaticResponseApdu]); -DEFINE_IID!(IID_ISmartCardAutomaticResponseApdu2, 1152301844, 21917, 17713, 78, 81, 137, 219, 111, 168, 165, 122); -RT_INTERFACE!{interface ISmartCardAutomaticResponseApdu2(ISmartCardAutomaticResponseApdu2Vtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardAutomaticResponseApdu2] { - fn get_InputState(&self, out: *mut *mut foundation::IReference) -> HRESULT, - fn put_InputState(&self, value: *mut foundation::IReference) -> HRESULT, - fn get_OutputState(&self, out: *mut *mut foundation::IReference) -> HRESULT, - fn put_OutputState(&self, value: *mut foundation::IReference) -> HRESULT +DEFINE_CLSID!(GpioChangeCounter(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,71,112,105,111,46,71,112,105,111,67,104,97,110,103,101,67,111,117,110,116,101,114,0]) [CLSID_GpioChangeCounter]); +DEFINE_IID!(IID_IGpioChangeCounterFactory, 343774390, 2718, 16652, 180, 250, 248, 159, 64, 82, 8, 77); +RT_INTERFACE!{static interface IGpioChangeCounterFactory(IGpioChangeCounterFactoryVtbl): IInspectable(IInspectableVtbl) [IID_IGpioChangeCounterFactory] { + fn Create(&self, pin: *mut GpioPin, out: *mut *mut GpioChangeCounter) -> HRESULT }} -impl ISmartCardAutomaticResponseApdu2 { - #[inline] pub fn get_input_state(&self) -> Result>>> { unsafe { +impl IGpioChangeCounterFactory { + #[inline] pub fn create(&self, pin: &GpioPin) -> Result> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_InputState)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, pin as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn set_input_state(&self, value: &foundation::IReference) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_InputState)(self as *const _ as *mut _, value as *const _ as *mut _); - if hr == S_OK { Ok(()) } else { err(hr) } +} +RT_ENUM! { enum GpioChangePolarity: i32 { + Falling (GpioChangePolarity_Falling) = 0, Rising (GpioChangePolarity_Rising) = 1, Both (GpioChangePolarity_Both) = 2, +}} +DEFINE_IID!(IID_IGpioChangeReader, 180127839, 57393, 18664, 133, 144, 112, 222, 120, 54, 60, 109); +RT_INTERFACE!{interface IGpioChangeReader(IGpioChangeReaderVtbl): IInspectable(IInspectableVtbl) [IID_IGpioChangeReader] { + fn get_Capacity(&self, out: *mut i32) -> HRESULT, + fn get_Length(&self, out: *mut i32) -> HRESULT, + fn get_IsEmpty(&self, out: *mut bool) -> HRESULT, + fn get_IsOverflowed(&self, out: *mut bool) -> HRESULT, + fn put_Polarity(&self, value: GpioChangePolarity) -> HRESULT, + fn get_Polarity(&self, out: *mut GpioChangePolarity) -> HRESULT, + fn get_IsStarted(&self, out: *mut bool) -> HRESULT, + fn Start(&self) -> HRESULT, + fn Stop(&self) -> HRESULT, + fn Clear(&self) -> HRESULT, + fn GetNextItem(&self, out: *mut GpioChangeRecord) -> HRESULT, + fn PeekNextItem(&self, out: *mut GpioChangeRecord) -> HRESULT, + fn GetAllItems(&self, out: *mut *mut foundation::collections::IVector) -> HRESULT, + fn WaitForItemsAsync(&self, count: i32, out: *mut *mut foundation::IAsyncAction) -> HRESULT +}} +impl IGpioChangeReader { + #[inline] pub fn get_capacity(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Capacity)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_output_state(&self) -> Result>>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_OutputState)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + #[inline] pub fn get_length(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Length)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn set_output_state(&self, value: &foundation::IReference) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_OutputState)(self as *const _ as *mut _, value as *const _ as *mut _); + #[inline] pub fn get_is_empty(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_IsEmpty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_is_overflowed(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_IsOverflowed)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_polarity(&self, value: GpioChangePolarity) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Polarity)(self as *const _ as *mut _, value); if hr == S_OK { Ok(()) } else { err(hr) } }} -} -DEFINE_IID!(IID_ISmartCardAutomaticResponseApdu3, 3208895092, 25974, 17298, 147, 103, 254, 59, 201, 226, 212, 150); -RT_INTERFACE!{interface ISmartCardAutomaticResponseApdu3(ISmartCardAutomaticResponseApdu3Vtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardAutomaticResponseApdu3] { - fn get_AllowWhenCryptogramGeneratorNotPrepared(&self, out: *mut bool) -> HRESULT, - fn put_AllowWhenCryptogramGeneratorNotPrepared(&self, value: bool) -> HRESULT -}} -impl ISmartCardAutomaticResponseApdu3 { - #[inline] pub fn get_allow_when_cryptogram_generator_not_prepared(&self) -> Result { unsafe { + #[inline] pub fn get_polarity(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_AllowWhenCryptogramGeneratorNotPrepared)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_Polarity)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn set_allow_when_cryptogram_generator_not_prepared(&self, value: bool) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_AllowWhenCryptogramGeneratorNotPrepared)(self as *const _ as *mut _, value); + #[inline] pub fn get_is_started(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_IsStarted)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn start(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).Start)(self as *const _ as *mut _); if hr == S_OK { Ok(()) } else { err(hr) } }} -} -DEFINE_IID!(IID_ISmartCardAutomaticResponseApduFactory, 3917390586, 53292, 19541, 176, 42, 140, 255, 127, 169, 240, 91); -RT_INTERFACE!{static interface ISmartCardAutomaticResponseApduFactory(ISmartCardAutomaticResponseApduFactoryVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardAutomaticResponseApduFactory] { - #[cfg(feature="windows-storage")] fn Create(&self, commandApdu: *mut super::super::storage::streams::IBuffer, responseApdu: *mut super::super::storage::streams::IBuffer, out: *mut *mut SmartCardAutomaticResponseApdu) -> HRESULT -}} -impl ISmartCardAutomaticResponseApduFactory { - #[cfg(feature="windows-storage")] #[inline] pub fn create(&self, commandApdu: &super::super::storage::streams::IBuffer, responseApdu: &super::super::storage::streams::IBuffer) -> Result> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, commandApdu as *const _ as *mut _, responseApdu as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + #[inline] pub fn stop(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).Stop)(self as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } }} -} -RT_ENUM! { enum SmartCardAutomaticResponseStatus: i32 { - None (SmartCardAutomaticResponseStatus_None) = 0, Success (SmartCardAutomaticResponseStatus_Success) = 1, UnknownError (SmartCardAutomaticResponseStatus_UnknownError) = 2, -}} -DEFINE_IID!(IID_ISmartCardChallengeContext, 422204185, 51652, 18759, 129, 204, 68, 121, 74, 97, 239, 145); -RT_INTERFACE!{interface ISmartCardChallengeContext(ISmartCardChallengeContextVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardChallengeContext] { - #[cfg(feature="windows-storage")] fn get_Challenge(&self, out: *mut *mut super::super::storage::streams::IBuffer) -> HRESULT, - #[cfg(feature="windows-storage")] fn VerifyResponseAsync(&self, response: *mut super::super::storage::streams::IBuffer, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, - #[cfg(feature="windows-storage")] fn ProvisionAsync(&self, response: *mut super::super::storage::streams::IBuffer, formatCard: bool, out: *mut *mut foundation::IAsyncAction) -> HRESULT, - #[cfg(feature="windows-storage")] fn ProvisionAsyncWithNewCardId(&self, response: *mut super::super::storage::streams::IBuffer, formatCard: bool, newCardId: Guid, out: *mut *mut foundation::IAsyncAction) -> HRESULT, - #[cfg(feature="windows-storage")] fn ChangeAdministrativeKeyAsync(&self, response: *mut super::super::storage::streams::IBuffer, newAdministrativeKey: *mut super::super::storage::streams::IBuffer, out: *mut *mut foundation::IAsyncAction) -> HRESULT -}} -impl ISmartCardChallengeContext { - #[cfg(feature="windows-storage")] #[inline] pub fn get_challenge(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Challenge)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + #[inline] pub fn clear(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).Clear)(self as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } }} - #[cfg(feature="windows-storage")] #[inline] pub fn verify_response_async(&self, response: &super::super::storage::streams::IBuffer) -> Result>> { unsafe { + #[inline] pub fn get_next_item(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).GetNextItem)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn peek_next_item(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).PeekNextItem)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_all_items(&self) -> Result>>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).VerifyResponseAsync)(self as *const _ as *mut _, response as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).GetAllItems)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[cfg(feature="windows-storage")] #[inline] pub fn provision_async(&self, response: &super::super::storage::streams::IBuffer, formatCard: bool) -> Result> { unsafe { + #[inline] pub fn wait_for_items_async(&self, count: i32) -> Result> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).ProvisionAsync)(self as *const _ as *mut _, response as *const _ as *mut _, formatCard, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } - }} - #[cfg(feature="windows-storage")] #[inline] pub fn provision_async_with_new_card_id(&self, response: &super::super::storage::streams::IBuffer, formatCard: bool, newCardId: Guid) -> Result> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).ProvisionAsyncWithNewCardId)(self as *const _ as *mut _, response as *const _ as *mut _, formatCard, newCardId, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } - }} - #[cfg(feature="windows-storage")] #[inline] pub fn change_administrative_key_async(&self, response: &super::super::storage::streams::IBuffer, newAdministrativeKey: &super::super::storage::streams::IBuffer) -> Result> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).ChangeAdministrativeKeyAsync)(self as *const _ as *mut _, response as *const _ as *mut _, newAdministrativeKey as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).WaitForItemsAsync)(self as *const _ as *mut _, count, &mut out); if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } -RT_CLASS!{class SmartCardChallengeContext: ISmartCardChallengeContext} -DEFINE_IID!(IID_ISmartCardConnect, 803178469, 653, 18718, 160, 88, 51, 130, 195, 152, 111, 64); -RT_INTERFACE!{interface ISmartCardConnect(ISmartCardConnectVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardConnect] { - fn ConnectAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT +RT_CLASS!{class GpioChangeReader: IGpioChangeReader} +impl RtActivatable for GpioChangeReader {} +impl GpioChangeReader { + #[inline] pub fn create(pin: &GpioPin) -> Result> { + >::get_activation_factory().create(pin) + } + #[inline] pub fn create_with_capacity(pin: &GpioPin, minCapacity: i32) -> Result> { + >::get_activation_factory().create_with_capacity(pin, minCapacity) + } +} +DEFINE_CLSID!(GpioChangeReader(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,71,112,105,111,46,71,112,105,111,67,104,97,110,103,101,82,101,97,100,101,114,0]) [CLSID_GpioChangeReader]); +DEFINE_IID!(IID_IGpioChangeReaderFactory, 2841218803, 14606, 17434, 157, 28, 232, 222, 11, 45, 240, 223); +RT_INTERFACE!{static interface IGpioChangeReaderFactory(IGpioChangeReaderFactoryVtbl): IInspectable(IInspectableVtbl) [IID_IGpioChangeReaderFactory] { + fn Create(&self, pin: *mut GpioPin, out: *mut *mut GpioChangeReader) -> HRESULT, + fn CreateWithCapacity(&self, pin: *mut GpioPin, minCapacity: i32, out: *mut *mut GpioChangeReader) -> HRESULT }} -impl ISmartCardConnect { - #[inline] pub fn connect_async(&self) -> Result>> { unsafe { +impl IGpioChangeReaderFactory { + #[inline] pub fn create(&self, pin: &GpioPin) -> Result> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).ConnectAsync)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, pin as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} -} -DEFINE_IID!(IID_ISmartCardConnection, 2128320794, 43034, 18364, 166, 73, 21, 107, 230, 183, 242, 49); -RT_INTERFACE!{interface ISmartCardConnection(ISmartCardConnectionVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardConnection] { - #[cfg(feature="windows-storage")] fn TransmitAsync(&self, command: *mut super::super::storage::streams::IBuffer, out: *mut *mut foundation::IAsyncOperation) -> HRESULT -}} -impl ISmartCardConnection { - #[cfg(feature="windows-storage")] #[inline] pub fn transmit_async(&self, command: &super::super::storage::streams::IBuffer) -> Result>> { unsafe { + #[inline] pub fn create_with_capacity(&self, pin: &GpioPin, minCapacity: i32) -> Result> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).TransmitAsync)(self as *const _ as *mut _, command as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).CreateWithCapacity)(self as *const _ as *mut _, pin as *const _ as *mut _, minCapacity, &mut out); if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } -RT_CLASS!{class SmartCardConnection: ISmartCardConnection} -RT_ENUM! { enum SmartCardCryptogramAlgorithm: i32 { - None (SmartCardCryptogramAlgorithm_None) = 0, CbcMac (SmartCardCryptogramAlgorithm_CbcMac) = 1, Cvc3Umd (SmartCardCryptogramAlgorithm_Cvc3Umd) = 2, DecimalizedMsd (SmartCardCryptogramAlgorithm_DecimalizedMsd) = 3, Cvc3MD (SmartCardCryptogramAlgorithm_Cvc3MD) = 4, Sha1 (SmartCardCryptogramAlgorithm_Sha1) = 5, SignedDynamicApplicationData (SmartCardCryptogramAlgorithm_SignedDynamicApplicationData) = 6, RsaPkcs1 (SmartCardCryptogramAlgorithm_RsaPkcs1) = 7, Sha256Hmac (SmartCardCryptogramAlgorithm_Sha256Hmac) = 8, +RT_STRUCT! { struct GpioChangeRecord { + RelativeTime: foundation::TimeSpan, Edge: GpioPinEdge, }} -DEFINE_IID!(IID_ISmartCardCryptogramGenerator, 3818870907, 60883, 20041, 181, 148, 15, 245, 228, 208, 199, 111); -RT_INTERFACE!{interface ISmartCardCryptogramGenerator(ISmartCardCryptogramGeneratorVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardCryptogramGenerator] { - fn get_SupportedCryptogramMaterialTypes(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT, - fn get_SupportedCryptogramAlgorithms(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT, - fn get_SupportedCryptogramMaterialPackageFormats(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT, - fn get_SupportedCryptogramMaterialPackageConfirmationResponseFormats(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT, - fn get_SupportedSmartCardCryptogramStorageKeyCapabilities(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT, - fn DeleteCryptogramMaterialStorageKeyAsync(&self, storageKeyName: HSTRING, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, - fn CreateCryptogramMaterialStorageKeyAsync(&self, promptingBehavior: SmartCardUnlockPromptingBehavior, storageKeyName: HSTRING, algorithm: SmartCardCryptogramStorageKeyAlgorithm, capabilities: SmartCardCryptogramStorageKeyCapabilities, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, - #[cfg(not(feature="windows-security"))] fn __Dummy7(&self) -> (), - #[cfg(feature="windows-security")] fn RequestCryptogramMaterialStorageKeyInfoAsync(&self, promptingBehavior: SmartCardUnlockPromptingBehavior, storageKeyName: HSTRING, format: super::super::security::cryptography::core::CryptographicPublicKeyBlobType, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, - #[cfg(not(feature="windows-storage"))] fn __Dummy8(&self) -> (), - #[cfg(feature="windows-storage")] fn ImportCryptogramMaterialPackageAsync(&self, format: SmartCardCryptogramMaterialPackageFormat, storageKeyName: HSTRING, materialPackageName: HSTRING, cryptogramMaterialPackage: *mut super::super::storage::streams::IBuffer, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, - #[cfg(not(feature="windows-storage"))] fn __Dummy9(&self) -> (), - #[cfg(feature="windows-storage")] fn TryProvePossessionOfCryptogramMaterialPackageAsync(&self, promptingBehavior: SmartCardUnlockPromptingBehavior, responseFormat: SmartCardCryptogramMaterialPackageConfirmationResponseFormat, materialPackageName: HSTRING, materialName: HSTRING, challenge: *mut super::super::storage::streams::IBuffer, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, - fn RequestUnlockCryptogramMaterialForUseAsync(&self, promptingBehavior: SmartCardUnlockPromptingBehavior, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, - fn DeleteCryptogramMaterialPackageAsync(&self, materialPackageName: HSTRING, out: *mut *mut foundation::IAsyncOperation) -> HRESULT +DEFINE_IID!(IID_IGpioController, 675287779, 29793, 18076, 168, 188, 97, 214, 157, 8, 165, 60); +RT_INTERFACE!{interface IGpioController(IGpioControllerVtbl): IInspectable(IInspectableVtbl) [IID_IGpioController] { + fn get_PinCount(&self, out: *mut i32) -> HRESULT, + fn OpenPin(&self, pinNumber: i32, out: *mut *mut GpioPin) -> HRESULT, + fn OpenPinWithSharingMode(&self, pinNumber: i32, sharingMode: GpioSharingMode, out: *mut *mut GpioPin) -> HRESULT, + fn TryOpenPin(&self, pinNumber: i32, sharingMode: GpioSharingMode, pin: *mut *mut GpioPin, openStatus: *mut GpioOpenStatus, out: *mut bool) -> HRESULT }} -impl ISmartCardCryptogramGenerator { - #[inline] pub fn get_supported_cryptogram_material_types(&self) -> Result>>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_SupportedCryptogramMaterialTypes)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } - }} - #[inline] pub fn get_supported_cryptogram_algorithms(&self) -> Result>>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_SupportedCryptogramAlgorithms)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } - }} - #[inline] pub fn get_supported_cryptogram_material_package_formats(&self) -> Result>>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_SupportedCryptogramMaterialPackageFormats)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } +impl IGpioController { + #[inline] pub fn get_pin_count(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_PinCount)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_supported_cryptogram_material_package_confirmation_response_formats(&self) -> Result>>> { unsafe { + #[inline] pub fn open_pin(&self, pinNumber: i32) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_SupportedCryptogramMaterialPackageConfirmationResponseFormats)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).OpenPin)(self as *const _ as *mut _, pinNumber, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn get_supported_smart_card_cryptogram_storage_key_capabilities(&self) -> Result>>> { unsafe { + #[inline] pub fn open_pin_with_sharing_mode(&self, pinNumber: i32, sharingMode: GpioSharingMode) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_SupportedSmartCardCryptogramStorageKeyCapabilities)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).OpenPinWithSharingMode)(self as *const _ as *mut _, pinNumber, sharingMode, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn delete_cryptogram_material_storage_key_async(&self, storageKeyName: &HStringArg) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).DeleteCryptogramMaterialStorageKeyAsync)(self as *const _ as *mut _, storageKeyName.get(), &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } - }} - #[inline] pub fn create_cryptogram_material_storage_key_async(&self, promptingBehavior: SmartCardUnlockPromptingBehavior, storageKeyName: &HStringArg, algorithm: SmartCardCryptogramStorageKeyAlgorithm, capabilities: SmartCardCryptogramStorageKeyCapabilities) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).CreateCryptogramMaterialStorageKeyAsync)(self as *const _ as *mut _, promptingBehavior, storageKeyName.get(), algorithm, capabilities, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } - }} - #[cfg(feature="windows-security")] #[inline] pub fn request_cryptogram_material_storage_key_info_async(&self, promptingBehavior: SmartCardUnlockPromptingBehavior, storageKeyName: &HStringArg, format: super::super::security::cryptography::core::CryptographicPublicKeyBlobType) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).RequestCryptogramMaterialStorageKeyInfoAsync)(self as *const _ as *mut _, promptingBehavior, storageKeyName.get(), format, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } - }} - #[cfg(feature="windows-storage")] #[inline] pub fn import_cryptogram_material_package_async(&self, format: SmartCardCryptogramMaterialPackageFormat, storageKeyName: &HStringArg, materialPackageName: &HStringArg, cryptogramMaterialPackage: &super::super::storage::streams::IBuffer) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).ImportCryptogramMaterialPackageAsync)(self as *const _ as *mut _, format, storageKeyName.get(), materialPackageName.get(), cryptogramMaterialPackage as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } - }} - #[cfg(feature="windows-storage")] #[inline] pub fn try_prove_possession_of_cryptogram_material_package_async(&self, promptingBehavior: SmartCardUnlockPromptingBehavior, responseFormat: SmartCardCryptogramMaterialPackageConfirmationResponseFormat, materialPackageName: &HStringArg, materialName: &HStringArg, challenge: &super::super::storage::streams::IBuffer) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).TryProvePossessionOfCryptogramMaterialPackageAsync)(self as *const _ as *mut _, promptingBehavior, responseFormat, materialPackageName.get(), materialName.get(), challenge as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } - }} - #[inline] pub fn request_unlock_cryptogram_material_for_use_async(&self, promptingBehavior: SmartCardUnlockPromptingBehavior) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).RequestUnlockCryptogramMaterialForUseAsync)(self as *const _ as *mut _, promptingBehavior, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } - }} - #[inline] pub fn delete_cryptogram_material_package_async(&self, materialPackageName: &HStringArg) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).DeleteCryptogramMaterialPackageAsync)(self as *const _ as *mut _, materialPackageName.get(), &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + #[inline] pub fn try_open_pin(&self, pinNumber: i32, sharingMode: GpioSharingMode) -> Result<(Option>, GpioOpenStatus, bool)> { unsafe { + let mut pin = null_mut(); let mut openStatus = zeroed(); let mut out = zeroed(); + let hr = ((*self.lpVtbl).TryOpenPin)(self as *const _ as *mut _, pinNumber, sharingMode, &mut pin, &mut openStatus, &mut out); + if hr == S_OK { Ok((ComPtr::wrap_optional(pin), openStatus, out)) } else { err(hr) } }} } -RT_CLASS!{class SmartCardCryptogramGenerator: ISmartCardCryptogramGenerator} -impl RtActivatable for SmartCardCryptogramGenerator {} -impl RtActivatable for SmartCardCryptogramGenerator {} -impl SmartCardCryptogramGenerator { - #[inline] pub fn get_smart_card_cryptogram_generator_async() -> Result>> { - >::get_activation_factory().get_smart_card_cryptogram_generator_async() +RT_CLASS!{class GpioController: IGpioController} +impl RtActivatable for GpioController {} +impl RtActivatable for GpioController {} +impl GpioController { + #[inline] pub fn get_default() -> Result>> { + >::get_activation_factory().get_default() } - #[inline] pub fn is_supported() -> Result { - >::get_activation_factory().is_supported() + #[inline] pub fn get_controllers_async(provider: &provider::IGpioProvider) -> Result>>> { + >::get_activation_factory().get_controllers_async(provider) + } + #[inline] pub fn get_default_async() -> Result>> { + >::get_activation_factory().get_default_async() } } -DEFINE_CLSID!(SmartCardCryptogramGenerator(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,83,109,97,114,116,67,97,114,100,115,46,83,109,97,114,116,67,97,114,100,67,114,121,112,116,111,103,114,97,109,71,101,110,101,114,97,116,111,114,0]) [CLSID_SmartCardCryptogramGenerator]); -DEFINE_IID!(IID_ISmartCardCryptogramGenerator2, 1897310772, 23917, 19274, 150, 163, 239, 164, 125, 42, 126, 37); -RT_INTERFACE!{interface ISmartCardCryptogramGenerator2(ISmartCardCryptogramGenerator2Vtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardCryptogramGenerator2] { - #[cfg(not(feature="windows-storage"))] fn __Dummy0(&self) -> (), - #[cfg(feature="windows-storage")] fn ValidateRequestApduAsync(&self, promptingBehavior: SmartCardUnlockPromptingBehavior, apduToValidate: *mut super::super::storage::streams::IBuffer, cryptogramPlacementSteps: *mut foundation::collections::IIterable, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, - fn GetAllCryptogramStorageKeyCharacteristicsAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, - fn GetAllCryptogramMaterialPackageCharacteristicsAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, - fn GetAllCryptogramMaterialPackageCharacteristicsWithStorageKeyAsync(&self, storageKeyName: HSTRING, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, - fn GetAllCryptogramMaterialCharacteristicsAsync(&self, promptingBehavior: SmartCardUnlockPromptingBehavior, materialPackageName: HSTRING, out: *mut *mut foundation::IAsyncOperation) -> HRESULT +DEFINE_CLSID!(GpioController(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,71,112,105,111,46,71,112,105,111,67,111,110,116,114,111,108,108,101,114,0]) [CLSID_GpioController]); +DEFINE_IID!(IID_IGpioControllerStatics, 785839150, 31479, 16662, 149, 51, 196, 61, 153, 161, 251, 100); +RT_INTERFACE!{static interface IGpioControllerStatics(IGpioControllerStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IGpioControllerStatics] { + fn GetDefault(&self, out: *mut *mut GpioController) -> HRESULT }} -impl ISmartCardCryptogramGenerator2 { - #[cfg(feature="windows-storage")] #[inline] pub fn validate_request_apdu_async(&self, promptingBehavior: SmartCardUnlockPromptingBehavior, apduToValidate: &super::super::storage::streams::IBuffer, cryptogramPlacementSteps: &foundation::collections::IIterable) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).ValidateRequestApduAsync)(self as *const _ as *mut _, promptingBehavior, apduToValidate as *const _ as *mut _, cryptogramPlacementSteps as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } - }} - #[inline] pub fn get_all_cryptogram_storage_key_characteristics_async(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetAllCryptogramStorageKeyCharacteristicsAsync)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } - }} - #[inline] pub fn get_all_cryptogram_material_package_characteristics_async(&self) -> Result>> { unsafe { +impl IGpioControllerStatics { + #[inline] pub fn get_default(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetAllCryptogramMaterialPackageCharacteristicsAsync)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).GetDefault)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn get_all_cryptogram_material_package_characteristics_with_storage_key_async(&self, storageKeyName: &HStringArg) -> Result>> { unsafe { +} +DEFINE_IID!(IID_IGpioControllerStatics2, 2435546400, 27812, 16646, 163, 115, 255, 253, 52, 107, 14, 91); +RT_INTERFACE!{static interface IGpioControllerStatics2(IGpioControllerStatics2Vtbl): IInspectable(IInspectableVtbl) [IID_IGpioControllerStatics2] { + fn GetControllersAsync(&self, provider: *mut provider::IGpioProvider, out: *mut *mut foundation::IAsyncOperation>) -> HRESULT, + fn GetDefaultAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT +}} +impl IGpioControllerStatics2 { + #[inline] pub fn get_controllers_async(&self, provider: &provider::IGpioProvider) -> Result>>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetAllCryptogramMaterialPackageCharacteristicsWithStorageKeyAsync)(self as *const _ as *mut _, storageKeyName.get(), &mut out); + let hr = ((*self.lpVtbl).GetControllersAsync)(self as *const _ as *mut _, provider as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_all_cryptogram_material_characteristics_async(&self, promptingBehavior: SmartCardUnlockPromptingBehavior, materialPackageName: &HStringArg) -> Result>> { unsafe { + #[inline] pub fn get_default_async(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetAllCryptogramMaterialCharacteristicsAsync)(self as *const _ as *mut _, promptingBehavior, materialPackageName.get(), &mut out); + let hr = ((*self.lpVtbl).GetDefaultAsync)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } -RT_ENUM! { enum SmartCardCryptogramGeneratorOperationStatus: i32 { - Success (SmartCardCryptogramGeneratorOperationStatus_Success) = 0, AuthorizationFailed (SmartCardCryptogramGeneratorOperationStatus_AuthorizationFailed) = 1, AuthorizationCanceled (SmartCardCryptogramGeneratorOperationStatus_AuthorizationCanceled) = 2, AuthorizationRequired (SmartCardCryptogramGeneratorOperationStatus_AuthorizationRequired) = 3, CryptogramMaterialPackageStorageKeyExists (SmartCardCryptogramGeneratorOperationStatus_CryptogramMaterialPackageStorageKeyExists) = 4, NoCryptogramMaterialPackageStorageKey (SmartCardCryptogramGeneratorOperationStatus_NoCryptogramMaterialPackageStorageKey) = 5, NoCryptogramMaterialPackage (SmartCardCryptogramGeneratorOperationStatus_NoCryptogramMaterialPackage) = 6, UnsupportedCryptogramMaterialPackage (SmartCardCryptogramGeneratorOperationStatus_UnsupportedCryptogramMaterialPackage) = 7, UnknownCryptogramMaterialName (SmartCardCryptogramGeneratorOperationStatus_UnknownCryptogramMaterialName) = 8, InvalidCryptogramMaterialUsage (SmartCardCryptogramGeneratorOperationStatus_InvalidCryptogramMaterialUsage) = 9, ApduResponseNotSent (SmartCardCryptogramGeneratorOperationStatus_ApduResponseNotSent) = 10, OtherError (SmartCardCryptogramGeneratorOperationStatus_OtherError) = 11, ValidationFailed (SmartCardCryptogramGeneratorOperationStatus_ValidationFailed) = 12, NotSupported (SmartCardCryptogramGeneratorOperationStatus_NotSupported) = 13, -}} -DEFINE_IID!(IID_ISmartCardCryptogramGeneratorStatics, 160643344, 52124, 16405, 150, 125, 82, 52, 243, 176, 41, 0); -RT_INTERFACE!{static interface ISmartCardCryptogramGeneratorStatics(ISmartCardCryptogramGeneratorStaticsVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardCryptogramGeneratorStatics] { - fn GetSmartCardCryptogramGeneratorAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT +RT_ENUM! { enum GpioOpenStatus: i32 { + PinOpened (GpioOpenStatus_PinOpened) = 0, PinUnavailable (GpioOpenStatus_PinUnavailable) = 1, SharingViolation (GpioOpenStatus_SharingViolation) = 2, MuxingConflict (GpioOpenStatus_MuxingConflict) = 3, UnknownError (GpioOpenStatus_UnknownError) = 4, }} -impl ISmartCardCryptogramGeneratorStatics { - #[inline] pub fn get_smart_card_cryptogram_generator_async(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetSmartCardCryptogramGeneratorAsync)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } - }} -} -DEFINE_IID!(IID_ISmartCardCryptogramGeneratorStatics2, 163444197, 46269, 20003, 165, 136, 116, 70, 146, 4, 193, 40); -RT_INTERFACE!{static interface ISmartCardCryptogramGeneratorStatics2(ISmartCardCryptogramGeneratorStatics2Vtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardCryptogramGeneratorStatics2] { - fn IsSupported(&self, out: *mut bool) -> HRESULT +DEFINE_IID!(IID_IGpioPin, 299479175, 44974, 18320, 158, 233, 224, 234, 201, 66, 210, 1); +RT_INTERFACE!{interface IGpioPin(IGpioPinVtbl): IInspectable(IInspectableVtbl) [IID_IGpioPin] { + fn add_ValueChanged(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_ValueChanged(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn get_DebounceTimeout(&self, out: *mut foundation::TimeSpan) -> HRESULT, + fn put_DebounceTimeout(&self, value: foundation::TimeSpan) -> HRESULT, + fn get_PinNumber(&self, out: *mut i32) -> HRESULT, + fn get_SharingMode(&self, out: *mut GpioSharingMode) -> HRESULT, + fn IsDriveModeSupported(&self, driveMode: GpioPinDriveMode, out: *mut bool) -> HRESULT, + fn GetDriveMode(&self, out: *mut GpioPinDriveMode) -> HRESULT, + fn SetDriveMode(&self, value: GpioPinDriveMode) -> HRESULT, + fn Write(&self, value: GpioPinValue) -> HRESULT, + fn Read(&self, out: *mut GpioPinValue) -> HRESULT }} -impl ISmartCardCryptogramGeneratorStatics2 { - #[inline] pub fn is_supported(&self) -> Result { unsafe { +impl IGpioPin { + #[inline] pub fn add_value_changed(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).IsSupported)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).add_ValueChanged)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} -} -DEFINE_IID!(IID_ISmartCardCryptogramGetAllCryptogramMaterialCharacteristicsResult, 664330281, 54919, 19602, 134, 198, 57, 158, 154, 14, 203, 9); -RT_INTERFACE!{interface ISmartCardCryptogramGetAllCryptogramMaterialCharacteristicsResult(ISmartCardCryptogramGetAllCryptogramMaterialCharacteristicsResultVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardCryptogramGetAllCryptogramMaterialCharacteristicsResult] { - fn get_OperationStatus(&self, out: *mut SmartCardCryptogramGeneratorOperationStatus) -> HRESULT, - fn get_Characteristics(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT -}} -impl ISmartCardCryptogramGetAllCryptogramMaterialCharacteristicsResult { - #[inline] pub fn get_operation_status(&self) -> Result { unsafe { + #[inline] pub fn remove_value_changed(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_ValueChanged)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_debounce_timeout(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_OperationStatus)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_DebounceTimeout)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_characteristics(&self) -> Result>>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Characteristics)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + #[inline] pub fn set_debounce_timeout(&self, value: foundation::TimeSpan) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_DebounceTimeout)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_pin_number(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_PinNumber)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_sharing_mode(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_SharingMode)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn is_drive_mode_supported(&self, driveMode: GpioPinDriveMode) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).IsDriveModeSupported)(self as *const _ as *mut _, driveMode, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_drive_mode(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).GetDriveMode)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_drive_mode(&self, value: GpioPinDriveMode) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).SetDriveMode)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn write(&self, value: GpioPinValue) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).Write)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn read(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).Read)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} } -RT_CLASS!{class SmartCardCryptogramGetAllCryptogramMaterialCharacteristicsResult: ISmartCardCryptogramGetAllCryptogramMaterialCharacteristicsResult} -impl RtActivatable for SmartCardCryptogramGetAllCryptogramMaterialCharacteristicsResult {} -DEFINE_CLSID!(SmartCardCryptogramGetAllCryptogramMaterialCharacteristicsResult(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,83,109,97,114,116,67,97,114,100,115,46,83,109,97,114,116,67,97,114,100,67,114,121,112,116,111,103,114,97,109,71,101,116,65,108,108,67,114,121,112,116,111,103,114,97,109,77,97,116,101,114,105,97,108,67,104,97,114,97,99,116,101,114,105,115,116,105,99,115,82,101,115,117,108,116,0]) [CLSID_SmartCardCryptogramGetAllCryptogramMaterialCharacteristicsResult]); -DEFINE_IID!(IID_ISmartCardCryptogramGetAllCryptogramMaterialPackageCharacteristicsResult, 1315605084, 38771, 18116, 163, 47, 177, 229, 67, 21, 158, 4); -RT_INTERFACE!{interface ISmartCardCryptogramGetAllCryptogramMaterialPackageCharacteristicsResult(ISmartCardCryptogramGetAllCryptogramMaterialPackageCharacteristicsResultVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardCryptogramGetAllCryptogramMaterialPackageCharacteristicsResult] { - fn get_OperationStatus(&self, out: *mut SmartCardCryptogramGeneratorOperationStatus) -> HRESULT, - fn get_Characteristics(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT +RT_CLASS!{class GpioPin: IGpioPin} +RT_ENUM! { enum GpioPinDriveMode: i32 { + Input (GpioPinDriveMode_Input) = 0, Output (GpioPinDriveMode_Output) = 1, InputPullUp (GpioPinDriveMode_InputPullUp) = 2, InputPullDown (GpioPinDriveMode_InputPullDown) = 3, OutputOpenDrain (GpioPinDriveMode_OutputOpenDrain) = 4, OutputOpenDrainPullUp (GpioPinDriveMode_OutputOpenDrainPullUp) = 5, OutputOpenSource (GpioPinDriveMode_OutputOpenSource) = 6, OutputOpenSourcePullDown (GpioPinDriveMode_OutputOpenSourcePullDown) = 7, }} -impl ISmartCardCryptogramGetAllCryptogramMaterialPackageCharacteristicsResult { - #[inline] pub fn get_operation_status(&self) -> Result { unsafe { +RT_ENUM! { enum GpioPinEdge: i32 { + FallingEdge (GpioPinEdge_FallingEdge) = 0, RisingEdge (GpioPinEdge_RisingEdge) = 1, +}} +RT_ENUM! { enum GpioPinValue: i32 { + Low (GpioPinValue_Low) = 0, High (GpioPinValue_High) = 1, +}} +DEFINE_IID!(IID_IGpioPinValueChangedEventArgs, 825731809, 28733, 16473, 189, 36, 181, 178, 93, 255, 184, 78); +RT_INTERFACE!{interface IGpioPinValueChangedEventArgs(IGpioPinValueChangedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IGpioPinValueChangedEventArgs] { + fn get_Edge(&self, out: *mut GpioPinEdge) -> HRESULT +}} +impl IGpioPinValueChangedEventArgs { + #[inline] pub fn get_edge(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_OperationStatus)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_Edge)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_characteristics(&self) -> Result>>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Characteristics)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } - }} } -RT_CLASS!{class SmartCardCryptogramGetAllCryptogramMaterialPackageCharacteristicsResult: ISmartCardCryptogramGetAllCryptogramMaterialPackageCharacteristicsResult} -impl RtActivatable for SmartCardCryptogramGetAllCryptogramMaterialPackageCharacteristicsResult {} -DEFINE_CLSID!(SmartCardCryptogramGetAllCryptogramMaterialPackageCharacteristicsResult(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,83,109,97,114,116,67,97,114,100,115,46,83,109,97,114,116,67,97,114,100,67,114,121,112,116,111,103,114,97,109,71,101,116,65,108,108,67,114,121,112,116,111,103,114,97,109,77,97,116,101,114,105,97,108,80,97,99,107,97,103,101,67,104,97,114,97,99,116,101,114,105,115,116,105,99,115,82,101,115,117,108,116,0]) [CLSID_SmartCardCryptogramGetAllCryptogramMaterialPackageCharacteristicsResult]); -DEFINE_IID!(IID_ISmartCardCryptogramGetAllCryptogramStorageKeyCharacteristicsResult, 2356996183, 42983, 18589, 185, 214, 54, 128, 97, 81, 80, 18); -RT_INTERFACE!{interface ISmartCardCryptogramGetAllCryptogramStorageKeyCharacteristicsResult(ISmartCardCryptogramGetAllCryptogramStorageKeyCharacteristicsResultVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardCryptogramGetAllCryptogramStorageKeyCharacteristicsResult] { - fn get_OperationStatus(&self, out: *mut SmartCardCryptogramGeneratorOperationStatus) -> HRESULT, - fn get_Characteristics(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT +RT_CLASS!{class GpioPinValueChangedEventArgs: IGpioPinValueChangedEventArgs} +RT_ENUM! { enum GpioSharingMode: i32 { + Exclusive (GpioSharingMode_Exclusive) = 0, SharedReadOnly (GpioSharingMode_SharedReadOnly) = 1, }} -impl ISmartCardCryptogramGetAllCryptogramStorageKeyCharacteristicsResult { - #[inline] pub fn get_operation_status(&self) -> Result { unsafe { +pub mod provider { // Windows.Devices.Gpio.Provider +use ::prelude::*; +DEFINE_IID!(IID_IGpioControllerProvider, 2903625415, 6634, 19233, 135, 79, 185, 26, 237, 74, 37, 219); +RT_INTERFACE!{interface IGpioControllerProvider(IGpioControllerProviderVtbl): IInspectable(IInspectableVtbl) [IID_IGpioControllerProvider] { + fn get_PinCount(&self, out: *mut i32) -> HRESULT, + fn OpenPinProvider(&self, pin: i32, sharingMode: ProviderGpioSharingMode, out: *mut *mut IGpioPinProvider) -> HRESULT +}} +impl IGpioControllerProvider { + #[inline] pub fn get_pin_count(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_OperationStatus)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_PinCount)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_characteristics(&self) -> Result>>> { unsafe { + #[inline] pub fn open_pin_provider(&self, pin: i32, sharingMode: ProviderGpioSharingMode) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Characteristics)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).OpenPinProvider)(self as *const _ as *mut _, pin, sharingMode, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } -RT_CLASS!{class SmartCardCryptogramGetAllCryptogramStorageKeyCharacteristicsResult: ISmartCardCryptogramGetAllCryptogramStorageKeyCharacteristicsResult} -impl RtActivatable for SmartCardCryptogramGetAllCryptogramStorageKeyCharacteristicsResult {} -DEFINE_CLSID!(SmartCardCryptogramGetAllCryptogramStorageKeyCharacteristicsResult(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,83,109,97,114,116,67,97,114,100,115,46,83,109,97,114,116,67,97,114,100,67,114,121,112,116,111,103,114,97,109,71,101,116,65,108,108,67,114,121,112,116,111,103,114,97,109,83,116,111,114,97,103,101,75,101,121,67,104,97,114,97,99,116,101,114,105,115,116,105,99,115,82,101,115,117,108,116,0]) [CLSID_SmartCardCryptogramGetAllCryptogramStorageKeyCharacteristicsResult]); -DEFINE_IID!(IID_ISmartCardCryptogramMaterialCharacteristics, 4238001612, 49623, 16723, 146, 59, 162, 212, 60, 108, 141, 73); -RT_INTERFACE!{interface ISmartCardCryptogramMaterialCharacteristics(ISmartCardCryptogramMaterialCharacteristicsVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardCryptogramMaterialCharacteristics] { - fn get_MaterialName(&self, out: *mut HSTRING) -> HRESULT, - fn get_AllowedAlgorithms(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT, - fn get_AllowedProofOfPossessionAlgorithms(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT, - fn get_AllowedValidations(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT, - fn get_MaterialType(&self, out: *mut SmartCardCryptogramMaterialType) -> HRESULT, - fn get_ProtectionMethod(&self, out: *mut SmartCardCryptogramMaterialProtectionMethod) -> HRESULT, - fn get_ProtectionVersion(&self, out: *mut i32) -> HRESULT, - fn get_MaterialLength(&self, out: *mut i32) -> HRESULT +DEFINE_IID!(IID_IGpioPinProvider, 1110723767, 27324, 16639, 156, 231, 115, 184, 83, 1, 185, 0); +RT_INTERFACE!{interface IGpioPinProvider(IGpioPinProviderVtbl): IInspectable(IInspectableVtbl) [IID_IGpioPinProvider] { + fn add_ValueChanged(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_ValueChanged(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn get_DebounceTimeout(&self, out: *mut foundation::TimeSpan) -> HRESULT, + fn put_DebounceTimeout(&self, value: foundation::TimeSpan) -> HRESULT, + fn get_PinNumber(&self, out: *mut i32) -> HRESULT, + fn get_SharingMode(&self, out: *mut ProviderGpioSharingMode) -> HRESULT, + fn IsDriveModeSupported(&self, driveMode: ProviderGpioPinDriveMode, out: *mut bool) -> HRESULT, + fn GetDriveMode(&self, out: *mut ProviderGpioPinDriveMode) -> HRESULT, + fn SetDriveMode(&self, value: ProviderGpioPinDriveMode) -> HRESULT, + fn Write(&self, value: ProviderGpioPinValue) -> HRESULT, + fn Read(&self, out: *mut ProviderGpioPinValue) -> HRESULT }} -impl ISmartCardCryptogramMaterialCharacteristics { - #[inline] pub fn get_material_name(&self) -> Result { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_MaterialName)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } +impl IGpioPinProvider { + #[inline] pub fn add_value_changed(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_ValueChanged)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_allowed_algorithms(&self) -> Result>>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_AllowedAlgorithms)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + #[inline] pub fn remove_value_changed(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_ValueChanged)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_allowed_proof_of_possession_algorithms(&self) -> Result>>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_AllowedProofOfPossessionAlgorithms)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + #[inline] pub fn get_debounce_timeout(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_DebounceTimeout)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_allowed_validations(&self) -> Result>>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_AllowedValidations)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + #[inline] pub fn set_debounce_timeout(&self, value: foundation::TimeSpan) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_DebounceTimeout)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_material_type(&self) -> Result { unsafe { + #[inline] pub fn get_pin_number(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_MaterialType)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_PinNumber)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_protection_method(&self) -> Result { unsafe { + #[inline] pub fn get_sharing_mode(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_ProtectionMethod)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_SharingMode)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_protection_version(&self) -> Result { unsafe { + #[inline] pub fn is_drive_mode_supported(&self, driveMode: ProviderGpioPinDriveMode) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_ProtectionVersion)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).IsDriveModeSupported)(self as *const _ as *mut _, driveMode, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_material_length(&self) -> Result { unsafe { + #[inline] pub fn get_drive_mode(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_MaterialLength)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).GetDriveMode)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} -} -RT_CLASS!{class SmartCardCryptogramMaterialCharacteristics: ISmartCardCryptogramMaterialCharacteristics} -impl RtActivatable for SmartCardCryptogramMaterialCharacteristics {} -DEFINE_CLSID!(SmartCardCryptogramMaterialCharacteristics(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,83,109,97,114,116,67,97,114,100,115,46,83,109,97,114,116,67,97,114,100,67,114,121,112,116,111,103,114,97,109,77,97,116,101,114,105,97,108,67,104,97,114,97,99,116,101,114,105,115,116,105,99,115,0]) [CLSID_SmartCardCryptogramMaterialCharacteristics]); -DEFINE_IID!(IID_ISmartCardCryptogramMaterialPackageCharacteristics, 4290088479, 1682, 19527, 147, 207, 52, 217, 31, 157, 205, 0); -RT_INTERFACE!{interface ISmartCardCryptogramMaterialPackageCharacteristics(ISmartCardCryptogramMaterialPackageCharacteristicsVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardCryptogramMaterialPackageCharacteristics] { - fn get_PackageName(&self, out: *mut HSTRING) -> HRESULT, - fn get_StorageKeyName(&self, out: *mut HSTRING) -> HRESULT, - fn get_DateImported(&self, out: *mut foundation::DateTime) -> HRESULT, - fn get_PackageFormat(&self, out: *mut SmartCardCryptogramMaterialPackageFormat) -> HRESULT -}} -impl ISmartCardCryptogramMaterialPackageCharacteristics { - #[inline] pub fn get_package_name(&self) -> Result { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_PackageName)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + #[inline] pub fn set_drive_mode(&self, value: ProviderGpioPinDriveMode) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).SetDriveMode)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_storage_key_name(&self) -> Result { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_StorageKeyName)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + #[inline] pub fn write(&self, value: ProviderGpioPinValue) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).Write)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_date_imported(&self) -> Result { unsafe { + #[inline] pub fn read(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_DateImported)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).Read)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_package_format(&self) -> Result { unsafe { +} +DEFINE_IID!(IID_IGpioPinProviderValueChangedEventArgs, 849794802, 15707, 17613, 143, 190, 19, 166, 159, 46, 219, 36); +RT_INTERFACE!{interface IGpioPinProviderValueChangedEventArgs(IGpioPinProviderValueChangedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IGpioPinProviderValueChangedEventArgs] { + fn get_Edge(&self, out: *mut ProviderGpioPinEdge) -> HRESULT +}} +impl IGpioPinProviderValueChangedEventArgs { + #[inline] pub fn get_edge(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_PackageFormat)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_Edge)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} } -RT_CLASS!{class SmartCardCryptogramMaterialPackageCharacteristics: ISmartCardCryptogramMaterialPackageCharacteristics} -impl RtActivatable for SmartCardCryptogramMaterialPackageCharacteristics {} -DEFINE_CLSID!(SmartCardCryptogramMaterialPackageCharacteristics(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,83,109,97,114,116,67,97,114,100,115,46,83,109,97,114,116,67,97,114,100,67,114,121,112,116,111,103,114,97,109,77,97,116,101,114,105,97,108,80,97,99,107,97,103,101,67,104,97,114,97,99,116,101,114,105,115,116,105,99,115,0]) [CLSID_SmartCardCryptogramMaterialPackageCharacteristics]); -RT_ENUM! { enum SmartCardCryptogramMaterialPackageConfirmationResponseFormat: i32 { - None (SmartCardCryptogramMaterialPackageConfirmationResponseFormat_None) = 0, VisaHmac (SmartCardCryptogramMaterialPackageConfirmationResponseFormat_VisaHmac) = 1, -}} -RT_ENUM! { enum SmartCardCryptogramMaterialPackageFormat: i32 { - None (SmartCardCryptogramMaterialPackageFormat_None) = 0, JweRsaPki (SmartCardCryptogramMaterialPackageFormat_JweRsaPki) = 1, -}} -DEFINE_IID!(IID_ISmartCardCryptogramMaterialPossessionProof, 3854150540, 41281, 16693, 154, 221, 176, 210, 227, 170, 31, 201); -RT_INTERFACE!{interface ISmartCardCryptogramMaterialPossessionProof(ISmartCardCryptogramMaterialPossessionProofVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardCryptogramMaterialPossessionProof] { - fn get_OperationStatus(&self, out: *mut SmartCardCryptogramGeneratorOperationStatus) -> HRESULT, - #[cfg(feature="windows-storage")] fn get_Proof(&self, out: *mut *mut super::super::storage::streams::IBuffer) -> HRESULT +RT_CLASS!{class GpioPinProviderValueChangedEventArgs: IGpioPinProviderValueChangedEventArgs} +impl RtActivatable for GpioPinProviderValueChangedEventArgs {} +impl GpioPinProviderValueChangedEventArgs { + #[inline] pub fn create(edge: ProviderGpioPinEdge) -> Result> { + >::get_activation_factory().create(edge) + } +} +DEFINE_CLSID!(GpioPinProviderValueChangedEventArgs(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,71,112,105,111,46,80,114,111,118,105,100,101,114,46,71,112,105,111,80,105,110,80,114,111,118,105,100,101,114,86,97,108,117,101,67,104,97,110,103,101,100,69,118,101,110,116,65,114,103,115,0]) [CLSID_GpioPinProviderValueChangedEventArgs]); +DEFINE_IID!(IID_IGpioPinProviderValueChangedEventArgsFactory, 1053494105, 22156, 17298, 178, 74, 138, 89, 169, 2, 177, 241); +RT_INTERFACE!{static interface IGpioPinProviderValueChangedEventArgsFactory(IGpioPinProviderValueChangedEventArgsFactoryVtbl): IInspectable(IInspectableVtbl) [IID_IGpioPinProviderValueChangedEventArgsFactory] { + fn Create(&self, edge: ProviderGpioPinEdge, out: *mut *mut GpioPinProviderValueChangedEventArgs) -> HRESULT }} -impl ISmartCardCryptogramMaterialPossessionProof { - #[inline] pub fn get_operation_status(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_OperationStatus)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } +impl IGpioPinProviderValueChangedEventArgsFactory { + #[inline] pub fn create(&self, edge: ProviderGpioPinEdge) -> Result> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, edge, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[cfg(feature="windows-storage")] #[inline] pub fn get_proof(&self) -> Result>> { unsafe { +} +DEFINE_IID!(IID_IGpioProvider, 1156065031, 2250, 17226, 175, 224, 214, 21, 128, 68, 111, 126); +RT_INTERFACE!{interface IGpioProvider(IGpioProviderVtbl): IInspectable(IInspectableVtbl) [IID_IGpioProvider] { + fn GetControllers(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT +}} +impl IGpioProvider { + #[inline] pub fn get_controllers(&self) -> Result>>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Proof)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).GetControllers)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } -RT_CLASS!{class SmartCardCryptogramMaterialPossessionProof: ISmartCardCryptogramMaterialPossessionProof} -RT_ENUM! { enum SmartCardCryptogramMaterialProtectionMethod: i32 { - None (SmartCardCryptogramMaterialProtectionMethod_None) = 0, WhiteBoxing (SmartCardCryptogramMaterialProtectionMethod_WhiteBoxing) = 1, +RT_ENUM! { enum ProviderGpioPinDriveMode: i32 { + Input (ProviderGpioPinDriveMode_Input) = 0, Output (ProviderGpioPinDriveMode_Output) = 1, InputPullUp (ProviderGpioPinDriveMode_InputPullUp) = 2, InputPullDown (ProviderGpioPinDriveMode_InputPullDown) = 3, OutputOpenDrain (ProviderGpioPinDriveMode_OutputOpenDrain) = 4, OutputOpenDrainPullUp (ProviderGpioPinDriveMode_OutputOpenDrainPullUp) = 5, OutputOpenSource (ProviderGpioPinDriveMode_OutputOpenSource) = 6, OutputOpenSourcePullDown (ProviderGpioPinDriveMode_OutputOpenSourcePullDown) = 7, }} -RT_ENUM! { enum SmartCardCryptogramMaterialType: i32 { - None (SmartCardCryptogramMaterialType_None) = 0, StaticDataAuthentication (SmartCardCryptogramMaterialType_StaticDataAuthentication) = 1, TripleDes112 (SmartCardCryptogramMaterialType_TripleDes112) = 2, Aes (SmartCardCryptogramMaterialType_Aes) = 3, RsaPkcs1 (SmartCardCryptogramMaterialType_RsaPkcs1) = 4, +RT_ENUM! { enum ProviderGpioPinEdge: i32 { + FallingEdge (ProviderGpioPinEdge_FallingEdge) = 0, RisingEdge (ProviderGpioPinEdge_RisingEdge) = 1, }} -RT_ENUM! { enum SmartCardCryptogramPlacementOptions: u32 { - None (SmartCardCryptogramPlacementOptions_None) = 0, UnitsAreInNibbles (SmartCardCryptogramPlacementOptions_UnitsAreInNibbles) = 1, ChainOutput (SmartCardCryptogramPlacementOptions_ChainOutput) = 2, +RT_ENUM! { enum ProviderGpioPinValue: i32 { + Low (ProviderGpioPinValue_Low) = 0, High (ProviderGpioPinValue_High) = 1, }} -DEFINE_IID!(IID_ISmartCardCryptogramPlacementStep, 2491089899, 33602, 18322, 162, 229, 146, 86, 54, 55, 138, 83); -RT_INTERFACE!{interface ISmartCardCryptogramPlacementStep(ISmartCardCryptogramPlacementStepVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardCryptogramPlacementStep] { - fn get_Algorithm(&self, out: *mut SmartCardCryptogramAlgorithm) -> HRESULT, - fn put_Algorithm(&self, value: SmartCardCryptogramAlgorithm) -> HRESULT, - #[cfg(not(feature="windows-storage"))] fn __Dummy2(&self) -> (), - #[cfg(feature="windows-storage")] fn get_SourceData(&self, out: *mut *mut super::super::storage::streams::IBuffer) -> HRESULT, - #[cfg(not(feature="windows-storage"))] fn __Dummy3(&self) -> (), - #[cfg(feature="windows-storage")] fn put_SourceData(&self, value: *mut super::super::storage::streams::IBuffer) -> HRESULT, - fn get_CryptogramMaterialPackageName(&self, out: *mut HSTRING) -> HRESULT, - fn put_CryptogramMaterialPackageName(&self, value: HSTRING) -> HRESULT, - fn get_CryptogramMaterialName(&self, out: *mut HSTRING) -> HRESULT, - fn put_CryptogramMaterialName(&self, value: HSTRING) -> HRESULT, - fn get_TemplateOffset(&self, out: *mut i32) -> HRESULT, - fn put_TemplateOffset(&self, value: i32) -> HRESULT, - fn get_CryptogramOffset(&self, out: *mut i32) -> HRESULT, - fn put_CryptogramOffset(&self, value: i32) -> HRESULT, - fn get_CryptogramLength(&self, out: *mut i32) -> HRESULT, - fn put_CryptogramLength(&self, value: i32) -> HRESULT, - fn get_CryptogramPlacementOptions(&self, out: *mut SmartCardCryptogramPlacementOptions) -> HRESULT, - fn put_CryptogramPlacementOptions(&self, value: SmartCardCryptogramPlacementOptions) -> HRESULT, - fn get_ChainedOutputStep(&self, out: *mut *mut SmartCardCryptogramPlacementStep) -> HRESULT, - fn put_ChainedOutputStep(&self, value: *mut SmartCardCryptogramPlacementStep) -> HRESULT +RT_ENUM! { enum ProviderGpioSharingMode: i32 { + Exclusive (ProviderGpioSharingMode_Exclusive) = 0, SharedReadOnly (ProviderGpioSharingMode_SharedReadOnly) = 1, }} -impl ISmartCardCryptogramPlacementStep { - #[inline] pub fn get_algorithm(&self) -> Result { unsafe { +} // Windows.Devices.Gpio.Provider +} // Windows.Devices.Gpio +pub mod i2c { // Windows.Devices.I2c +use ::prelude::*; +RT_ENUM! { enum I2cBusSpeed: i32 { + StandardMode (I2cBusSpeed_StandardMode) = 0, FastMode (I2cBusSpeed_FastMode) = 1, +}} +DEFINE_IID!(IID_II2cConnectionSettings, 4074443527, 43887, 17977, 167, 103, 84, 83, 109, 195, 70, 15); +RT_INTERFACE!{interface II2cConnectionSettings(II2cConnectionSettingsVtbl): IInspectable(IInspectableVtbl) [IID_II2cConnectionSettings] { + fn get_SlaveAddress(&self, out: *mut i32) -> HRESULT, + fn put_SlaveAddress(&self, value: i32) -> HRESULT, + fn get_BusSpeed(&self, out: *mut I2cBusSpeed) -> HRESULT, + fn put_BusSpeed(&self, value: I2cBusSpeed) -> HRESULT, + fn get_SharingMode(&self, out: *mut I2cSharingMode) -> HRESULT, + fn put_SharingMode(&self, value: I2cSharingMode) -> HRESULT +}} +impl II2cConnectionSettings { + #[inline] pub fn get_slave_address(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_Algorithm)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_SlaveAddress)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn set_algorithm(&self, value: SmartCardCryptogramAlgorithm) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_Algorithm)(self as *const _ as *mut _, value); + #[inline] pub fn set_slave_address(&self, value: i32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_SlaveAddress)(self as *const _ as *mut _, value); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[cfg(feature="windows-storage")] #[inline] pub fn get_source_data(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_SourceData)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + #[inline] pub fn get_bus_speed(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_BusSpeed)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} - #[cfg(feature="windows-storage")] #[inline] pub fn set_source_data(&self, value: &super::super::storage::streams::IBuffer) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_SourceData)(self as *const _ as *mut _, value as *const _ as *mut _); + #[inline] pub fn set_bus_speed(&self, value: I2cBusSpeed) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_BusSpeed)(self as *const _ as *mut _, value); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_cryptogram_material_package_name(&self) -> Result { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_CryptogramMaterialPackageName)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + #[inline] pub fn get_sharing_mode(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_SharingMode)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn set_cryptogram_material_package_name(&self, value: &HStringArg) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_CryptogramMaterialPackageName)(self as *const _ as *mut _, value.get()); + #[inline] pub fn set_sharing_mode(&self, value: I2cSharingMode) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_SharingMode)(self as *const _ as *mut _, value); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_cryptogram_material_name(&self) -> Result { unsafe { +} +RT_CLASS!{class I2cConnectionSettings: II2cConnectionSettings} +impl RtActivatable for I2cConnectionSettings {} +impl I2cConnectionSettings { + #[inline] pub fn create(slaveAddress: i32) -> Result> { + >::get_activation_factory().create(slaveAddress) + } +} +DEFINE_CLSID!(I2cConnectionSettings(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,73,50,99,46,73,50,99,67,111,110,110,101,99,116,105,111,110,83,101,116,116,105,110,103,115,0]) [CLSID_I2cConnectionSettings]); +DEFINE_IID!(IID_II2cConnectionSettingsFactory, 2176157363, 38547, 16817, 162, 67, 222, 212, 246, 230, 105, 38); +RT_INTERFACE!{static interface II2cConnectionSettingsFactory(II2cConnectionSettingsFactoryVtbl): IInspectable(IInspectableVtbl) [IID_II2cConnectionSettingsFactory] { + fn Create(&self, slaveAddress: i32, out: *mut *mut I2cConnectionSettings) -> HRESULT +}} +impl II2cConnectionSettingsFactory { + #[inline] pub fn create(&self, slaveAddress: i32) -> Result> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_CryptogramMaterialName)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, slaveAddress, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn set_cryptogram_material_name(&self, value: &HStringArg) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_CryptogramMaterialName)(self as *const _ as *mut _, value.get()); - if hr == S_OK { Ok(()) } else { err(hr) } +} +DEFINE_IID!(IID_II2cController, 3297423794, 34720, 16742, 142, 62, 180, 184, 249, 124, 215, 41); +RT_INTERFACE!{interface II2cController(II2cControllerVtbl): IInspectable(IInspectableVtbl) [IID_II2cController] { + fn GetDevice(&self, settings: *mut I2cConnectionSettings, out: *mut *mut I2cDevice) -> HRESULT +}} +impl II2cController { + #[inline] pub fn get_device(&self, settings: &I2cConnectionSettings) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetDevice)(self as *const _ as *mut _, settings as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn get_template_offset(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_TemplateOffset)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } +} +RT_CLASS!{class I2cController: II2cController} +impl RtActivatable for I2cController {} +impl I2cController { + #[inline] pub fn get_controllers_async(provider: &provider::II2cProvider) -> Result>>> { + >::get_activation_factory().get_controllers_async(provider) + } + #[inline] pub fn get_default_async() -> Result>> { + >::get_activation_factory().get_default_async() + } +} +DEFINE_CLSID!(I2cController(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,73,50,99,46,73,50,99,67,111,110,116,114,111,108,108,101,114,0]) [CLSID_I2cController]); +DEFINE_IID!(IID_II2cControllerStatics, 1090257765, 24325, 20094, 132, 189, 16, 13, 184, 224, 174, 197); +RT_INTERFACE!{static interface II2cControllerStatics(II2cControllerStaticsVtbl): IInspectable(IInspectableVtbl) [IID_II2cControllerStatics] { + fn GetControllersAsync(&self, provider: *mut provider::II2cProvider, out: *mut *mut foundation::IAsyncOperation>) -> HRESULT, + fn GetDefaultAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT +}} +impl II2cControllerStatics { + #[inline] pub fn get_controllers_async(&self, provider: &provider::II2cProvider) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetControllersAsync)(self as *const _ as *mut _, provider as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn set_template_offset(&self, value: i32) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_TemplateOffset)(self as *const _ as *mut _, value); + #[inline] pub fn get_default_async(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetDefaultAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} +} +DEFINE_IID!(IID_II2cDevice, 2251735350, 47557, 20336, 148, 73, 204, 70, 220, 111, 87, 235); +RT_INTERFACE!{interface II2cDevice(II2cDeviceVtbl): IInspectable(IInspectableVtbl) [IID_II2cDevice] { + fn get_DeviceId(&self, out: *mut HSTRING) -> HRESULT, + fn get_ConnectionSettings(&self, out: *mut *mut I2cConnectionSettings) -> HRESULT, + fn Write(&self, bufferSize: u32, buffer: *mut u8) -> HRESULT, + fn WritePartial(&self, bufferSize: u32, buffer: *mut u8, out: *mut I2cTransferResult) -> HRESULT, + fn Read(&self, bufferSize: u32, buffer: *mut u8) -> HRESULT, + fn ReadPartial(&self, bufferSize: u32, buffer: *mut u8, out: *mut I2cTransferResult) -> HRESULT, + fn WriteRead(&self, writeBufferSize: u32, writeBuffer: *mut u8, readBufferSize: u32, readBuffer: *mut u8) -> HRESULT, + fn WriteReadPartial(&self, writeBufferSize: u32, writeBuffer: *mut u8, readBufferSize: u32, readBuffer: *mut u8, out: *mut I2cTransferResult) -> HRESULT +}} +impl II2cDevice { + #[inline] pub fn get_device_id(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_DeviceId)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_connection_settings(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ConnectionSettings)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn write(&self, buffer: &[u8]) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).Write)(self as *const _ as *mut _, buffer.len() as u32, buffer.as_ptr() as *mut _); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_cryptogram_offset(&self) -> Result { unsafe { + #[inline] pub fn write_partial(&self, buffer: &[u8]) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_CryptogramOffset)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).WritePartial)(self as *const _ as *mut _, buffer.len() as u32, buffer.as_ptr() as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn set_cryptogram_offset(&self, value: i32) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_CryptogramOffset)(self as *const _ as *mut _, value); + #[inline] pub fn read(&self, buffer: &mut [u8]) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).Read)(self as *const _ as *mut _, buffer.len() as u32, buffer.as_mut_ptr() as *mut _); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_cryptogram_length(&self) -> Result { unsafe { + #[inline] pub fn read_partial(&self, buffer: &mut [u8]) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_CryptogramLength)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).ReadPartial)(self as *const _ as *mut _, buffer.len() as u32, buffer.as_mut_ptr() as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn set_cryptogram_length(&self, value: i32) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_CryptogramLength)(self as *const _ as *mut _, value); + #[inline] pub fn write_read(&self, writeBuffer: &[u8], readBuffer: &mut [u8]) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).WriteRead)(self as *const _ as *mut _, writeBuffer.len() as u32, writeBuffer.as_ptr() as *mut _, readBuffer.len() as u32, readBuffer.as_mut_ptr() as *mut _); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_cryptogram_placement_options(&self) -> Result { unsafe { + #[inline] pub fn write_read_partial(&self, writeBuffer: &[u8], readBuffer: &mut [u8]) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_CryptogramPlacementOptions)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).WriteReadPartial)(self as *const _ as *mut _, writeBuffer.len() as u32, writeBuffer.as_ptr() as *mut _, readBuffer.len() as u32, readBuffer.as_mut_ptr() as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn set_cryptogram_placement_options(&self, value: SmartCardCryptogramPlacementOptions) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_CryptogramPlacementOptions)(self as *const _ as *mut _, value); - if hr == S_OK { Ok(()) } else { err(hr) } +} +RT_CLASS!{class I2cDevice: II2cDevice} +impl RtActivatable for I2cDevice {} +impl I2cDevice { + #[inline] pub fn get_device_selector() -> Result { + >::get_activation_factory().get_device_selector() + } + #[inline] pub fn get_device_selector_from_friendly_name(friendlyName: &HStringArg) -> Result { + >::get_activation_factory().get_device_selector_from_friendly_name(friendlyName) + } + #[inline] pub fn from_id_async(deviceId: &HStringArg, settings: &I2cConnectionSettings) -> Result>> { + >::get_activation_factory().from_id_async(deviceId, settings) + } +} +DEFINE_CLSID!(I2cDevice(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,73,50,99,46,73,50,99,68,101,118,105,99,101,0]) [CLSID_I2cDevice]); +DEFINE_IID!(IID_II2cDeviceStatics, 2443394019, 29492, 17682, 150, 188, 251, 174, 148, 89, 245, 246); +RT_INTERFACE!{static interface II2cDeviceStatics(II2cDeviceStaticsVtbl): IInspectable(IInspectableVtbl) [IID_II2cDeviceStatics] { + fn GetDeviceSelector(&self, out: *mut HSTRING) -> HRESULT, + fn GetDeviceSelectorFromFriendlyName(&self, friendlyName: HSTRING, out: *mut HSTRING) -> HRESULT, + fn FromIdAsync(&self, deviceId: HSTRING, settings: *mut I2cConnectionSettings, out: *mut *mut foundation::IAsyncOperation) -> HRESULT +}} +impl II2cDeviceStatics { + #[inline] pub fn get_device_selector(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetDeviceSelector)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_chained_output_step(&self) -> Result>> { unsafe { + #[inline] pub fn get_device_selector_from_friendly_name(&self, friendlyName: &HStringArg) -> Result { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_ChainedOutputStep)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).GetDeviceSelectorFromFriendlyName)(self as *const _ as *mut _, friendlyName.get(), &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} - #[inline] pub fn set_chained_output_step(&self, value: &SmartCardCryptogramPlacementStep) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_ChainedOutputStep)(self as *const _ as *mut _, value as *const _ as *mut _); - if hr == S_OK { Ok(()) } else { err(hr) } + #[inline] pub fn from_id_async(&self, deviceId: &HStringArg, settings: &I2cConnectionSettings) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).FromIdAsync)(self as *const _ as *mut _, deviceId.get(), settings as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } -RT_CLASS!{class SmartCardCryptogramPlacementStep: ISmartCardCryptogramPlacementStep} -impl RtActivatable for SmartCardCryptogramPlacementStep {} -DEFINE_CLSID!(SmartCardCryptogramPlacementStep(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,83,109,97,114,116,67,97,114,100,115,46,83,109,97,114,116,67,97,114,100,67,114,121,112,116,111,103,114,97,109,80,108,97,99,101,109,101,110,116,83,116,101,112,0]) [CLSID_SmartCardCryptogramPlacementStep]); -RT_ENUM! { enum SmartCardCryptogramStorageKeyAlgorithm: i32 { - None (SmartCardCryptogramStorageKeyAlgorithm_None) = 0, Rsa2048 (SmartCardCryptogramStorageKeyAlgorithm_Rsa2048) = 1, +RT_ENUM! { enum I2cSharingMode: i32 { + Exclusive (I2cSharingMode_Exclusive) = 0, Shared (I2cSharingMode_Shared) = 1, }} -RT_ENUM! { enum SmartCardCryptogramStorageKeyCapabilities: u32 { - None (SmartCardCryptogramStorageKeyCapabilities_None) = 0, HardwareProtection (SmartCardCryptogramStorageKeyCapabilities_HardwareProtection) = 1, UnlockPrompt (SmartCardCryptogramStorageKeyCapabilities_UnlockPrompt) = 2, +RT_STRUCT! { struct I2cTransferResult { + Status: I2cTransferStatus, BytesTransferred: u32, }} -DEFINE_IID!(IID_ISmartCardCryptogramStorageKeyCharacteristics, 2236765294, 17495, 18469, 180, 100, 99, 84, 113, 163, 159, 92); -RT_INTERFACE!{interface ISmartCardCryptogramStorageKeyCharacteristics(ISmartCardCryptogramStorageKeyCharacteristicsVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardCryptogramStorageKeyCharacteristics] { - fn get_StorageKeyName(&self, out: *mut HSTRING) -> HRESULT, - fn get_DateCreated(&self, out: *mut foundation::DateTime) -> HRESULT, - fn get_Algorithm(&self, out: *mut SmartCardCryptogramStorageKeyAlgorithm) -> HRESULT, - fn get_Capabilities(&self, out: *mut SmartCardCryptogramStorageKeyCapabilities) -> HRESULT +RT_ENUM! { enum I2cTransferStatus: i32 { + FullTransfer (I2cTransferStatus_FullTransfer) = 0, PartialTransfer (I2cTransferStatus_PartialTransfer) = 1, SlaveAddressNotAcknowledged (I2cTransferStatus_SlaveAddressNotAcknowledged) = 2, ClockStretchTimeout (I2cTransferStatus_ClockStretchTimeout) = 3, UnknownError (I2cTransferStatus_UnknownError) = 4, }} -impl ISmartCardCryptogramStorageKeyCharacteristics { - #[inline] pub fn get_storage_key_name(&self) -> Result { unsafe { +pub mod provider { // Windows.Devices.I2c.Provider +use ::prelude::*; +DEFINE_IID!(IID_II2cControllerProvider, 1640151938, 17680, 16739, 168, 124, 78, 21, 169, 85, 137, 128); +RT_INTERFACE!{interface II2cControllerProvider(II2cControllerProviderVtbl): IInspectable(IInspectableVtbl) [IID_II2cControllerProvider] { + fn GetDeviceProvider(&self, settings: *mut ProviderI2cConnectionSettings, out: *mut *mut II2cDeviceProvider) -> HRESULT +}} +impl II2cControllerProvider { + #[inline] pub fn get_device_provider(&self, settings: &ProviderI2cConnectionSettings) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_StorageKeyName)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).GetDeviceProvider)(self as *const _ as *mut _, settings as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +DEFINE_IID!(IID_II2cDeviceProvider, 2905876052, 22504, 17726, 131, 41, 209, 228, 71, 209, 3, 169); +RT_INTERFACE!{interface II2cDeviceProvider(II2cDeviceProviderVtbl): IInspectable(IInspectableVtbl) [IID_II2cDeviceProvider] { + fn get_DeviceId(&self, out: *mut HSTRING) -> HRESULT, + fn Write(&self, bufferSize: u32, buffer: *mut u8) -> HRESULT, + fn WritePartial(&self, bufferSize: u32, buffer: *mut u8, out: *mut ProviderI2cTransferResult) -> HRESULT, + fn Read(&self, bufferSize: u32, buffer: *mut u8) -> HRESULT, + fn ReadPartial(&self, bufferSize: u32, buffer: *mut u8, out: *mut ProviderI2cTransferResult) -> HRESULT, + fn WriteRead(&self, writeBufferSize: u32, writeBuffer: *mut u8, readBufferSize: u32, readBuffer: *mut u8) -> HRESULT, + fn WriteReadPartial(&self, writeBufferSize: u32, writeBuffer: *mut u8, readBufferSize: u32, readBuffer: *mut u8, out: *mut ProviderI2cTransferResult) -> HRESULT +}} +impl II2cDeviceProvider { + #[inline] pub fn get_device_id(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_DeviceId)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_date_created(&self) -> Result { unsafe { + #[inline] pub fn write(&self, buffer: &[u8]) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).Write)(self as *const _ as *mut _, buffer.len() as u32, buffer.as_ptr() as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn write_partial(&self, buffer: &[u8]) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_DateCreated)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).WritePartial)(self as *const _ as *mut _, buffer.len() as u32, buffer.as_ptr() as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_algorithm(&self) -> Result { unsafe { + #[inline] pub fn read(&self, buffer: &mut [u8]) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).Read)(self as *const _ as *mut _, buffer.len() as u32, buffer.as_mut_ptr() as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn read_partial(&self, buffer: &mut [u8]) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_Algorithm)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).ReadPartial)(self as *const _ as *mut _, buffer.len() as u32, buffer.as_mut_ptr() as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_capabilities(&self) -> Result { unsafe { + #[inline] pub fn write_read(&self, writeBuffer: &[u8], readBuffer: &mut [u8]) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).WriteRead)(self as *const _ as *mut _, writeBuffer.len() as u32, writeBuffer.as_ptr() as *mut _, readBuffer.len() as u32, readBuffer.as_mut_ptr() as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn write_read_partial(&self, writeBuffer: &[u8], readBuffer: &mut [u8]) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_Capabilities)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).WriteReadPartial)(self as *const _ as *mut _, writeBuffer.len() as u32, writeBuffer.as_ptr() as *mut _, readBuffer.len() as u32, readBuffer.as_mut_ptr() as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} } -RT_CLASS!{class SmartCardCryptogramStorageKeyCharacteristics: ISmartCardCryptogramStorageKeyCharacteristics} -impl RtActivatable for SmartCardCryptogramStorageKeyCharacteristics {} -DEFINE_CLSID!(SmartCardCryptogramStorageKeyCharacteristics(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,83,109,97,114,116,67,97,114,100,115,46,83,109,97,114,116,67,97,114,100,67,114,121,112,116,111,103,114,97,109,83,116,111,114,97,103,101,75,101,121,67,104,97,114,97,99,116,101,114,105,115,116,105,99,115,0]) [CLSID_SmartCardCryptogramStorageKeyCharacteristics]); -DEFINE_IID!(IID_ISmartCardCryptogramStorageKeyInfo, 2008084493, 45207, 20321, 162, 106, 149, 97, 99, 156, 156, 58); -RT_INTERFACE!{interface ISmartCardCryptogramStorageKeyInfo(ISmartCardCryptogramStorageKeyInfoVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardCryptogramStorageKeyInfo] { - fn get_OperationStatus(&self, out: *mut SmartCardCryptogramGeneratorOperationStatus) -> HRESULT, - #[cfg(not(feature="windows-security"))] fn __Dummy1(&self) -> (), - #[cfg(feature="windows-security")] fn get_PublicKeyBlobType(&self, out: *mut super::super::security::cryptography::core::CryptographicPublicKeyBlobType) -> HRESULT, - #[cfg(not(feature="windows-storage"))] fn __Dummy2(&self) -> (), - #[cfg(feature="windows-storage")] fn get_PublicKey(&self, out: *mut *mut super::super::storage::streams::IBuffer) -> HRESULT, - fn get_AttestationStatus(&self, out: *mut SmartCardCryptographicKeyAttestationStatus) -> HRESULT, - #[cfg(not(feature="windows-storage"))] fn __Dummy4(&self) -> (), - #[cfg(feature="windows-storage")] fn get_Attestation(&self, out: *mut *mut super::super::storage::streams::IBuffer) -> HRESULT, - #[cfg(not(feature="windows-storage"))] fn __Dummy5(&self) -> (), - #[cfg(feature="windows-storage")] fn get_AttestationCertificateChain(&self, out: *mut *mut super::super::storage::streams::IBuffer) -> HRESULT, - fn get_Capabilities(&self, out: *mut SmartCardCryptogramStorageKeyCapabilities) -> HRESULT +DEFINE_IID!(IID_II2cProvider, 1863518270, 48994, 20450, 169, 90, 240, 137, 153, 102, 152, 24); +RT_INTERFACE!{interface II2cProvider(II2cProviderVtbl): IInspectable(IInspectableVtbl) [IID_II2cProvider] { + fn GetControllersAsync(&self, out: *mut *mut foundation::IAsyncOperation>) -> HRESULT }} -impl ISmartCardCryptogramStorageKeyInfo { - #[inline] pub fn get_operation_status(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_OperationStatus)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } +impl II2cProvider { + #[inline] pub fn get_controllers_async(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetControllersAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[cfg(feature="windows-security")] #[inline] pub fn get_public_key_blob_type(&self) -> Result { unsafe { +} +RT_ENUM! { enum ProviderI2cBusSpeed: i32 { + StandardMode (ProviderI2cBusSpeed_StandardMode) = 0, FastMode (ProviderI2cBusSpeed_FastMode) = 1, +}} +DEFINE_IID!(IID_IProviderI2cConnectionSettings, 3923463732, 58640, 17591, 128, 157, 242, 248, 91, 85, 83, 57); +RT_INTERFACE!{interface IProviderI2cConnectionSettings(IProviderI2cConnectionSettingsVtbl): IInspectable(IInspectableVtbl) [IID_IProviderI2cConnectionSettings] { + fn get_SlaveAddress(&self, out: *mut i32) -> HRESULT, + fn put_SlaveAddress(&self, value: i32) -> HRESULT, + fn get_BusSpeed(&self, out: *mut ProviderI2cBusSpeed) -> HRESULT, + fn put_BusSpeed(&self, value: ProviderI2cBusSpeed) -> HRESULT, + fn get_SharingMode(&self, out: *mut ProviderI2cSharingMode) -> HRESULT, + fn put_SharingMode(&self, value: ProviderI2cSharingMode) -> HRESULT +}} +impl IProviderI2cConnectionSettings { + #[inline] pub fn get_slave_address(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_PublicKeyBlobType)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_SlaveAddress)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[cfg(feature="windows-storage")] #[inline] pub fn get_public_key(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_PublicKey)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + #[inline] pub fn set_slave_address(&self, value: i32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_SlaveAddress)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_attestation_status(&self) -> Result { unsafe { + #[inline] pub fn get_bus_speed(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_AttestationStatus)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_BusSpeed)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[cfg(feature="windows-storage")] #[inline] pub fn get_attestation(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Attestation)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } - }} - #[cfg(feature="windows-storage")] #[inline] pub fn get_attestation_certificate_chain(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_AttestationCertificateChain)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + #[inline] pub fn set_bus_speed(&self, value: ProviderI2cBusSpeed) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_BusSpeed)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_capabilities(&self) -> Result { unsafe { + #[inline] pub fn get_sharing_mode(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_Capabilities)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_SharingMode)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} -} -RT_CLASS!{class SmartCardCryptogramStorageKeyInfo: ISmartCardCryptogramStorageKeyInfo} -DEFINE_IID!(IID_ISmartCardCryptogramStorageKeyInfo2, 278777, 63485, 16765, 137, 225, 251, 176, 56, 42, 220, 77); -RT_INTERFACE!{interface ISmartCardCryptogramStorageKeyInfo2(ISmartCardCryptogramStorageKeyInfo2Vtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardCryptogramStorageKeyInfo2] { - fn get_OperationalRequirements(&self, out: *mut HSTRING) -> HRESULT -}} -impl ISmartCardCryptogramStorageKeyInfo2 { - #[inline] pub fn get_operational_requirements(&self) -> Result { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_OperationalRequirements)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + #[inline] pub fn set_sharing_mode(&self, value: ProviderI2cSharingMode) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_SharingMode)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } }} } -RT_ENUM! { enum SmartCardCryptographicKeyAttestationStatus: i32 { - NoAttestation (SmartCardCryptographicKeyAttestationStatus_NoAttestation) = 0, SoftwareKeyWithoutTpm (SmartCardCryptographicKeyAttestationStatus_SoftwareKeyWithoutTpm) = 1, SoftwareKeyWithTpm (SmartCardCryptographicKeyAttestationStatus_SoftwareKeyWithTpm) = 2, TpmKeyUnknownAttestationStatus (SmartCardCryptographicKeyAttestationStatus_TpmKeyUnknownAttestationStatus) = 3, TpmKeyWithoutAttestationCapability (SmartCardCryptographicKeyAttestationStatus_TpmKeyWithoutAttestationCapability) = 4, TpmKeyWithTemporaryAttestationFailure (SmartCardCryptographicKeyAttestationStatus_TpmKeyWithTemporaryAttestationFailure) = 5, TpmKeyWithLongTermAttestationFailure (SmartCardCryptographicKeyAttestationStatus_TpmKeyWithLongTermAttestationFailure) = 6, TpmKeyWithAttestation (SmartCardCryptographicKeyAttestationStatus_TpmKeyWithAttestation) = 7, +RT_CLASS!{class ProviderI2cConnectionSettings: IProviderI2cConnectionSettings} +RT_ENUM! { enum ProviderI2cSharingMode: i32 { + Exclusive (ProviderI2cSharingMode_Exclusive) = 0, Shared (ProviderI2cSharingMode_Shared) = 1, }} -RT_ENUM! { enum SmartCardEmulationCategory: i32 { - Other (SmartCardEmulationCategory_Other) = 0, Payment (SmartCardEmulationCategory_Payment) = 1, +RT_STRUCT! { struct ProviderI2cTransferResult { + Status: ProviderI2cTransferStatus, BytesTransferred: u32, }} -RT_ENUM! { enum SmartCardEmulationType: i32 { - Host (SmartCardEmulationType_Host) = 0, Uicc (SmartCardEmulationType_Uicc) = 1, EmbeddedSE (SmartCardEmulationType_EmbeddedSE) = 2, +RT_ENUM! { enum ProviderI2cTransferStatus: i32 { + FullTransfer (ProviderI2cTransferStatus_FullTransfer) = 0, PartialTransfer (ProviderI2cTransferStatus_PartialTransfer) = 1, SlaveAddressNotAcknowledged (ProviderI2cTransferStatus_SlaveAddressNotAcknowledged) = 2, }} -DEFINE_IID!(IID_ISmartCardEmulator, 3753445042, 34654, 18405, 128, 119, 232, 191, 241, 177, 198, 251); -RT_INTERFACE!{interface ISmartCardEmulator(ISmartCardEmulatorVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardEmulator] { - fn get_EnablementPolicy(&self, out: *mut SmartCardEmulatorEnablementPolicy) -> HRESULT +} // Windows.Devices.I2c.Provider +} // Windows.Devices.I2c +pub mod pwm { // Windows.Devices.Pwm +use ::prelude::*; +DEFINE_IID!(IID_IPwmController, 3294583941, 53992, 17103, 155, 214, 207, 94, 208, 41, 230, 167); +RT_INTERFACE!{interface IPwmController(IPwmControllerVtbl): IInspectable(IInspectableVtbl) [IID_IPwmController] { + fn get_PinCount(&self, out: *mut i32) -> HRESULT, + fn get_ActualFrequency(&self, out: *mut f64) -> HRESULT, + fn SetDesiredFrequency(&self, desiredFrequency: f64, out: *mut f64) -> HRESULT, + fn get_MinFrequency(&self, out: *mut f64) -> HRESULT, + fn get_MaxFrequency(&self, out: *mut f64) -> HRESULT, + fn OpenPin(&self, pinNumber: i32, out: *mut *mut PwmPin) -> HRESULT }} -impl ISmartCardEmulator { - #[inline] pub fn get_enablement_policy(&self) -> Result { unsafe { +impl IPwmController { + #[inline] pub fn get_pin_count(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_EnablementPolicy)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_PinCount)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} -} -RT_CLASS!{class SmartCardEmulator: ISmartCardEmulator} -impl RtActivatable for SmartCardEmulator {} -impl RtActivatable for SmartCardEmulator {} -impl RtActivatable for SmartCardEmulator {} -impl SmartCardEmulator { - #[inline] pub fn get_default_async() -> Result>> { - >::get_activation_factory().get_default_async() - } - #[inline] pub fn get_applet_id_group_registrations_async() -> Result>>> { - >::get_activation_factory().get_applet_id_group_registrations_async() - } - #[inline] pub fn register_applet_id_group_async(appletIdGroup: &SmartCardAppletIdGroup) -> Result>> { - >::get_activation_factory().register_applet_id_group_async(appletIdGroup) - } - #[inline] pub fn unregister_applet_id_group_async(registration: &SmartCardAppletIdGroupRegistration) -> Result> { - >::get_activation_factory().unregister_applet_id_group_async(registration) - } - #[inline] pub fn get_max_applet_id_group_registrations() -> Result { - >::get_activation_factory().get_max_applet_id_group_registrations() - } - #[inline] pub fn is_supported() -> Result { - >::get_activation_factory().is_supported() - } -} -DEFINE_CLSID!(SmartCardEmulator(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,83,109,97,114,116,67,97,114,100,115,46,83,109,97,114,116,67,97,114,100,69,109,117,108,97,116,111,114,0]) [CLSID_SmartCardEmulator]); -DEFINE_IID!(IID_ISmartCardEmulator2, 4265590968, 34089, 16666, 128, 123, 72, 237, 194, 160, 171, 68); -RT_INTERFACE!{interface ISmartCardEmulator2(ISmartCardEmulator2Vtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardEmulator2] { - fn add_ApduReceived(&self, value: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, - fn remove_ApduReceived(&self, value: foundation::EventRegistrationToken) -> HRESULT, - fn add_ConnectionDeactivated(&self, value: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, - fn remove_ConnectionDeactivated(&self, value: foundation::EventRegistrationToken) -> HRESULT, - fn Start(&self) -> HRESULT, - fn IsHostCardEmulationSupported(&self, out: *mut bool) -> HRESULT -}} -impl ISmartCardEmulator2 { - #[inline] pub fn add_apdu_received(&self, value: &foundation::TypedEventHandler) -> Result { unsafe { + #[inline] pub fn get_actual_frequency(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).add_ApduReceived)(self as *const _ as *mut _, value as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_ActualFrequency)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn remove_apdu_received(&self, value: foundation::EventRegistrationToken) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).remove_ApduReceived)(self as *const _ as *mut _, value); - if hr == S_OK { Ok(()) } else { err(hr) } - }} - #[inline] pub fn add_connection_deactivated(&self, value: &foundation::TypedEventHandler) -> Result { unsafe { + #[inline] pub fn set_desired_frequency(&self, desiredFrequency: f64) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).add_ConnectionDeactivated)(self as *const _ as *mut _, value as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).SetDesiredFrequency)(self as *const _ as *mut _, desiredFrequency, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn remove_connection_deactivated(&self, value: foundation::EventRegistrationToken) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).remove_ConnectionDeactivated)(self as *const _ as *mut _, value); - if hr == S_OK { Ok(()) } else { err(hr) } - }} - #[inline] pub fn start(&self) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).Start)(self as *const _ as *mut _); - if hr == S_OK { Ok(()) } else { err(hr) } + #[inline] pub fn get_min_frequency(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_MinFrequency)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn is_host_card_emulation_supported(&self) -> Result { unsafe { + #[inline] pub fn get_max_frequency(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).IsHostCardEmulationSupported)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_MaxFrequency)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} -} -DEFINE_IID!(IID_ISmartCardEmulatorApduReceivedEventArgs, 3579647350, 27090, 21299, 91, 95, 248, 192, 214, 233, 240, 159); -RT_INTERFACE!{interface ISmartCardEmulatorApduReceivedEventArgs(ISmartCardEmulatorApduReceivedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardEmulatorApduReceivedEventArgs] { - #[cfg(not(feature="windows-storage"))] fn __Dummy0(&self) -> (), - #[cfg(feature="windows-storage")] fn get_CommandApdu(&self, out: *mut *mut super::super::storage::streams::IBuffer) -> HRESULT, - fn get_ConnectionProperties(&self, out: *mut *mut SmartCardEmulatorConnectionProperties) -> HRESULT, - #[cfg(not(feature="windows-storage"))] fn __Dummy2(&self) -> (), - #[cfg(feature="windows-storage")] fn TryRespondAsync(&self, responseApdu: *mut super::super::storage::streams::IBuffer, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, - fn get_AutomaticResponseStatus(&self, out: *mut SmartCardAutomaticResponseStatus) -> HRESULT -}} -impl ISmartCardEmulatorApduReceivedEventArgs { - #[cfg(feature="windows-storage")] #[inline] pub fn get_command_apdu(&self) -> Result>> { unsafe { + #[inline] pub fn open_pin(&self, pinNumber: i32) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_CommandApdu)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).OpenPin)(self as *const _ as *mut _, pinNumber, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn get_connection_properties(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_ConnectionProperties)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } - }} - #[cfg(feature="windows-storage")] #[inline] pub fn try_respond_async(&self, responseApdu: &super::super::storage::streams::IBuffer) -> Result>> { unsafe { +} +RT_CLASS!{class PwmController: IPwmController} +impl RtActivatable for PwmController {} +impl RtActivatable for PwmController {} +impl RtActivatable for PwmController {} +impl PwmController { + #[inline] pub fn get_controllers_async(provider: &provider::IPwmProvider) -> Result>>> { + >::get_activation_factory().get_controllers_async(provider) + } + #[inline] pub fn get_default_async() -> Result>> { + >::get_activation_factory().get_default_async() + } + #[inline] pub fn get_device_selector() -> Result { + >::get_activation_factory().get_device_selector() + } + #[inline] pub fn get_device_selector_from_friendly_name(friendlyName: &HStringArg) -> Result { + >::get_activation_factory().get_device_selector_from_friendly_name(friendlyName) + } + #[inline] pub fn from_id_async(deviceId: &HStringArg) -> Result>> { + >::get_activation_factory().from_id_async(deviceId) + } +} +DEFINE_CLSID!(PwmController(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,80,119,109,46,80,119,109,67,111,110,116,114,111,108,108,101,114,0]) [CLSID_PwmController]); +DEFINE_IID!(IID_IPwmControllerStatics, 1113832865, 35142, 17412, 189, 72, 129, 221, 18, 74, 244, 217); +RT_INTERFACE!{static interface IPwmControllerStatics(IPwmControllerStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IPwmControllerStatics] { + fn GetControllersAsync(&self, provider: *mut provider::IPwmProvider, out: *mut *mut foundation::IAsyncOperation>) -> HRESULT +}} +impl IPwmControllerStatics { + #[inline] pub fn get_controllers_async(&self, provider: &provider::IPwmProvider) -> Result>>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).TryRespondAsync)(self as *const _ as *mut _, responseApdu as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).GetControllersAsync)(self as *const _ as *mut _, provider as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_automatic_response_status(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_AutomaticResponseStatus)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } - }} } -RT_CLASS!{class SmartCardEmulatorApduReceivedEventArgs: ISmartCardEmulatorApduReceivedEventArgs} -DEFINE_IID!(IID_ISmartCardEmulatorApduReceivedEventArgs2, 2348367344, 8929, 16952, 134, 16, 148, 206, 74, 150, 84, 37); -RT_INTERFACE!{interface ISmartCardEmulatorApduReceivedEventArgs2(ISmartCardEmulatorApduReceivedEventArgs2Vtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardEmulatorApduReceivedEventArgs2] { - fn get_State(&self, out: *mut u32) -> HRESULT, - #[cfg(feature="windows-storage")] fn TryRespondWithStateAsync(&self, responseApdu: *mut super::super::storage::streams::IBuffer, nextState: *mut foundation::IReference, out: *mut *mut foundation::IAsyncOperation) -> HRESULT +DEFINE_IID!(IID_IPwmControllerStatics2, 1157389087, 61721, 19421, 151, 173, 247, 110, 249, 134, 115, 109); +RT_INTERFACE!{static interface IPwmControllerStatics2(IPwmControllerStatics2Vtbl): IInspectable(IInspectableVtbl) [IID_IPwmControllerStatics2] { + fn GetDefaultAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT }} -impl ISmartCardEmulatorApduReceivedEventArgs2 { - #[inline] pub fn get_state(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_State)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } - }} - #[cfg(feature="windows-storage")] #[inline] pub fn try_respond_with_state_async(&self, responseApdu: &super::super::storage::streams::IBuffer, nextState: &foundation::IReference) -> Result>> { unsafe { +impl IPwmControllerStatics2 { + #[inline] pub fn get_default_async(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).TryRespondWithStateAsync)(self as *const _ as *mut _, responseApdu as *const _ as *mut _, nextState as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).GetDefaultAsync)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } -DEFINE_IID!(IID_ISmartCardEmulatorApduReceivedEventArgsWithCryptograms, 3578837703, 47039, 20009, 146, 148, 12, 74, 195, 201, 65, 189); -RT_INTERFACE!{interface ISmartCardEmulatorApduReceivedEventArgsWithCryptograms(ISmartCardEmulatorApduReceivedEventArgsWithCryptogramsVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardEmulatorApduReceivedEventArgsWithCryptograms] { - #[cfg(feature="windows-storage")] fn TryRespondWithCryptogramsAsync(&self, responseTemplate: *mut super::super::storage::streams::IBuffer, cryptogramPlacementSteps: *mut foundation::collections::IIterable, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, - #[cfg(feature="windows-storage")] fn TryRespondWithCryptogramsAndStateAsync(&self, responseTemplate: *mut super::super::storage::streams::IBuffer, cryptogramPlacementSteps: *mut foundation::collections::IIterable, nextState: *mut foundation::IReference, out: *mut *mut foundation::IAsyncOperation) -> HRESULT +DEFINE_IID!(IID_IPwmControllerStatics3, 2992117873, 553, 17220, 174, 63, 155, 124, 208, 230, 107, 148); +RT_INTERFACE!{static interface IPwmControllerStatics3(IPwmControllerStatics3Vtbl): IInspectable(IInspectableVtbl) [IID_IPwmControllerStatics3] { + fn GetDeviceSelector(&self, out: *mut HSTRING) -> HRESULT, + fn GetDeviceSelectorFromFriendlyName(&self, friendlyName: HSTRING, out: *mut HSTRING) -> HRESULT, + fn FromIdAsync(&self, deviceId: HSTRING, out: *mut *mut foundation::IAsyncOperation) -> HRESULT }} -impl ISmartCardEmulatorApduReceivedEventArgsWithCryptograms { - #[cfg(feature="windows-storage")] #[inline] pub fn try_respond_with_cryptograms_async(&self, responseTemplate: &super::super::storage::streams::IBuffer, cryptogramPlacementSteps: &foundation::collections::IIterable) -> Result>> { unsafe { +impl IPwmControllerStatics3 { + #[inline] pub fn get_device_selector(&self) -> Result { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).TryRespondWithCryptogramsAsync)(self as *const _ as *mut _, responseTemplate as *const _ as *mut _, cryptogramPlacementSteps as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).GetDeviceSelector)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} - #[cfg(feature="windows-storage")] #[inline] pub fn try_respond_with_cryptograms_and_state_async(&self, responseTemplate: &super::super::storage::streams::IBuffer, cryptogramPlacementSteps: &foundation::collections::IIterable, nextState: &foundation::IReference) -> Result>> { unsafe { + #[inline] pub fn get_device_selector_from_friendly_name(&self, friendlyName: &HStringArg) -> Result { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).TryRespondWithCryptogramsAndStateAsync)(self as *const _ as *mut _, responseTemplate as *const _ as *mut _, cryptogramPlacementSteps as *const _ as *mut _, nextState as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).GetDeviceSelectorFromFriendlyName)(self as *const _ as *mut _, friendlyName.get(), &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn from_id_async(&self, deviceId: &HStringArg) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).FromIdAsync)(self as *const _ as *mut _, deviceId.get(), &mut out); if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } -DEFINE_IID!(IID_ISmartCardEmulatorConnectionDeactivatedEventArgs, 562485459, 50667, 21090, 67, 223, 98, 160, 161, 181, 85, 87); -RT_INTERFACE!{interface ISmartCardEmulatorConnectionDeactivatedEventArgs(ISmartCardEmulatorConnectionDeactivatedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardEmulatorConnectionDeactivatedEventArgs] { - fn get_ConnectionProperties(&self, out: *mut *mut SmartCardEmulatorConnectionProperties) -> HRESULT, - fn get_Reason(&self, out: *mut SmartCardEmulatorConnectionDeactivatedReason) -> HRESULT +DEFINE_IID!(IID_IPwmPin, 580333000, 50895, 18465, 183, 249, 198, 69, 79, 182, 175, 121); +RT_INTERFACE!{interface IPwmPin(IPwmPinVtbl): IInspectable(IInspectableVtbl) [IID_IPwmPin] { + fn get_Controller(&self, out: *mut *mut PwmController) -> HRESULT, + fn GetActiveDutyCyclePercentage(&self, out: *mut f64) -> HRESULT, + fn SetActiveDutyCyclePercentage(&self, dutyCyclePercentage: f64) -> HRESULT, + fn get_Polarity(&self, out: *mut PwmPulsePolarity) -> HRESULT, + fn put_Polarity(&self, value: PwmPulsePolarity) -> HRESULT, + fn Start(&self) -> HRESULT, + fn Stop(&self) -> HRESULT, + fn get_IsStarted(&self, out: *mut bool) -> HRESULT }} -impl ISmartCardEmulatorConnectionDeactivatedEventArgs { - #[inline] pub fn get_connection_properties(&self) -> Result>> { unsafe { +impl IPwmPin { + #[inline] pub fn get_controller(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_ConnectionProperties)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_Controller)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn get_reason(&self) -> Result { unsafe { + #[inline] pub fn get_active_duty_cycle_percentage(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_Reason)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).GetActiveDutyCyclePercentage)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} -} -RT_CLASS!{class SmartCardEmulatorConnectionDeactivatedEventArgs: ISmartCardEmulatorConnectionDeactivatedEventArgs} -RT_ENUM! { enum SmartCardEmulatorConnectionDeactivatedReason: i32 { - ConnectionLost (SmartCardEmulatorConnectionDeactivatedReason_ConnectionLost) = 0, ConnectionRedirected (SmartCardEmulatorConnectionDeactivatedReason_ConnectionRedirected) = 1, -}} -DEFINE_IID!(IID_ISmartCardEmulatorConnectionProperties, 1311548910, 63849, 20605, 108, 249, 52, 226, 209, 141, 243, 17); -RT_INTERFACE!{interface ISmartCardEmulatorConnectionProperties(ISmartCardEmulatorConnectionPropertiesVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardEmulatorConnectionProperties] { - fn get_Id(&self, out: *mut Guid) -> HRESULT, - fn get_Source(&self, out: *mut SmartCardEmulatorConnectionSource) -> HRESULT -}} -impl ISmartCardEmulatorConnectionProperties { - #[inline] pub fn get_id(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_Id)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } + #[inline] pub fn set_active_duty_cycle_percentage(&self, dutyCyclePercentage: f64) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).SetActiveDutyCyclePercentage)(self as *const _ as *mut _, dutyCyclePercentage); + if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_source(&self) -> Result { unsafe { + #[inline] pub fn get_polarity(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_Source)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_Polarity)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} -} -RT_CLASS!{class SmartCardEmulatorConnectionProperties: ISmartCardEmulatorConnectionProperties} -RT_ENUM! { enum SmartCardEmulatorConnectionSource: i32 { - Unknown (SmartCardEmulatorConnectionSource_Unknown) = 0, NfcReader (SmartCardEmulatorConnectionSource_NfcReader) = 1, -}} -RT_ENUM! { enum SmartCardEmulatorEnablementPolicy: i32 { - Never (SmartCardEmulatorEnablementPolicy_Never) = 0, Always (SmartCardEmulatorEnablementPolicy_Always) = 1, ScreenOn (SmartCardEmulatorEnablementPolicy_ScreenOn) = 2, ScreenUnlocked (SmartCardEmulatorEnablementPolicy_ScreenUnlocked) = 3, -}} -DEFINE_IID!(IID_ISmartCardEmulatorStatics, 2057043019, 50387, 18767, 184, 162, 98, 21, 216, 30, 133, 178); -RT_INTERFACE!{static interface ISmartCardEmulatorStatics(ISmartCardEmulatorStaticsVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardEmulatorStatics] { - fn GetDefaultAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT -}} -impl ISmartCardEmulatorStatics { - #[inline] pub fn get_default_async(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetDefaultAsync)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } - }} -} -DEFINE_IID!(IID_ISmartCardEmulatorStatics2, 1773051786, 46965, 18571, 132, 54, 108, 30, 40, 237, 115, 31); -RT_INTERFACE!{static interface ISmartCardEmulatorStatics2(ISmartCardEmulatorStatics2Vtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardEmulatorStatics2] { - fn GetAppletIdGroupRegistrationsAsync(&self, out: *mut *mut foundation::IAsyncOperation>) -> HRESULT, - fn RegisterAppletIdGroupAsync(&self, appletIdGroup: *mut SmartCardAppletIdGroup, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, - fn UnregisterAppletIdGroupAsync(&self, registration: *mut SmartCardAppletIdGroupRegistration, out: *mut *mut foundation::IAsyncAction) -> HRESULT, - fn get_MaxAppletIdGroupRegistrations(&self, out: *mut u16) -> HRESULT -}} -impl ISmartCardEmulatorStatics2 { - #[inline] pub fn get_applet_id_group_registrations_async(&self) -> Result>>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetAppletIdGroupRegistrationsAsync)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + #[inline] pub fn set_polarity(&self, value: PwmPulsePolarity) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Polarity)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn register_applet_id_group_async(&self, appletIdGroup: &SmartCardAppletIdGroup) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).RegisterAppletIdGroupAsync)(self as *const _ as *mut _, appletIdGroup as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + #[inline] pub fn start(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).Start)(self as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn unregister_applet_id_group_async(&self, registration: &SmartCardAppletIdGroupRegistration) -> Result> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).UnregisterAppletIdGroupAsync)(self as *const _ as *mut _, registration as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + #[inline] pub fn stop(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).Stop)(self as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_max_applet_id_group_registrations(&self) -> Result { unsafe { + #[inline] pub fn get_is_started(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_MaxAppletIdGroupRegistrations)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_IsStarted)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} } -DEFINE_IID!(IID_ISmartCardEmulatorStatics3, 1508512810, 40713, 17397, 133, 101, 207, 168, 20, 142, 76, 178); -RT_INTERFACE!{static interface ISmartCardEmulatorStatics3(ISmartCardEmulatorStatics3Vtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardEmulatorStatics3] { - fn IsSupported(&self, out: *mut bool) -> HRESULT +RT_CLASS!{class PwmPin: IPwmPin} +RT_ENUM! { enum PwmPulsePolarity: i32 { + ActiveHigh (PwmPulsePolarity_ActiveHigh) = 0, ActiveLow (PwmPulsePolarity_ActiveLow) = 1, }} -impl ISmartCardEmulatorStatics3 { - #[inline] pub fn is_supported(&self) -> Result { unsafe { +pub mod provider { // Windows.Devices.Pwm.Provider +use ::prelude::*; +DEFINE_IID!(IID_IPwmControllerProvider, 318789947, 58083, 16548, 183, 217, 72, 223, 240, 55, 122, 82); +RT_INTERFACE!{interface IPwmControllerProvider(IPwmControllerProviderVtbl): IInspectable(IInspectableVtbl) [IID_IPwmControllerProvider] { + fn get_PinCount(&self, out: *mut i32) -> HRESULT, + fn get_ActualFrequency(&self, out: *mut f64) -> HRESULT, + fn SetDesiredFrequency(&self, frequency: f64, out: *mut f64) -> HRESULT, + fn get_MaxFrequency(&self, out: *mut f64) -> HRESULT, + fn get_MinFrequency(&self, out: *mut f64) -> HRESULT, + fn AcquirePin(&self, pin: i32) -> HRESULT, + fn ReleasePin(&self, pin: i32) -> HRESULT, + fn EnablePin(&self, pin: i32) -> HRESULT, + fn DisablePin(&self, pin: i32) -> HRESULT, + fn SetPulseParameters(&self, pin: i32, dutyCycle: f64, invertPolarity: bool) -> HRESULT +}} +impl IPwmControllerProvider { + #[inline] pub fn get_pin_count(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).IsSupported)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_PinCount)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} -} -RT_ENUM! { enum SmartCardLaunchBehavior: i32 { - Default (SmartCardLaunchBehavior_Default) = 0, AboveLock (SmartCardLaunchBehavior_AboveLock) = 1, -}} -RT_ENUM! { enum SmartCardPinCharacterPolicyOption: i32 { - Allow (SmartCardPinCharacterPolicyOption_Allow) = 0, RequireAtLeastOne (SmartCardPinCharacterPolicyOption_RequireAtLeastOne) = 1, Disallow (SmartCardPinCharacterPolicyOption_Disallow) = 2, -}} -DEFINE_IID!(IID_ISmartCardPinPolicy, 406643076, 19894, 18497, 172, 158, 42, 193, 243, 155, 115, 4); -RT_INTERFACE!{interface ISmartCardPinPolicy(ISmartCardPinPolicyVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardPinPolicy] { - fn get_MinLength(&self, out: *mut u32) -> HRESULT, - fn put_MinLength(&self, value: u32) -> HRESULT, - fn get_MaxLength(&self, out: *mut u32) -> HRESULT, - fn put_MaxLength(&self, value: u32) -> HRESULT, - fn get_UppercaseLetters(&self, out: *mut SmartCardPinCharacterPolicyOption) -> HRESULT, - fn put_UppercaseLetters(&self, value: SmartCardPinCharacterPolicyOption) -> HRESULT, - fn get_LowercaseLetters(&self, out: *mut SmartCardPinCharacterPolicyOption) -> HRESULT, - fn put_LowercaseLetters(&self, value: SmartCardPinCharacterPolicyOption) -> HRESULT, - fn get_Digits(&self, out: *mut SmartCardPinCharacterPolicyOption) -> HRESULT, - fn put_Digits(&self, value: SmartCardPinCharacterPolicyOption) -> HRESULT, - fn get_SpecialCharacters(&self, out: *mut SmartCardPinCharacterPolicyOption) -> HRESULT, - fn put_SpecialCharacters(&self, value: SmartCardPinCharacterPolicyOption) -> HRESULT -}} -impl ISmartCardPinPolicy { - #[inline] pub fn get_min_length(&self) -> Result { unsafe { + #[inline] pub fn get_actual_frequency(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_MinLength)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_ActualFrequency)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn set_min_length(&self, value: u32) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_MinLength)(self as *const _ as *mut _, value); - if hr == S_OK { Ok(()) } else { err(hr) } - }} - #[inline] pub fn get_max_length(&self) -> Result { unsafe { + #[inline] pub fn set_desired_frequency(&self, frequency: f64) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_MaxLength)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).SetDesiredFrequency)(self as *const _ as *mut _, frequency, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn set_max_length(&self, value: u32) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_MaxLength)(self as *const _ as *mut _, value); - if hr == S_OK { Ok(()) } else { err(hr) } - }} - #[inline] pub fn get_uppercase_letters(&self) -> Result { unsafe { + #[inline] pub fn get_max_frequency(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_UppercaseLetters)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_MaxFrequency)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn set_uppercase_letters(&self, value: SmartCardPinCharacterPolicyOption) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_UppercaseLetters)(self as *const _ as *mut _, value); - if hr == S_OK { Ok(()) } else { err(hr) } - }} - #[inline] pub fn get_lowercase_letters(&self) -> Result { unsafe { + #[inline] pub fn get_min_frequency(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_LowercaseLetters)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_MinFrequency)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn set_lowercase_letters(&self, value: SmartCardPinCharacterPolicyOption) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_LowercaseLetters)(self as *const _ as *mut _, value); + #[inline] pub fn acquire_pin(&self, pin: i32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).AcquirePin)(self as *const _ as *mut _, pin); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_digits(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_Digits)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } - }} - #[inline] pub fn set_digits(&self, value: SmartCardPinCharacterPolicyOption) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_Digits)(self as *const _ as *mut _, value); + #[inline] pub fn release_pin(&self, pin: i32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).ReleasePin)(self as *const _ as *mut _, pin); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_special_characters(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_SpecialCharacters)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } - }} - #[inline] pub fn set_special_characters(&self, value: SmartCardPinCharacterPolicyOption) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_SpecialCharacters)(self as *const _ as *mut _, value); + #[inline] pub fn enable_pin(&self, pin: i32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).EnablePin)(self as *const _ as *mut _, pin); if hr == S_OK { Ok(()) } else { err(hr) } }} -} -RT_CLASS!{class SmartCardPinPolicy: ISmartCardPinPolicy} -impl RtActivatable for SmartCardPinPolicy {} -DEFINE_CLSID!(SmartCardPinPolicy(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,83,109,97,114,116,67,97,114,100,115,46,83,109,97,114,116,67,97,114,100,80,105,110,80,111,108,105,99,121,0]) [CLSID_SmartCardPinPolicy]); -DEFINE_IID!(IID_ISmartCardPinResetDeferral, 415845036, 30725, 16388, 133, 228, 187, 239, 172, 143, 104, 132); -RT_INTERFACE!{interface ISmartCardPinResetDeferral(ISmartCardPinResetDeferralVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardPinResetDeferral] { - fn Complete(&self) -> HRESULT -}} -impl ISmartCardPinResetDeferral { - #[inline] pub fn complete(&self) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).Complete)(self as *const _ as *mut _); + #[inline] pub fn disable_pin(&self, pin: i32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).DisablePin)(self as *const _ as *mut _, pin); if hr == S_OK { Ok(()) } else { err(hr) } }} -} -RT_CLASS!{class SmartCardPinResetDeferral: ISmartCardPinResetDeferral} -DEFINE_IID!(IID_SmartCardPinResetHandler, 328031808, 62396, 19036, 180, 29, 75, 78, 246, 132, 226, 55); -RT_DELEGATE!{delegate SmartCardPinResetHandler(SmartCardPinResetHandlerVtbl, SmartCardPinResetHandlerImpl) [IID_SmartCardPinResetHandler] { - fn Invoke(&self, sender: *mut SmartCardProvisioning, request: *mut SmartCardPinResetRequest) -> HRESULT -}} -impl SmartCardPinResetHandler { - #[inline] pub fn invoke(&self, sender: &SmartCardProvisioning, request: &SmartCardPinResetRequest) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).Invoke)(self as *const _ as *mut _, sender as *const _ as *mut _, request as *const _ as *mut _); + #[inline] pub fn set_pulse_parameters(&self, pin: i32, dutyCycle: f64, invertPolarity: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).SetPulseParameters)(self as *const _ as *mut _, pin, dutyCycle, invertPolarity); if hr == S_OK { Ok(()) } else { err(hr) } }} } -DEFINE_IID!(IID_ISmartCardPinResetRequest, 318651469, 24505, 20110, 159, 246, 97, 244, 117, 18, 79, 239); -RT_INTERFACE!{interface ISmartCardPinResetRequest(ISmartCardPinResetRequestVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardPinResetRequest] { - #[cfg(feature="windows-storage")] fn get_Challenge(&self, out: *mut *mut super::super::storage::streams::IBuffer) -> HRESULT, - fn get_Deadline(&self, out: *mut foundation::DateTime) -> HRESULT, - fn GetDeferral(&self, out: *mut *mut SmartCardPinResetDeferral) -> HRESULT, - #[cfg(feature="windows-storage")] fn SetResponse(&self, response: *mut super::super::storage::streams::IBuffer) -> HRESULT +DEFINE_IID!(IID_IPwmProvider, 2737836584, 21233, 18352, 147, 73, 102, 186, 67, 210, 89, 2); +RT_INTERFACE!{interface IPwmProvider(IPwmProviderVtbl): IInspectable(IInspectableVtbl) [IID_IPwmProvider] { + fn GetControllers(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT }} -impl ISmartCardPinResetRequest { - #[cfg(feature="windows-storage")] #[inline] pub fn get_challenge(&self) -> Result>> { unsafe { +impl IPwmProvider { + #[inline] pub fn get_controllers(&self) -> Result>>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Challenge)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).GetControllers)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn get_deadline(&self) -> Result { unsafe { +} +} // Windows.Devices.Pwm.Provider +} // Windows.Devices.Pwm +pub mod spi { // Windows.Devices.Spi +use ::prelude::*; +DEFINE_IID!(IID_ISpiBusInfo, 2569618506, 21746, 18630, 185, 82, 156, 50, 252, 2, 198, 105); +RT_INTERFACE!{interface ISpiBusInfo(ISpiBusInfoVtbl): IInspectable(IInspectableVtbl) [IID_ISpiBusInfo] { + fn get_ChipSelectLineCount(&self, out: *mut i32) -> HRESULT, + fn get_MinClockFrequency(&self, out: *mut i32) -> HRESULT, + fn get_MaxClockFrequency(&self, out: *mut i32) -> HRESULT, + fn get_SupportedDataBitLengths(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT +}} +impl ISpiBusInfo { + #[inline] pub fn get_chip_select_line_count(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_Deadline)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_ChipSelectLineCount)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_deferral(&self) -> Result>> { unsafe { + #[inline] pub fn get_min_clock_frequency(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_MinClockFrequency)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_max_clock_frequency(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_MaxClockFrequency)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_supported_data_bit_lengths(&self) -> Result>>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetDeferral)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_SupportedDataBitLengths)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[cfg(feature="windows-storage")] #[inline] pub fn set_response(&self, response: &super::super::storage::streams::IBuffer) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).SetResponse)(self as *const _ as *mut _, response as *const _ as *mut _); - if hr == S_OK { Ok(()) } else { err(hr) } - }} } -RT_CLASS!{class SmartCardPinResetRequest: ISmartCardPinResetRequest} -DEFINE_IID!(IID_ISmartCardProvisioning, 435088829, 8107, 18300, 183, 18, 26, 44, 90, 241, 253, 110); -RT_INTERFACE!{interface ISmartCardProvisioning(ISmartCardProvisioningVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardProvisioning] { - fn get_SmartCard(&self, out: *mut *mut SmartCard) -> HRESULT, - fn GetIdAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, - fn GetNameAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, - fn GetChallengeContextAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, - fn RequestPinChangeAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, - fn RequestPinResetAsync(&self, handler: *mut SmartCardPinResetHandler, out: *mut *mut foundation::IAsyncOperation) -> HRESULT +RT_CLASS!{class SpiBusInfo: ISpiBusInfo} +DEFINE_IID!(IID_ISpiConnectionSettings, 1384358783, 63797, 19359, 167, 167, 58, 120, 144, 175, 165, 206); +RT_INTERFACE!{interface ISpiConnectionSettings(ISpiConnectionSettingsVtbl): IInspectable(IInspectableVtbl) [IID_ISpiConnectionSettings] { + fn get_ChipSelectLine(&self, out: *mut i32) -> HRESULT, + fn put_ChipSelectLine(&self, value: i32) -> HRESULT, + fn get_Mode(&self, out: *mut SpiMode) -> HRESULT, + fn put_Mode(&self, value: SpiMode) -> HRESULT, + fn get_DataBitLength(&self, out: *mut i32) -> HRESULT, + fn put_DataBitLength(&self, value: i32) -> HRESULT, + fn get_ClockFrequency(&self, out: *mut i32) -> HRESULT, + fn put_ClockFrequency(&self, value: i32) -> HRESULT, + fn get_SharingMode(&self, out: *mut SpiSharingMode) -> HRESULT, + fn put_SharingMode(&self, value: SpiSharingMode) -> HRESULT }} -impl ISmartCardProvisioning { - #[inline] pub fn get_smart_card(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_SmartCard)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } +impl ISpiConnectionSettings { + #[inline] pub fn get_chip_select_line(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_ChipSelectLine)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_id_async(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetIdAsync)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + #[inline] pub fn set_chip_select_line(&self, value: i32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_ChipSelectLine)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_name_async(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetNameAsync)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + #[inline] pub fn get_mode(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Mode)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_challenge_context_async(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetChallengeContextAsync)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + #[inline] pub fn set_mode(&self, value: SpiMode) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Mode)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn request_pin_change_async(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).RequestPinChangeAsync)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + #[inline] pub fn get_data_bit_length(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_DataBitLength)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn request_pin_reset_async(&self, handler: &SmartCardPinResetHandler) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).RequestPinResetAsync)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + #[inline] pub fn set_data_bit_length(&self, value: i32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_DataBitLength)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_clock_frequency(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_ClockFrequency)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_clock_frequency(&self, value: i32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_ClockFrequency)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_sharing_mode(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_SharingMode)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_sharing_mode(&self, value: SpiSharingMode) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_SharingMode)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } }} } -RT_CLASS!{class SmartCardProvisioning: ISmartCardProvisioning} -impl RtActivatable for SmartCardProvisioning {} -impl RtActivatable for SmartCardProvisioning {} -impl SmartCardProvisioning { - #[inline] pub fn from_smart_card_async(card: &SmartCard) -> Result>> { - >::get_activation_factory().from_smart_card_async(card) - } - #[cfg(feature="windows-storage")] #[inline] pub fn request_virtual_smart_card_creation_async(friendlyName: &HStringArg, administrativeKey: &super::super::storage::streams::IBuffer, pinPolicy: &SmartCardPinPolicy) -> Result>> { - >::get_activation_factory().request_virtual_smart_card_creation_async(friendlyName, administrativeKey, pinPolicy) - } - #[cfg(feature="windows-storage")] #[inline] pub fn request_virtual_smart_card_creation_async_with_card_id(friendlyName: &HStringArg, administrativeKey: &super::super::storage::streams::IBuffer, pinPolicy: &SmartCardPinPolicy, cardId: Guid) -> Result>> { - >::get_activation_factory().request_virtual_smart_card_creation_async_with_card_id(friendlyName, administrativeKey, pinPolicy, cardId) - } - #[inline] pub fn request_virtual_smart_card_deletion_async(card: &SmartCard) -> Result>> { - >::get_activation_factory().request_virtual_smart_card_deletion_async(card) - } - #[cfg(feature="windows-storage")] #[inline] pub fn request_attested_virtual_smart_card_creation_async(friendlyName: &HStringArg, administrativeKey: &super::super::storage::streams::IBuffer, pinPolicy: &SmartCardPinPolicy) -> Result>> { - >::get_activation_factory().request_attested_virtual_smart_card_creation_async(friendlyName, administrativeKey, pinPolicy) - } - #[cfg(feature="windows-storage")] #[inline] pub fn request_attested_virtual_smart_card_creation_async_with_card_id(friendlyName: &HStringArg, administrativeKey: &super::super::storage::streams::IBuffer, pinPolicy: &SmartCardPinPolicy, cardId: Guid) -> Result>> { - >::get_activation_factory().request_attested_virtual_smart_card_creation_async_with_card_id(friendlyName, administrativeKey, pinPolicy, cardId) +RT_CLASS!{class SpiConnectionSettings: ISpiConnectionSettings} +impl RtActivatable for SpiConnectionSettings {} +impl SpiConnectionSettings { + #[inline] pub fn create(chipSelectLine: i32) -> Result> { + >::get_activation_factory().create(chipSelectLine) } } -DEFINE_CLSID!(SmartCardProvisioning(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,83,109,97,114,116,67,97,114,100,115,46,83,109,97,114,116,67,97,114,100,80,114,111,118,105,115,105,111,110,105,110,103,0]) [CLSID_SmartCardProvisioning]); -DEFINE_IID!(IID_ISmartCardProvisioning2, 285026539, 16249, 19302, 155, 124, 17, 193, 73, 183, 208, 188); -RT_INTERFACE!{interface ISmartCardProvisioning2(ISmartCardProvisioning2Vtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardProvisioning2] { - fn GetAuthorityKeyContainerNameAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT +DEFINE_CLSID!(SpiConnectionSettings(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,83,112,105,46,83,112,105,67,111,110,110,101,99,116,105,111,110,83,101,116,116,105,110,103,115,0]) [CLSID_SpiConnectionSettings]); +DEFINE_IID!(IID_ISpiConnectionSettingsFactory, 4288219166, 4292, 17591, 159, 234, 167, 72, 181, 164, 111, 49); +RT_INTERFACE!{static interface ISpiConnectionSettingsFactory(ISpiConnectionSettingsFactoryVtbl): IInspectable(IInspectableVtbl) [IID_ISpiConnectionSettingsFactory] { + fn Create(&self, chipSelectLine: i32, out: *mut *mut SpiConnectionSettings) -> HRESULT }} -impl ISmartCardProvisioning2 { - #[inline] pub fn get_authority_key_container_name_async(&self) -> Result>> { unsafe { +impl ISpiConnectionSettingsFactory { + #[inline] pub fn create(&self, chipSelectLine: i32) -> Result> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetAuthorityKeyContainerNameAsync)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, chipSelectLine, &mut out); if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } -DEFINE_IID!(IID_ISmartCardProvisioningStatics, 327690312, 3347, 20080, 151, 53, 81, 218, 236, 165, 37, 79); -RT_INTERFACE!{static interface ISmartCardProvisioningStatics(ISmartCardProvisioningStaticsVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardProvisioningStatics] { - fn FromSmartCardAsync(&self, card: *mut SmartCard, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, - #[cfg(not(feature="windows-storage"))] fn __Dummy1(&self) -> (), - #[cfg(feature="windows-storage")] fn RequestVirtualSmartCardCreationAsync(&self, friendlyName: HSTRING, administrativeKey: *mut super::super::storage::streams::IBuffer, pinPolicy: *mut SmartCardPinPolicy, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, - #[cfg(not(feature="windows-storage"))] fn __Dummy2(&self) -> (), - #[cfg(feature="windows-storage")] fn RequestVirtualSmartCardCreationAsyncWithCardId(&self, friendlyName: HSTRING, administrativeKey: *mut super::super::storage::streams::IBuffer, pinPolicy: *mut SmartCardPinPolicy, cardId: Guid, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, - fn RequestVirtualSmartCardDeletionAsync(&self, card: *mut SmartCard, out: *mut *mut foundation::IAsyncOperation) -> HRESULT +DEFINE_IID!(IID_ISpiController, 2832451625, 39061, 16729, 169, 52, 135, 65, 241, 238, 109, 39); +RT_INTERFACE!{interface ISpiController(ISpiControllerVtbl): IInspectable(IInspectableVtbl) [IID_ISpiController] { + fn GetDevice(&self, settings: *mut SpiConnectionSettings, out: *mut *mut SpiDevice) -> HRESULT }} -impl ISmartCardProvisioningStatics { - #[inline] pub fn from_smart_card_async(&self, card: &SmartCard) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).FromSmartCardAsync)(self as *const _ as *mut _, card as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } - }} - #[cfg(feature="windows-storage")] #[inline] pub fn request_virtual_smart_card_creation_async(&self, friendlyName: &HStringArg, administrativeKey: &super::super::storage::streams::IBuffer, pinPolicy: &SmartCardPinPolicy) -> Result>> { unsafe { +impl ISpiController { + #[inline] pub fn get_device(&self, settings: &SpiConnectionSettings) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).RequestVirtualSmartCardCreationAsync)(self as *const _ as *mut _, friendlyName.get(), administrativeKey as *const _ as *mut _, pinPolicy as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } - }} - #[cfg(feature="windows-storage")] #[inline] pub fn request_virtual_smart_card_creation_async_with_card_id(&self, friendlyName: &HStringArg, administrativeKey: &super::super::storage::streams::IBuffer, pinPolicy: &SmartCardPinPolicy, cardId: Guid) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).RequestVirtualSmartCardCreationAsyncWithCardId)(self as *const _ as *mut _, friendlyName.get(), administrativeKey as *const _ as *mut _, pinPolicy as *const _ as *mut _, cardId, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } - }} - #[inline] pub fn request_virtual_smart_card_deletion_async(&self, card: &SmartCard) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).RequestVirtualSmartCardDeletionAsync)(self as *const _ as *mut _, card as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).GetDevice)(self as *const _ as *mut _, settings as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } -DEFINE_IID!(IID_ISmartCardProvisioningStatics2, 877119144, 51616, 19414, 181, 13, 37, 31, 78, 141, 58, 98); -RT_INTERFACE!{static interface ISmartCardProvisioningStatics2(ISmartCardProvisioningStatics2Vtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardProvisioningStatics2] { - #[cfg(feature="windows-storage")] fn RequestAttestedVirtualSmartCardCreationAsync(&self, friendlyName: HSTRING, administrativeKey: *mut super::super::storage::streams::IBuffer, pinPolicy: *mut SmartCardPinPolicy, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, - #[cfg(feature="windows-storage")] fn RequestAttestedVirtualSmartCardCreationAsyncWithCardId(&self, friendlyName: HSTRING, administrativeKey: *mut super::super::storage::streams::IBuffer, pinPolicy: *mut SmartCardPinPolicy, cardId: Guid, out: *mut *mut foundation::IAsyncOperation) -> HRESULT +RT_CLASS!{class SpiController: ISpiController} +impl RtActivatable for SpiController {} +impl SpiController { + #[inline] pub fn get_default_async() -> Result>> { + >::get_activation_factory().get_default_async() + } + #[inline] pub fn get_controllers_async(provider: &provider::ISpiProvider) -> Result>>> { + >::get_activation_factory().get_controllers_async(provider) + } +} +DEFINE_CLSID!(SpiController(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,83,112,105,46,83,112,105,67,111,110,116,114,111,108,108,101,114,0]) [CLSID_SpiController]); +DEFINE_IID!(IID_ISpiControllerStatics, 223488482, 5003, 20040, 185, 100, 79, 47, 121, 185, 197, 162); +RT_INTERFACE!{static interface ISpiControllerStatics(ISpiControllerStaticsVtbl): IInspectable(IInspectableVtbl) [IID_ISpiControllerStatics] { + fn GetDefaultAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn GetControllersAsync(&self, provider: *mut provider::ISpiProvider, out: *mut *mut foundation::IAsyncOperation>) -> HRESULT }} -impl ISmartCardProvisioningStatics2 { - #[cfg(feature="windows-storage")] #[inline] pub fn request_attested_virtual_smart_card_creation_async(&self, friendlyName: &HStringArg, administrativeKey: &super::super::storage::streams::IBuffer, pinPolicy: &SmartCardPinPolicy) -> Result>> { unsafe { +impl ISpiControllerStatics { + #[inline] pub fn get_default_async(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).RequestAttestedVirtualSmartCardCreationAsync)(self as *const _ as *mut _, friendlyName.get(), administrativeKey as *const _ as *mut _, pinPolicy as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).GetDefaultAsync)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[cfg(feature="windows-storage")] #[inline] pub fn request_attested_virtual_smart_card_creation_async_with_card_id(&self, friendlyName: &HStringArg, administrativeKey: &super::super::storage::streams::IBuffer, pinPolicy: &SmartCardPinPolicy, cardId: Guid) -> Result>> { unsafe { + #[inline] pub fn get_controllers_async(&self, provider: &provider::ISpiProvider) -> Result>>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).RequestAttestedVirtualSmartCardCreationAsyncWithCardId)(self as *const _ as *mut _, friendlyName.get(), administrativeKey as *const _ as *mut _, pinPolicy as *const _ as *mut _, cardId, &mut out); + let hr = ((*self.lpVtbl).GetControllersAsync)(self as *const _ as *mut _, provider as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } -DEFINE_IID!(IID_ISmartCardReader, 276083936, 21698, 19952, 129, 122, 20, 193, 67, 120, 240, 108); -RT_INTERFACE!{interface ISmartCardReader(ISmartCardReaderVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardReader] { +DEFINE_IID!(IID_ISpiDevice, 97858925, 4534, 19769, 132, 213, 149, 223, 180, 201, 242, 206); +RT_INTERFACE!{interface ISpiDevice(ISpiDeviceVtbl): IInspectable(IInspectableVtbl) [IID_ISpiDevice] { fn get_DeviceId(&self, out: *mut HSTRING) -> HRESULT, - fn get_Name(&self, out: *mut HSTRING) -> HRESULT, - fn get_Kind(&self, out: *mut SmartCardReaderKind) -> HRESULT, - fn GetStatusAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, - fn FindAllCardsAsync(&self, out: *mut *mut foundation::IAsyncOperation>) -> HRESULT, - fn add_CardAdded(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, - fn remove_CardAdded(&self, token: foundation::EventRegistrationToken) -> HRESULT, - fn add_CardRemoved(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, - fn remove_CardRemoved(&self, token: foundation::EventRegistrationToken) -> HRESULT + fn get_ConnectionSettings(&self, out: *mut *mut SpiConnectionSettings) -> HRESULT, + fn Write(&self, bufferSize: u32, buffer: *mut u8) -> HRESULT, + fn Read(&self, bufferSize: u32, buffer: *mut u8) -> HRESULT, + fn TransferSequential(&self, writeBufferSize: u32, writeBuffer: *mut u8, readBufferSize: u32, readBuffer: *mut u8) -> HRESULT, + fn TransferFullDuplex(&self, writeBufferSize: u32, writeBuffer: *mut u8, readBufferSize: u32, readBuffer: *mut u8) -> HRESULT }} -impl ISmartCardReader { +impl ISpiDevice { #[inline] pub fn get_device_id(&self) -> Result { unsafe { let mut out = null_mut(); let hr = ((*self.lpVtbl).get_DeviceId)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_name(&self) -> Result { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Name)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } - }} - #[inline] pub fn get_kind(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_Kind)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } - }} - #[inline] pub fn get_status_async(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetStatusAsync)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } - }} - #[inline] pub fn find_all_cards_async(&self) -> Result>>> { unsafe { + #[inline] pub fn get_connection_settings(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).FindAllCardsAsync)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).get_ConnectionSettings)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn add_card_added(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).add_CardAdded)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } + #[inline] pub fn write(&self, buffer: &[u8]) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).Write)(self as *const _ as *mut _, buffer.len() as u32, buffer.as_ptr() as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn remove_card_added(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).remove_CardAdded)(self as *const _ as *mut _, token); + #[inline] pub fn read(&self, buffer: &mut [u8]) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).Read)(self as *const _ as *mut _, buffer.len() as u32, buffer.as_mut_ptr() as *mut _); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn add_card_removed(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).add_CardRemoved)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } + #[inline] pub fn transfer_sequential(&self, writeBuffer: &[u8], readBuffer: &mut [u8]) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).TransferSequential)(self as *const _ as *mut _, writeBuffer.len() as u32, writeBuffer.as_ptr() as *mut _, readBuffer.len() as u32, readBuffer.as_mut_ptr() as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn remove_card_removed(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).remove_CardRemoved)(self as *const _ as *mut _, token); + #[inline] pub fn transfer_full_duplex(&self, writeBuffer: &[u8], readBuffer: &mut [u8]) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).TransferFullDuplex)(self as *const _ as *mut _, writeBuffer.len() as u32, writeBuffer.as_ptr() as *mut _, readBuffer.len() as u32, readBuffer.as_mut_ptr() as *mut _); if hr == S_OK { Ok(()) } else { err(hr) } }} } -RT_CLASS!{class SmartCardReader: ISmartCardReader} -impl RtActivatable for SmartCardReader {} -impl SmartCardReader { +RT_CLASS!{class SpiDevice: ISpiDevice} +impl RtActivatable for SpiDevice {} +impl SpiDevice { #[inline] pub fn get_device_selector() -> Result { - >::get_activation_factory().get_device_selector() + >::get_activation_factory().get_device_selector() } - #[inline] pub fn get_device_selector_with_kind(kind: SmartCardReaderKind) -> Result { - >::get_activation_factory().get_device_selector_with_kind(kind) + #[inline] pub fn get_device_selector_from_friendly_name(friendlyName: &HStringArg) -> Result { + >::get_activation_factory().get_device_selector_from_friendly_name(friendlyName) } - #[inline] pub fn from_id_async(deviceId: &HStringArg) -> Result>> { - >::get_activation_factory().from_id_async(deviceId) + #[inline] pub fn get_bus_info(busId: &HStringArg) -> Result>> { + >::get_activation_factory().get_bus_info(busId) + } + #[inline] pub fn from_id_async(busId: &HStringArg, settings: &SpiConnectionSettings) -> Result>> { + >::get_activation_factory().from_id_async(busId, settings) } } -DEFINE_CLSID!(SmartCardReader(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,83,109,97,114,116,67,97,114,100,115,46,83,109,97,114,116,67,97,114,100,82,101,97,100,101,114,0]) [CLSID_SmartCardReader]); -RT_ENUM! { enum SmartCardReaderKind: i32 { - Any (SmartCardReaderKind_Any) = 0, Generic (SmartCardReaderKind_Generic) = 1, Tpm (SmartCardReaderKind_Tpm) = 2, Nfc (SmartCardReaderKind_Nfc) = 3, Uicc (SmartCardReaderKind_Uicc) = 4, EmbeddedSE (SmartCardReaderKind_EmbeddedSE) = 5, -}} -DEFINE_IID!(IID_ISmartCardReaderStatics, 272368865, 41418, 18674, 162, 129, 91, 111, 102, 154, 241, 7); -RT_INTERFACE!{static interface ISmartCardReaderStatics(ISmartCardReaderStaticsVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardReaderStatics] { +DEFINE_CLSID!(SpiDevice(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,83,112,105,46,83,112,105,68,101,118,105,99,101,0]) [CLSID_SpiDevice]); +DEFINE_IID!(IID_ISpiDeviceStatics, 2725832025, 22304, 19775, 189, 147, 86, 245, 255, 90, 88, 121); +RT_INTERFACE!{static interface ISpiDeviceStatics(ISpiDeviceStaticsVtbl): IInspectable(IInspectableVtbl) [IID_ISpiDeviceStatics] { fn GetDeviceSelector(&self, out: *mut HSTRING) -> HRESULT, - fn GetDeviceSelectorWithKind(&self, kind: SmartCardReaderKind, out: *mut HSTRING) -> HRESULT, - fn FromIdAsync(&self, deviceId: HSTRING, out: *mut *mut foundation::IAsyncOperation) -> HRESULT + fn GetDeviceSelectorFromFriendlyName(&self, friendlyName: HSTRING, out: *mut HSTRING) -> HRESULT, + fn GetBusInfo(&self, busId: HSTRING, out: *mut *mut SpiBusInfo) -> HRESULT, + fn FromIdAsync(&self, busId: HSTRING, settings: *mut SpiConnectionSettings, out: *mut *mut foundation::IAsyncOperation) -> HRESULT }} -impl ISmartCardReaderStatics { +impl ISpiDeviceStatics { #[inline] pub fn get_device_selector(&self) -> Result { unsafe { let mut out = null_mut(); let hr = ((*self.lpVtbl).GetDeviceSelector)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_device_selector_with_kind(&self, kind: SmartCardReaderKind) -> Result { unsafe { + #[inline] pub fn get_device_selector_from_friendly_name(&self, friendlyName: &HStringArg) -> Result { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetDeviceSelectorWithKind)(self as *const _ as *mut _, kind, &mut out); + let hr = ((*self.lpVtbl).GetDeviceSelectorFromFriendlyName)(self as *const _ as *mut _, friendlyName.get(), &mut out); if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} - #[inline] pub fn from_id_async(&self, deviceId: &HStringArg) -> Result>> { unsafe { + #[inline] pub fn get_bus_info(&self, busId: &HStringArg) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).FromIdAsync)(self as *const _ as *mut _, deviceId.get(), &mut out); + let hr = ((*self.lpVtbl).GetBusInfo)(self as *const _ as *mut _, busId.get(), &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn from_id_async(&self, busId: &HStringArg, settings: &SpiConnectionSettings) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).FromIdAsync)(self as *const _ as *mut _, busId.get(), settings as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } -RT_ENUM! { enum SmartCardReaderStatus: i32 { - Disconnected (SmartCardReaderStatus_Disconnected) = 0, Ready (SmartCardReaderStatus_Ready) = 1, Exclusive (SmartCardReaderStatus_Exclusive) = 2, +RT_ENUM! { enum SpiMode: i32 { + Mode0 (SpiMode_Mode0) = 0, Mode1 (SpiMode_Mode1) = 1, Mode2 (SpiMode_Mode2) = 2, Mode3 (SpiMode_Mode3) = 3, }} -RT_ENUM! { enum SmartCardStatus: i32 { - Disconnected (SmartCardStatus_Disconnected) = 0, Ready (SmartCardStatus_Ready) = 1, Shared (SmartCardStatus_Shared) = 2, Exclusive (SmartCardStatus_Exclusive) = 3, Unresponsive (SmartCardStatus_Unresponsive) = 4, +RT_ENUM! { enum SpiSharingMode: i32 { + Exclusive (SpiSharingMode_Exclusive) = 0, Shared (SpiSharingMode_Shared) = 1, }} -DEFINE_IID!(IID_ISmartCardTriggerDetails, 1604055326, 14831, 20267, 180, 79, 10, 145, 85, 177, 119, 188); -RT_INTERFACE!{interface ISmartCardTriggerDetails(ISmartCardTriggerDetailsVtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardTriggerDetails] { - fn get_TriggerType(&self, out: *mut SmartCardTriggerType) -> HRESULT, - #[cfg(feature="windows-storage")] fn get_SourceAppletId(&self, out: *mut *mut super::super::storage::streams::IBuffer) -> HRESULT, - #[cfg(feature="windows-storage")] fn get_TriggerData(&self, out: *mut *mut super::super::storage::streams::IBuffer) -> HRESULT +pub mod provider { // Windows.Devices.Spi.Provider +use ::prelude::*; +DEFINE_IID!(IID_IProviderSpiConnectionSettings, 4127409488, 42306, 20160, 150, 1, 164, 221, 104, 248, 105, 123); +RT_INTERFACE!{interface IProviderSpiConnectionSettings(IProviderSpiConnectionSettingsVtbl): IInspectable(IInspectableVtbl) [IID_IProviderSpiConnectionSettings] { + fn get_ChipSelectLine(&self, out: *mut i32) -> HRESULT, + fn put_ChipSelectLine(&self, value: i32) -> HRESULT, + fn get_Mode(&self, out: *mut ProviderSpiMode) -> HRESULT, + fn put_Mode(&self, value: ProviderSpiMode) -> HRESULT, + fn get_DataBitLength(&self, out: *mut i32) -> HRESULT, + fn put_DataBitLength(&self, value: i32) -> HRESULT, + fn get_ClockFrequency(&self, out: *mut i32) -> HRESULT, + fn put_ClockFrequency(&self, value: i32) -> HRESULT, + fn get_SharingMode(&self, out: *mut ProviderSpiSharingMode) -> HRESULT, + fn put_SharingMode(&self, value: ProviderSpiSharingMode) -> HRESULT }} -impl ISmartCardTriggerDetails { - #[inline] pub fn get_trigger_type(&self) -> Result { unsafe { +impl IProviderSpiConnectionSettings { + #[inline] pub fn get_chip_select_line(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_TriggerType)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_ChipSelectLine)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[cfg(feature="windows-storage")] #[inline] pub fn get_source_applet_id(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_SourceAppletId)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + #[inline] pub fn set_chip_select_line(&self, value: i32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_ChipSelectLine)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } }} - #[cfg(feature="windows-storage")] #[inline] pub fn get_trigger_data(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_TriggerData)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + #[inline] pub fn get_mode(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Mode)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} -} -RT_CLASS!{class SmartCardTriggerDetails: ISmartCardTriggerDetails} -DEFINE_IID!(IID_ISmartCardTriggerDetails2, 692438377, 35189, 19025, 158, 26, 95, 138, 118, 238, 81, 175); -RT_INTERFACE!{interface ISmartCardTriggerDetails2(ISmartCardTriggerDetails2Vtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardTriggerDetails2] { - fn get_Emulator(&self, out: *mut *mut SmartCardEmulator) -> HRESULT, - fn TryLaunchCurrentAppAsync(&self, arguments: HSTRING, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, - fn TryLaunchCurrentAppWithBehaviorAsync(&self, arguments: HSTRING, behavior: SmartCardLaunchBehavior, out: *mut *mut foundation::IAsyncOperation) -> HRESULT -}} -impl ISmartCardTriggerDetails2 { - #[inline] pub fn get_emulator(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Emulator)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + #[inline] pub fn set_mode(&self, value: ProviderSpiMode) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Mode)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn try_launch_current_app_async(&self, arguments: &HStringArg) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).TryLaunchCurrentAppAsync)(self as *const _ as *mut _, arguments.get(), &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + #[inline] pub fn get_data_bit_length(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_DataBitLength)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn try_launch_current_app_with_behavior_async(&self, arguments: &HStringArg, behavior: SmartCardLaunchBehavior) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).TryLaunchCurrentAppWithBehaviorAsync)(self as *const _ as *mut _, arguments.get(), behavior, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + #[inline] pub fn set_data_bit_length(&self, value: i32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_DataBitLength)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } }} -} -DEFINE_IID!(IID_ISmartCardTriggerDetails3, 3017982589, 6342, 19368, 131, 118, 239, 3, 212, 145, 38, 102); -RT_INTERFACE!{interface ISmartCardTriggerDetails3(ISmartCardTriggerDetails3Vtbl): IInspectable(IInspectableVtbl) [IID_ISmartCardTriggerDetails3] { - fn get_SmartCard(&self, out: *mut *mut SmartCard) -> HRESULT -}} -impl ISmartCardTriggerDetails3 { - #[inline] pub fn get_smart_card(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_SmartCard)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + #[inline] pub fn get_clock_frequency(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_ClockFrequency)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_clock_frequency(&self, value: i32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_ClockFrequency)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_sharing_mode(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_SharingMode)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_sharing_mode(&self, value: ProviderSpiSharingMode) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_SharingMode)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } }} } -RT_ENUM! { enum SmartCardTriggerType: i32 { - EmulatorTransaction (SmartCardTriggerType_EmulatorTransaction) = 0, EmulatorNearFieldEntry (SmartCardTriggerType_EmulatorNearFieldEntry) = 1, EmulatorNearFieldExit (SmartCardTriggerType_EmulatorNearFieldExit) = 2, EmulatorHostApplicationActivated (SmartCardTriggerType_EmulatorHostApplicationActivated) = 3, EmulatorAppletIdGroupRegistrationChanged (SmartCardTriggerType_EmulatorAppletIdGroupRegistrationChanged) = 4, ReaderCardAdded (SmartCardTriggerType_ReaderCardAdded) = 5, -}} -RT_ENUM! { enum SmartCardUnlockPromptingBehavior: i32 { - AllowUnlockPrompt (SmartCardUnlockPromptingBehavior_AllowUnlockPrompt) = 0, RequireUnlockPrompt (SmartCardUnlockPromptingBehavior_RequireUnlockPrompt) = 1, PreventUnlockPrompt (SmartCardUnlockPromptingBehavior_PreventUnlockPrompt) = 2, +RT_CLASS!{class ProviderSpiConnectionSettings: IProviderSpiConnectionSettings} +impl RtActivatable for ProviderSpiConnectionSettings {} +impl ProviderSpiConnectionSettings { + #[inline] pub fn create(chipSelectLine: i32) -> Result> { + >::get_activation_factory().create(chipSelectLine) + } +} +DEFINE_CLSID!(ProviderSpiConnectionSettings(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,83,112,105,46,80,114,111,118,105,100,101,114,46,80,114,111,118,105,100,101,114,83,112,105,67,111,110,110,101,99,116,105,111,110,83,101,116,116,105,110,103,115,0]) [CLSID_ProviderSpiConnectionSettings]); +DEFINE_IID!(IID_IProviderSpiConnectionSettingsFactory, 1715825498, 3193, 17379, 159, 60, 229, 151, 128, 172, 24, 250); +RT_INTERFACE!{static interface IProviderSpiConnectionSettingsFactory(IProviderSpiConnectionSettingsFactoryVtbl): IInspectable(IInspectableVtbl) [IID_IProviderSpiConnectionSettingsFactory] { + fn Create(&self, chipSelectLine: i32, out: *mut *mut ProviderSpiConnectionSettings) -> HRESULT }} -} // Windows.Devices.SmartCards +impl IProviderSpiConnectionSettingsFactory { + #[inline] pub fn create(&self, chipSelectLine: i32) -> Result> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, chipSelectLine, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} +} +RT_ENUM! { enum ProviderSpiMode: i32 { + Mode0 (ProviderSpiMode_Mode0) = 0, Mode1 (ProviderSpiMode_Mode1) = 1, Mode2 (ProviderSpiMode_Mode2) = 2, Mode3 (ProviderSpiMode_Mode3) = 3, +}} +RT_ENUM! { enum ProviderSpiSharingMode: i32 { + Exclusive (ProviderSpiSharingMode_Exclusive) = 0, Shared (ProviderSpiSharingMode_Shared) = 1, +}} +DEFINE_IID!(IID_ISpiControllerProvider, 3244844292, 718, 16934, 163, 133, 79, 17, 251, 4, 180, 27); +RT_INTERFACE!{interface ISpiControllerProvider(ISpiControllerProviderVtbl): IInspectable(IInspectableVtbl) [IID_ISpiControllerProvider] { + fn GetDeviceProvider(&self, settings: *mut ProviderSpiConnectionSettings, out: *mut *mut ISpiDeviceProvider) -> HRESULT +}} +impl ISpiControllerProvider { + #[inline] pub fn get_device_provider(&self, settings: &ProviderSpiConnectionSettings) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetDeviceProvider)(self as *const _ as *mut _, settings as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +DEFINE_IID!(IID_ISpiDeviceProvider, 219952195, 12363, 16476, 180, 247, 245, 171, 16, 116, 70, 30); +RT_INTERFACE!{interface ISpiDeviceProvider(ISpiDeviceProviderVtbl): IInspectable(IInspectableVtbl) [IID_ISpiDeviceProvider] { + fn get_DeviceId(&self, out: *mut HSTRING) -> HRESULT, + fn get_ConnectionSettings(&self, out: *mut *mut ProviderSpiConnectionSettings) -> HRESULT, + fn Write(&self, bufferSize: u32, buffer: *mut u8) -> HRESULT, + fn Read(&self, bufferSize: u32, buffer: *mut u8) -> HRESULT, + fn TransferSequential(&self, writeBufferSize: u32, writeBuffer: *mut u8, readBufferSize: u32, readBuffer: *mut u8) -> HRESULT, + fn TransferFullDuplex(&self, writeBufferSize: u32, writeBuffer: *mut u8, readBufferSize: u32, readBuffer: *mut u8) -> HRESULT +}} +impl ISpiDeviceProvider { + #[inline] pub fn get_device_id(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_DeviceId)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_connection_settings(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ConnectionSettings)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn write(&self, buffer: &[u8]) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).Write)(self as *const _ as *mut _, buffer.len() as u32, buffer.as_ptr() as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn read(&self, buffer: &mut [u8]) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).Read)(self as *const _ as *mut _, buffer.len() as u32, buffer.as_mut_ptr() as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn transfer_sequential(&self, writeBuffer: &[u8], readBuffer: &mut [u8]) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).TransferSequential)(self as *const _ as *mut _, writeBuffer.len() as u32, writeBuffer.as_ptr() as *mut _, readBuffer.len() as u32, readBuffer.as_mut_ptr() as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn transfer_full_duplex(&self, writeBuffer: &[u8], readBuffer: &mut [u8]) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).TransferFullDuplex)(self as *const _ as *mut _, writeBuffer.len() as u32, writeBuffer.as_ptr() as *mut _, readBuffer.len() as u32, readBuffer.as_mut_ptr() as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +DEFINE_IID!(IID_ISpiProvider, 2528403938, 30676, 18638, 170, 160, 117, 113, 90, 131, 98, 207); +RT_INTERFACE!{interface ISpiProvider(ISpiProviderVtbl): IInspectable(IInspectableVtbl) [IID_ISpiProvider] { + fn GetControllersAsync(&self, out: *mut *mut foundation::IAsyncOperation>) -> HRESULT +}} +impl ISpiProvider { + #[inline] pub fn get_controllers_async(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetControllersAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} +} +} // Windows.Devices.Spi.Provider +} // Windows.Devices.Spi pub mod power { // Windows.Devices.Power use ::prelude::*; DEFINE_IID!(IID_IBattery, 3163115462, 114, 18376, 139, 93, 97, 74, 170, 122, 67, 126); @@ -6612,6 +6612,23 @@ impl BluetoothAdapter { } } DEFINE_CLSID!(BluetoothAdapter(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,66,108,117,101,116,111,111,116,104,46,66,108,117,101,116,111,111,116,104,65,100,97,112,116,101,114,0]) [CLSID_BluetoothAdapter]); +DEFINE_IID!(IID_IBluetoothAdapter2, 2895433420, 9429, 16819, 145, 109, 16, 151, 197, 11, 16, 43); +RT_INTERFACE!{interface IBluetoothAdapter2(IBluetoothAdapter2Vtbl): IInspectable(IInspectableVtbl) [IID_IBluetoothAdapter2] { + fn get_AreClassicSecureConnectionsSupported(&self, out: *mut bool) -> HRESULT, + fn get_AreLowEnergySecureConnectionsSupported(&self, out: *mut bool) -> HRESULT +}} +impl IBluetoothAdapter2 { + #[inline] pub fn get_are_classic_secure_connections_supported(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_AreClassicSecureConnectionsSupported)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_are_low_energy_secure_connections_supported(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_AreLowEnergySecureConnectionsSupported)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} DEFINE_IID!(IID_IBluetoothAdapterStatics, 2332228458, 44108, 18241, 134, 97, 142, 171, 125, 23, 234, 159); RT_INTERFACE!{static interface IBluetoothAdapterStatics(IBluetoothAdapterStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IBluetoothAdapterStatics] { fn GetDeviceSelector(&self, out: *mut HSTRING) -> HRESULT, @@ -6885,6 +6902,17 @@ impl IBluetoothDevice4 { if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IBluetoothDevice5, 3051402117, 24197, 17753, 161, 13, 28, 114, 129, 55, 159, 150); +RT_INTERFACE!{interface IBluetoothDevice5(IBluetoothDevice5Vtbl): IInspectable(IInspectableVtbl) [IID_IBluetoothDevice5] { + fn get_WasSecureConnectionUsedForPairing(&self, out: *mut bool) -> HRESULT +}} +impl IBluetoothDevice5 { + #[inline] pub fn get_was_secure_connection_used_for_pairing(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_WasSecureConnectionUsedForPairing)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} DEFINE_IID!(IID_IBluetoothDeviceId, 3245951407, 22465, 17986, 188, 206, 230, 192, 107, 32, 174, 118); RT_INTERFACE!{interface IBluetoothDeviceId(IBluetoothDeviceIdVtbl): IInspectable(IInspectableVtbl) [IID_IBluetoothDeviceId] { fn get_Id(&self, out: *mut HSTRING) -> HRESULT, @@ -7701,6 +7729,17 @@ impl IBluetoothLEDevice4 { if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IBluetoothLEDevice5, 2640974432, 21127, 17806, 149, 186, 23, 200, 183, 187, 50, 110); +RT_INTERFACE!{interface IBluetoothLEDevice5(IBluetoothLEDevice5Vtbl): IInspectable(IInspectableVtbl) [IID_IBluetoothLEDevice5] { + fn get_WasSecureConnectionUsedForPairing(&self, out: *mut bool) -> HRESULT +}} +impl IBluetoothLEDevice5 { + #[inline] pub fn get_was_secure_connection_used_for_pairing(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_WasSecureConnectionUsedForPairing)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} DEFINE_IID!(IID_IBluetoothLEDeviceStatics, 3369015833, 61622, 19440, 134, 137, 65, 48, 61, 226, 217, 244); RT_INTERFACE!{static interface IBluetoothLEDeviceStatics(IBluetoothLEDeviceStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IBluetoothLEDeviceStatics] { fn FromIdAsync(&self, deviceId: HSTRING, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, @@ -13296,6 +13335,185 @@ impl IPnpObjectWatcher { RT_CLASS!{class PnpObjectWatcher: IPnpObjectWatcher} } // Windows.Devices.Enumeration.Pnp } // Windows.Devices.Enumeration +pub mod display { // Windows.Devices.Display +use ::prelude::*; +DEFINE_IID!(IID_IDisplayMonitor, 527111636, 7425, 19537, 135, 226, 111, 149, 74, 119, 43, 89); +RT_INTERFACE!{interface IDisplayMonitor(IDisplayMonitorVtbl): IInspectable(IInspectableVtbl) [IID_IDisplayMonitor] { + fn get_DeviceId(&self, out: *mut HSTRING) -> HRESULT, + fn get_DisplayName(&self, out: *mut HSTRING) -> HRESULT, + fn get_ConnectionKind(&self, out: *mut DisplayMonitorConnectionKind) -> HRESULT, + fn get_PhysicalConnector(&self, out: *mut DisplayMonitorPhysicalConnectorKind) -> HRESULT, + fn get_DisplayAdapterDeviceId(&self, out: *mut HSTRING) -> HRESULT, + #[cfg(not(feature="windows-graphics"))] fn __Dummy5(&self) -> (), + #[cfg(feature="windows-graphics")] fn get_DisplayAdapterId(&self, out: *mut super::super::graphics::DisplayAdapterId) -> HRESULT, + fn get_DisplayAdapterTargetId(&self, out: *mut u32) -> HRESULT, + fn get_UsageKind(&self, out: *mut DisplayMonitorUsageKind) -> HRESULT, + #[cfg(not(feature="windows-graphics"))] fn __Dummy8(&self) -> (), + #[cfg(feature="windows-graphics")] fn get_NativeResolutionInRawPixels(&self, out: *mut super::super::graphics::SizeInt32) -> HRESULT, + fn get_PhysicalSizeInInches(&self, out: *mut *mut foundation::IReference) -> HRESULT, + fn get_RawDpiX(&self, out: *mut f32) -> HRESULT, + fn get_RawDpiY(&self, out: *mut f32) -> HRESULT, + fn get_RedPrimary(&self, out: *mut foundation::Point) -> HRESULT, + fn get_GreenPrimary(&self, out: *mut foundation::Point) -> HRESULT, + fn get_BluePrimary(&self, out: *mut foundation::Point) -> HRESULT, + fn get_WhitePoint(&self, out: *mut foundation::Point) -> HRESULT, + fn get_MaxLuminanceInNits(&self, out: *mut f32) -> HRESULT, + fn get_MinLuminanceInNits(&self, out: *mut f32) -> HRESULT, + fn get_MaxAverageFullFrameLuminanceInNits(&self, out: *mut f32) -> HRESULT, + fn GetDescriptor(&self, descriptorKind: DisplayMonitorDescriptorKind, outSize: *mut u32, out: *mut *mut u8) -> HRESULT +}} +impl IDisplayMonitor { + #[inline] pub fn get_device_id(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_DeviceId)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_display_name(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_DisplayName)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_connection_kind(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_ConnectionKind)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_physical_connector(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_PhysicalConnector)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_display_adapter_device_id(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_DisplayAdapterDeviceId)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[cfg(feature="windows-graphics")] #[inline] pub fn get_display_adapter_id(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_DisplayAdapterId)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_display_adapter_target_id(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_DisplayAdapterTargetId)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_usage_kind(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_UsageKind)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[cfg(feature="windows-graphics")] #[inline] pub fn get_native_resolution_in_raw_pixels(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_NativeResolutionInRawPixels)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_physical_size_in_inches(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_PhysicalSizeInInches)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_raw_dpi_x(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_RawDpiX)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_raw_dpi_y(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_RawDpiY)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_red_primary(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_RedPrimary)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_green_primary(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_GreenPrimary)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_blue_primary(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_BluePrimary)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_white_point(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_WhitePoint)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_max_luminance_in_nits(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_MaxLuminanceInNits)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_min_luminance_in_nits(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_MinLuminanceInNits)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_max_average_full_frame_luminance_in_nits(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_MaxAverageFullFrameLuminanceInNits)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_descriptor(&self, descriptorKind: DisplayMonitorDescriptorKind) -> Result> { unsafe { + let mut outSize = 0; let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetDescriptor)(self as *const _ as *mut _, descriptorKind, &mut outSize, &mut out); + if hr == S_OK { Ok(ComArray::from_raw(outSize, out)) } else { err(hr) } + }} +} +RT_CLASS!{class DisplayMonitor: IDisplayMonitor} +impl RtActivatable for DisplayMonitor {} +impl DisplayMonitor { + #[inline] pub fn get_device_selector() -> Result { + >::get_activation_factory().get_device_selector() + } + #[inline] pub fn from_id_async(deviceId: &HStringArg) -> Result>> { + >::get_activation_factory().from_id_async(deviceId) + } + #[inline] pub fn from_interface_id_async(deviceInterfaceId: &HStringArg) -> Result>> { + >::get_activation_factory().from_interface_id_async(deviceInterfaceId) + } +} +DEFINE_CLSID!(DisplayMonitor(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,68,105,115,112,108,97,121,46,68,105,115,112,108,97,121,77,111,110,105,116,111,114,0]) [CLSID_DisplayMonitor]); +RT_ENUM! { enum DisplayMonitorConnectionKind: i32 { + Internal (DisplayMonitorConnectionKind_Internal) = 0, Wired (DisplayMonitorConnectionKind_Wired) = 1, Wireless (DisplayMonitorConnectionKind_Wireless) = 2, Virtual (DisplayMonitorConnectionKind_Virtual) = 3, +}} +RT_ENUM! { enum DisplayMonitorDescriptorKind: i32 { + Edid (DisplayMonitorDescriptorKind_Edid) = 0, DisplayId (DisplayMonitorDescriptorKind_DisplayId) = 1, +}} +RT_ENUM! { enum DisplayMonitorPhysicalConnectorKind: i32 { + Unknown (DisplayMonitorPhysicalConnectorKind_Unknown) = 0, HD15 (DisplayMonitorPhysicalConnectorKind_HD15) = 1, AnalogTV (DisplayMonitorPhysicalConnectorKind_AnalogTV) = 2, Dvi (DisplayMonitorPhysicalConnectorKind_Dvi) = 3, Hdmi (DisplayMonitorPhysicalConnectorKind_Hdmi) = 4, Lvds (DisplayMonitorPhysicalConnectorKind_Lvds) = 5, Sdi (DisplayMonitorPhysicalConnectorKind_Sdi) = 6, DisplayPort (DisplayMonitorPhysicalConnectorKind_DisplayPort) = 7, +}} +DEFINE_IID!(IID_IDisplayMonitorStatics, 1856924047, 41512, 19461, 130, 29, 182, 149, 214, 103, 222, 142); +RT_INTERFACE!{static interface IDisplayMonitorStatics(IDisplayMonitorStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IDisplayMonitorStatics] { + fn GetDeviceSelector(&self, out: *mut HSTRING) -> HRESULT, + fn FromIdAsync(&self, deviceId: HSTRING, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn FromInterfaceIdAsync(&self, deviceInterfaceId: HSTRING, out: *mut *mut foundation::IAsyncOperation) -> HRESULT +}} +impl IDisplayMonitorStatics { + #[inline] pub fn get_device_selector(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetDeviceSelector)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn from_id_async(&self, deviceId: &HStringArg) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).FromIdAsync)(self as *const _ as *mut _, deviceId.get(), &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn from_interface_id_async(&self, deviceInterfaceId: &HStringArg) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).FromInterfaceIdAsync)(self as *const _ as *mut _, deviceInterfaceId.get(), &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} +} +RT_ENUM! { enum DisplayMonitorUsageKind: i32 { + Standard (DisplayMonitorUsageKind_Standard) = 0, HeadMounted (DisplayMonitorUsageKind_HeadMounted) = 1, SpecialPurpose (DisplayMonitorUsageKind_SpecialPurpose) = 2, +}} +} // Windows.Devices.Display pub mod geolocation { // Windows.Devices.Geolocation use ::prelude::*; RT_ENUM! { enum AltitudeReferenceSystem: i32 { @@ -15351,70 +15569,397 @@ impl ITouchCapabilities { RT_CLASS!{class TouchCapabilities: ITouchCapabilities} impl RtActivatable for TouchCapabilities {} DEFINE_CLSID!(TouchCapabilities(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,73,110,112,117,116,46,84,111,117,99,104,67,97,112,97,98,105,108,105,116,105,101,115,0]) [CLSID_TouchCapabilities]); -} // Windows.Devices.Input -pub mod lights { // Windows.Devices.Lights +pub mod preview { // Windows.Devices.Input.Preview use ::prelude::*; -DEFINE_IID!(IID_ILamp, 75324314, 59973, 19243, 177, 162, 20, 223, 240, 11, 222, 123); -RT_INTERFACE!{interface ILamp(ILampVtbl): IInspectable(IInspectableVtbl) [IID_ILamp] { - fn get_DeviceId(&self, out: *mut HSTRING) -> HRESULT, - fn get_IsEnabled(&self, out: *mut bool) -> HRESULT, - fn put_IsEnabled(&self, value: bool) -> HRESULT, - fn get_BrightnessLevel(&self, out: *mut f32) -> HRESULT, - fn put_BrightnessLevel(&self, value: f32) -> HRESULT, - fn get_IsColorSettable(&self, out: *mut bool) -> HRESULT, - #[cfg(not(feature="windows-ui"))] fn __Dummy6(&self) -> (), - #[cfg(feature="windows-ui")] fn get_Color(&self, out: *mut super::super::ui::Color) -> HRESULT, - #[cfg(not(feature="windows-ui"))] fn __Dummy7(&self) -> (), - #[cfg(feature="windows-ui")] fn put_Color(&self, value: super::super::ui::Color) -> HRESULT, - fn add_AvailabilityChanged(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, - fn remove_AvailabilityChanged(&self, token: foundation::EventRegistrationToken) -> HRESULT +RT_ENUM! { enum GazeDeviceConfigurationStatePreview: i32 { + Unknown (GazeDeviceConfigurationStatePreview_Unknown) = 0, Ready (GazeDeviceConfigurationStatePreview_Ready) = 1, Configuring (GazeDeviceConfigurationStatePreview_Configuring) = 2, ScreenSetupNeeded (GazeDeviceConfigurationStatePreview_ScreenSetupNeeded) = 3, UserCalibrationNeeded (GazeDeviceConfigurationStatePreview_UserCalibrationNeeded) = 4, }} -impl ILamp { - #[inline] pub fn get_device_id(&self) -> Result { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_DeviceId)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } - }} - #[inline] pub fn get_is_enabled(&self) -> Result { unsafe { +DEFINE_IID!(IID_IGazeDevicePreview, 3885924073, 45961, 4583, 178, 1, 200, 211, 255, 183, 87, 33); +RT_INTERFACE!{interface IGazeDevicePreview(IGazeDevicePreviewVtbl): IInspectable(IInspectableVtbl) [IID_IGazeDevicePreview] { + fn get_Id(&self, out: *mut u32) -> HRESULT, + fn get_CanTrackEyes(&self, out: *mut bool) -> HRESULT, + fn get_CanTrackHead(&self, out: *mut bool) -> HRESULT, + fn get_ConfigurationState(&self, out: *mut GazeDeviceConfigurationStatePreview) -> HRESULT, + fn RequestCalibrationAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn GetNumericControlDescriptions(&self, usagePage: u16, usageId: u16, out: *mut *mut foundation::collections::IVectorView) -> HRESULT, + fn GetBooleanControlDescriptions(&self, usagePage: u16, usageId: u16, out: *mut *mut foundation::collections::IVectorView) -> HRESULT +}} +impl IGazeDevicePreview { + #[inline] pub fn get_id(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_IsEnabled)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_Id)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn set_is_enabled(&self, value: bool) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_IsEnabled)(self as *const _ as *mut _, value); - if hr == S_OK { Ok(()) } else { err(hr) } - }} - #[inline] pub fn get_brightness_level(&self) -> Result { unsafe { + #[inline] pub fn get_can_track_eyes(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_BrightnessLevel)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_CanTrackEyes)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn set_brightness_level(&self, value: f32) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_BrightnessLevel)(self as *const _ as *mut _, value); - if hr == S_OK { Ok(()) } else { err(hr) } - }} - #[inline] pub fn get_is_color_settable(&self) -> Result { unsafe { + #[inline] pub fn get_can_track_head(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_IsColorSettable)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_CanTrackHead)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[cfg(feature="windows-ui")] #[inline] pub fn get_color(&self) -> Result { unsafe { + #[inline] pub fn get_configuration_state(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_Color)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_ConfigurationState)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[cfg(feature="windows-ui")] #[inline] pub fn set_color(&self, value: super::super::ui::Color) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).put_Color)(self as *const _ as *mut _, value); - if hr == S_OK { Ok(()) } else { err(hr) } - }} - #[inline] pub fn add_availability_changed(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).add_AvailabilityChanged)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } + #[inline] pub fn request_calibration_async(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).RequestCalibrationAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn remove_availability_changed(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).remove_AvailabilityChanged)(self as *const _ as *mut _, token); - if hr == S_OK { Ok(()) } else { err(hr) } + #[inline] pub fn get_numeric_control_descriptions(&self, usagePage: u16, usageId: u16) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetNumericControlDescriptions)(self as *const _ as *mut _, usagePage, usageId, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_boolean_control_descriptions(&self, usagePage: u16, usageId: u16) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetBooleanControlDescriptions)(self as *const _ as *mut _, usagePage, usageId, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +RT_CLASS!{class GazeDevicePreview: IGazeDevicePreview} +DEFINE_IID!(IID_IGazeDeviceWatcherAddedPreviewEventArgs, 3885924077, 45961, 4583, 178, 1, 200, 211, 255, 183, 87, 33); +RT_INTERFACE!{interface IGazeDeviceWatcherAddedPreviewEventArgs(IGazeDeviceWatcherAddedPreviewEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IGazeDeviceWatcherAddedPreviewEventArgs] { + fn get_Device(&self, out: *mut *mut GazeDevicePreview) -> HRESULT +}} +impl IGazeDeviceWatcherAddedPreviewEventArgs { + #[inline] pub fn get_device(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Device)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +RT_CLASS!{class GazeDeviceWatcherAddedPreviewEventArgs: IGazeDeviceWatcherAddedPreviewEventArgs} +DEFINE_IID!(IID_IGazeDeviceWatcherPreview, 3885924071, 45961, 4583, 178, 1, 200, 211, 255, 183, 87, 33); +RT_INTERFACE!{interface IGazeDeviceWatcherPreview(IGazeDeviceWatcherPreviewVtbl): IInspectable(IInspectableVtbl) [IID_IGazeDeviceWatcherPreview] { + fn add_Added(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_Added(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn add_Removed(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_Removed(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn add_Updated(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_Updated(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn add_EnumerationCompleted(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_EnumerationCompleted(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn Start(&self) -> HRESULT, + fn Stop(&self) -> HRESULT +}} +impl IGazeDeviceWatcherPreview { + #[inline] pub fn add_added(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_Added)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_added(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_Added)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_removed(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_Removed)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_removed(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_Removed)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_updated(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_Updated)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_updated(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_Updated)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_enumeration_completed(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_EnumerationCompleted)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_enumeration_completed(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_EnumerationCompleted)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn start(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).Start)(self as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn stop(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).Stop)(self as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class GazeDeviceWatcherPreview: IGazeDeviceWatcherPreview} +DEFINE_IID!(IID_IGazeDeviceWatcherRemovedPreviewEventArgs, 4066582280, 3647, 17183, 166, 6, 80, 179, 90, 249, 74, 28); +RT_INTERFACE!{interface IGazeDeviceWatcherRemovedPreviewEventArgs(IGazeDeviceWatcherRemovedPreviewEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IGazeDeviceWatcherRemovedPreviewEventArgs] { + fn get_Device(&self, out: *mut *mut GazeDevicePreview) -> HRESULT +}} +impl IGazeDeviceWatcherRemovedPreviewEventArgs { + #[inline] pub fn get_device(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Device)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +RT_CLASS!{class GazeDeviceWatcherRemovedPreviewEventArgs: IGazeDeviceWatcherRemovedPreviewEventArgs} +DEFINE_IID!(IID_IGazeDeviceWatcherUpdatedPreviewEventArgs, 2145923311, 32520, 18231, 136, 225, 74, 131, 174, 78, 72, 133); +RT_INTERFACE!{interface IGazeDeviceWatcherUpdatedPreviewEventArgs(IGazeDeviceWatcherUpdatedPreviewEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IGazeDeviceWatcherUpdatedPreviewEventArgs] { + fn get_Device(&self, out: *mut *mut GazeDevicePreview) -> HRESULT +}} +impl IGazeDeviceWatcherUpdatedPreviewEventArgs { + #[inline] pub fn get_device(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Device)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +RT_CLASS!{class GazeDeviceWatcherUpdatedPreviewEventArgs: IGazeDeviceWatcherUpdatedPreviewEventArgs} +DEFINE_IID!(IID_IGazeEnteredPreviewEventArgs, 627556163, 4645, 18591, 157, 209, 218, 167, 197, 15, 191, 75); +RT_INTERFACE!{interface IGazeEnteredPreviewEventArgs(IGazeEnteredPreviewEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IGazeEnteredPreviewEventArgs] { + fn get_Handled(&self, out: *mut bool) -> HRESULT, + fn put_Handled(&self, value: bool) -> HRESULT, + fn get_CurrentPoint(&self, out: *mut *mut GazePointPreview) -> HRESULT +}} +impl IGazeEnteredPreviewEventArgs { + #[inline] pub fn get_handled(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Handled)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_handled(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Handled)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_current_point(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_CurrentPoint)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +RT_CLASS!{class GazeEnteredPreviewEventArgs: IGazeEnteredPreviewEventArgs} +DEFINE_IID!(IID_IGazeExitedPreviewEventArgs, 1560998014, 32131, 16623, 159, 10, 251, 193, 187, 220, 197, 172); +RT_INTERFACE!{interface IGazeExitedPreviewEventArgs(IGazeExitedPreviewEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IGazeExitedPreviewEventArgs] { + fn get_Handled(&self, out: *mut bool) -> HRESULT, + fn put_Handled(&self, value: bool) -> HRESULT, + fn get_CurrentPoint(&self, out: *mut *mut GazePointPreview) -> HRESULT +}} +impl IGazeExitedPreviewEventArgs { + #[inline] pub fn get_handled(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Handled)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_handled(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Handled)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_current_point(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_CurrentPoint)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +RT_CLASS!{class GazeExitedPreviewEventArgs: IGazeExitedPreviewEventArgs} +DEFINE_IID!(IID_IGazeInputSourcePreview, 3885924072, 45961, 4583, 178, 1, 200, 211, 255, 183, 87, 33); +RT_INTERFACE!{interface IGazeInputSourcePreview(IGazeInputSourcePreviewVtbl): IInspectable(IInspectableVtbl) [IID_IGazeInputSourcePreview] { + fn add_GazeMoved(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_GazeMoved(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn add_GazeEntered(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_GazeEntered(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn add_GazeExited(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_GazeExited(&self, token: foundation::EventRegistrationToken) -> HRESULT +}} +impl IGazeInputSourcePreview { + #[inline] pub fn add_gaze_moved(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_GazeMoved)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_gaze_moved(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_GazeMoved)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_gaze_entered(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_GazeEntered)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_gaze_entered(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_GazeEntered)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_gaze_exited(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_GazeExited)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_gaze_exited(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_GazeExited)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class GazeInputSourcePreview: IGazeInputSourcePreview} +impl RtActivatable for GazeInputSourcePreview {} +impl GazeInputSourcePreview { + #[inline] pub fn get_for_current_view() -> Result>> { + >::get_activation_factory().get_for_current_view() + } + #[inline] pub fn create_watcher() -> Result>> { + >::get_activation_factory().create_watcher() + } +} +DEFINE_CLSID!(GazeInputSourcePreview(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,73,110,112,117,116,46,80,114,101,118,105,101,119,46,71,97,122,101,73,110,112,117,116,83,111,117,114,99,101,80,114,101,118,105,101,119,0]) [CLSID_GazeInputSourcePreview]); +DEFINE_IID!(IID_IGazeInputSourcePreviewStatics, 3885924070, 45961, 4583, 178, 1, 200, 211, 255, 183, 87, 33); +RT_INTERFACE!{static interface IGazeInputSourcePreviewStatics(IGazeInputSourcePreviewStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IGazeInputSourcePreviewStatics] { + fn GetForCurrentView(&self, out: *mut *mut GazeInputSourcePreview) -> HRESULT, + fn CreateWatcher(&self, out: *mut *mut GazeDeviceWatcherPreview) -> HRESULT +}} +impl IGazeInputSourcePreviewStatics { + #[inline] pub fn get_for_current_view(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetForCurrentView)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn create_watcher(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreateWatcher)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +DEFINE_IID!(IID_IGazeMovedPreviewEventArgs, 3885924075, 45961, 4583, 178, 1, 200, 211, 255, 183, 87, 33); +RT_INTERFACE!{interface IGazeMovedPreviewEventArgs(IGazeMovedPreviewEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IGazeMovedPreviewEventArgs] { + fn get_Handled(&self, out: *mut bool) -> HRESULT, + fn put_Handled(&self, value: bool) -> HRESULT, + fn get_CurrentPoint(&self, out: *mut *mut GazePointPreview) -> HRESULT, + fn GetIntermediatePoints(&self, out: *mut *mut foundation::collections::IVector) -> HRESULT +}} +impl IGazeMovedPreviewEventArgs { + #[inline] pub fn get_handled(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Handled)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_handled(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Handled)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_current_point(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_CurrentPoint)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_intermediate_points(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetIntermediatePoints)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +RT_CLASS!{class GazeMovedPreviewEventArgs: IGazeMovedPreviewEventArgs} +DEFINE_IID!(IID_IGazePointPreview, 3885924074, 45961, 4583, 178, 1, 200, 211, 255, 183, 87, 33); +RT_INTERFACE!{interface IGazePointPreview(IGazePointPreviewVtbl): IInspectable(IInspectableVtbl) [IID_IGazePointPreview] { + fn get_SourceDevice(&self, out: *mut *mut GazeDevicePreview) -> HRESULT, + fn get_EyeGazePosition(&self, out: *mut *mut foundation::IReference) -> HRESULT, + fn get_HeadGazePosition(&self, out: *mut *mut foundation::IReference) -> HRESULT, + fn get_Timestamp(&self, out: *mut u64) -> HRESULT, + fn get_HidInputReport(&self, out: *mut *mut super::super::humaninterfacedevice::HidInputReport) -> HRESULT +}} +impl IGazePointPreview { + #[inline] pub fn get_source_device(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_SourceDevice)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_eye_gaze_position(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_EyeGazePosition)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_head_gaze_position(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_HeadGazePosition)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_timestamp(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Timestamp)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_hid_input_report(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_HidInputReport)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +RT_CLASS!{class GazePointPreview: IGazePointPreview} +} // Windows.Devices.Input.Preview +} // Windows.Devices.Input +pub mod lights { // Windows.Devices.Lights +use ::prelude::*; +DEFINE_IID!(IID_ILamp, 75324314, 59973, 19243, 177, 162, 20, 223, 240, 11, 222, 123); +RT_INTERFACE!{interface ILamp(ILampVtbl): IInspectable(IInspectableVtbl) [IID_ILamp] { + fn get_DeviceId(&self, out: *mut HSTRING) -> HRESULT, + fn get_IsEnabled(&self, out: *mut bool) -> HRESULT, + fn put_IsEnabled(&self, value: bool) -> HRESULT, + fn get_BrightnessLevel(&self, out: *mut f32) -> HRESULT, + fn put_BrightnessLevel(&self, value: f32) -> HRESULT, + fn get_IsColorSettable(&self, out: *mut bool) -> HRESULT, + #[cfg(not(feature="windows-ui"))] fn __Dummy6(&self) -> (), + #[cfg(feature="windows-ui")] fn get_Color(&self, out: *mut super::super::ui::Color) -> HRESULT, + #[cfg(not(feature="windows-ui"))] fn __Dummy7(&self) -> (), + #[cfg(feature="windows-ui")] fn put_Color(&self, value: super::super::ui::Color) -> HRESULT, + fn add_AvailabilityChanged(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_AvailabilityChanged(&self, token: foundation::EventRegistrationToken) -> HRESULT +}} +impl ILamp { + #[inline] pub fn get_device_id(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_DeviceId)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_is_enabled(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_IsEnabled)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_is_enabled(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_IsEnabled)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_brightness_level(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_BrightnessLevel)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_brightness_level(&self, value: f32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_BrightnessLevel)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_is_color_settable(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_IsColorSettable)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[cfg(feature="windows-ui")] #[inline] pub fn get_color(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Color)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[cfg(feature="windows-ui")] #[inline] pub fn set_color(&self, value: super::super::ui::Color) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Color)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_availability_changed(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_AvailabilityChanged)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_availability_changed(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_AvailabilityChanged)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } }} } RT_CLASS!{class Lamp: ILamp} @@ -18500,6 +19045,24 @@ impl IBarcodeScannerReport { }} } RT_CLASS!{class BarcodeScannerReport: IBarcodeScannerReport} +impl RtActivatable for BarcodeScannerReport {} +impl BarcodeScannerReport { + #[cfg(feature="windows-storage")] #[inline] pub fn create_instance(scanDataType: u32, scanData: &super::super::storage::streams::IBuffer, scanDataLabel: &super::super::storage::streams::IBuffer) -> Result> { + >::get_activation_factory().create_instance(scanDataType, scanData, scanDataLabel) + } +} +DEFINE_CLSID!(BarcodeScannerReport(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,80,111,105,110,116,79,102,83,101,114,118,105,99,101,46,66,97,114,99,111,100,101,83,99,97,110,110,101,114,82,101,112,111,114,116,0]) [CLSID_BarcodeScannerReport]); +DEFINE_IID!(IID_IBarcodeScannerReportFactory, 2723443494, 8211, 17788, 137, 99, 73, 193, 93, 202, 120, 206); +RT_INTERFACE!{static interface IBarcodeScannerReportFactory(IBarcodeScannerReportFactoryVtbl): IInspectable(IInspectableVtbl) [IID_IBarcodeScannerReportFactory] { + #[cfg(feature="windows-storage")] fn CreateInstance(&self, scanDataType: u32, scanData: *mut super::super::storage::streams::IBuffer, scanDataLabel: *mut super::super::storage::streams::IBuffer, out: *mut *mut BarcodeScannerReport) -> HRESULT +}} +impl IBarcodeScannerReportFactory { + #[cfg(feature="windows-storage")] #[inline] pub fn create_instance(&self, scanDataType: u32, scanData: &super::super::storage::streams::IBuffer, scanDataLabel: &super::super::storage::streams::IBuffer) -> Result> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreateInstance)(self as *const _ as *mut _, scanDataType, scanData as *const _ as *mut _, scanDataLabel as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IBarcodeScannerStatics, 1561419631, 55881, 16872, 140, 140, 240, 203, 98, 169, 196, 252); RT_INTERFACE!{static interface IBarcodeScannerStatics(IBarcodeScannerStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IBarcodeScannerStatics] { fn GetDefaultAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, @@ -19988,6 +20551,33 @@ impl IClaimedBarcodeScanner2 { if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IClaimedBarcodeScanner3, 3872306224, 28974, 17916, 139, 134, 205, 85, 245, 174, 247, 157); +RT_INTERFACE!{interface IClaimedBarcodeScanner3(IClaimedBarcodeScanner3Vtbl): IInspectable(IInspectableVtbl) [IID_IClaimedBarcodeScanner3] { + fn ShowVideoPreviewAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn HideVideoPreview(&self) -> HRESULT, + fn put_IsVideoPreviewShownOnEnable(&self, value: bool) -> HRESULT, + fn get_IsVideoPreviewShownOnEnable(&self, out: *mut bool) -> HRESULT +}} +impl IClaimedBarcodeScanner3 { + #[inline] pub fn show_video_preview_async(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).ShowVideoPreviewAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn hide_video_preview(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).HideVideoPreview)(self as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn set_is_video_preview_shown_on_enable(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_IsVideoPreviewShownOnEnable)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_is_video_preview_shown_on_enable(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_IsVideoPreviewShownOnEnable)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} DEFINE_IID!(IID_IClaimedCashDrawer, 3393165743, 43960, 17089, 138, 132, 92, 102, 81, 47, 90, 117); RT_INTERFACE!{interface IClaimedCashDrawer(IClaimedCashDrawerVtbl): IInspectable(IInspectableVtbl) [IID_IClaimedCashDrawer] { fn get_DeviceId(&self, out: *mut HSTRING) -> HRESULT, @@ -21719,518 +22309,873 @@ impl IMagneticStripeReader { let hr = ((*self.lpVtbl).get_SupportedCardTypes)(self as *const _ as *mut _, &mut outSize, &mut out); if hr == S_OK { Ok(ComArray::from_raw(outSize, out)) } else { err(hr) } }} - #[inline] pub fn get_device_authentication_protocol(&self) -> Result { unsafe { + #[inline] pub fn get_device_authentication_protocol(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_DeviceAuthenticationProtocol)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn check_health_async(&self, level: UnifiedPosHealthCheckLevel) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).CheckHealthAsync)(self as *const _ as *mut _, level, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn claim_reader_async(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).ClaimReaderAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[cfg(feature="windows-storage")] #[inline] pub fn retrieve_statistics_async(&self, statisticsCategories: &foundation::collections::IIterable) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).RetrieveStatisticsAsync)(self as *const _ as *mut _, statisticsCategories as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_error_reporting_type(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).GetErrorReportingType)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn add_status_updated(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_StatusUpdated)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_status_updated(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_StatusUpdated)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class MagneticStripeReader: IMagneticStripeReader} +impl RtActivatable for MagneticStripeReader {} +impl RtActivatable for MagneticStripeReader {} +impl MagneticStripeReader { + #[inline] pub fn get_default_async() -> Result>> { + >::get_activation_factory().get_default_async() + } + #[inline] pub fn from_id_async(deviceId: &HStringArg) -> Result>> { + >::get_activation_factory().from_id_async(deviceId) + } + #[inline] pub fn get_device_selector() -> Result { + >::get_activation_factory().get_device_selector() + } + #[inline] pub fn get_device_selector_with_connection_types(connectionTypes: PosConnectionTypes) -> Result { + >::get_activation_factory().get_device_selector_with_connection_types(connectionTypes) + } +} +DEFINE_CLSID!(MagneticStripeReader(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,80,111,105,110,116,79,102,83,101,114,118,105,99,101,46,77,97,103,110,101,116,105,99,83,116,114,105,112,101,82,101,97,100,101,114,0]) [CLSID_MagneticStripeReader]); +DEFINE_IID!(IID_IMagneticStripeReaderAamvaCardDataReceivedEventArgs, 172735825, 49942, 18704, 135, 243, 122, 98, 186, 134, 45, 49); +RT_INTERFACE!{interface IMagneticStripeReaderAamvaCardDataReceivedEventArgs(IMagneticStripeReaderAamvaCardDataReceivedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IMagneticStripeReaderAamvaCardDataReceivedEventArgs] { + fn get_Report(&self, out: *mut *mut MagneticStripeReaderReport) -> HRESULT, + fn get_LicenseNumber(&self, out: *mut HSTRING) -> HRESULT, + fn get_ExpirationDate(&self, out: *mut HSTRING) -> HRESULT, + fn get_Restrictions(&self, out: *mut HSTRING) -> HRESULT, + fn get_Class(&self, out: *mut HSTRING) -> HRESULT, + fn get_Endorsements(&self, out: *mut HSTRING) -> HRESULT, + fn get_BirthDate(&self, out: *mut HSTRING) -> HRESULT, + fn get_FirstName(&self, out: *mut HSTRING) -> HRESULT, + fn get_Surname(&self, out: *mut HSTRING) -> HRESULT, + fn get_Suffix(&self, out: *mut HSTRING) -> HRESULT, + fn get_Gender(&self, out: *mut HSTRING) -> HRESULT, + fn get_HairColor(&self, out: *mut HSTRING) -> HRESULT, + fn get_EyeColor(&self, out: *mut HSTRING) -> HRESULT, + fn get_Height(&self, out: *mut HSTRING) -> HRESULT, + fn get_Weight(&self, out: *mut HSTRING) -> HRESULT, + fn get_Address(&self, out: *mut HSTRING) -> HRESULT, + fn get_City(&self, out: *mut HSTRING) -> HRESULT, + fn get_State(&self, out: *mut HSTRING) -> HRESULT, + fn get_PostalCode(&self, out: *mut HSTRING) -> HRESULT +}} +impl IMagneticStripeReaderAamvaCardDataReceivedEventArgs { + #[inline] pub fn get_report(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Report)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_license_number(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_LicenseNumber)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_expiration_date(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ExpirationDate)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_restrictions(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Restrictions)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_class(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Class)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_endorsements(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Endorsements)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_birth_date(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_BirthDate)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_first_name(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_FirstName)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_surname(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Surname)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_suffix(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Suffix)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_gender(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Gender)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_hair_color(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_HairColor)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_eye_color(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_EyeColor)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_height(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Height)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_weight(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Weight)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_address(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Address)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_city(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_City)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_state(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_State)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_postal_code(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_PostalCode)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} +} +RT_CLASS!{class MagneticStripeReaderAamvaCardDataReceivedEventArgs: IMagneticStripeReaderAamvaCardDataReceivedEventArgs} +RT_ENUM! { enum MagneticStripeReaderAuthenticationLevel: i32 { + NotSupported (MagneticStripeReaderAuthenticationLevel_NotSupported) = 0, Optional (MagneticStripeReaderAuthenticationLevel_Optional) = 1, Required (MagneticStripeReaderAuthenticationLevel_Required) = 2, +}} +RT_ENUM! { enum MagneticStripeReaderAuthenticationProtocol: i32 { + None (MagneticStripeReaderAuthenticationProtocol_None) = 0, ChallengeResponse (MagneticStripeReaderAuthenticationProtocol_ChallengeResponse) = 1, +}} +DEFINE_IID!(IID_IMagneticStripeReaderBankCardDataReceivedEventArgs, 781551651, 41754, 18275, 136, 44, 35, 114, 94, 57, 176, 142); +RT_INTERFACE!{interface IMagneticStripeReaderBankCardDataReceivedEventArgs(IMagneticStripeReaderBankCardDataReceivedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IMagneticStripeReaderBankCardDataReceivedEventArgs] { + fn get_Report(&self, out: *mut *mut MagneticStripeReaderReport) -> HRESULT, + fn get_AccountNumber(&self, out: *mut HSTRING) -> HRESULT, + fn get_ExpirationDate(&self, out: *mut HSTRING) -> HRESULT, + fn get_ServiceCode(&self, out: *mut HSTRING) -> HRESULT, + fn get_Title(&self, out: *mut HSTRING) -> HRESULT, + fn get_FirstName(&self, out: *mut HSTRING) -> HRESULT, + fn get_MiddleInitial(&self, out: *mut HSTRING) -> HRESULT, + fn get_Surname(&self, out: *mut HSTRING) -> HRESULT, + fn get_Suffix(&self, out: *mut HSTRING) -> HRESULT +}} +impl IMagneticStripeReaderBankCardDataReceivedEventArgs { + #[inline] pub fn get_report(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Report)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_account_number(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_AccountNumber)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_expiration_date(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ExpirationDate)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_service_code(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ServiceCode)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_title(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Title)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_first_name(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_FirstName)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_middle_initial(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_MiddleInitial)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_surname(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Surname)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_suffix(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Suffix)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} +} +RT_CLASS!{class MagneticStripeReaderBankCardDataReceivedEventArgs: IMagneticStripeReaderBankCardDataReceivedEventArgs} +DEFINE_IID!(IID_IMagneticStripeReaderCapabilities, 1898479772, 50240, 17570, 164, 103, 70, 145, 117, 208, 40, 150); +RT_INTERFACE!{interface IMagneticStripeReaderCapabilities(IMagneticStripeReaderCapabilitiesVtbl): IInspectable(IInspectableVtbl) [IID_IMagneticStripeReaderCapabilities] { + fn get_CardAuthentication(&self, out: *mut HSTRING) -> HRESULT, + fn get_SupportedEncryptionAlgorithms(&self, out: *mut u32) -> HRESULT, + fn get_AuthenticationLevel(&self, out: *mut MagneticStripeReaderAuthenticationLevel) -> HRESULT, + fn get_IsIsoSupported(&self, out: *mut bool) -> HRESULT, + fn get_IsJisOneSupported(&self, out: *mut bool) -> HRESULT, + fn get_IsJisTwoSupported(&self, out: *mut bool) -> HRESULT, + fn get_PowerReportingType(&self, out: *mut UnifiedPosPowerReportingType) -> HRESULT, + fn get_IsStatisticsReportingSupported(&self, out: *mut bool) -> HRESULT, + fn get_IsStatisticsUpdatingSupported(&self, out: *mut bool) -> HRESULT, + fn get_IsTrackDataMaskingSupported(&self, out: *mut bool) -> HRESULT, + fn get_IsTransmitSentinelsSupported(&self, out: *mut bool) -> HRESULT +}} +impl IMagneticStripeReaderCapabilities { + #[inline] pub fn get_card_authentication(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_CardAuthentication)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_supported_encryption_algorithms(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_SupportedEncryptionAlgorithms)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_authentication_level(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_AuthenticationLevel)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_is_iso_supported(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_IsIsoSupported)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_is_jis_one_supported(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_IsJisOneSupported)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_is_jis_two_supported(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_IsJisTwoSupported)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_power_reporting_type(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_PowerReportingType)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_is_statistics_reporting_supported(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_IsStatisticsReportingSupported)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_is_statistics_updating_supported(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_IsStatisticsUpdatingSupported)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_is_track_data_masking_supported(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_IsTrackDataMaskingSupported)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_is_transmit_sentinels_supported(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_IsTransmitSentinelsSupported)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} +RT_CLASS!{class MagneticStripeReaderCapabilities: IMagneticStripeReaderCapabilities} +RT_CLASS!{static class MagneticStripeReaderCardTypes} +impl RtActivatable for MagneticStripeReaderCardTypes {} +impl MagneticStripeReaderCardTypes { + #[inline] pub fn get_unknown() -> Result { + >::get_activation_factory().get_unknown() + } + #[inline] pub fn get_bank() -> Result { + >::get_activation_factory().get_bank() + } + #[inline] pub fn get_aamva() -> Result { + >::get_activation_factory().get_aamva() + } + #[inline] pub fn get_extended_base() -> Result { + >::get_activation_factory().get_extended_base() + } +} +DEFINE_CLSID!(MagneticStripeReaderCardTypes(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,80,111,105,110,116,79,102,83,101,114,118,105,99,101,46,77,97,103,110,101,116,105,99,83,116,114,105,112,101,82,101,97,100,101,114,67,97,114,100,84,121,112,101,115,0]) [CLSID_MagneticStripeReaderCardTypes]); +DEFINE_IID!(IID_IMagneticStripeReaderCardTypesStatics, 1385114717, 10630, 18255, 132, 84, 124, 205, 5, 146, 141, 95); +RT_INTERFACE!{static interface IMagneticStripeReaderCardTypesStatics(IMagneticStripeReaderCardTypesStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IMagneticStripeReaderCardTypesStatics] { + fn get_Unknown(&self, out: *mut u32) -> HRESULT, + fn get_Bank(&self, out: *mut u32) -> HRESULT, + fn get_Aamva(&self, out: *mut u32) -> HRESULT, + fn get_ExtendedBase(&self, out: *mut u32) -> HRESULT +}} +impl IMagneticStripeReaderCardTypesStatics { + #[inline] pub fn get_unknown(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Unknown)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_bank(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Bank)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_aamva(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Aamva)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_extended_base(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_ExtendedBase)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} +RT_CLASS!{static class MagneticStripeReaderEncryptionAlgorithms} +impl RtActivatable for MagneticStripeReaderEncryptionAlgorithms {} +impl MagneticStripeReaderEncryptionAlgorithms { + #[inline] pub fn get_none() -> Result { + >::get_activation_factory().get_none() + } + #[inline] pub fn get_triple_des_dukpt() -> Result { + >::get_activation_factory().get_triple_des_dukpt() + } + #[inline] pub fn get_extended_base() -> Result { + >::get_activation_factory().get_extended_base() + } +} +DEFINE_CLSID!(MagneticStripeReaderEncryptionAlgorithms(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,80,111,105,110,116,79,102,83,101,114,118,105,99,101,46,77,97,103,110,101,116,105,99,83,116,114,105,112,101,82,101,97,100,101,114,69,110,99,114,121,112,116,105,111,110,65,108,103,111,114,105,116,104,109,115,0]) [CLSID_MagneticStripeReaderEncryptionAlgorithms]); +DEFINE_IID!(IID_IMagneticStripeReaderEncryptionAlgorithmsStatics, 1404400464, 50139, 18260, 156, 0, 65, 57, 35, 116, 161, 9); +RT_INTERFACE!{static interface IMagneticStripeReaderEncryptionAlgorithmsStatics(IMagneticStripeReaderEncryptionAlgorithmsStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IMagneticStripeReaderEncryptionAlgorithmsStatics] { + fn get_None(&self, out: *mut u32) -> HRESULT, + fn get_TripleDesDukpt(&self, out: *mut u32) -> HRESULT, + fn get_ExtendedBase(&self, out: *mut u32) -> HRESULT +}} +impl IMagneticStripeReaderEncryptionAlgorithmsStatics { + #[inline] pub fn get_none(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_None)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_triple_des_dukpt(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_TripleDesDukpt)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_extended_base(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_DeviceAuthenticationProtocol)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_ExtendedBase)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn check_health_async(&self, level: UnifiedPosHealthCheckLevel) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).CheckHealthAsync)(self as *const _ as *mut _, level, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } - }} - #[inline] pub fn claim_reader_async(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).ClaimReaderAsync)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } - }} - #[cfg(feature="windows-storage")] #[inline] pub fn retrieve_statistics_async(&self, statisticsCategories: &foundation::collections::IIterable) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).RetrieveStatisticsAsync)(self as *const _ as *mut _, statisticsCategories as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } +} +DEFINE_IID!(IID_IMagneticStripeReaderErrorOccurredEventArgs, 535689565, 11396, 16813, 183, 120, 242, 53, 106, 120, 154, 177); +RT_INTERFACE!{interface IMagneticStripeReaderErrorOccurredEventArgs(IMagneticStripeReaderErrorOccurredEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IMagneticStripeReaderErrorOccurredEventArgs] { + fn get_Track1Status(&self, out: *mut MagneticStripeReaderTrackErrorType) -> HRESULT, + fn get_Track2Status(&self, out: *mut MagneticStripeReaderTrackErrorType) -> HRESULT, + fn get_Track3Status(&self, out: *mut MagneticStripeReaderTrackErrorType) -> HRESULT, + fn get_Track4Status(&self, out: *mut MagneticStripeReaderTrackErrorType) -> HRESULT, + fn get_ErrorData(&self, out: *mut *mut UnifiedPosErrorData) -> HRESULT, + fn get_PartialInputData(&self, out: *mut *mut MagneticStripeReaderReport) -> HRESULT +}} +impl IMagneticStripeReaderErrorOccurredEventArgs { + #[inline] pub fn get_track1_status(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Track1Status)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_error_reporting_type(&self) -> Result { unsafe { + #[inline] pub fn get_track2_status(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).GetErrorReportingType)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_Track2Status)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn add_status_updated(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + #[inline] pub fn get_track3_status(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).add_StatusUpdated)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_Track3Status)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn remove_status_updated(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).remove_StatusUpdated)(self as *const _ as *mut _, token); - if hr == S_OK { Ok(()) } else { err(hr) } + #[inline] pub fn get_track4_status(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Track4Status)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} -} -RT_CLASS!{class MagneticStripeReader: IMagneticStripeReader} -impl RtActivatable for MagneticStripeReader {} -impl RtActivatable for MagneticStripeReader {} -impl MagneticStripeReader { - #[inline] pub fn get_default_async() -> Result>> { - >::get_activation_factory().get_default_async() - } - #[inline] pub fn from_id_async(deviceId: &HStringArg) -> Result>> { - >::get_activation_factory().from_id_async(deviceId) - } - #[inline] pub fn get_device_selector() -> Result { - >::get_activation_factory().get_device_selector() - } - #[inline] pub fn get_device_selector_with_connection_types(connectionTypes: PosConnectionTypes) -> Result { - >::get_activation_factory().get_device_selector_with_connection_types(connectionTypes) - } -} -DEFINE_CLSID!(MagneticStripeReader(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,80,111,105,110,116,79,102,83,101,114,118,105,99,101,46,77,97,103,110,101,116,105,99,83,116,114,105,112,101,82,101,97,100,101,114,0]) [CLSID_MagneticStripeReader]); -DEFINE_IID!(IID_IMagneticStripeReaderAamvaCardDataReceivedEventArgs, 172735825, 49942, 18704, 135, 243, 122, 98, 186, 134, 45, 49); -RT_INTERFACE!{interface IMagneticStripeReaderAamvaCardDataReceivedEventArgs(IMagneticStripeReaderAamvaCardDataReceivedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IMagneticStripeReaderAamvaCardDataReceivedEventArgs] { - fn get_Report(&self, out: *mut *mut MagneticStripeReaderReport) -> HRESULT, - fn get_LicenseNumber(&self, out: *mut HSTRING) -> HRESULT, - fn get_ExpirationDate(&self, out: *mut HSTRING) -> HRESULT, - fn get_Restrictions(&self, out: *mut HSTRING) -> HRESULT, - fn get_Class(&self, out: *mut HSTRING) -> HRESULT, - fn get_Endorsements(&self, out: *mut HSTRING) -> HRESULT, - fn get_BirthDate(&self, out: *mut HSTRING) -> HRESULT, - fn get_FirstName(&self, out: *mut HSTRING) -> HRESULT, - fn get_Surname(&self, out: *mut HSTRING) -> HRESULT, - fn get_Suffix(&self, out: *mut HSTRING) -> HRESULT, - fn get_Gender(&self, out: *mut HSTRING) -> HRESULT, - fn get_HairColor(&self, out: *mut HSTRING) -> HRESULT, - fn get_EyeColor(&self, out: *mut HSTRING) -> HRESULT, - fn get_Height(&self, out: *mut HSTRING) -> HRESULT, - fn get_Weight(&self, out: *mut HSTRING) -> HRESULT, - fn get_Address(&self, out: *mut HSTRING) -> HRESULT, - fn get_City(&self, out: *mut HSTRING) -> HRESULT, - fn get_State(&self, out: *mut HSTRING) -> HRESULT, - fn get_PostalCode(&self, out: *mut HSTRING) -> HRESULT -}} -impl IMagneticStripeReaderAamvaCardDataReceivedEventArgs { - #[inline] pub fn get_report(&self) -> Result>> { unsafe { + #[inline] pub fn get_error_data(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Report)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_ErrorData)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn get_license_number(&self) -> Result { unsafe { + #[inline] pub fn get_partial_input_data(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_LicenseNumber)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).get_PartialInputData)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn get_expiration_date(&self) -> Result { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_ExpirationDate)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } +} +RT_CLASS!{class MagneticStripeReaderErrorOccurredEventArgs: IMagneticStripeReaderErrorOccurredEventArgs} +RT_ENUM! { enum MagneticStripeReaderErrorReportingType: i32 { + CardLevel (MagneticStripeReaderErrorReportingType_CardLevel) = 0, TrackLevel (MagneticStripeReaderErrorReportingType_TrackLevel) = 1, +}} +DEFINE_IID!(IID_IMagneticStripeReaderReport, 1784373319, 39344, 16776, 190, 241, 237, 223, 121, 247, 143, 230); +RT_INTERFACE!{interface IMagneticStripeReaderReport(IMagneticStripeReaderReportVtbl): IInspectable(IInspectableVtbl) [IID_IMagneticStripeReaderReport] { + fn get_CardType(&self, out: *mut u32) -> HRESULT, + fn get_Track1(&self, out: *mut *mut MagneticStripeReaderTrackData) -> HRESULT, + fn get_Track2(&self, out: *mut *mut MagneticStripeReaderTrackData) -> HRESULT, + fn get_Track3(&self, out: *mut *mut MagneticStripeReaderTrackData) -> HRESULT, + fn get_Track4(&self, out: *mut *mut MagneticStripeReaderTrackData) -> HRESULT, + fn get_Properties(&self, out: *mut *mut foundation::collections::IMapView) -> HRESULT, + #[cfg(feature="windows-storage")] fn get_CardAuthenticationData(&self, out: *mut *mut super::super::storage::streams::IBuffer) -> HRESULT, + fn get_CardAuthenticationDataLength(&self, out: *mut u32) -> HRESULT, + #[cfg(feature="windows-storage")] fn get_AdditionalSecurityInformation(&self, out: *mut *mut super::super::storage::streams::IBuffer) -> HRESULT +}} +impl IMagneticStripeReaderReport { + #[inline] pub fn get_card_type(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_CardType)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_restrictions(&self) -> Result { unsafe { + #[inline] pub fn get_track1(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Restrictions)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).get_Track1)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn get_class(&self) -> Result { unsafe { + #[inline] pub fn get_track2(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Class)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).get_Track2)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn get_endorsements(&self) -> Result { unsafe { + #[inline] pub fn get_track3(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Endorsements)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).get_Track3)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn get_birth_date(&self) -> Result { unsafe { + #[inline] pub fn get_track4(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_BirthDate)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).get_Track4)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn get_first_name(&self) -> Result { unsafe { + #[inline] pub fn get_properties(&self) -> Result>>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_FirstName)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).get_Properties)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn get_surname(&self) -> Result { unsafe { + #[cfg(feature="windows-storage")] #[inline] pub fn get_card_authentication_data(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Surname)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).get_CardAuthenticationData)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn get_suffix(&self) -> Result { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Suffix)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + #[inline] pub fn get_card_authentication_data_length(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_CardAuthenticationDataLength)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_gender(&self) -> Result { unsafe { + #[cfg(feature="windows-storage")] #[inline] pub fn get_additional_security_information(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Gender)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).get_AdditionalSecurityInformation)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn get_hair_color(&self) -> Result { unsafe { +} +RT_CLASS!{class MagneticStripeReaderReport: IMagneticStripeReaderReport} +DEFINE_IID!(IID_IMagneticStripeReaderStatics, 3294604106, 61399, 18272, 165, 206, 21, 176, 228, 126, 148, 235); +RT_INTERFACE!{static interface IMagneticStripeReaderStatics(IMagneticStripeReaderStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IMagneticStripeReaderStatics] { + fn GetDefaultAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn FromIdAsync(&self, deviceId: HSTRING, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn GetDeviceSelector(&self, out: *mut HSTRING) -> HRESULT +}} +impl IMagneticStripeReaderStatics { + #[inline] pub fn get_default_async(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_HairColor)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).GetDefaultAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_eye_color(&self) -> Result { unsafe { + #[inline] pub fn from_id_async(&self, deviceId: &HStringArg) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_EyeColor)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).FromIdAsync)(self as *const _ as *mut _, deviceId.get(), &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_height(&self) -> Result { unsafe { + #[inline] pub fn get_device_selector(&self) -> Result { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Height)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).GetDeviceSelector)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_weight(&self) -> Result { unsafe { +} +DEFINE_IID!(IID_IMagneticStripeReaderStatics2, 2360197986, 54887, 18682, 134, 188, 245, 174, 17, 137, 38, 43); +RT_INTERFACE!{static interface IMagneticStripeReaderStatics2(IMagneticStripeReaderStatics2Vtbl): IInspectable(IInspectableVtbl) [IID_IMagneticStripeReaderStatics2] { + fn GetDeviceSelectorWithConnectionTypes(&self, connectionTypes: PosConnectionTypes, out: *mut HSTRING) -> HRESULT +}} +impl IMagneticStripeReaderStatics2 { + #[inline] pub fn get_device_selector_with_connection_types(&self, connectionTypes: PosConnectionTypes) -> Result { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Weight)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).GetDeviceSelectorWithConnectionTypes)(self as *const _ as *mut _, connectionTypes, &mut out); if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_address(&self) -> Result { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Address)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } +} +RT_ENUM! { enum MagneticStripeReaderStatus: i32 { + Unauthenticated (MagneticStripeReaderStatus_Unauthenticated) = 0, Authenticated (MagneticStripeReaderStatus_Authenticated) = 1, Extended (MagneticStripeReaderStatus_Extended) = 2, +}} +DEFINE_IID!(IID_IMagneticStripeReaderStatusUpdatedEventArgs, 164391856, 12898, 16413, 158, 138, 232, 13, 99, 88, 144, 107); +RT_INTERFACE!{interface IMagneticStripeReaderStatusUpdatedEventArgs(IMagneticStripeReaderStatusUpdatedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IMagneticStripeReaderStatusUpdatedEventArgs] { + fn get_Status(&self, out: *mut MagneticStripeReaderStatus) -> HRESULT, + fn get_ExtendedStatus(&self, out: *mut u32) -> HRESULT +}} +impl IMagneticStripeReaderStatusUpdatedEventArgs { + #[inline] pub fn get_status(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Status)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_city(&self) -> Result { unsafe { + #[inline] pub fn get_extended_status(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_ExtendedStatus)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} +RT_CLASS!{class MagneticStripeReaderStatusUpdatedEventArgs: IMagneticStripeReaderStatusUpdatedEventArgs} +DEFINE_IID!(IID_IMagneticStripeReaderTrackData, 273479281, 19101, 17518, 171, 197, 32, 64, 35, 7, 186, 54); +RT_INTERFACE!{interface IMagneticStripeReaderTrackData(IMagneticStripeReaderTrackDataVtbl): IInspectable(IInspectableVtbl) [IID_IMagneticStripeReaderTrackData] { + #[cfg(feature="windows-storage")] fn get_Data(&self, out: *mut *mut super::super::storage::streams::IBuffer) -> HRESULT, + #[cfg(feature="windows-storage")] fn get_DiscretionaryData(&self, out: *mut *mut super::super::storage::streams::IBuffer) -> HRESULT, + #[cfg(feature="windows-storage")] fn get_EncryptedData(&self, out: *mut *mut super::super::storage::streams::IBuffer) -> HRESULT +}} +impl IMagneticStripeReaderTrackData { + #[cfg(feature="windows-storage")] #[inline] pub fn get_data(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_City)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).get_Data)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn get_state(&self) -> Result { unsafe { + #[cfg(feature="windows-storage")] #[inline] pub fn get_discretionary_data(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_State)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).get_DiscretionaryData)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn get_postal_code(&self) -> Result { unsafe { + #[cfg(feature="windows-storage")] #[inline] pub fn get_encrypted_data(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_PostalCode)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).get_EncryptedData)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } -RT_CLASS!{class MagneticStripeReaderAamvaCardDataReceivedEventArgs: IMagneticStripeReaderAamvaCardDataReceivedEventArgs} -RT_ENUM! { enum MagneticStripeReaderAuthenticationLevel: i32 { - NotSupported (MagneticStripeReaderAuthenticationLevel_NotSupported) = 0, Optional (MagneticStripeReaderAuthenticationLevel_Optional) = 1, Required (MagneticStripeReaderAuthenticationLevel_Required) = 2, +RT_CLASS!{class MagneticStripeReaderTrackData: IMagneticStripeReaderTrackData} +RT_ENUM! { enum MagneticStripeReaderTrackErrorType: i32 { + None (MagneticStripeReaderTrackErrorType_None) = 0, StartSentinelError (MagneticStripeReaderTrackErrorType_StartSentinelError) = 1, EndSentinelError (MagneticStripeReaderTrackErrorType_EndSentinelError) = 2, ParityError (MagneticStripeReaderTrackErrorType_ParityError) = 3, LrcError (MagneticStripeReaderTrackErrorType_LrcError) = 4, Unknown (MagneticStripeReaderTrackErrorType_Unknown) = -1, }} -RT_ENUM! { enum MagneticStripeReaderAuthenticationProtocol: i32 { - None (MagneticStripeReaderAuthenticationProtocol_None) = 0, ChallengeResponse (MagneticStripeReaderAuthenticationProtocol_ChallengeResponse) = 1, +RT_ENUM! { enum MagneticStripeReaderTrackIds: i32 { + None (MagneticStripeReaderTrackIds_None) = 0, Track1 (MagneticStripeReaderTrackIds_Track1) = 1, Track2 (MagneticStripeReaderTrackIds_Track2) = 2, Track3 (MagneticStripeReaderTrackIds_Track3) = 4, Track4 (MagneticStripeReaderTrackIds_Track4) = 8, }} -DEFINE_IID!(IID_IMagneticStripeReaderBankCardDataReceivedEventArgs, 781551651, 41754, 18275, 136, 44, 35, 114, 94, 57, 176, 142); -RT_INTERFACE!{interface IMagneticStripeReaderBankCardDataReceivedEventArgs(IMagneticStripeReaderBankCardDataReceivedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IMagneticStripeReaderBankCardDataReceivedEventArgs] { - fn get_Report(&self, out: *mut *mut MagneticStripeReaderReport) -> HRESULT, - fn get_AccountNumber(&self, out: *mut HSTRING) -> HRESULT, - fn get_ExpirationDate(&self, out: *mut HSTRING) -> HRESULT, - fn get_ServiceCode(&self, out: *mut HSTRING) -> HRESULT, - fn get_Title(&self, out: *mut HSTRING) -> HRESULT, - fn get_FirstName(&self, out: *mut HSTRING) -> HRESULT, - fn get_MiddleInitial(&self, out: *mut HSTRING) -> HRESULT, - fn get_Surname(&self, out: *mut HSTRING) -> HRESULT, - fn get_Suffix(&self, out: *mut HSTRING) -> HRESULT +DEFINE_IID!(IID_IMagneticStripeReaderVendorSpecificCardDataReceivedEventArgs, 2936689940, 22988, 19040, 153, 232, 153, 165, 61, 172, 229, 170); +RT_INTERFACE!{interface IMagneticStripeReaderVendorSpecificCardDataReceivedEventArgs(IMagneticStripeReaderVendorSpecificCardDataReceivedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IMagneticStripeReaderVendorSpecificCardDataReceivedEventArgs] { + fn get_Report(&self, out: *mut *mut MagneticStripeReaderReport) -> HRESULT }} -impl IMagneticStripeReaderBankCardDataReceivedEventArgs { +impl IMagneticStripeReaderVendorSpecificCardDataReceivedEventArgs { #[inline] pub fn get_report(&self) -> Result>> { unsafe { let mut out = null_mut(); let hr = ((*self.lpVtbl).get_Report)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn get_account_number(&self) -> Result { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_AccountNumber)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } - }} - #[inline] pub fn get_expiration_date(&self) -> Result { unsafe { +} +RT_CLASS!{class MagneticStripeReaderVendorSpecificCardDataReceivedEventArgs: IMagneticStripeReaderVendorSpecificCardDataReceivedEventArgs} +RT_ENUM! { enum PosConnectionTypes: u32 { + Local (PosConnectionTypes_Local) = 1, IP (PosConnectionTypes_IP) = 2, Bluetooth (PosConnectionTypes_Bluetooth) = 4, All (PosConnectionTypes_All) = 4294967295, +}} +DEFINE_IID!(IID_IPosPrinter, 704889102, 39449, 18945, 153, 79, 18, 223, 173, 106, 220, 191); +RT_INTERFACE!{interface IPosPrinter(IPosPrinterVtbl): IInspectable(IInspectableVtbl) [IID_IPosPrinter] { + fn get_DeviceId(&self, out: *mut HSTRING) -> HRESULT, + fn get_Capabilities(&self, out: *mut *mut PosPrinterCapabilities) -> HRESULT, + fn get_SupportedCharacterSets(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT, + fn get_SupportedTypeFaces(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT, + fn get_Status(&self, out: *mut *mut PosPrinterStatus) -> HRESULT, + fn ClaimPrinterAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn CheckHealthAsync(&self, level: UnifiedPosHealthCheckLevel, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn GetStatisticsAsync(&self, statisticsCategories: *mut foundation::collections::IIterable, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn add_StatusUpdated(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_StatusUpdated(&self, token: foundation::EventRegistrationToken) -> HRESULT +}} +impl IPosPrinter { + #[inline] pub fn get_device_id(&self) -> Result { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_ExpirationDate)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_DeviceId)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_service_code(&self) -> Result { unsafe { + #[inline] pub fn get_capabilities(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_ServiceCode)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).get_Capabilities)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn get_title(&self) -> Result { unsafe { + #[inline] pub fn get_supported_character_sets(&self) -> Result>>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Title)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).get_SupportedCharacterSets)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn get_first_name(&self) -> Result { unsafe { + #[inline] pub fn get_supported_type_faces(&self) -> Result>>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_FirstName)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).get_SupportedTypeFaces)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn get_middle_initial(&self) -> Result { unsafe { + #[inline] pub fn get_status(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_MiddleInitial)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).get_Status)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn get_surname(&self) -> Result { unsafe { + #[inline] pub fn claim_printer_async(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Surname)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).ClaimPrinterAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_suffix(&self) -> Result { unsafe { + #[inline] pub fn check_health_async(&self, level: UnifiedPosHealthCheckLevel) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Suffix)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).CheckHealthAsync)(self as *const _ as *mut _, level, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} -} -RT_CLASS!{class MagneticStripeReaderBankCardDataReceivedEventArgs: IMagneticStripeReaderBankCardDataReceivedEventArgs} -DEFINE_IID!(IID_IMagneticStripeReaderCapabilities, 1898479772, 50240, 17570, 164, 103, 70, 145, 117, 208, 40, 150); -RT_INTERFACE!{interface IMagneticStripeReaderCapabilities(IMagneticStripeReaderCapabilitiesVtbl): IInspectable(IInspectableVtbl) [IID_IMagneticStripeReaderCapabilities] { - fn get_CardAuthentication(&self, out: *mut HSTRING) -> HRESULT, - fn get_SupportedEncryptionAlgorithms(&self, out: *mut u32) -> HRESULT, - fn get_AuthenticationLevel(&self, out: *mut MagneticStripeReaderAuthenticationLevel) -> HRESULT, - fn get_IsIsoSupported(&self, out: *mut bool) -> HRESULT, - fn get_IsJisOneSupported(&self, out: *mut bool) -> HRESULT, - fn get_IsJisTwoSupported(&self, out: *mut bool) -> HRESULT, - fn get_PowerReportingType(&self, out: *mut UnifiedPosPowerReportingType) -> HRESULT, - fn get_IsStatisticsReportingSupported(&self, out: *mut bool) -> HRESULT, - fn get_IsStatisticsUpdatingSupported(&self, out: *mut bool) -> HRESULT, - fn get_IsTrackDataMaskingSupported(&self, out: *mut bool) -> HRESULT, - fn get_IsTransmitSentinelsSupported(&self, out: *mut bool) -> HRESULT -}} -impl IMagneticStripeReaderCapabilities { - #[inline] pub fn get_card_authentication(&self) -> Result { unsafe { + #[inline] pub fn get_statistics_async(&self, statisticsCategories: &foundation::collections::IIterable) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_CardAuthentication)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } - }} - #[inline] pub fn get_supported_encryption_algorithms(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_SupportedEncryptionAlgorithms)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } - }} - #[inline] pub fn get_authentication_level(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_AuthenticationLevel)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } - }} - #[inline] pub fn get_is_iso_supported(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_IsIsoSupported)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } - }} - #[inline] pub fn get_is_jis_one_supported(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_IsJisOneSupported)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } - }} - #[inline] pub fn get_is_jis_two_supported(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_IsJisTwoSupported)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } - }} - #[inline] pub fn get_power_reporting_type(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_PowerReportingType)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } - }} - #[inline] pub fn get_is_statistics_reporting_supported(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_IsStatisticsReportingSupported)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } - }} - #[inline] pub fn get_is_statistics_updating_supported(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_IsStatisticsUpdatingSupported)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } + let hr = ((*self.lpVtbl).GetStatisticsAsync)(self as *const _ as *mut _, statisticsCategories as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_is_track_data_masking_supported(&self) -> Result { unsafe { + #[inline] pub fn add_status_updated(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_IsTrackDataMaskingSupported)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).add_StatusUpdated)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_is_transmit_sentinels_supported(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_IsTransmitSentinelsSupported)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } + #[inline] pub fn remove_status_updated(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_StatusUpdated)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } }} } -RT_CLASS!{class MagneticStripeReaderCapabilities: IMagneticStripeReaderCapabilities} -RT_CLASS!{static class MagneticStripeReaderCardTypes} -impl RtActivatable for MagneticStripeReaderCardTypes {} -impl MagneticStripeReaderCardTypes { - #[inline] pub fn get_unknown() -> Result { - >::get_activation_factory().get_unknown() +RT_CLASS!{class PosPrinter: IPosPrinter} +impl RtActivatable for PosPrinter {} +impl RtActivatable for PosPrinter {} +impl PosPrinter { + #[inline] pub fn get_default_async() -> Result>> { + >::get_activation_factory().get_default_async() } - #[inline] pub fn get_bank() -> Result { - >::get_activation_factory().get_bank() + #[inline] pub fn from_id_async(deviceId: &HStringArg) -> Result>> { + >::get_activation_factory().from_id_async(deviceId) } - #[inline] pub fn get_aamva() -> Result { - >::get_activation_factory().get_aamva() + #[inline] pub fn get_device_selector() -> Result { + >::get_activation_factory().get_device_selector() } - #[inline] pub fn get_extended_base() -> Result { - >::get_activation_factory().get_extended_base() + #[inline] pub fn get_device_selector_with_connection_types(connectionTypes: PosConnectionTypes) -> Result { + >::get_activation_factory().get_device_selector_with_connection_types(connectionTypes) } } -DEFINE_CLSID!(MagneticStripeReaderCardTypes(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,80,111,105,110,116,79,102,83,101,114,118,105,99,101,46,77,97,103,110,101,116,105,99,83,116,114,105,112,101,82,101,97,100,101,114,67,97,114,100,84,121,112,101,115,0]) [CLSID_MagneticStripeReaderCardTypes]); -DEFINE_IID!(IID_IMagneticStripeReaderCardTypesStatics, 1385114717, 10630, 18255, 132, 84, 124, 205, 5, 146, 141, 95); -RT_INTERFACE!{static interface IMagneticStripeReaderCardTypesStatics(IMagneticStripeReaderCardTypesStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IMagneticStripeReaderCardTypesStatics] { - fn get_Unknown(&self, out: *mut u32) -> HRESULT, - fn get_Bank(&self, out: *mut u32) -> HRESULT, - fn get_Aamva(&self, out: *mut u32) -> HRESULT, - fn get_ExtendedBase(&self, out: *mut u32) -> HRESULT +DEFINE_CLSID!(PosPrinter(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,80,111,105,110,116,79,102,83,101,114,118,105,99,101,46,80,111,115,80,114,105,110,116,101,114,0]) [CLSID_PosPrinter]); +RT_ENUM! { enum PosPrinterAlignment: i32 { + Left (PosPrinterAlignment_Left) = 0, Center (PosPrinterAlignment_Center) = 1, Right (PosPrinterAlignment_Right) = 2, }} -impl IMagneticStripeReaderCardTypesStatics { - #[inline] pub fn get_unknown(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_Unknown)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } - }} - #[inline] pub fn get_bank(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_Bank)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } - }} - #[inline] pub fn get_aamva(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_Aamva)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } - }} - #[inline] pub fn get_extended_base(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_ExtendedBase)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } - }} -} -RT_CLASS!{static class MagneticStripeReaderEncryptionAlgorithms} -impl RtActivatable for MagneticStripeReaderEncryptionAlgorithms {} -impl MagneticStripeReaderEncryptionAlgorithms { - #[inline] pub fn get_none() -> Result { - >::get_activation_factory().get_none() - } - #[inline] pub fn get_triple_des_dukpt() -> Result { - >::get_activation_factory().get_triple_des_dukpt() - } - #[inline] pub fn get_extended_base() -> Result { - >::get_activation_factory().get_extended_base() - } -} -DEFINE_CLSID!(MagneticStripeReaderEncryptionAlgorithms(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,80,111,105,110,116,79,102,83,101,114,118,105,99,101,46,77,97,103,110,101,116,105,99,83,116,114,105,112,101,82,101,97,100,101,114,69,110,99,114,121,112,116,105,111,110,65,108,103,111,114,105,116,104,109,115,0]) [CLSID_MagneticStripeReaderEncryptionAlgorithms]); -DEFINE_IID!(IID_IMagneticStripeReaderEncryptionAlgorithmsStatics, 1404400464, 50139, 18260, 156, 0, 65, 57, 35, 116, 161, 9); -RT_INTERFACE!{static interface IMagneticStripeReaderEncryptionAlgorithmsStatics(IMagneticStripeReaderEncryptionAlgorithmsStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IMagneticStripeReaderEncryptionAlgorithmsStatics] { - fn get_None(&self, out: *mut u32) -> HRESULT, - fn get_TripleDesDukpt(&self, out: *mut u32) -> HRESULT, - fn get_ExtendedBase(&self, out: *mut u32) -> HRESULT +RT_ENUM! { enum PosPrinterBarcodeTextPosition: i32 { + None (PosPrinterBarcodeTextPosition_None) = 0, Above (PosPrinterBarcodeTextPosition_Above) = 1, Below (PosPrinterBarcodeTextPosition_Below) = 2, +}} +DEFINE_IID!(IID_IPosPrinterCapabilities, 3454621473, 17280, 18821, 173, 197, 57, 219, 48, 205, 147, 188); +RT_INTERFACE!{interface IPosPrinterCapabilities(IPosPrinterCapabilitiesVtbl): IInspectable(IInspectableVtbl) [IID_IPosPrinterCapabilities] { + fn get_PowerReportingType(&self, out: *mut UnifiedPosPowerReportingType) -> HRESULT, + fn get_IsStatisticsReportingSupported(&self, out: *mut bool) -> HRESULT, + fn get_IsStatisticsUpdatingSupported(&self, out: *mut bool) -> HRESULT, + fn get_DefaultCharacterSet(&self, out: *mut u32) -> HRESULT, + fn get_HasCoverSensor(&self, out: *mut bool) -> HRESULT, + fn get_CanMapCharacterSet(&self, out: *mut bool) -> HRESULT, + fn get_IsTransactionSupported(&self, out: *mut bool) -> HRESULT, + fn get_Receipt(&self, out: *mut *mut ReceiptPrinterCapabilities) -> HRESULT, + fn get_Slip(&self, out: *mut *mut SlipPrinterCapabilities) -> HRESULT, + fn get_Journal(&self, out: *mut *mut JournalPrinterCapabilities) -> HRESULT }} -impl IMagneticStripeReaderEncryptionAlgorithmsStatics { - #[inline] pub fn get_none(&self) -> Result { unsafe { +impl IPosPrinterCapabilities { + #[inline] pub fn get_power_reporting_type(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_None)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_PowerReportingType)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_triple_des_dukpt(&self) -> Result { unsafe { + #[inline] pub fn get_is_statistics_reporting_supported(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_TripleDesDukpt)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_IsStatisticsReportingSupported)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_extended_base(&self) -> Result { unsafe { + #[inline] pub fn get_is_statistics_updating_supported(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_ExtendedBase)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_IsStatisticsUpdatingSupported)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} -} -DEFINE_IID!(IID_IMagneticStripeReaderErrorOccurredEventArgs, 535689565, 11396, 16813, 183, 120, 242, 53, 106, 120, 154, 177); -RT_INTERFACE!{interface IMagneticStripeReaderErrorOccurredEventArgs(IMagneticStripeReaderErrorOccurredEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IMagneticStripeReaderErrorOccurredEventArgs] { - fn get_Track1Status(&self, out: *mut MagneticStripeReaderTrackErrorType) -> HRESULT, - fn get_Track2Status(&self, out: *mut MagneticStripeReaderTrackErrorType) -> HRESULT, - fn get_Track3Status(&self, out: *mut MagneticStripeReaderTrackErrorType) -> HRESULT, - fn get_Track4Status(&self, out: *mut MagneticStripeReaderTrackErrorType) -> HRESULT, - fn get_ErrorData(&self, out: *mut *mut UnifiedPosErrorData) -> HRESULT, - fn get_PartialInputData(&self, out: *mut *mut MagneticStripeReaderReport) -> HRESULT -}} -impl IMagneticStripeReaderErrorOccurredEventArgs { - #[inline] pub fn get_track1_status(&self) -> Result { unsafe { + #[inline] pub fn get_default_character_set(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_Track1Status)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_DefaultCharacterSet)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_track2_status(&self) -> Result { unsafe { + #[inline] pub fn get_has_cover_sensor(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_Track2Status)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_HasCoverSensor)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_track3_status(&self) -> Result { unsafe { + #[inline] pub fn get_can_map_character_set(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_Track3Status)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_CanMapCharacterSet)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_track4_status(&self) -> Result { unsafe { + #[inline] pub fn get_is_transaction_supported(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_Track4Status)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_IsTransactionSupported)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_error_data(&self) -> Result>> { unsafe { + #[inline] pub fn get_receipt(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_ErrorData)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_Receipt)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn get_partial_input_data(&self) -> Result>> { unsafe { + #[inline] pub fn get_slip(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_PartialInputData)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_Slip)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_journal(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Journal)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } -RT_CLASS!{class MagneticStripeReaderErrorOccurredEventArgs: IMagneticStripeReaderErrorOccurredEventArgs} -RT_ENUM! { enum MagneticStripeReaderErrorReportingType: i32 { - CardLevel (MagneticStripeReaderErrorReportingType_CardLevel) = 0, TrackLevel (MagneticStripeReaderErrorReportingType_TrackLevel) = 1, +RT_CLASS!{class PosPrinterCapabilities: IPosPrinterCapabilities} +RT_ENUM! { enum PosPrinterCartridgeSensors: u32 { + None (PosPrinterCartridgeSensors_None) = 0, Removed (PosPrinterCartridgeSensors_Removed) = 1, Empty (PosPrinterCartridgeSensors_Empty) = 2, HeadCleaning (PosPrinterCartridgeSensors_HeadCleaning) = 4, NearEnd (PosPrinterCartridgeSensors_NearEnd) = 8, }} -DEFINE_IID!(IID_IMagneticStripeReaderReport, 1784373319, 39344, 16776, 190, 241, 237, 223, 121, 247, 143, 230); -RT_INTERFACE!{interface IMagneticStripeReaderReport(IMagneticStripeReaderReportVtbl): IInspectable(IInspectableVtbl) [IID_IMagneticStripeReaderReport] { - fn get_CardType(&self, out: *mut u32) -> HRESULT, - fn get_Track1(&self, out: *mut *mut MagneticStripeReaderTrackData) -> HRESULT, - fn get_Track2(&self, out: *mut *mut MagneticStripeReaderTrackData) -> HRESULT, - fn get_Track3(&self, out: *mut *mut MagneticStripeReaderTrackData) -> HRESULT, - fn get_Track4(&self, out: *mut *mut MagneticStripeReaderTrackData) -> HRESULT, - fn get_Properties(&self, out: *mut *mut foundation::collections::IMapView) -> HRESULT, - #[cfg(feature="windows-storage")] fn get_CardAuthenticationData(&self, out: *mut *mut super::super::storage::streams::IBuffer) -> HRESULT, - fn get_CardAuthenticationDataLength(&self, out: *mut u32) -> HRESULT, - #[cfg(feature="windows-storage")] fn get_AdditionalSecurityInformation(&self, out: *mut *mut super::super::storage::streams::IBuffer) -> HRESULT +RT_CLASS!{static class PosPrinterCharacterSetIds} +impl RtActivatable for PosPrinterCharacterSetIds {} +impl PosPrinterCharacterSetIds { + #[inline] pub fn get_utf16_le() -> Result { + >::get_activation_factory().get_utf16_le() + } + #[inline] pub fn get_ascii() -> Result { + >::get_activation_factory().get_ascii() + } + #[inline] pub fn get_ansi() -> Result { + >::get_activation_factory().get_ansi() + } +} +DEFINE_CLSID!(PosPrinterCharacterSetIds(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,80,111,105,110,116,79,102,83,101,114,118,105,99,101,46,80,111,115,80,114,105,110,116,101,114,67,104,97,114,97,99,116,101,114,83,101,116,73,100,115,0]) [CLSID_PosPrinterCharacterSetIds]); +DEFINE_IID!(IID_IPosPrinterCharacterSetIdsStatics, 1550884607, 28826, 20455, 178, 21, 6, 167, 72, 163, 139, 57); +RT_INTERFACE!{static interface IPosPrinterCharacterSetIdsStatics(IPosPrinterCharacterSetIdsStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IPosPrinterCharacterSetIdsStatics] { + fn get_Utf16LE(&self, out: *mut u32) -> HRESULT, + fn get_Ascii(&self, out: *mut u32) -> HRESULT, + fn get_Ansi(&self, out: *mut u32) -> HRESULT }} -impl IMagneticStripeReaderReport { - #[inline] pub fn get_card_type(&self) -> Result { unsafe { +impl IPosPrinterCharacterSetIdsStatics { + #[inline] pub fn get_utf16_le(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_CardType)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_Utf16LE)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_track1(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Track1)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } - }} - #[inline] pub fn get_track2(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Track2)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } - }} - #[inline] pub fn get_track3(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Track3)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + #[inline] pub fn get_ascii(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Ascii)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_track4(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Track4)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + #[inline] pub fn get_ansi(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Ansi)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_properties(&self) -> Result>>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Properties)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } +} +RT_ENUM! { enum PosPrinterColorCapabilities: u32 { + None (PosPrinterColorCapabilities_None) = 0, Primary (PosPrinterColorCapabilities_Primary) = 1, Custom1 (PosPrinterColorCapabilities_Custom1) = 2, Custom2 (PosPrinterColorCapabilities_Custom2) = 4, Custom3 (PosPrinterColorCapabilities_Custom3) = 8, Custom4 (PosPrinterColorCapabilities_Custom4) = 16, Custom5 (PosPrinterColorCapabilities_Custom5) = 32, Custom6 (PosPrinterColorCapabilities_Custom6) = 64, Cyan (PosPrinterColorCapabilities_Cyan) = 128, Magenta (PosPrinterColorCapabilities_Magenta) = 256, Yellow (PosPrinterColorCapabilities_Yellow) = 512, Full (PosPrinterColorCapabilities_Full) = 1024, +}} +RT_ENUM! { enum PosPrinterColorCartridge: i32 { + Unknown (PosPrinterColorCartridge_Unknown) = 0, Primary (PosPrinterColorCartridge_Primary) = 1, Custom1 (PosPrinterColorCartridge_Custom1) = 2, Custom2 (PosPrinterColorCartridge_Custom2) = 3, Custom3 (PosPrinterColorCartridge_Custom3) = 4, Custom4 (PosPrinterColorCartridge_Custom4) = 5, Custom5 (PosPrinterColorCartridge_Custom5) = 6, Custom6 (PosPrinterColorCartridge_Custom6) = 7, Cyan (PosPrinterColorCartridge_Cyan) = 8, Magenta (PosPrinterColorCartridge_Magenta) = 9, Yellow (PosPrinterColorCartridge_Yellow) = 10, +}} +DEFINE_IID!(IID_IPosPrinterJob, 2593390684, 1557, 17809, 165, 143, 48, 248, 126, 223, 226, 228); +RT_INTERFACE!{interface IPosPrinterJob(IPosPrinterJobVtbl): IInspectable(IInspectableVtbl) [IID_IPosPrinterJob] { + fn Print(&self, data: HSTRING) -> HRESULT, + fn PrintLine(&self, data: HSTRING) -> HRESULT, + fn PrintNewline(&self) -> HRESULT, + fn ExecuteAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT +}} +impl IPosPrinterJob { + #[inline] pub fn print(&self, data: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).Print)(self as *const _ as *mut _, data.get()); + if hr == S_OK { Ok(()) } else { err(hr) } }} - #[cfg(feature="windows-storage")] #[inline] pub fn get_card_authentication_data(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_CardAuthenticationData)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + #[inline] pub fn print_line(&self, data: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).PrintLine)(self as *const _ as *mut _, data.get()); + if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_card_authentication_data_length(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_CardAuthenticationDataLength)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } + #[inline] pub fn print_newline(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).PrintNewline)(self as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } }} - #[cfg(feature="windows-storage")] #[inline] pub fn get_additional_security_information(&self) -> Result>> { unsafe { + #[inline] pub fn execute_async(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_AdditionalSecurityInformation)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).ExecuteAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } -RT_CLASS!{class MagneticStripeReaderReport: IMagneticStripeReaderReport} -DEFINE_IID!(IID_IMagneticStripeReaderStatics, 3294604106, 61399, 18272, 165, 206, 21, 176, 228, 126, 148, 235); -RT_INTERFACE!{static interface IMagneticStripeReaderStatics(IMagneticStripeReaderStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IMagneticStripeReaderStatics] { - fn GetDefaultAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, - fn FromIdAsync(&self, deviceId: HSTRING, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, +RT_ENUM! { enum PosPrinterLineDirection: i32 { + Horizontal (PosPrinterLineDirection_Horizontal) = 0, Vertical (PosPrinterLineDirection_Vertical) = 1, +}} +RT_ENUM! { enum PosPrinterLineStyle: i32 { + SingleSolid (PosPrinterLineStyle_SingleSolid) = 0, DoubleSolid (PosPrinterLineStyle_DoubleSolid) = 1, Broken (PosPrinterLineStyle_Broken) = 2, Chain (PosPrinterLineStyle_Chain) = 3, +}} +RT_ENUM! { enum PosPrinterMapMode: i32 { + Dots (PosPrinterMapMode_Dots) = 0, Twips (PosPrinterMapMode_Twips) = 1, English (PosPrinterMapMode_English) = 2, Metric (PosPrinterMapMode_Metric) = 3, +}} +RT_ENUM! { enum PosPrinterMarkFeedCapabilities: u32 { + None (PosPrinterMarkFeedCapabilities_None) = 0, ToTakeUp (PosPrinterMarkFeedCapabilities_ToTakeUp) = 1, ToCutter (PosPrinterMarkFeedCapabilities_ToCutter) = 2, ToCurrentTopOfForm (PosPrinterMarkFeedCapabilities_ToCurrentTopOfForm) = 4, ToNextTopOfForm (PosPrinterMarkFeedCapabilities_ToNextTopOfForm) = 8, +}} +RT_ENUM! { enum PosPrinterMarkFeedKind: i32 { + ToTakeUp (PosPrinterMarkFeedKind_ToTakeUp) = 0, ToCutter (PosPrinterMarkFeedKind_ToCutter) = 1, ToCurrentTopOfForm (PosPrinterMarkFeedKind_ToCurrentTopOfForm) = 2, ToNextTopOfForm (PosPrinterMarkFeedKind_ToNextTopOfForm) = 3, +}} +RT_ENUM! { enum PosPrinterPrintSide: i32 { + Unknown (PosPrinterPrintSide_Unknown) = 0, Side1 (PosPrinterPrintSide_Side1) = 1, Side2 (PosPrinterPrintSide_Side2) = 2, +}} +DEFINE_IID!(IID_IPosPrinterReleaseDeviceRequestedEventArgs, 734765913, 7407, 16562, 158, 203, 249, 39, 248, 86, 174, 60); +RT_INTERFACE!{interface IPosPrinterReleaseDeviceRequestedEventArgs(IPosPrinterReleaseDeviceRequestedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IPosPrinterReleaseDeviceRequestedEventArgs] { + +}} +RT_CLASS!{class PosPrinterReleaseDeviceRequestedEventArgs: IPosPrinterReleaseDeviceRequestedEventArgs} +RT_ENUM! { enum PosPrinterRotation: i32 { + Normal (PosPrinterRotation_Normal) = 0, Right90 (PosPrinterRotation_Right90) = 1, Left90 (PosPrinterRotation_Left90) = 2, Rotate180 (PosPrinterRotation_Rotate180) = 3, +}} +RT_ENUM! { enum PosPrinterRuledLineCapabilities: u32 { + None (PosPrinterRuledLineCapabilities_None) = 0, Horizontal (PosPrinterRuledLineCapabilities_Horizontal) = 1, Vertical (PosPrinterRuledLineCapabilities_Vertical) = 2, +}} +DEFINE_IID!(IID_IPosPrinterStatics, 2363544810, 4911, 19679, 166, 74, 45, 13, 124, 150, 168, 91); +RT_INTERFACE!{static interface IPosPrinterStatics(IPosPrinterStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IPosPrinterStatics] { + fn GetDefaultAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn FromIdAsync(&self, deviceId: HSTRING, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, fn GetDeviceSelector(&self, out: *mut HSTRING) -> HRESULT }} -impl IMagneticStripeReaderStatics { - #[inline] pub fn get_default_async(&self) -> Result>> { unsafe { +impl IPosPrinterStatics { + #[inline] pub fn get_default_async(&self) -> Result>> { unsafe { let mut out = null_mut(); let hr = ((*self.lpVtbl).GetDefaultAsync)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn from_id_async(&self, deviceId: &HStringArg) -> Result>> { unsafe { + #[inline] pub fn from_id_async(&self, deviceId: &HStringArg) -> Result>> { unsafe { let mut out = null_mut(); let hr = ((*self.lpVtbl).FromIdAsync)(self as *const _ as *mut _, deviceId.get(), &mut out); if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } @@ -22241,591 +23186,805 @@ impl IMagneticStripeReaderStatics { if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} } -DEFINE_IID!(IID_IMagneticStripeReaderStatics2, 2360197986, 54887, 18682, 134, 188, 245, 174, 17, 137, 38, 43); -RT_INTERFACE!{static interface IMagneticStripeReaderStatics2(IMagneticStripeReaderStatics2Vtbl): IInspectable(IInspectableVtbl) [IID_IMagneticStripeReaderStatics2] { +DEFINE_IID!(IID_IPosPrinterStatics2, 4006423580, 45264, 17127, 177, 55, 184, 155, 22, 36, 77, 65); +RT_INTERFACE!{static interface IPosPrinterStatics2(IPosPrinterStatics2Vtbl): IInspectable(IInspectableVtbl) [IID_IPosPrinterStatics2] { fn GetDeviceSelectorWithConnectionTypes(&self, connectionTypes: PosConnectionTypes, out: *mut HSTRING) -> HRESULT }} -impl IMagneticStripeReaderStatics2 { +impl IPosPrinterStatics2 { #[inline] pub fn get_device_selector_with_connection_types(&self, connectionTypes: PosConnectionTypes) -> Result { unsafe { let mut out = null_mut(); let hr = ((*self.lpVtbl).GetDeviceSelectorWithConnectionTypes)(self as *const _ as *mut _, connectionTypes, &mut out); if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} } -RT_ENUM! { enum MagneticStripeReaderStatus: i32 { - Unauthenticated (MagneticStripeReaderStatus_Unauthenticated) = 0, Authenticated (MagneticStripeReaderStatus_Authenticated) = 1, Extended (MagneticStripeReaderStatus_Extended) = 2, -}} -DEFINE_IID!(IID_IMagneticStripeReaderStatusUpdatedEventArgs, 164391856, 12898, 16413, 158, 138, 232, 13, 99, 88, 144, 107); -RT_INTERFACE!{interface IMagneticStripeReaderStatusUpdatedEventArgs(IMagneticStripeReaderStatusUpdatedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IMagneticStripeReaderStatusUpdatedEventArgs] { - fn get_Status(&self, out: *mut MagneticStripeReaderStatus) -> HRESULT, +DEFINE_IID!(IID_IPosPrinterStatus, 3522217776, 55872, 17192, 191, 118, 81, 86, 250, 51, 183, 71); +RT_INTERFACE!{interface IPosPrinterStatus(IPosPrinterStatusVtbl): IInspectable(IInspectableVtbl) [IID_IPosPrinterStatus] { + fn get_StatusKind(&self, out: *mut PosPrinterStatusKind) -> HRESULT, fn get_ExtendedStatus(&self, out: *mut u32) -> HRESULT }} -impl IMagneticStripeReaderStatusUpdatedEventArgs { - #[inline] pub fn get_status(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_Status)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } - }} - #[inline] pub fn get_extended_status(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_ExtendedStatus)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } - }} -} -RT_CLASS!{class MagneticStripeReaderStatusUpdatedEventArgs: IMagneticStripeReaderStatusUpdatedEventArgs} -DEFINE_IID!(IID_IMagneticStripeReaderTrackData, 273479281, 19101, 17518, 171, 197, 32, 64, 35, 7, 186, 54); -RT_INTERFACE!{interface IMagneticStripeReaderTrackData(IMagneticStripeReaderTrackDataVtbl): IInspectable(IInspectableVtbl) [IID_IMagneticStripeReaderTrackData] { - #[cfg(feature="windows-storage")] fn get_Data(&self, out: *mut *mut super::super::storage::streams::IBuffer) -> HRESULT, - #[cfg(feature="windows-storage")] fn get_DiscretionaryData(&self, out: *mut *mut super::super::storage::streams::IBuffer) -> HRESULT, - #[cfg(feature="windows-storage")] fn get_EncryptedData(&self, out: *mut *mut super::super::storage::streams::IBuffer) -> HRESULT -}} -impl IMagneticStripeReaderTrackData { - #[cfg(feature="windows-storage")] #[inline] pub fn get_data(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Data)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } - }} - #[cfg(feature="windows-storage")] #[inline] pub fn get_discretionary_data(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_DiscretionaryData)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } +impl IPosPrinterStatus { + #[inline] pub fn get_status_kind(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_StatusKind)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} - #[cfg(feature="windows-storage")] #[inline] pub fn get_encrypted_data(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_EncryptedData)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + #[inline] pub fn get_extended_status(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_ExtendedStatus)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } }} } -RT_CLASS!{class MagneticStripeReaderTrackData: IMagneticStripeReaderTrackData} -RT_ENUM! { enum MagneticStripeReaderTrackErrorType: i32 { - None (MagneticStripeReaderTrackErrorType_None) = 0, StartSentinelError (MagneticStripeReaderTrackErrorType_StartSentinelError) = 1, EndSentinelError (MagneticStripeReaderTrackErrorType_EndSentinelError) = 2, ParityError (MagneticStripeReaderTrackErrorType_ParityError) = 3, LrcError (MagneticStripeReaderTrackErrorType_LrcError) = 4, Unknown (MagneticStripeReaderTrackErrorType_Unknown) = -1, -}} -RT_ENUM! { enum MagneticStripeReaderTrackIds: i32 { - None (MagneticStripeReaderTrackIds_None) = 0, Track1 (MagneticStripeReaderTrackIds_Track1) = 1, Track2 (MagneticStripeReaderTrackIds_Track2) = 2, Track3 (MagneticStripeReaderTrackIds_Track3) = 4, Track4 (MagneticStripeReaderTrackIds_Track4) = 8, +RT_CLASS!{class PosPrinterStatus: IPosPrinterStatus} +RT_ENUM! { enum PosPrinterStatusKind: i32 { + Online (PosPrinterStatusKind_Online) = 0, Off (PosPrinterStatusKind_Off) = 1, Offline (PosPrinterStatusKind_Offline) = 2, OffOrOffline (PosPrinterStatusKind_OffOrOffline) = 3, Extended (PosPrinterStatusKind_Extended) = 4, }} -DEFINE_IID!(IID_IMagneticStripeReaderVendorSpecificCardDataReceivedEventArgs, 2936689940, 22988, 19040, 153, 232, 153, 165, 61, 172, 229, 170); -RT_INTERFACE!{interface IMagneticStripeReaderVendorSpecificCardDataReceivedEventArgs(IMagneticStripeReaderVendorSpecificCardDataReceivedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IMagneticStripeReaderVendorSpecificCardDataReceivedEventArgs] { - fn get_Report(&self, out: *mut *mut MagneticStripeReaderReport) -> HRESULT +DEFINE_IID!(IID_IPosPrinterStatusUpdatedEventArgs, 786139103, 5030, 17037, 186, 129, 176, 231, 195, 229, 163, 205); +RT_INTERFACE!{interface IPosPrinterStatusUpdatedEventArgs(IPosPrinterStatusUpdatedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IPosPrinterStatusUpdatedEventArgs] { + fn get_Status(&self, out: *mut *mut PosPrinterStatus) -> HRESULT }} -impl IMagneticStripeReaderVendorSpecificCardDataReceivedEventArgs { - #[inline] pub fn get_report(&self) -> Result>> { unsafe { +impl IPosPrinterStatusUpdatedEventArgs { + #[inline] pub fn get_status(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Report)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_Status)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } -RT_CLASS!{class MagneticStripeReaderVendorSpecificCardDataReceivedEventArgs: IMagneticStripeReaderVendorSpecificCardDataReceivedEventArgs} -RT_ENUM! { enum PosConnectionTypes: u32 { - Local (PosConnectionTypes_Local) = 1, IP (PosConnectionTypes_IP) = 2, Bluetooth (PosConnectionTypes_Bluetooth) = 4, All (PosConnectionTypes_All) = 4294967295, -}} -DEFINE_IID!(IID_IPosPrinter, 704889102, 39449, 18945, 153, 79, 18, 223, 173, 106, 220, 191); -RT_INTERFACE!{interface IPosPrinter(IPosPrinterVtbl): IInspectable(IInspectableVtbl) [IID_IPosPrinter] { - fn get_DeviceId(&self, out: *mut HSTRING) -> HRESULT, - fn get_Capabilities(&self, out: *mut *mut PosPrinterCapabilities) -> HRESULT, - fn get_SupportedCharacterSets(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT, - fn get_SupportedTypeFaces(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT, - fn get_Status(&self, out: *mut *mut PosPrinterStatus) -> HRESULT, - fn ClaimPrinterAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, - fn CheckHealthAsync(&self, level: UnifiedPosHealthCheckLevel, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, - fn GetStatisticsAsync(&self, statisticsCategories: *mut foundation::collections::IIterable, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, - fn add_StatusUpdated(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, - fn remove_StatusUpdated(&self, token: foundation::EventRegistrationToken) -> HRESULT +RT_CLASS!{class PosPrinterStatusUpdatedEventArgs: IPosPrinterStatusUpdatedEventArgs} +DEFINE_IID!(IID_IReceiptOrSlipJob, 1394710974, 51395, 19906, 137, 233, 92, 74, 55, 179, 77, 220); +RT_INTERFACE!{interface IReceiptOrSlipJob(IReceiptOrSlipJobVtbl): IInspectable(IInspectableVtbl) [IID_IReceiptOrSlipJob] { + fn SetBarcodeRotation(&self, value: PosPrinterRotation) -> HRESULT, + fn SetPrintRotation(&self, value: PosPrinterRotation, includeBitmaps: bool) -> HRESULT, + fn SetPrintArea(&self, value: foundation::Rect) -> HRESULT, + #[cfg(feature="windows-graphics")] fn SetBitmap(&self, bitmapNumber: u32, bitmap: *mut super::super::graphics::imaging::BitmapFrame, alignment: PosPrinterAlignment) -> HRESULT, + #[cfg(feature="windows-graphics")] fn SetBitmapCustomWidthStandardAlign(&self, bitmapNumber: u32, bitmap: *mut super::super::graphics::imaging::BitmapFrame, alignment: PosPrinterAlignment, width: u32) -> HRESULT, + #[cfg(feature="windows-graphics")] fn SetCustomAlignedBitmap(&self, bitmapNumber: u32, bitmap: *mut super::super::graphics::imaging::BitmapFrame, alignmentDistance: u32) -> HRESULT, + #[cfg(feature="windows-graphics")] fn SetBitmapCustomWidthCustomAlign(&self, bitmapNumber: u32, bitmap: *mut super::super::graphics::imaging::BitmapFrame, alignmentDistance: u32, width: u32) -> HRESULT, + fn PrintSavedBitmap(&self, bitmapNumber: u32) -> HRESULT, + fn DrawRuledLine(&self, positionList: HSTRING, lineDirection: PosPrinterLineDirection, lineWidth: u32, lineStyle: PosPrinterLineStyle, lineColor: u32) -> HRESULT, + fn PrintBarcode(&self, data: HSTRING, symbology: u32, height: u32, width: u32, textPosition: PosPrinterBarcodeTextPosition, alignment: PosPrinterAlignment) -> HRESULT, + fn PrintBarcodeCustomAlign(&self, data: HSTRING, symbology: u32, height: u32, width: u32, textPosition: PosPrinterBarcodeTextPosition, alignmentDistance: u32) -> HRESULT, + #[cfg(feature="windows-graphics")] fn PrintBitmap(&self, bitmap: *mut super::super::graphics::imaging::BitmapFrame, alignment: PosPrinterAlignment) -> HRESULT, + #[cfg(feature="windows-graphics")] fn PrintBitmapCustomWidthStandardAlign(&self, bitmap: *mut super::super::graphics::imaging::BitmapFrame, alignment: PosPrinterAlignment, width: u32) -> HRESULT, + #[cfg(feature="windows-graphics")] fn PrintCustomAlignedBitmap(&self, bitmap: *mut super::super::graphics::imaging::BitmapFrame, alignmentDistance: u32) -> HRESULT, + #[cfg(feature="windows-graphics")] fn PrintBitmapCustomWidthCustomAlign(&self, bitmap: *mut super::super::graphics::imaging::BitmapFrame, alignmentDistance: u32, width: u32) -> HRESULT }} -impl IPosPrinter { - #[inline] pub fn get_device_id(&self) -> Result { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_DeviceId)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } +impl IReceiptOrSlipJob { + #[inline] pub fn set_barcode_rotation(&self, value: PosPrinterRotation) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).SetBarcodeRotation)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_capabilities(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Capabilities)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + #[inline] pub fn set_print_rotation(&self, value: PosPrinterRotation, includeBitmaps: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).SetPrintRotation)(self as *const _ as *mut _, value, includeBitmaps); + if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_supported_character_sets(&self) -> Result>>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_SupportedCharacterSets)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + #[inline] pub fn set_print_area(&self, value: foundation::Rect) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).SetPrintArea)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_supported_type_faces(&self) -> Result>>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_SupportedTypeFaces)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + #[cfg(feature="windows-graphics")] #[inline] pub fn set_bitmap(&self, bitmapNumber: u32, bitmap: &super::super::graphics::imaging::BitmapFrame, alignment: PosPrinterAlignment) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).SetBitmap)(self as *const _ as *mut _, bitmapNumber, bitmap as *const _ as *mut _, alignment); + if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_status(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Status)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + #[cfg(feature="windows-graphics")] #[inline] pub fn set_bitmap_custom_width_standard_align(&self, bitmapNumber: u32, bitmap: &super::super::graphics::imaging::BitmapFrame, alignment: PosPrinterAlignment, width: u32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).SetBitmapCustomWidthStandardAlign)(self as *const _ as *mut _, bitmapNumber, bitmap as *const _ as *mut _, alignment, width); + if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn claim_printer_async(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).ClaimPrinterAsync)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + #[cfg(feature="windows-graphics")] #[inline] pub fn set_custom_aligned_bitmap(&self, bitmapNumber: u32, bitmap: &super::super::graphics::imaging::BitmapFrame, alignmentDistance: u32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).SetCustomAlignedBitmap)(self as *const _ as *mut _, bitmapNumber, bitmap as *const _ as *mut _, alignmentDistance); + if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn check_health_async(&self, level: UnifiedPosHealthCheckLevel) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).CheckHealthAsync)(self as *const _ as *mut _, level, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + #[cfg(feature="windows-graphics")] #[inline] pub fn set_bitmap_custom_width_custom_align(&self, bitmapNumber: u32, bitmap: &super::super::graphics::imaging::BitmapFrame, alignmentDistance: u32, width: u32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).SetBitmapCustomWidthCustomAlign)(self as *const _ as *mut _, bitmapNumber, bitmap as *const _ as *mut _, alignmentDistance, width); + if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_statistics_async(&self, statisticsCategories: &foundation::collections::IIterable) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetStatisticsAsync)(self as *const _ as *mut _, statisticsCategories as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + #[inline] pub fn print_saved_bitmap(&self, bitmapNumber: u32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).PrintSavedBitmap)(self as *const _ as *mut _, bitmapNumber); + if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn add_status_updated(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).add_StatusUpdated)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } + #[inline] pub fn draw_ruled_line(&self, positionList: &HStringArg, lineDirection: PosPrinterLineDirection, lineWidth: u32, lineStyle: PosPrinterLineStyle, lineColor: u32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).DrawRuledLine)(self as *const _ as *mut _, positionList.get(), lineDirection, lineWidth, lineStyle, lineColor); + if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn remove_status_updated(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).remove_StatusUpdated)(self as *const _ as *mut _, token); + #[inline] pub fn print_barcode(&self, data: &HStringArg, symbology: u32, height: u32, width: u32, textPosition: PosPrinterBarcodeTextPosition, alignment: PosPrinterAlignment) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).PrintBarcode)(self as *const _ as *mut _, data.get(), symbology, height, width, textPosition, alignment); if hr == S_OK { Ok(()) } else { err(hr) } }} -} -RT_CLASS!{class PosPrinter: IPosPrinter} -impl RtActivatable for PosPrinter {} -impl RtActivatable for PosPrinter {} -impl PosPrinter { - #[inline] pub fn get_default_async() -> Result>> { - >::get_activation_factory().get_default_async() - } - #[inline] pub fn from_id_async(deviceId: &HStringArg) -> Result>> { - >::get_activation_factory().from_id_async(deviceId) - } - #[inline] pub fn get_device_selector() -> Result { - >::get_activation_factory().get_device_selector() - } - #[inline] pub fn get_device_selector_with_connection_types(connectionTypes: PosConnectionTypes) -> Result { - >::get_activation_factory().get_device_selector_with_connection_types(connectionTypes) - } -} -DEFINE_CLSID!(PosPrinter(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,80,111,105,110,116,79,102,83,101,114,118,105,99,101,46,80,111,115,80,114,105,110,116,101,114,0]) [CLSID_PosPrinter]); -RT_ENUM! { enum PosPrinterAlignment: i32 { - Left (PosPrinterAlignment_Left) = 0, Center (PosPrinterAlignment_Center) = 1, Right (PosPrinterAlignment_Right) = 2, -}} -RT_ENUM! { enum PosPrinterBarcodeTextPosition: i32 { - None (PosPrinterBarcodeTextPosition_None) = 0, Above (PosPrinterBarcodeTextPosition_Above) = 1, Below (PosPrinterBarcodeTextPosition_Below) = 2, -}} -DEFINE_IID!(IID_IPosPrinterCapabilities, 3454621473, 17280, 18821, 173, 197, 57, 219, 48, 205, 147, 188); -RT_INTERFACE!{interface IPosPrinterCapabilities(IPosPrinterCapabilitiesVtbl): IInspectable(IInspectableVtbl) [IID_IPosPrinterCapabilities] { - fn get_PowerReportingType(&self, out: *mut UnifiedPosPowerReportingType) -> HRESULT, - fn get_IsStatisticsReportingSupported(&self, out: *mut bool) -> HRESULT, - fn get_IsStatisticsUpdatingSupported(&self, out: *mut bool) -> HRESULT, - fn get_DefaultCharacterSet(&self, out: *mut u32) -> HRESULT, - fn get_HasCoverSensor(&self, out: *mut bool) -> HRESULT, - fn get_CanMapCharacterSet(&self, out: *mut bool) -> HRESULT, - fn get_IsTransactionSupported(&self, out: *mut bool) -> HRESULT, - fn get_Receipt(&self, out: *mut *mut ReceiptPrinterCapabilities) -> HRESULT, - fn get_Slip(&self, out: *mut *mut SlipPrinterCapabilities) -> HRESULT, - fn get_Journal(&self, out: *mut *mut JournalPrinterCapabilities) -> HRESULT -}} -impl IPosPrinterCapabilities { - #[inline] pub fn get_power_reporting_type(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_PowerReportingType)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } + #[inline] pub fn print_barcode_custom_align(&self, data: &HStringArg, symbology: u32, height: u32, width: u32, textPosition: PosPrinterBarcodeTextPosition, alignmentDistance: u32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).PrintBarcodeCustomAlign)(self as *const _ as *mut _, data.get(), symbology, height, width, textPosition, alignmentDistance); + if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_is_statistics_reporting_supported(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_IsStatisticsReportingSupported)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } + #[cfg(feature="windows-graphics")] #[inline] pub fn print_bitmap(&self, bitmap: &super::super::graphics::imaging::BitmapFrame, alignment: PosPrinterAlignment) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).PrintBitmap)(self as *const _ as *mut _, bitmap as *const _ as *mut _, alignment); + if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_is_statistics_updating_supported(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_IsStatisticsUpdatingSupported)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } + #[cfg(feature="windows-graphics")] #[inline] pub fn print_bitmap_custom_width_standard_align(&self, bitmap: &super::super::graphics::imaging::BitmapFrame, alignment: PosPrinterAlignment, width: u32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).PrintBitmapCustomWidthStandardAlign)(self as *const _ as *mut _, bitmap as *const _ as *mut _, alignment, width); + if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_default_character_set(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_DefaultCharacterSet)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } + #[cfg(feature="windows-graphics")] #[inline] pub fn print_custom_aligned_bitmap(&self, bitmap: &super::super::graphics::imaging::BitmapFrame, alignmentDistance: u32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).PrintCustomAlignedBitmap)(self as *const _ as *mut _, bitmap as *const _ as *mut _, alignmentDistance); + if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_has_cover_sensor(&self) -> Result { unsafe { + #[cfg(feature="windows-graphics")] #[inline] pub fn print_bitmap_custom_width_custom_align(&self, bitmap: &super::super::graphics::imaging::BitmapFrame, alignmentDistance: u32, width: u32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).PrintBitmapCustomWidthCustomAlign)(self as *const _ as *mut _, bitmap as *const _ as *mut _, alignmentDistance, width); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +DEFINE_IID!(IID_IReceiptPrinterCapabilities, 3102782863, 20904, 17404, 155, 213, 141, 226, 114, 166, 65, 91); +RT_INTERFACE!{interface IReceiptPrinterCapabilities(IReceiptPrinterCapabilitiesVtbl): IInspectable(IInspectableVtbl) [IID_IReceiptPrinterCapabilities] { + fn get_CanCutPaper(&self, out: *mut bool) -> HRESULT, + fn get_IsStampSupported(&self, out: *mut bool) -> HRESULT, + fn get_MarkFeedCapabilities(&self, out: *mut PosPrinterMarkFeedCapabilities) -> HRESULT +}} +impl IReceiptPrinterCapabilities { + #[inline] pub fn get_can_cut_paper(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_HasCoverSensor)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_CanCutPaper)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_can_map_character_set(&self) -> Result { unsafe { + #[inline] pub fn get_is_stamp_supported(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_CanMapCharacterSet)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_IsStampSupported)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_is_transaction_supported(&self) -> Result { unsafe { + #[inline] pub fn get_mark_feed_capabilities(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_IsTransactionSupported)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_MarkFeedCapabilities)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_receipt(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Receipt)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } +} +RT_CLASS!{class ReceiptPrinterCapabilities: IReceiptPrinterCapabilities} +DEFINE_IID!(IID_IReceiptPrintJob, 2861958766, 44205, 19321, 157, 15, 192, 207, 192, 141, 199, 123); +RT_INTERFACE!{interface IReceiptPrintJob(IReceiptPrintJobVtbl): IInspectable(IInspectableVtbl) [IID_IReceiptPrintJob] { + fn MarkFeed(&self, kind: PosPrinterMarkFeedKind) -> HRESULT, + fn CutPaper(&self, percentage: f64) -> HRESULT, + fn CutPaperDefault(&self) -> HRESULT +}} +impl IReceiptPrintJob { + #[inline] pub fn mark_feed(&self, kind: PosPrinterMarkFeedKind) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).MarkFeed)(self as *const _ as *mut _, kind); + if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_slip(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Slip)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + #[inline] pub fn cut_paper(&self, percentage: f64) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).CutPaper)(self as *const _ as *mut _, percentage); + if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn get_journal(&self) -> Result>> { unsafe { - let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Journal)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + #[inline] pub fn cut_paper_default(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).CutPaperDefault)(self as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } }} } -RT_CLASS!{class PosPrinterCapabilities: IPosPrinterCapabilities} -RT_ENUM! { enum PosPrinterCartridgeSensors: u32 { - None (PosPrinterCartridgeSensors_None) = 0, Removed (PosPrinterCartridgeSensors_Removed) = 1, Empty (PosPrinterCartridgeSensors_Empty) = 2, HeadCleaning (PosPrinterCartridgeSensors_HeadCleaning) = 4, NearEnd (PosPrinterCartridgeSensors_NearEnd) = 8, +RT_CLASS!{class ReceiptPrintJob: IReceiptPrintJob} +DEFINE_IID!(IID_ISlipPrinterCapabilities, 2578539417, 18572, 16727, 138, 194, 159, 87, 247, 8, 211, 219); +RT_INTERFACE!{interface ISlipPrinterCapabilities(ISlipPrinterCapabilitiesVtbl): IInspectable(IInspectableVtbl) [IID_ISlipPrinterCapabilities] { + fn get_IsFullLengthSupported(&self, out: *mut bool) -> HRESULT, + fn get_IsBothSidesPrintingSupported(&self, out: *mut bool) -> HRESULT }} -RT_CLASS!{static class PosPrinterCharacterSetIds} -impl RtActivatable for PosPrinterCharacterSetIds {} -impl PosPrinterCharacterSetIds { - #[inline] pub fn get_utf16_le() -> Result { - >::get_activation_factory().get_utf16_le() - } - #[inline] pub fn get_ascii() -> Result { - >::get_activation_factory().get_ascii() - } - #[inline] pub fn get_ansi() -> Result { - >::get_activation_factory().get_ansi() - } +impl ISlipPrinterCapabilities { + #[inline] pub fn get_is_full_length_supported(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_IsFullLengthSupported)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_is_both_sides_printing_supported(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_IsBothSidesPrintingSupported)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} } -DEFINE_CLSID!(PosPrinterCharacterSetIds(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,80,111,105,110,116,79,102,83,101,114,118,105,99,101,46,80,111,115,80,114,105,110,116,101,114,67,104,97,114,97,99,116,101,114,83,101,116,73,100,115,0]) [CLSID_PosPrinterCharacterSetIds]); -DEFINE_IID!(IID_IPosPrinterCharacterSetIdsStatics, 1550884607, 28826, 20455, 178, 21, 6, 167, 72, 163, 139, 57); -RT_INTERFACE!{static interface IPosPrinterCharacterSetIdsStatics(IPosPrinterCharacterSetIdsStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IPosPrinterCharacterSetIdsStatics] { - fn get_Utf16LE(&self, out: *mut u32) -> HRESULT, - fn get_Ascii(&self, out: *mut u32) -> HRESULT, - fn get_Ansi(&self, out: *mut u32) -> HRESULT +RT_CLASS!{class SlipPrinterCapabilities: ISlipPrinterCapabilities} +RT_CLASS!{class SlipPrintJob: IReceiptOrSlipJob} +DEFINE_IID!(IID_IUnifiedPosErrorData, 731483194, 21852, 18569, 142, 216, 197, 153, 187, 58, 113, 42); +RT_INTERFACE!{interface IUnifiedPosErrorData(IUnifiedPosErrorDataVtbl): IInspectable(IInspectableVtbl) [IID_IUnifiedPosErrorData] { + fn get_Message(&self, out: *mut HSTRING) -> HRESULT, + fn get_Severity(&self, out: *mut UnifiedPosErrorSeverity) -> HRESULT, + fn get_Reason(&self, out: *mut UnifiedPosErrorReason) -> HRESULT, + fn get_ExtendedReason(&self, out: *mut u32) -> HRESULT }} -impl IPosPrinterCharacterSetIdsStatics { - #[inline] pub fn get_utf16_le(&self) -> Result { unsafe { +impl IUnifiedPosErrorData { + #[inline] pub fn get_message(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Message)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_severity(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_Utf16LE)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_Severity)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_ascii(&self) -> Result { unsafe { + #[inline] pub fn get_reason(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_Ascii)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_Reason)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_ansi(&self) -> Result { unsafe { + #[inline] pub fn get_extended_reason(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_Ansi)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_ExtendedReason)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} } -RT_ENUM! { enum PosPrinterColorCapabilities: u32 { - None (PosPrinterColorCapabilities_None) = 0, Primary (PosPrinterColorCapabilities_Primary) = 1, Custom1 (PosPrinterColorCapabilities_Custom1) = 2, Custom2 (PosPrinterColorCapabilities_Custom2) = 4, Custom3 (PosPrinterColorCapabilities_Custom3) = 8, Custom4 (PosPrinterColorCapabilities_Custom4) = 16, Custom5 (PosPrinterColorCapabilities_Custom5) = 32, Custom6 (PosPrinterColorCapabilities_Custom6) = 64, Cyan (PosPrinterColorCapabilities_Cyan) = 128, Magenta (PosPrinterColorCapabilities_Magenta) = 256, Yellow (PosPrinterColorCapabilities_Yellow) = 512, Full (PosPrinterColorCapabilities_Full) = 1024, -}} -RT_ENUM! { enum PosPrinterColorCartridge: i32 { - Unknown (PosPrinterColorCartridge_Unknown) = 0, Primary (PosPrinterColorCartridge_Primary) = 1, Custom1 (PosPrinterColorCartridge_Custom1) = 2, Custom2 (PosPrinterColorCartridge_Custom2) = 3, Custom3 (PosPrinterColorCartridge_Custom3) = 4, Custom4 (PosPrinterColorCartridge_Custom4) = 5, Custom5 (PosPrinterColorCartridge_Custom5) = 6, Custom6 (PosPrinterColorCartridge_Custom6) = 7, Cyan (PosPrinterColorCartridge_Cyan) = 8, Magenta (PosPrinterColorCartridge_Magenta) = 9, Yellow (PosPrinterColorCartridge_Yellow) = 10, -}} -DEFINE_IID!(IID_IPosPrinterJob, 2593390684, 1557, 17809, 165, 143, 48, 248, 126, 223, 226, 228); -RT_INTERFACE!{interface IPosPrinterJob(IPosPrinterJobVtbl): IInspectable(IInspectableVtbl) [IID_IPosPrinterJob] { - fn Print(&self, data: HSTRING) -> HRESULT, - fn PrintLine(&self, data: HSTRING) -> HRESULT, - fn PrintNewline(&self) -> HRESULT, - fn ExecuteAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT +RT_CLASS!{class UnifiedPosErrorData: IUnifiedPosErrorData} +impl RtActivatable for UnifiedPosErrorData {} +impl UnifiedPosErrorData { + #[inline] pub fn create_instance(message: &HStringArg, severity: UnifiedPosErrorSeverity, reason: UnifiedPosErrorReason, extendedReason: u32) -> Result> { + >::get_activation_factory().create_instance(message, severity, reason, extendedReason) + } +} +DEFINE_CLSID!(UnifiedPosErrorData(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,80,111,105,110,116,79,102,83,101,114,118,105,99,101,46,85,110,105,102,105,101,100,80,111,115,69,114,114,111,114,68,97,116,97,0]) [CLSID_UnifiedPosErrorData]); +DEFINE_IID!(IID_IUnifiedPosErrorDataFactory, 1268262225, 8190, 17691, 163, 104, 99, 224, 206, 70, 95, 90); +RT_INTERFACE!{static interface IUnifiedPosErrorDataFactory(IUnifiedPosErrorDataFactoryVtbl): IInspectable(IInspectableVtbl) [IID_IUnifiedPosErrorDataFactory] { + fn CreateInstance(&self, message: HSTRING, severity: UnifiedPosErrorSeverity, reason: UnifiedPosErrorReason, extendedReason: u32, out: *mut *mut UnifiedPosErrorData) -> HRESULT }} -impl IPosPrinterJob { - #[inline] pub fn print(&self, data: &HStringArg) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).Print)(self as *const _ as *mut _, data.get()); - if hr == S_OK { Ok(()) } else { err(hr) } - }} - #[inline] pub fn print_line(&self, data: &HStringArg) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).PrintLine)(self as *const _ as *mut _, data.get()); - if hr == S_OK { Ok(()) } else { err(hr) } - }} - #[inline] pub fn print_newline(&self) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).PrintNewline)(self as *const _ as *mut _); - if hr == S_OK { Ok(()) } else { err(hr) } - }} - #[inline] pub fn execute_async(&self) -> Result>> { unsafe { +impl IUnifiedPosErrorDataFactory { + #[inline] pub fn create_instance(&self, message: &HStringArg, severity: UnifiedPosErrorSeverity, reason: UnifiedPosErrorReason, extendedReason: u32) -> Result> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).ExecuteAsync)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).CreateInstance)(self as *const _ as *mut _, message.get(), severity, reason, extendedReason, &mut out); if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } -RT_ENUM! { enum PosPrinterLineDirection: i32 { - Horizontal (PosPrinterLineDirection_Horizontal) = 0, Vertical (PosPrinterLineDirection_Vertical) = 1, -}} -RT_ENUM! { enum PosPrinterLineStyle: i32 { - SingleSolid (PosPrinterLineStyle_SingleSolid) = 0, DoubleSolid (PosPrinterLineStyle_DoubleSolid) = 1, Broken (PosPrinterLineStyle_Broken) = 2, Chain (PosPrinterLineStyle_Chain) = 3, -}} -RT_ENUM! { enum PosPrinterMapMode: i32 { - Dots (PosPrinterMapMode_Dots) = 0, Twips (PosPrinterMapMode_Twips) = 1, English (PosPrinterMapMode_English) = 2, Metric (PosPrinterMapMode_Metric) = 3, -}} -RT_ENUM! { enum PosPrinterMarkFeedCapabilities: u32 { - None (PosPrinterMarkFeedCapabilities_None) = 0, ToTakeUp (PosPrinterMarkFeedCapabilities_ToTakeUp) = 1, ToCutter (PosPrinterMarkFeedCapabilities_ToCutter) = 2, ToCurrentTopOfForm (PosPrinterMarkFeedCapabilities_ToCurrentTopOfForm) = 4, ToNextTopOfForm (PosPrinterMarkFeedCapabilities_ToNextTopOfForm) = 8, -}} -RT_ENUM! { enum PosPrinterMarkFeedKind: i32 { - ToTakeUp (PosPrinterMarkFeedKind_ToTakeUp) = 0, ToCutter (PosPrinterMarkFeedKind_ToCutter) = 1, ToCurrentTopOfForm (PosPrinterMarkFeedKind_ToCurrentTopOfForm) = 2, ToNextTopOfForm (PosPrinterMarkFeedKind_ToNextTopOfForm) = 3, -}} -RT_ENUM! { enum PosPrinterPrintSide: i32 { - Unknown (PosPrinterPrintSide_Unknown) = 0, Side1 (PosPrinterPrintSide_Side1) = 1, Side2 (PosPrinterPrintSide_Side2) = 2, +RT_ENUM! { enum UnifiedPosErrorReason: i32 { + UnknownErrorReason (UnifiedPosErrorReason_UnknownErrorReason) = 0, NoService (UnifiedPosErrorReason_NoService) = 1, Disabled (UnifiedPosErrorReason_Disabled) = 2, Illegal (UnifiedPosErrorReason_Illegal) = 3, NoHardware (UnifiedPosErrorReason_NoHardware) = 4, Closed (UnifiedPosErrorReason_Closed) = 5, Offline (UnifiedPosErrorReason_Offline) = 6, Failure (UnifiedPosErrorReason_Failure) = 7, Timeout (UnifiedPosErrorReason_Timeout) = 8, Busy (UnifiedPosErrorReason_Busy) = 9, Extended (UnifiedPosErrorReason_Extended) = 10, }} -DEFINE_IID!(IID_IPosPrinterReleaseDeviceRequestedEventArgs, 734765913, 7407, 16562, 158, 203, 249, 39, 248, 86, 174, 60); -RT_INTERFACE!{interface IPosPrinterReleaseDeviceRequestedEventArgs(IPosPrinterReleaseDeviceRequestedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IPosPrinterReleaseDeviceRequestedEventArgs] { - +RT_ENUM! { enum UnifiedPosErrorSeverity: i32 { + UnknownErrorSeverity (UnifiedPosErrorSeverity_UnknownErrorSeverity) = 0, Warning (UnifiedPosErrorSeverity_Warning) = 1, Recoverable (UnifiedPosErrorSeverity_Recoverable) = 2, Unrecoverable (UnifiedPosErrorSeverity_Unrecoverable) = 3, AssistanceRequired (UnifiedPosErrorSeverity_AssistanceRequired) = 4, Fatal (UnifiedPosErrorSeverity_Fatal) = 5, }} -RT_CLASS!{class PosPrinterReleaseDeviceRequestedEventArgs: IPosPrinterReleaseDeviceRequestedEventArgs} -RT_ENUM! { enum PosPrinterRotation: i32 { - Normal (PosPrinterRotation_Normal) = 0, Right90 (PosPrinterRotation_Right90) = 1, Left90 (PosPrinterRotation_Left90) = 2, Rotate180 (PosPrinterRotation_Rotate180) = 3, +RT_ENUM! { enum UnifiedPosHealthCheckLevel: i32 { + UnknownHealthCheckLevel (UnifiedPosHealthCheckLevel_UnknownHealthCheckLevel) = 0, POSInternal (UnifiedPosHealthCheckLevel_POSInternal) = 1, External (UnifiedPosHealthCheckLevel_External) = 2, Interactive (UnifiedPosHealthCheckLevel_Interactive) = 3, }} -RT_ENUM! { enum PosPrinterRuledLineCapabilities: u32 { - None (PosPrinterRuledLineCapabilities_None) = 0, Horizontal (PosPrinterRuledLineCapabilities_Horizontal) = 1, Vertical (PosPrinterRuledLineCapabilities_Vertical) = 2, +RT_ENUM! { enum UnifiedPosPowerReportingType: i32 { + UnknownPowerReportingType (UnifiedPosPowerReportingType_UnknownPowerReportingType) = 0, Standard (UnifiedPosPowerReportingType_Standard) = 1, Advanced (UnifiedPosPowerReportingType_Advanced) = 2, }} -DEFINE_IID!(IID_IPosPrinterStatics, 2363544810, 4911, 19679, 166, 74, 45, 13, 124, 150, 168, 91); -RT_INTERFACE!{static interface IPosPrinterStatics(IPosPrinterStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IPosPrinterStatics] { - fn GetDefaultAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, - fn FromIdAsync(&self, deviceId: HSTRING, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, - fn GetDeviceSelector(&self, out: *mut HSTRING) -> HRESULT +pub mod provider { // Windows.Devices.PointOfService.Provider +use ::prelude::*; +DEFINE_IID!(IID_IBarcodeScannerDisableScannerRequest, 2297231296, 14265, 17013, 142, 119, 200, 229, 42, 229, 169, 200); +RT_INTERFACE!{interface IBarcodeScannerDisableScannerRequest(IBarcodeScannerDisableScannerRequestVtbl): IInspectable(IInspectableVtbl) [IID_IBarcodeScannerDisableScannerRequest] { + fn ReportCompletedAsync(&self, out: *mut *mut foundation::IAsyncAction) -> HRESULT, + fn ReportFailedAsync(&self, out: *mut *mut foundation::IAsyncAction) -> HRESULT }} -impl IPosPrinterStatics { - #[inline] pub fn get_default_async(&self) -> Result>> { unsafe { +impl IBarcodeScannerDisableScannerRequest { + #[inline] pub fn report_completed_async(&self) -> Result> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetDefaultAsync)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).ReportCompletedAsync)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn from_id_async(&self, deviceId: &HStringArg) -> Result>> { unsafe { + #[inline] pub fn report_failed_async(&self) -> Result> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).FromIdAsync)(self as *const _ as *mut _, deviceId.get(), &mut out); + let hr = ((*self.lpVtbl).ReportFailedAsync)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} - #[inline] pub fn get_device_selector(&self) -> Result { unsafe { +} +RT_CLASS!{class BarcodeScannerDisableScannerRequest: IBarcodeScannerDisableScannerRequest} +DEFINE_IID!(IID_IBarcodeScannerDisableScannerRequestEventArgs, 1879499074, 59394, 18165, 182, 4, 53, 42, 21, 206, 146, 50); +RT_INTERFACE!{interface IBarcodeScannerDisableScannerRequestEventArgs(IBarcodeScannerDisableScannerRequestEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IBarcodeScannerDisableScannerRequestEventArgs] { + fn get_Request(&self, out: *mut *mut BarcodeScannerDisableScannerRequest) -> HRESULT, + fn GetDeferral(&self, out: *mut *mut foundation::Deferral) -> HRESULT +}} +impl IBarcodeScannerDisableScannerRequestEventArgs { + #[inline] pub fn get_request(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetDeviceSelector)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).get_Request)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_deferral(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetDeferral)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } -DEFINE_IID!(IID_IPosPrinterStatics2, 4006423580, 45264, 17127, 177, 55, 184, 155, 22, 36, 77, 65); -RT_INTERFACE!{static interface IPosPrinterStatics2(IPosPrinterStatics2Vtbl): IInspectable(IInspectableVtbl) [IID_IPosPrinterStatics2] { - fn GetDeviceSelectorWithConnectionTypes(&self, connectionTypes: PosConnectionTypes, out: *mut HSTRING) -> HRESULT +RT_CLASS!{class BarcodeScannerDisableScannerRequestEventArgs: IBarcodeScannerDisableScannerRequestEventArgs} +DEFINE_IID!(IID_IBarcodeScannerEnableScannerRequest, 3233016250, 33130, 17707, 189, 119, 183, 228, 83, 236, 68, 109); +RT_INTERFACE!{interface IBarcodeScannerEnableScannerRequest(IBarcodeScannerEnableScannerRequestVtbl): IInspectable(IInspectableVtbl) [IID_IBarcodeScannerEnableScannerRequest] { + fn ReportCompletedAsync(&self, out: *mut *mut foundation::IAsyncAction) -> HRESULT, + fn ReportFailedAsync(&self, out: *mut *mut foundation::IAsyncAction) -> HRESULT }} -impl IPosPrinterStatics2 { - #[inline] pub fn get_device_selector_with_connection_types(&self, connectionTypes: PosConnectionTypes) -> Result { unsafe { +impl IBarcodeScannerEnableScannerRequest { + #[inline] pub fn report_completed_async(&self) -> Result> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).GetDeviceSelectorWithConnectionTypes)(self as *const _ as *mut _, connectionTypes, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).ReportCompletedAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn report_failed_async(&self) -> Result> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).ReportFailedAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } -DEFINE_IID!(IID_IPosPrinterStatus, 3522217776, 55872, 17192, 191, 118, 81, 86, 250, 51, 183, 71); -RT_INTERFACE!{interface IPosPrinterStatus(IPosPrinterStatusVtbl): IInspectable(IInspectableVtbl) [IID_IPosPrinterStatus] { - fn get_StatusKind(&self, out: *mut PosPrinterStatusKind) -> HRESULT, - fn get_ExtendedStatus(&self, out: *mut u32) -> HRESULT +RT_CLASS!{class BarcodeScannerEnableScannerRequest: IBarcodeScannerEnableScannerRequest} +DEFINE_IID!(IID_IBarcodeScannerEnableScannerRequestEventArgs, 2506920985, 31566, 17489, 140, 65, 142, 16, 207, 188, 91, 65); +RT_INTERFACE!{interface IBarcodeScannerEnableScannerRequestEventArgs(IBarcodeScannerEnableScannerRequestEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IBarcodeScannerEnableScannerRequestEventArgs] { + fn get_Request(&self, out: *mut *mut BarcodeScannerEnableScannerRequest) -> HRESULT, + fn GetDeferral(&self, out: *mut *mut foundation::Deferral) -> HRESULT }} -impl IPosPrinterStatus { - #[inline] pub fn get_status_kind(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_StatusKind)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } +impl IBarcodeScannerEnableScannerRequestEventArgs { + #[inline] pub fn get_request(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Request)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn get_extended_status(&self) -> Result { unsafe { + #[inline] pub fn get_deferral(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetDeferral)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +RT_CLASS!{class BarcodeScannerEnableScannerRequestEventArgs: IBarcodeScannerEnableScannerRequestEventArgs} +DEFINE_IID!(IID_IBarcodeScannerGetSymbologyAttributesRequest, 2541012074, 22756, 19551, 184, 233, 228, 20, 103, 99, 39, 0); +RT_INTERFACE!{interface IBarcodeScannerGetSymbologyAttributesRequest(IBarcodeScannerGetSymbologyAttributesRequestVtbl): IInspectable(IInspectableVtbl) [IID_IBarcodeScannerGetSymbologyAttributesRequest] { + fn get_Symbology(&self, out: *mut u32) -> HRESULT, + fn ReportCompletedAsync(&self, attributes: *mut super::BarcodeSymbologyAttributes, out: *mut *mut foundation::IAsyncAction) -> HRESULT, + fn ReportFailedAsync(&self, out: *mut *mut foundation::IAsyncAction) -> HRESULT +}} +impl IBarcodeScannerGetSymbologyAttributesRequest { + #[inline] pub fn get_symbology(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_ExtendedStatus)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_Symbology)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} + #[inline] pub fn report_completed_async(&self, attributes: &super::BarcodeSymbologyAttributes) -> Result> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).ReportCompletedAsync)(self as *const _ as *mut _, attributes as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn report_failed_async(&self) -> Result> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).ReportFailedAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} } -RT_CLASS!{class PosPrinterStatus: IPosPrinterStatus} -RT_ENUM! { enum PosPrinterStatusKind: i32 { - Online (PosPrinterStatusKind_Online) = 0, Off (PosPrinterStatusKind_Off) = 1, Offline (PosPrinterStatusKind_Offline) = 2, OffOrOffline (PosPrinterStatusKind_OffOrOffline) = 3, Extended (PosPrinterStatusKind_Extended) = 4, -}} -DEFINE_IID!(IID_IPosPrinterStatusUpdatedEventArgs, 786139103, 5030, 17037, 186, 129, 176, 231, 195, 229, 163, 205); -RT_INTERFACE!{interface IPosPrinterStatusUpdatedEventArgs(IPosPrinterStatusUpdatedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IPosPrinterStatusUpdatedEventArgs] { - fn get_Status(&self, out: *mut *mut PosPrinterStatus) -> HRESULT +RT_CLASS!{class BarcodeScannerGetSymbologyAttributesRequest: IBarcodeScannerGetSymbologyAttributesRequest} +DEFINE_IID!(IID_IBarcodeScannerGetSymbologyAttributesRequestEventArgs, 2139741758, 64349, 18748, 180, 2, 53, 107, 36, 213, 116, 166); +RT_INTERFACE!{interface IBarcodeScannerGetSymbologyAttributesRequestEventArgs(IBarcodeScannerGetSymbologyAttributesRequestEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IBarcodeScannerGetSymbologyAttributesRequestEventArgs] { + fn get_Request(&self, out: *mut *mut BarcodeScannerGetSymbologyAttributesRequest) -> HRESULT, + fn GetDeferral(&self, out: *mut *mut foundation::Deferral) -> HRESULT }} -impl IPosPrinterStatusUpdatedEventArgs { - #[inline] pub fn get_status(&self) -> Result>> { unsafe { +impl IBarcodeScannerGetSymbologyAttributesRequestEventArgs { + #[inline] pub fn get_request(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Status)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_Request)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_deferral(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetDeferral)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } -RT_CLASS!{class PosPrinterStatusUpdatedEventArgs: IPosPrinterStatusUpdatedEventArgs} -DEFINE_IID!(IID_IReceiptOrSlipJob, 1394710974, 51395, 19906, 137, 233, 92, 74, 55, 179, 77, 220); -RT_INTERFACE!{interface IReceiptOrSlipJob(IReceiptOrSlipJobVtbl): IInspectable(IInspectableVtbl) [IID_IReceiptOrSlipJob] { - fn SetBarcodeRotation(&self, value: PosPrinterRotation) -> HRESULT, - fn SetPrintRotation(&self, value: PosPrinterRotation, includeBitmaps: bool) -> HRESULT, - fn SetPrintArea(&self, value: foundation::Rect) -> HRESULT, - #[cfg(feature="windows-graphics")] fn SetBitmap(&self, bitmapNumber: u32, bitmap: *mut super::super::graphics::imaging::BitmapFrame, alignment: PosPrinterAlignment) -> HRESULT, - #[cfg(feature="windows-graphics")] fn SetBitmapCustomWidthStandardAlign(&self, bitmapNumber: u32, bitmap: *mut super::super::graphics::imaging::BitmapFrame, alignment: PosPrinterAlignment, width: u32) -> HRESULT, - #[cfg(feature="windows-graphics")] fn SetCustomAlignedBitmap(&self, bitmapNumber: u32, bitmap: *mut super::super::graphics::imaging::BitmapFrame, alignmentDistance: u32) -> HRESULT, - #[cfg(feature="windows-graphics")] fn SetBitmapCustomWidthCustomAlign(&self, bitmapNumber: u32, bitmap: *mut super::super::graphics::imaging::BitmapFrame, alignmentDistance: u32, width: u32) -> HRESULT, - fn PrintSavedBitmap(&self, bitmapNumber: u32) -> HRESULT, - fn DrawRuledLine(&self, positionList: HSTRING, lineDirection: PosPrinterLineDirection, lineWidth: u32, lineStyle: PosPrinterLineStyle, lineColor: u32) -> HRESULT, - fn PrintBarcode(&self, data: HSTRING, symbology: u32, height: u32, width: u32, textPosition: PosPrinterBarcodeTextPosition, alignment: PosPrinterAlignment) -> HRESULT, - fn PrintBarcodeCustomAlign(&self, data: HSTRING, symbology: u32, height: u32, width: u32, textPosition: PosPrinterBarcodeTextPosition, alignmentDistance: u32) -> HRESULT, - #[cfg(feature="windows-graphics")] fn PrintBitmap(&self, bitmap: *mut super::super::graphics::imaging::BitmapFrame, alignment: PosPrinterAlignment) -> HRESULT, - #[cfg(feature="windows-graphics")] fn PrintBitmapCustomWidthStandardAlign(&self, bitmap: *mut super::super::graphics::imaging::BitmapFrame, alignment: PosPrinterAlignment, width: u32) -> HRESULT, - #[cfg(feature="windows-graphics")] fn PrintCustomAlignedBitmap(&self, bitmap: *mut super::super::graphics::imaging::BitmapFrame, alignmentDistance: u32) -> HRESULT, - #[cfg(feature="windows-graphics")] fn PrintBitmapCustomWidthCustomAlign(&self, bitmap: *mut super::super::graphics::imaging::BitmapFrame, alignmentDistance: u32, width: u32) -> HRESULT +RT_CLASS!{class BarcodeScannerGetSymbologyAttributesRequestEventArgs: IBarcodeScannerGetSymbologyAttributesRequestEventArgs} +DEFINE_IID!(IID_IBarcodeScannerHideVideoPreviewRequest, 4199464575, 26224, 16609, 185, 11, 187, 16, 216, 212, 37, 250); +RT_INTERFACE!{interface IBarcodeScannerHideVideoPreviewRequest(IBarcodeScannerHideVideoPreviewRequestVtbl): IInspectable(IInspectableVtbl) [IID_IBarcodeScannerHideVideoPreviewRequest] { + fn ReportCompletedAsync(&self, out: *mut *mut foundation::IAsyncAction) -> HRESULT, + fn ReportFailedAsync(&self, out: *mut *mut foundation::IAsyncAction) -> HRESULT }} -impl IReceiptOrSlipJob { - #[inline] pub fn set_barcode_rotation(&self, value: PosPrinterRotation) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).SetBarcodeRotation)(self as *const _ as *mut _, value); - if hr == S_OK { Ok(()) } else { err(hr) } +impl IBarcodeScannerHideVideoPreviewRequest { + #[inline] pub fn report_completed_async(&self) -> Result> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).ReportCompletedAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn report_failed_async(&self) -> Result> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).ReportFailedAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} +} +RT_CLASS!{class BarcodeScannerHideVideoPreviewRequest: IBarcodeScannerHideVideoPreviewRequest} +DEFINE_IID!(IID_IBarcodeScannerHideVideoPreviewRequestEventArgs, 379748860, 54974, 19399, 157, 241, 51, 116, 31, 62, 173, 234); +RT_INTERFACE!{interface IBarcodeScannerHideVideoPreviewRequestEventArgs(IBarcodeScannerHideVideoPreviewRequestEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IBarcodeScannerHideVideoPreviewRequestEventArgs] { + fn get_Request(&self, out: *mut *mut BarcodeScannerHideVideoPreviewRequest) -> HRESULT, + fn GetDeferral(&self, out: *mut *mut foundation::Deferral) -> HRESULT +}} +impl IBarcodeScannerHideVideoPreviewRequestEventArgs { + #[inline] pub fn get_request(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Request)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_deferral(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetDeferral)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +RT_CLASS!{class BarcodeScannerHideVideoPreviewRequestEventArgs: IBarcodeScannerHideVideoPreviewRequestEventArgs} +DEFINE_IID!(IID_IBarcodeScannerProviderConnection, 3024800749, 2874, 20387, 134, 197, 73, 30, 163, 7, 128, 235); +RT_INTERFACE!{interface IBarcodeScannerProviderConnection(IBarcodeScannerProviderConnectionVtbl): IInspectable(IInspectableVtbl) [IID_IBarcodeScannerProviderConnection] { + fn get_Id(&self, out: *mut HSTRING) -> HRESULT, + fn get_VideoDeviceId(&self, out: *mut HSTRING) -> HRESULT, + fn get_SupportedSymbologies(&self, out: *mut *mut foundation::collections::IVector) -> HRESULT, + fn get_CompanyName(&self, out: *mut HSTRING) -> HRESULT, + fn put_CompanyName(&self, value: HSTRING) -> HRESULT, + fn get_Name(&self, out: *mut HSTRING) -> HRESULT, + fn put_Name(&self, value: HSTRING) -> HRESULT, + fn get_Version(&self, out: *mut HSTRING) -> HRESULT, + fn put_Version(&self, value: HSTRING) -> HRESULT, + fn Start(&self) -> HRESULT, + fn ReportScannedDataAsync(&self, report: *mut super::BarcodeScannerReport, out: *mut *mut foundation::IAsyncAction) -> HRESULT, + fn ReportTriggerStateAsync(&self, state: BarcodeScannerTriggerState, out: *mut *mut foundation::IAsyncAction) -> HRESULT, + fn ReportErrorAsync(&self, errorData: *mut super::UnifiedPosErrorData, out: *mut *mut foundation::IAsyncAction) -> HRESULT, + fn ReportErrorAsyncWithScanReport(&self, errorData: *mut super::UnifiedPosErrorData, isRetriable: bool, scanReport: *mut super::BarcodeScannerReport, out: *mut *mut foundation::IAsyncAction) -> HRESULT, + fn add_EnableScannerRequested(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_EnableScannerRequested(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn add_DisableScannerRequested(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_DisableScannerRequested(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn add_SetActiveSymbologiesRequested(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_SetActiveSymbologiesRequested(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn add_StartSoftwareTriggerRequested(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_StartSoftwareTriggerRequested(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn add_StopSoftwareTriggerRequested(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_StopSoftwareTriggerRequested(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn add_GetBarcodeSymbologyAttributesRequested(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_GetBarcodeSymbologyAttributesRequested(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn add_SetBarcodeSymbologyAttributesRequested(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_SetBarcodeSymbologyAttributesRequested(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn add_HideVideoPreviewRequested(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_HideVideoPreviewRequested(&self, token: foundation::EventRegistrationToken) -> HRESULT +}} +impl IBarcodeScannerProviderConnection { + #[inline] pub fn get_id(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Id)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} - #[inline] pub fn set_print_rotation(&self, value: PosPrinterRotation, includeBitmaps: bool) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).SetPrintRotation)(self as *const _ as *mut _, value, includeBitmaps); - if hr == S_OK { Ok(()) } else { err(hr) } + #[inline] pub fn get_video_device_id(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_VideoDeviceId)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} - #[inline] pub fn set_print_area(&self, value: foundation::Rect) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).SetPrintArea)(self as *const _ as *mut _, value); - if hr == S_OK { Ok(()) } else { err(hr) } + #[inline] pub fn get_supported_symbologies(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_SupportedSymbologies)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[cfg(feature="windows-graphics")] #[inline] pub fn set_bitmap(&self, bitmapNumber: u32, bitmap: &super::super::graphics::imaging::BitmapFrame, alignment: PosPrinterAlignment) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).SetBitmap)(self as *const _ as *mut _, bitmapNumber, bitmap as *const _ as *mut _, alignment); - if hr == S_OK { Ok(()) } else { err(hr) } + #[inline] pub fn get_company_name(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_CompanyName)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} - #[cfg(feature="windows-graphics")] #[inline] pub fn set_bitmap_custom_width_standard_align(&self, bitmapNumber: u32, bitmap: &super::super::graphics::imaging::BitmapFrame, alignment: PosPrinterAlignment, width: u32) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).SetBitmapCustomWidthStandardAlign)(self as *const _ as *mut _, bitmapNumber, bitmap as *const _ as *mut _, alignment, width); + #[inline] pub fn set_company_name(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_CompanyName)(self as *const _ as *mut _, value.get()); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[cfg(feature="windows-graphics")] #[inline] pub fn set_custom_aligned_bitmap(&self, bitmapNumber: u32, bitmap: &super::super::graphics::imaging::BitmapFrame, alignmentDistance: u32) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).SetCustomAlignedBitmap)(self as *const _ as *mut _, bitmapNumber, bitmap as *const _ as *mut _, alignmentDistance); - if hr == S_OK { Ok(()) } else { err(hr) } + #[inline] pub fn get_name(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Name)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} - #[cfg(feature="windows-graphics")] #[inline] pub fn set_bitmap_custom_width_custom_align(&self, bitmapNumber: u32, bitmap: &super::super::graphics::imaging::BitmapFrame, alignmentDistance: u32, width: u32) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).SetBitmapCustomWidthCustomAlign)(self as *const _ as *mut _, bitmapNumber, bitmap as *const _ as *mut _, alignmentDistance, width); + #[inline] pub fn set_name(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Name)(self as *const _ as *mut _, value.get()); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn print_saved_bitmap(&self, bitmapNumber: u32) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).PrintSavedBitmap)(self as *const _ as *mut _, bitmapNumber); - if hr == S_OK { Ok(()) } else { err(hr) } + #[inline] pub fn get_version(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Version)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} - #[inline] pub fn draw_ruled_line(&self, positionList: &HStringArg, lineDirection: PosPrinterLineDirection, lineWidth: u32, lineStyle: PosPrinterLineStyle, lineColor: u32) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).DrawRuledLine)(self as *const _ as *mut _, positionList.get(), lineDirection, lineWidth, lineStyle, lineColor); + #[inline] pub fn set_version(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Version)(self as *const _ as *mut _, value.get()); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn print_barcode(&self, data: &HStringArg, symbology: u32, height: u32, width: u32, textPosition: PosPrinterBarcodeTextPosition, alignment: PosPrinterAlignment) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).PrintBarcode)(self as *const _ as *mut _, data.get(), symbology, height, width, textPosition, alignment); + #[inline] pub fn start(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).Start)(self as *const _ as *mut _); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[inline] pub fn print_barcode_custom_align(&self, data: &HStringArg, symbology: u32, height: u32, width: u32, textPosition: PosPrinterBarcodeTextPosition, alignmentDistance: u32) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).PrintBarcodeCustomAlign)(self as *const _ as *mut _, data.get(), symbology, height, width, textPosition, alignmentDistance); + #[inline] pub fn report_scanned_data_async(&self, report: &super::BarcodeScannerReport) -> Result> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).ReportScannedDataAsync)(self as *const _ as *mut _, report as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn report_trigger_state_async(&self, state: BarcodeScannerTriggerState) -> Result> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).ReportTriggerStateAsync)(self as *const _ as *mut _, state, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn report_error_async(&self, errorData: &super::UnifiedPosErrorData) -> Result> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).ReportErrorAsync)(self as *const _ as *mut _, errorData as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn report_error_async_with_scan_report(&self, errorData: &super::UnifiedPosErrorData, isRetriable: bool, scanReport: &super::BarcodeScannerReport) -> Result> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).ReportErrorAsyncWithScanReport)(self as *const _ as *mut _, errorData as *const _ as *mut _, isRetriable, scanReport as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn add_enable_scanner_requested(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_EnableScannerRequested)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_enable_scanner_requested(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_EnableScannerRequested)(self as *const _ as *mut _, token); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[cfg(feature="windows-graphics")] #[inline] pub fn print_bitmap(&self, bitmap: &super::super::graphics::imaging::BitmapFrame, alignment: PosPrinterAlignment) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).PrintBitmap)(self as *const _ as *mut _, bitmap as *const _ as *mut _, alignment); + #[inline] pub fn add_disable_scanner_requested(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_DisableScannerRequested)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_disable_scanner_requested(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_DisableScannerRequested)(self as *const _ as *mut _, token); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[cfg(feature="windows-graphics")] #[inline] pub fn print_bitmap_custom_width_standard_align(&self, bitmap: &super::super::graphics::imaging::BitmapFrame, alignment: PosPrinterAlignment, width: u32) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).PrintBitmapCustomWidthStandardAlign)(self as *const _ as *mut _, bitmap as *const _ as *mut _, alignment, width); + #[inline] pub fn add_set_active_symbologies_requested(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_SetActiveSymbologiesRequested)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_set_active_symbologies_requested(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_SetActiveSymbologiesRequested)(self as *const _ as *mut _, token); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[cfg(feature="windows-graphics")] #[inline] pub fn print_custom_aligned_bitmap(&self, bitmap: &super::super::graphics::imaging::BitmapFrame, alignmentDistance: u32) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).PrintCustomAlignedBitmap)(self as *const _ as *mut _, bitmap as *const _ as *mut _, alignmentDistance); + #[inline] pub fn add_start_software_trigger_requested(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_StartSoftwareTriggerRequested)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_start_software_trigger_requested(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_StartSoftwareTriggerRequested)(self as *const _ as *mut _, token); if hr == S_OK { Ok(()) } else { err(hr) } }} - #[cfg(feature="windows-graphics")] #[inline] pub fn print_bitmap_custom_width_custom_align(&self, bitmap: &super::super::graphics::imaging::BitmapFrame, alignmentDistance: u32, width: u32) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).PrintBitmapCustomWidthCustomAlign)(self as *const _ as *mut _, bitmap as *const _ as *mut _, alignmentDistance, width); + #[inline] pub fn add_stop_software_trigger_requested(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_StopSoftwareTriggerRequested)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_stop_software_trigger_requested(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_StopSoftwareTriggerRequested)(self as *const _ as *mut _, token); if hr == S_OK { Ok(()) } else { err(hr) } }} -} -DEFINE_IID!(IID_IReceiptPrinterCapabilities, 3102782863, 20904, 17404, 155, 213, 141, 226, 114, 166, 65, 91); -RT_INTERFACE!{interface IReceiptPrinterCapabilities(IReceiptPrinterCapabilitiesVtbl): IInspectable(IInspectableVtbl) [IID_IReceiptPrinterCapabilities] { - fn get_CanCutPaper(&self, out: *mut bool) -> HRESULT, - fn get_IsStampSupported(&self, out: *mut bool) -> HRESULT, - fn get_MarkFeedCapabilities(&self, out: *mut PosPrinterMarkFeedCapabilities) -> HRESULT -}} -impl IReceiptPrinterCapabilities { - #[inline] pub fn get_can_cut_paper(&self) -> Result { unsafe { + #[inline] pub fn add_get_barcode_symbology_attributes_requested(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_CanCutPaper)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).add_GetBarcodeSymbologyAttributesRequested)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_is_stamp_supported(&self) -> Result { unsafe { + #[inline] pub fn remove_get_barcode_symbology_attributes_requested(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_GetBarcodeSymbologyAttributesRequested)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_set_barcode_symbology_attributes_requested(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_IsStampSupported)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).add_SetBarcodeSymbologyAttributesRequested)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_mark_feed_capabilities(&self) -> Result { unsafe { + #[inline] pub fn remove_set_barcode_symbology_attributes_requested(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_SetBarcodeSymbologyAttributesRequested)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_hide_video_preview_requested(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_MarkFeedCapabilities)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).add_HideVideoPreviewRequested)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} + #[inline] pub fn remove_hide_video_preview_requested(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_HideVideoPreviewRequested)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} } -RT_CLASS!{class ReceiptPrinterCapabilities: IReceiptPrinterCapabilities} -DEFINE_IID!(IID_IReceiptPrintJob, 2861958766, 44205, 19321, 157, 15, 192, 207, 192, 141, 199, 123); -RT_INTERFACE!{interface IReceiptPrintJob(IReceiptPrintJobVtbl): IInspectable(IInspectableVtbl) [IID_IReceiptPrintJob] { - fn MarkFeed(&self, kind: PosPrinterMarkFeedKind) -> HRESULT, - fn CutPaper(&self, percentage: f64) -> HRESULT, - fn CutPaperDefault(&self) -> HRESULT +RT_CLASS!{class BarcodeScannerProviderConnection: IBarcodeScannerProviderConnection} +DEFINE_IID!(IID_IBarcodeScannerProviderTriggerDetails, 1350921602, 9443, 18638, 153, 199, 112, 170, 193, 203, 201, 247); +RT_INTERFACE!{interface IBarcodeScannerProviderTriggerDetails(IBarcodeScannerProviderTriggerDetailsVtbl): IInspectable(IInspectableVtbl) [IID_IBarcodeScannerProviderTriggerDetails] { + fn get_Connection(&self, out: *mut *mut BarcodeScannerProviderConnection) -> HRESULT }} -impl IReceiptPrintJob { - #[inline] pub fn mark_feed(&self, kind: PosPrinterMarkFeedKind) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).MarkFeed)(self as *const _ as *mut _, kind); - if hr == S_OK { Ok(()) } else { err(hr) } +impl IBarcodeScannerProviderTriggerDetails { + #[inline] pub fn get_connection(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Connection)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn cut_paper(&self, percentage: f64) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).CutPaper)(self as *const _ as *mut _, percentage); - if hr == S_OK { Ok(()) } else { err(hr) } +} +RT_CLASS!{class BarcodeScannerProviderTriggerDetails: IBarcodeScannerProviderTriggerDetails} +DEFINE_IID!(IID_IBarcodeScannerSetActiveSymbologiesRequest, 3678352057, 63450, 16801, 159, 121, 7, 188, 217, 95, 11, 223); +RT_INTERFACE!{interface IBarcodeScannerSetActiveSymbologiesRequest(IBarcodeScannerSetActiveSymbologiesRequestVtbl): IInspectable(IInspectableVtbl) [IID_IBarcodeScannerSetActiveSymbologiesRequest] { + fn get_Symbologies(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT, + fn ReportCompletedAsync(&self, out: *mut *mut foundation::IAsyncAction) -> HRESULT, + fn ReportFailedAsync(&self, out: *mut *mut foundation::IAsyncAction) -> HRESULT +}} +impl IBarcodeScannerSetActiveSymbologiesRequest { + #[inline] pub fn get_symbologies(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Symbologies)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn cut_paper_default(&self) -> Result<()> { unsafe { - let hr = ((*self.lpVtbl).CutPaperDefault)(self as *const _ as *mut _); - if hr == S_OK { Ok(()) } else { err(hr) } + #[inline] pub fn report_completed_async(&self) -> Result> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).ReportCompletedAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn report_failed_async(&self) -> Result> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).ReportFailedAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } -RT_CLASS!{class ReceiptPrintJob: IReceiptPrintJob} -DEFINE_IID!(IID_ISlipPrinterCapabilities, 2578539417, 18572, 16727, 138, 194, 159, 87, 247, 8, 211, 219); -RT_INTERFACE!{interface ISlipPrinterCapabilities(ISlipPrinterCapabilitiesVtbl): IInspectable(IInspectableVtbl) [IID_ISlipPrinterCapabilities] { - fn get_IsFullLengthSupported(&self, out: *mut bool) -> HRESULT, - fn get_IsBothSidesPrintingSupported(&self, out: *mut bool) -> HRESULT +RT_CLASS!{class BarcodeScannerSetActiveSymbologiesRequest: IBarcodeScannerSetActiveSymbologiesRequest} +DEFINE_IID!(IID_IBarcodeScannerSetActiveSymbologiesRequestEventArgs, 103832314, 31734, 19794, 128, 26, 51, 2, 114, 246, 10, 225); +RT_INTERFACE!{interface IBarcodeScannerSetActiveSymbologiesRequestEventArgs(IBarcodeScannerSetActiveSymbologiesRequestEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IBarcodeScannerSetActiveSymbologiesRequestEventArgs] { + fn get_Request(&self, out: *mut *mut BarcodeScannerSetActiveSymbologiesRequest) -> HRESULT, + fn GetDeferral(&self, out: *mut *mut foundation::Deferral) -> HRESULT }} -impl ISlipPrinterCapabilities { - #[inline] pub fn get_is_full_length_supported(&self) -> Result { unsafe { - let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_IsFullLengthSupported)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(out) } else { err(hr) } +impl IBarcodeScannerSetActiveSymbologiesRequestEventArgs { + #[inline] pub fn get_request(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Request)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn get_is_both_sides_printing_supported(&self) -> Result { unsafe { + #[inline] pub fn get_deferral(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetDeferral)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +RT_CLASS!{class BarcodeScannerSetActiveSymbologiesRequestEventArgs: IBarcodeScannerSetActiveSymbologiesRequestEventArgs} +DEFINE_IID!(IID_IBarcodeScannerSetSymbologyAttributesRequest, 855343439, 41855, 18608, 172, 234, 220, 225, 72, 15, 18, 174); +RT_INTERFACE!{interface IBarcodeScannerSetSymbologyAttributesRequest(IBarcodeScannerSetSymbologyAttributesRequestVtbl): IInspectable(IInspectableVtbl) [IID_IBarcodeScannerSetSymbologyAttributesRequest] { + fn get_Symbology(&self, out: *mut u32) -> HRESULT, + fn get_Attributes(&self, out: *mut *mut super::BarcodeSymbologyAttributes) -> HRESULT, + fn ReportCompletedAsync(&self, out: *mut *mut foundation::IAsyncAction) -> HRESULT, + fn ReportFailedAsync(&self, out: *mut *mut foundation::IAsyncAction) -> HRESULT +}} +impl IBarcodeScannerSetSymbologyAttributesRequest { + #[inline] pub fn get_symbology(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_IsBothSidesPrintingSupported)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_Symbology)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} + #[inline] pub fn get_attributes(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Attributes)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn report_completed_async(&self) -> Result> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).ReportCompletedAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn report_failed_async(&self) -> Result> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).ReportFailedAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} } -RT_CLASS!{class SlipPrinterCapabilities: ISlipPrinterCapabilities} -RT_CLASS!{class SlipPrintJob: IReceiptOrSlipJob} -DEFINE_IID!(IID_IUnifiedPosErrorData, 731483194, 21852, 18569, 142, 216, 197, 153, 187, 58, 113, 42); -RT_INTERFACE!{interface IUnifiedPosErrorData(IUnifiedPosErrorDataVtbl): IInspectable(IInspectableVtbl) [IID_IUnifiedPosErrorData] { - fn get_Message(&self, out: *mut HSTRING) -> HRESULT, - fn get_Severity(&self, out: *mut UnifiedPosErrorSeverity) -> HRESULT, - fn get_Reason(&self, out: *mut UnifiedPosErrorReason) -> HRESULT, - fn get_ExtendedReason(&self, out: *mut u32) -> HRESULT +RT_CLASS!{class BarcodeScannerSetSymbologyAttributesRequest: IBarcodeScannerSetSymbologyAttributesRequest} +DEFINE_IID!(IID_IBarcodeScannerSetSymbologyAttributesRequestEventArgs, 2998441993, 38948, 18388, 133, 189, 208, 7, 123, 170, 123, 210); +RT_INTERFACE!{interface IBarcodeScannerSetSymbologyAttributesRequestEventArgs(IBarcodeScannerSetSymbologyAttributesRequestEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IBarcodeScannerSetSymbologyAttributesRequestEventArgs] { + fn get_Request(&self, out: *mut *mut BarcodeScannerSetSymbologyAttributesRequest) -> HRESULT, + fn GetDeferral(&self, out: *mut *mut foundation::Deferral) -> HRESULT }} -impl IUnifiedPosErrorData { - #[inline] pub fn get_message(&self) -> Result { unsafe { +impl IBarcodeScannerSetSymbologyAttributesRequestEventArgs { + #[inline] pub fn get_request(&self) -> Result>> { unsafe { let mut out = null_mut(); - let hr = ((*self.lpVtbl).get_Message)(self as *const _ as *mut _, &mut out); - if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + let hr = ((*self.lpVtbl).get_Request)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} - #[inline] pub fn get_severity(&self) -> Result { unsafe { + #[inline] pub fn get_deferral(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetDeferral)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +RT_CLASS!{class BarcodeScannerSetSymbologyAttributesRequestEventArgs: IBarcodeScannerSetSymbologyAttributesRequestEventArgs} +DEFINE_IID!(IID_IBarcodeScannerStartSoftwareTriggerRequest, 3824843559, 65378, 17492, 175, 74, 203, 97, 68, 163, 227, 247); +RT_INTERFACE!{interface IBarcodeScannerStartSoftwareTriggerRequest(IBarcodeScannerStartSoftwareTriggerRequestVtbl): IInspectable(IInspectableVtbl) [IID_IBarcodeScannerStartSoftwareTriggerRequest] { + fn ReportCompletedAsync(&self, out: *mut *mut foundation::IAsyncAction) -> HRESULT, + fn ReportFailedAsync(&self, out: *mut *mut foundation::IAsyncAction) -> HRESULT +}} +impl IBarcodeScannerStartSoftwareTriggerRequest { + #[inline] pub fn report_completed_async(&self) -> Result> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).ReportCompletedAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn report_failed_async(&self) -> Result> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).ReportFailedAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} +} +RT_CLASS!{class BarcodeScannerStartSoftwareTriggerRequest: IBarcodeScannerStartSoftwareTriggerRequest} +DEFINE_IID!(IID_IBarcodeScannerStartSoftwareTriggerRequestEventArgs, 587585603, 51343, 20283, 140, 59, 211, 223, 7, 16, 81, 236); +RT_INTERFACE!{interface IBarcodeScannerStartSoftwareTriggerRequestEventArgs(IBarcodeScannerStartSoftwareTriggerRequestEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IBarcodeScannerStartSoftwareTriggerRequestEventArgs] { + fn get_Request(&self, out: *mut *mut BarcodeScannerStartSoftwareTriggerRequest) -> HRESULT, + fn GetDeferral(&self, out: *mut *mut foundation::Deferral) -> HRESULT +}} +impl IBarcodeScannerStartSoftwareTriggerRequestEventArgs { + #[inline] pub fn get_request(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Request)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_deferral(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetDeferral)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +RT_CLASS!{class BarcodeScannerStartSoftwareTriggerRequestEventArgs: IBarcodeScannerStartSoftwareTriggerRequestEventArgs} +DEFINE_IID!(IID_IBarcodeScannerStopSoftwareTriggerRequest, 1872736053, 57991, 19624, 183, 13, 90, 145, 214, 148, 246, 104); +RT_INTERFACE!{interface IBarcodeScannerStopSoftwareTriggerRequest(IBarcodeScannerStopSoftwareTriggerRequestVtbl): IInspectable(IInspectableVtbl) [IID_IBarcodeScannerStopSoftwareTriggerRequest] { + fn ReportCompletedAsync(&self, out: *mut *mut foundation::IAsyncAction) -> HRESULT, + fn ReportFailedAsync(&self, out: *mut *mut foundation::IAsyncAction) -> HRESULT +}} +impl IBarcodeScannerStopSoftwareTriggerRequest { + #[inline] pub fn report_completed_async(&self) -> Result> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).ReportCompletedAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn report_failed_async(&self) -> Result> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).ReportFailedAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} +} +RT_CLASS!{class BarcodeScannerStopSoftwareTriggerRequest: IBarcodeScannerStopSoftwareTriggerRequest} +DEFINE_IID!(IID_IBarcodeScannerStopSoftwareTriggerRequestEventArgs, 3938665552, 20151, 18458, 146, 115, 20, 122, 39, 59, 153, 184); +RT_INTERFACE!{interface IBarcodeScannerStopSoftwareTriggerRequestEventArgs(IBarcodeScannerStopSoftwareTriggerRequestEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IBarcodeScannerStopSoftwareTriggerRequestEventArgs] { + fn get_Request(&self, out: *mut *mut BarcodeScannerStopSoftwareTriggerRequest) -> HRESULT, + fn GetDeferral(&self, out: *mut *mut foundation::Deferral) -> HRESULT +}} +impl IBarcodeScannerStopSoftwareTriggerRequestEventArgs { + #[inline] pub fn get_request(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Request)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_deferral(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetDeferral)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +RT_CLASS!{class BarcodeScannerStopSoftwareTriggerRequestEventArgs: IBarcodeScannerStopSoftwareTriggerRequestEventArgs} +RT_ENUM! { enum BarcodeScannerTriggerState: i32 { + Released (BarcodeScannerTriggerState_Released) = 0, Pressed (BarcodeScannerTriggerState_Pressed) = 1, +}} +DEFINE_IID!(IID_IBarcodeSymbologyAttributesBuilder, 3313175743, 58613, 16569, 132, 207, 230, 63, 186, 234, 66, 180); +RT_INTERFACE!{interface IBarcodeSymbologyAttributesBuilder(IBarcodeSymbologyAttributesBuilderVtbl): IInspectable(IInspectableVtbl) [IID_IBarcodeSymbologyAttributesBuilder] { + fn get_IsCheckDigitValidationSupported(&self, out: *mut bool) -> HRESULT, + fn put_IsCheckDigitValidationSupported(&self, value: bool) -> HRESULT, + fn get_IsCheckDigitTransmissionSupported(&self, out: *mut bool) -> HRESULT, + fn put_IsCheckDigitTransmissionSupported(&self, value: bool) -> HRESULT, + fn get_IsDecodeLengthSupported(&self, out: *mut bool) -> HRESULT, + fn put_IsDecodeLengthSupported(&self, value: bool) -> HRESULT, + fn CreateAttributes(&self, out: *mut *mut super::BarcodeSymbologyAttributes) -> HRESULT +}} +impl IBarcodeSymbologyAttributesBuilder { + #[inline] pub fn get_is_check_digit_validation_supported(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_Severity)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_IsCheckDigitValidationSupported)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_reason(&self) -> Result { unsafe { + #[inline] pub fn set_is_check_digit_validation_supported(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_IsCheckDigitValidationSupported)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_is_check_digit_transmission_supported(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_Reason)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_IsCheckDigitTransmissionSupported)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} - #[inline] pub fn get_extended_reason(&self) -> Result { unsafe { + #[inline] pub fn set_is_check_digit_transmission_supported(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_IsCheckDigitTransmissionSupported)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_is_decode_length_supported(&self) -> Result { unsafe { let mut out = zeroed(); - let hr = ((*self.lpVtbl).get_ExtendedReason)(self as *const _ as *mut _, &mut out); + let hr = ((*self.lpVtbl).get_IsDecodeLengthSupported)(self as *const _ as *mut _, &mut out); if hr == S_OK { Ok(out) } else { err(hr) } }} + #[inline] pub fn set_is_decode_length_supported(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_IsDecodeLengthSupported)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn create_attributes(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreateAttributes)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} } -RT_CLASS!{class UnifiedPosErrorData: IUnifiedPosErrorData} -RT_ENUM! { enum UnifiedPosErrorReason: i32 { - UnknownErrorReason (UnifiedPosErrorReason_UnknownErrorReason) = 0, NoService (UnifiedPosErrorReason_NoService) = 1, Disabled (UnifiedPosErrorReason_Disabled) = 2, Illegal (UnifiedPosErrorReason_Illegal) = 3, NoHardware (UnifiedPosErrorReason_NoHardware) = 4, Closed (UnifiedPosErrorReason_Closed) = 5, Offline (UnifiedPosErrorReason_Offline) = 6, Failure (UnifiedPosErrorReason_Failure) = 7, Timeout (UnifiedPosErrorReason_Timeout) = 8, Busy (UnifiedPosErrorReason_Busy) = 9, Extended (UnifiedPosErrorReason_Extended) = 10, -}} -RT_ENUM! { enum UnifiedPosErrorSeverity: i32 { - UnknownErrorSeverity (UnifiedPosErrorSeverity_UnknownErrorSeverity) = 0, Warning (UnifiedPosErrorSeverity_Warning) = 1, Recoverable (UnifiedPosErrorSeverity_Recoverable) = 2, Unrecoverable (UnifiedPosErrorSeverity_Unrecoverable) = 3, AssistanceRequired (UnifiedPosErrorSeverity_AssistanceRequired) = 4, Fatal (UnifiedPosErrorSeverity_Fatal) = 5, -}} -RT_ENUM! { enum UnifiedPosHealthCheckLevel: i32 { - UnknownHealthCheckLevel (UnifiedPosHealthCheckLevel_UnknownHealthCheckLevel) = 0, POSInternal (UnifiedPosHealthCheckLevel_POSInternal) = 1, External (UnifiedPosHealthCheckLevel_External) = 2, Interactive (UnifiedPosHealthCheckLevel_Interactive) = 3, -}} -RT_ENUM! { enum UnifiedPosPowerReportingType: i32 { - UnknownPowerReportingType (UnifiedPosPowerReportingType_UnknownPowerReportingType) = 0, Standard (UnifiedPosPowerReportingType_Standard) = 1, Advanced (UnifiedPosPowerReportingType_Advanced) = 2, -}} +RT_CLASS!{class BarcodeSymbologyAttributesBuilder: IBarcodeSymbologyAttributesBuilder} +impl RtActivatable for BarcodeSymbologyAttributesBuilder {} +DEFINE_CLSID!(BarcodeSymbologyAttributesBuilder(&[87,105,110,100,111,119,115,46,68,101,118,105,99,101,115,46,80,111,105,110,116,79,102,83,101,114,118,105,99,101,46,80,114,111,118,105,100,101,114,46,66,97,114,99,111,100,101,83,121,109,98,111,108,111,103,121,65,116,116,114,105,98,117,116,101,115,66,117,105,108,100,101,114,0]) [CLSID_BarcodeSymbologyAttributesBuilder]); +} // Windows.Devices.PointOfService.Provider } // Windows.Devices.PointOfService pub mod radios { // Windows.Devices.Radios use ::prelude::*; diff --git a/src/rt/gen/windows/foundation.rs b/src/rt/gen/windows/foundation.rs index 24aae84..d422e36 100644 --- a/src/rt/gen/windows/foundation.rs +++ b/src/rt/gen/windows/foundation.rs @@ -1225,6 +1225,7 @@ RT_PINTERFACE!{ for AsyncActionWithProgressCompletedHandler => [0xe6ff857b, RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0xc1d3d1a2,0xae17,0x5a5f,0xb5,0xa2,0xbd,0xcc,0x88,0x44,0x88,0x9a] as IID_AsyncOperationCompletedHandler_1_System_Boolean } RT_PINTERFACE!{ for AsyncOperationCompletedHandler> => [0x39bb624e,0xb5c6,0x5785,0xba,0x46,0x3f,0x45,0xaa,0xf3,0xef,0x35] as IID_AsyncOperationCompletedHandler_1_Windows_Foundation_Collections_IMap_2_System_String_System_String } RT_PINTERFACE!{ for AsyncOperationCompletedHandler> => [0x7344f356,0x8399,0x5756,0xa2,0xf8,0xab,0xd5,0x0c,0x41,0x46,0xff] as IID_AsyncOperationCompletedHandler_1_Windows_Foundation_Collections_IMap_2_System_String_System_Object } +RT_PINTERFACE!{ for AsyncOperationCompletedHandler> => [0x75e3182c,0xe6e1,0x589c,0xab,0x73,0xe8,0x64,0x4b,0xc2,0x85,0xbf] as IID_AsyncOperationCompletedHandler_1_Windows_Foundation_Collections_IMapView_2_System_String_System_String } RT_PINTERFACE!{ for AsyncOperationCompletedHandler> => [0x89981889,0x1207,0x5ae6,0x9b,0x28,0xcc,0xc5,0x8f,0x3a,0xac,0x6e] as IID_AsyncOperationCompletedHandler_1_Windows_Foundation_Collections_IMapView_2_System_String_System_Object } #[cfg(feature="windows-perception")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler> => [0x3a950aa3,0x9c65,0x586e,0xaf,0x75,0x1a,0xcf,0x07,0x19,0x0e,0x90] as IID_AsyncOperationCompletedHandler_1_Windows_Foundation_Collections_IMapView_2_System_String_Windows_Perception_Spatial_SpatialAnchor } #[cfg(feature="windows-storage")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler> => [0xd4cb6b80,0x821a,0x5a7b,0x89,0x8d,0xd5,0x89,0x17,0xb3,0x1a,0x36] as IID_AsyncOperationCompletedHandler_1_Windows_Foundation_Collections_IMapView_2_System_String_Windows_Storage_Streams_RandomAccessStreamReference } @@ -1233,6 +1234,7 @@ RT_PINTERFACE!{ for AsyncOperationCompletedHandler => RT_PINTERFACE!{ for AsyncOperationCompletedHandler> => [0xfae4b396,0x97c8,0x5cc3,0xbf,0x88,0xea,0x30,0x98,0xed,0xf6,0xb2] as IID_AsyncOperationCompletedHandler_1_Windows_Foundation_Collections_IVector_1_System_String } #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler> => [0x589b0543,0xeeae,0x5ca2,0xa6,0x3b,0x76,0x01,0x0c,0x64,0xfc,0xcb] as IID_AsyncOperationCompletedHandler_1_Windows_Foundation_Collections_IVector_1_Windows_ApplicationModel_Contacts_Contact } #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler> => [0x52465bf3,0x3ca6,0x5681,0xa7,0xb4,0x91,0x84,0x77,0x57,0xb5,0xfd] as IID_AsyncOperationCompletedHandler_1_Windows_Foundation_Collections_IVector_1_Windows_ApplicationModel_PackageContentGroup } +#[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler> => [0x3df67ad8,0x7d8d,0x52bd,0x98,0x92,0x0f,0xf9,0xbf,0x93,0xfc,0x80] as IID_AsyncOperationCompletedHandler_1_Windows_Foundation_Collections_IVector_1_Windows_ApplicationModel_UserActivities_UserActivitySessionHistoryItem } #[cfg(feature="windows-media")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler> => [0xb0a53153,0x2015,0x58b3,0x9d,0xd0,0xbd,0xf2,0x91,0xb8,0x56,0xb2] as IID_AsyncOperationCompletedHandler_1_Windows_Foundation_Collections_IVector_1_Windows_Media_FaceAnalysis_DetectedFace } #[cfg(feature="windows-system")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler> => [0xcc3f5f7e,0x4160,0x567f,0xa0,0xf6,0xaa,0x9a,0xeb,0x18,0x7a,0xf3] as IID_AsyncOperationCompletedHandler_1_Windows_Foundation_Collections_IVector_1_Windows_System_AppDiagnosticInfo } RT_PINTERFACE!{ for AsyncOperationCompletedHandler>> => [0xa782a13a,0x16a0,0x5326,0xb9,0x85,0xc4,0xca,0x49,0xe5,0x4e,0x77] as IID_AsyncOperationCompletedHandler_1_Windows_Foundation_Collections_IVectorView_1_Windows_Foundation_Collections_IMapView_2_System_String_System_Object } @@ -1316,6 +1318,7 @@ RT_PINTERFACE!{ for AsyncOperationCompletedHandler> => [0xc2090d8c,0x37d8,0x5c47,0x95,0x81,0x0f,0x17,0xb9,0x1a,0x0c,0xd3] as IID_AsyncOperationCompletedHandler_1_Windows_Foundation_Collections_IVectorView_1_Windows_Security_Credentials_WebAccount } #[cfg(feature="windows-security")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler> => [0x1896faee,0x23e2,0x59ca,0x98,0x02,0x0f,0x48,0xee,0xd9,0x8e,0xf4] as IID_AsyncOperationCompletedHandler_1_Windows_Foundation_Collections_IVectorView_1_Windows_Security_Cryptography_Certificates_Certificate } #[cfg(feature="windows-services")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler> => [0xf8491bcd,0x2db5,0x58e0,0x8c,0x47,0x44,0xe6,0xeb,0x10,0xc1,0x2d] as IID_AsyncOperationCompletedHandler_1_Windows_Foundation_Collections_IVectorView_1_Windows_Services_Store_StorePackageUpdate } +#[cfg(feature="windows-services")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler> => [0x776b0864,0xb93d,0x5669,0xa7,0x5d,0x70,0xa2,0x93,0x25,0xe9,0x19] as IID_AsyncOperationCompletedHandler_1_Windows_Foundation_Collections_IVectorView_1_Windows_Services_Store_StoreQueueItem } #[cfg(feature="windows-storage")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler> => [0xebdb2c85,0xd27a,0x5c93,0xa1,0xb3,0x6c,0xa3,0x65,0x1a,0xda,0x5d] as IID_AsyncOperationCompletedHandler_1_Windows_Foundation_Collections_IVectorView_1_Windows_Storage_BulkAccess_FileInformation } #[cfg(feature="windows-storage")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler> => [0x020713ec,0x604a,0x5e45,0xb0,0x3f,0x1b,0x9e,0x65,0x25,0x38,0x04] as IID_AsyncOperationCompletedHandler_1_Windows_Foundation_Collections_IVectorView_1_Windows_Storage_BulkAccess_FolderInformation } #[cfg(feature="windows-storage")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler> => [0xff163034,0xece9,0x55be,0xa6,0xf8,0x08,0xc7,0x2a,0xae,0x56,0xb4] as IID_AsyncOperationCompletedHandler_1_Windows_Foundation_Collections_IVectorView_1_Windows_Storage_BulkAccess_IStorageItemInformation } @@ -1324,6 +1327,7 @@ RT_PINTERFACE!{ for AsyncOperationCompletedHandler> => [0xcb4206c5,0x0988,0x5104,0xaf,0xa9,0x25,0x3c,0x29,0x8f,0x86,0xfd] as IID_AsyncOperationCompletedHandler_1_Windows_Foundation_Collections_IVectorView_1_Windows_Storage_StorageFile } #[cfg(feature="windows-storage")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler> => [0xed2d1d9b,0x26ec,0x5be7,0xa8,0xa3,0x56,0x45,0x89,0x33,0xd2,0x5f] as IID_AsyncOperationCompletedHandler_1_Windows_Foundation_Collections_IVectorView_1_Windows_Storage_StorageFolder } #[cfg(feature="windows-storage")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler> => [0xab9cea41,0x6df8,0x535d,0x81,0x71,0x46,0xaf,0xf1,0x87,0x15,0x8f] as IID_AsyncOperationCompletedHandler_1_Windows_Foundation_Collections_IVectorView_1_Windows_Storage_StorageLibraryChange } +#[cfg(feature="windows-system")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler> => [0xeb945c7c,0x7edd,0x565a,0x8b,0xcc,0x82,0xba,0xf4,0xea,0x17,0xb6] as IID_AsyncOperationCompletedHandler_1_Windows_Foundation_Collections_IVectorView_1_Windows_System_Inventory_InstalledDesktopApp } #[cfg(feature="windows-system")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler> => [0x09870533,0xf7cb,0x569c,0xb7,0x97,0xdc,0xb4,0x8d,0xeb,0xd7,0x09] as IID_AsyncOperationCompletedHandler_1_Windows_Foundation_Collections_IVectorView_1_Windows_System_User } #[cfg(feature="windows-ui")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler> => [0xece8567f,0x8080,0x5ced,0x89,0x88,0xbb,0x03,0x64,0xc8,0x03,0xd4] as IID_AsyncOperationCompletedHandler_1_Windows_Foundation_Collections_IVectorView_1_Windows_UI_Input_Inking_InkRecognitionResult } #[cfg(feature="windows-ui")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler> => [0x4650e069,0x3052,0x530e,0xbc,0x38,0x93,0xc4,0x11,0x77,0x3b,0x77] as IID_AsyncOperationCompletedHandler_1_Windows_Foundation_Collections_IVectorView_1_Windows_UI_Notifications_ToastCollection } @@ -1338,6 +1342,8 @@ RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0xd3ef5872,0x7d4e,0x RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0x3f08262e,0xa2e1,0x5134,0x92,0x97,0xe9,0x21,0x1f,0x48,0x1a,0x2d] as IID_AsyncOperationCompletedHandler_1_System_Object } RT_PINTERFACE!{ for AsyncOperationCompletedHandler> => [0xc4225d5e,0x1b7c,0x571e,0x9b,0x88,0x2a,0xb2,0xee,0xfa,0x8c,0x8f] as IID_AsyncOperationCompletedHandler_1_Windows_Foundation_IReference_1_Windows_Foundation_DateTime } RT_PINTERFACE!{ for AsyncOperationCompletedHandler> => [0xe137b677,0xbfef,0x54b0,0xb2,0x00,0x95,0xc5,0xc2,0x90,0x2a,0x25] as IID_AsyncOperationCompletedHandler_1_Windows_Foundation_IReference_1_Windows_Foundation_TimeSpan } +#[cfg(feature="windows-ai")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0xf21682d4,0x4fcb,0x5ad7,0x9b,0x4e,0x1f,0xe9,0xc5,0x94,0x2b,0xfb] as IID_AsyncOperationCompletedHandler_1_Windows_AI_MachineLearning_Preview_LearningModelEvaluationResultPreview } +#[cfg(feature="windows-ai")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0xa76c9ad9,0x6f09,0x5d01,0x8c,0x1f,0x51,0x66,0x23,0xcb,0xfa,0x85] as IID_AsyncOperationCompletedHandler_1_Windows_AI_MachineLearning_Preview_LearningModelPreview } #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0xb640ed04,0x9331,0x5b28,0x92,0x47,0x01,0x46,0xbc,0xf5,0xb7,0x2a] as IID_AsyncOperationCompletedHandler_1_Windows_ApplicationModel_Appointments_Appointment } #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0x6d9cb651,0x5af6,0x51b0,0x9c,0xd3,0x45,0xdd,0x51,0xf1,0x79,0x49] as IID_AsyncOperationCompletedHandler_1_Windows_ApplicationModel_Appointments_AppointmentCalendar } #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0x82fb40fe,0x05b1,0x523c,0x9b,0x53,0xb3,0xdd,0x75,0x9c,0x9f,0x75] as IID_AsyncOperationCompletedHandler_1_Windows_ApplicationModel_Appointments_AppointmentConflictResult } @@ -1390,6 +1396,7 @@ RT_PINTERFACE!{ for AsyncOperationCompletedHandler> => [0xe #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0x07e1dc01,0x18ba,0x596a,0xb7,0x45,0x79,0xf9,0xcd,0xe4,0x4c,0xcc] as IID_AsyncOperationCompletedHandler_1_Windows_ApplicationModel_ExtendedExecution_Foreground_ExtendedExecutionForegroundResult } #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0x6c5f9b5d,0x3c24,0x5087,0xae,0x15,0x6a,0xb4,0x94,0x2c,0x46,0x39] as IID_AsyncOperationCompletedHandler_1_Windows_ApplicationModel_PackageCatalogAddOptionalPackageResult } #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0xf168612c,0x6882,0x5c8c,0xa4,0x64,0x7e,0xa2,0x5e,0x26,0x98,0x76] as IID_AsyncOperationCompletedHandler_1_Windows_ApplicationModel_PackageCatalogRemoveOptionalPackagesResult } +#[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0x142b78d7,0x5cc3,0x5b40,0xa5,0x8d,0x43,0xa5,0x82,0xca,0x83,0xea] as IID_AsyncOperationCompletedHandler_1_Windows_ApplicationModel_PackageCatalogRemoveResourcePackagesResult } #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0x2253dc38,0x9a1a,0x5364,0x9a,0x3b,0x03,0xa7,0xda,0x61,0x54,0x99] as IID_AsyncOperationCompletedHandler_1_Windows_ApplicationModel_PackageContentGroup } #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0x89ae5b89,0x6d05,0x5842,0x9c,0xdf,0xf4,0xcb,0xf7,0x06,0xdc,0x5e] as IID_AsyncOperationCompletedHandler_1_Windows_ApplicationModel_Payments_PaymentCanMakePaymentResult } #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0xbec8b726,0x9056,0x5e47,0xb2,0x2a,0x0d,0xa0,0x9a,0xa8,0x4a,0xfe] as IID_AsyncOperationCompletedHandler_1_Windows_ApplicationModel_Payments_PaymentRequestChangedResult } @@ -1450,6 +1457,7 @@ RT_PINTERFACE!{ for AsyncOperationCompletedHandler> => [0xe #[cfg(feature="windows-devices")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0x522c25d1,0x866b,0x5de4,0xbd,0x8e,0x1f,0xeb,0x5a,0xe6,0x0d,0x47] as IID_AsyncOperationCompletedHandler_1_Windows_Devices_Bluetooth_Rfcomm_RfcommDeviceServicesResult } #[cfg(feature="windows-devices")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0x446a7f50,0x8f2e,0x51f0,0xae,0xbb,0x1b,0xc3,0xd1,0x92,0x90,0x5f] as IID_AsyncOperationCompletedHandler_1_Windows_Devices_Bluetooth_Rfcomm_RfcommServiceProvider } #[cfg(feature="windows-devices")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0x1fdd39b0,0xe0e5,0x5c59,0xb2,0x7d,0xa5,0x49,0xb1,0x07,0x5c,0xe9] as IID_AsyncOperationCompletedHandler_1_Windows_Devices_Custom_CustomDevice } +#[cfg(feature="windows-devices")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0x620f34a8,0x5dba,0x59df,0xb7,0x19,0x99,0xb7,0x79,0x70,0x34,0x4c] as IID_AsyncOperationCompletedHandler_1_Windows_Devices_Display_DisplayMonitor } #[cfg(feature="windows-devices")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0xee154d83,0x805b,0x53e8,0x84,0x69,0x90,0x71,0x50,0x36,0xd0,0x13] as IID_AsyncOperationCompletedHandler_1_Windows_Devices_Enumeration_DeviceAccessStatus } #[cfg(feature="windows-devices")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0xbb483df2,0x7bb6,0x5923,0xa2,0x8d,0x83,0x42,0xec,0x30,0x04,0x6b] as IID_AsyncOperationCompletedHandler_1_Windows_Devices_Enumeration_DeviceInformation } #[cfg(feature="windows-devices")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0x4a458732,0x527e,0x5c73,0x9a,0x68,0xa7,0x3d,0xa3,0x70,0xf7,0x82] as IID_AsyncOperationCompletedHandler_1_Windows_Devices_Enumeration_DeviceInformationCollection } @@ -1553,6 +1561,7 @@ RT_PINTERFACE!{ for AsyncOperationCompletedHandler> => [0xe #[cfg(feature="windows-gaming")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0x05f86a80,0xbe5b,0x5e7e,0xb9,0x77,0x82,0x57,0xc5,0xe4,0x8a,0xcc] as IID_AsyncOperationCompletedHandler_1_Windows_Gaming_XboxLive_Storage_GameSaveContainerInfoGetResult } #[cfg(feature="windows-gaming")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0xee53e64f,0x5319,0x56fd,0xa2,0x8a,0x2c,0x47,0x4f,0xc4,0x2e,0x48] as IID_AsyncOperationCompletedHandler_1_Windows_Gaming_XboxLive_Storage_GameSaveOperationResult } #[cfg(feature="windows-gaming")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0x7617548d,0x8e60,0x50cb,0xa1,0x1e,0x12,0x0f,0xa2,0x08,0x2e,0x5b] as IID_AsyncOperationCompletedHandler_1_Windows_Gaming_XboxLive_Storage_GameSaveProviderGetResult } +#[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0x43004a3c,0xffe7,0x5352,0x85,0xa6,0x7b,0xc4,0x1b,0x78,0x2f,0xca] as IID_AsyncOperationCompletedHandler_1_Windows_Graphics_Capture_GraphicsCaptureItem } #[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0xbb6514f2,0x3cfb,0x566f,0x82,0xbc,0x60,0xaa,0xbd,0x30,0x2d,0x53] as IID_AsyncOperationCompletedHandler_1_Windows_Graphics_Imaging_BitmapDecoder } #[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0x5df1afc5,0x478d,0x55dd,0xb3,0x17,0x02,0x42,0x74,0x06,0x2a,0x0d] as IID_AsyncOperationCompletedHandler_1_Windows_Graphics_Imaging_BitmapEncoder } #[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0x2817455a,0x983f,0x5a06,0x9f,0xe4,0xfb,0x96,0x37,0x68,0x43,0x20] as IID_AsyncOperationCompletedHandler_1_Windows_Graphics_Imaging_BitmapFrame } @@ -1573,6 +1582,7 @@ RT_PINTERFACE!{ for AsyncOperationCompletedHandler> => [0xe #[cfg(feature="windows-media")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0x504d1efd,0xc11c,0x506e,0xb8,0xc9,0xaf,0x17,0xc7,0x71,0xef,0xb5] as IID_AsyncOperationCompletedHandler_1_Windows_Media_Audio_CreateAudioFileInputNodeResult } #[cfg(feature="windows-media")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0xa7a95713,0xa08f,0x5fdf,0x89,0xc6,0x96,0x27,0xbc,0xf5,0xd8,0x0a] as IID_AsyncOperationCompletedHandler_1_Windows_Media_Audio_CreateAudioFileOutputNodeResult } #[cfg(feature="windows-media")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0x4e660bda,0xd438,0x5741,0x8b,0x66,0x85,0xfe,0x72,0x57,0x4a,0xab] as IID_AsyncOperationCompletedHandler_1_Windows_Media_Audio_CreateAudioGraphResult } +#[cfg(feature="windows-media")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0xe471b446,0x3a01,0x5190,0x89,0xc9,0x15,0xe7,0x40,0x37,0x4c,0xfc] as IID_AsyncOperationCompletedHandler_1_Windows_Media_Audio_CreateMediaSourceAudioInputNodeResult } #[cfg(feature="windows-media")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0xedf3452c,0xd918,0x5c95,0x8e,0x3a,0x24,0x50,0x44,0xdd,0x70,0xdf] as IID_AsyncOperationCompletedHandler_1_Windows_Media_Capture_AdvancedCapturedPhoto } #[cfg(feature="windows-media")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0xd1dfaec8,0xeed3,0x5ce3,0x98,0x32,0x18,0x34,0x4c,0x98,0xfa,0x71] as IID_AsyncOperationCompletedHandler_1_Windows_Media_Capture_AdvancedPhotoCapture } #[cfg(feature="windows-media")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0xfdb0aa78,0x04e1,0x56b3,0xb6,0xfc,0xf4,0xde,0x79,0xcd,0x41,0xa0] as IID_AsyncOperationCompletedHandler_1_Windows_Media_Capture_CapturedPhoto } @@ -1627,11 +1637,14 @@ RT_PINTERFACE!{ for AsyncOperationCompletedHandler> => [0xe #[cfg(feature="windows-networking")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0xe4f0c96a,0x0571,0x59f4,0xa9,0xa9,0xaf,0xac,0x3e,0x61,0xca,0xa0] as IID_AsyncOperationCompletedHandler_1_Windows_Networking_Connectivity_ConnectionProfile } #[cfg(feature="windows-networking")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0x3bc680d8,0x9e83,0x5086,0x8f,0x49,0x7a,0x29,0xbf,0xb1,0xc7,0xe1] as IID_AsyncOperationCompletedHandler_1_Windows_Networking_Connectivity_ConnectionSession } #[cfg(feature="windows-networking")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0x035b2567,0xefb9,0x5bc3,0xb6,0x09,0xf9,0xa8,0xc2,0x0b,0x70,0x01] as IID_AsyncOperationCompletedHandler_1_Windows_Networking_Connectivity_ProxyConfiguration } +#[cfg(feature="windows-networking")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0x800d3596,0xfb0b,0x501a,0xbd,0xa6,0x80,0x24,0x09,0xc1,0xea,0x22] as IID_AsyncOperationCompletedHandler_1_Windows_Networking_NetworkOperators_ESimDownloadProfileMetadataResult } +#[cfg(feature="windows-networking")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0x15887528,0xfa3f,0x5ae2,0xbd,0x7f,0x11,0x19,0xe6,0x2d,0x85,0xb6] as IID_AsyncOperationCompletedHandler_1_Windows_Networking_NetworkOperators_ESimOperationResult } #[cfg(feature="windows-networking")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0x7f254beb,0x471f,0x5000,0x94,0xce,0x10,0x2c,0xc3,0x33,0x05,0x5f] as IID_AsyncOperationCompletedHandler_1_Windows_Networking_NetworkOperators_HotspotCredentialsAuthenticationResult } #[cfg(feature="windows-networking")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0x98f9a3f7,0x92a2,0x5431,0x90,0x2f,0x9b,0xf0,0x10,0x67,0xab,0x60] as IID_AsyncOperationCompletedHandler_1_Windows_Networking_NetworkOperators_MobileBroadbandCellsInfo } #[cfg(feature="windows-networking")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0x21f0ce4f,0x8f33,0x5e71,0xa4,0x57,0xdd,0xa5,0x53,0xb0,0xd6,0xbb] as IID_AsyncOperationCompletedHandler_1_Windows_Networking_NetworkOperators_MobileBroadbandDeviceServiceCommandResult } #[cfg(feature="windows-networking")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0xc11e0649,0x8237,0x5c93,0xbb,0xdb,0x2e,0xda,0x52,0x16,0xfd,0x3f] as IID_AsyncOperationCompletedHandler_1_Windows_Networking_NetworkOperators_MobileBroadbandModemConfiguration } #[cfg(feature="windows-networking")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0xb8628318,0xee4f,0x5af4,0x9e,0x3b,0xaf,0x99,0x4f,0xa9,0x6c,0x51] as IID_AsyncOperationCompletedHandler_1_Windows_Networking_NetworkOperators_MobileBroadbandModemStatus } +#[cfg(feature="windows-networking")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0xc7d3fc9e,0xc381,0x545c,0xa8,0xae,0x6a,0x46,0x4e,0xdb,0x16,0xa2] as IID_AsyncOperationCompletedHandler_1_Windows_Networking_NetworkOperators_MobileBroadbandPco } #[cfg(feature="windows-networking")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0x595ad094,0x60e3,0x5349,0x8f,0xe6,0xea,0x8e,0xcb,0xbb,0x25,0x41] as IID_AsyncOperationCompletedHandler_1_Windows_Networking_NetworkOperators_MobileBroadbandPinOperationResult } #[cfg(feature="windows-networking")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0xb81892b3,0x4ca9,0x5ec4,0x89,0x71,0x2f,0xbc,0x19,0xb5,0x6c,0xa9] as IID_AsyncOperationCompletedHandler_1_Windows_Networking_NetworkOperators_MobileBroadbandUiccAppReadRecordResult } #[cfg(feature="windows-networking")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0xd0b53858,0x0e54,0x5791,0x82,0xed,0x33,0x13,0xdc,0x75,0xda,0x45] as IID_AsyncOperationCompletedHandler_1_Windows_Networking_NetworkOperators_MobileBroadbandUiccAppRecordDetailsResult } @@ -1660,6 +1673,7 @@ RT_PINTERFACE!{ for AsyncOperationCompletedHandler> => [0xe #[cfg(feature="windows-security")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0xa04902e8,0xf830,0x50ea,0x89,0xea,0x96,0xe2,0xa6,0xfb,0x94,0x53] as IID_AsyncOperationCompletedHandler_1_Windows_Security_Authentication_Identity_Provider_SecondaryAuthenticationFactorRegistrationResult } #[cfg(feature="windows-security")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0x05f9f2ec,0x5950,0x56f8,0xb7,0xf8,0x22,0xe2,0x0b,0x98,0x46,0x79] as IID_AsyncOperationCompletedHandler_1_Windows_Security_Authentication_OnlineId_OnlineIdSystemTicketResult } #[cfg(feature="windows-security")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0xcded76fd,0x7841,0x52a0,0xa7,0x71,0x76,0xcd,0x75,0x1d,0x13,0xcd] as IID_AsyncOperationCompletedHandler_1_Windows_Security_Authentication_OnlineId_UserIdentity } +#[cfg(feature="windows-security")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0x5de9ba5e,0x0ade,0x5344,0x9f,0xe4,0x98,0x7f,0x1d,0x38,0x7e,0xf7] as IID_AsyncOperationCompletedHandler_1_Windows_Security_Authentication_Web_Core_FindAllAccountsResult } #[cfg(feature="windows-security")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0xdeb54b22,0x70f2,0x55ab,0x97,0xc0,0x6c,0xbd,0xc5,0xdd,0xb6,0xf0] as IID_AsyncOperationCompletedHandler_1_Windows_Security_Authentication_Web_Core_WebTokenRequestResult } #[cfg(feature="windows-security")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0x3c1ec44c,0xe942,0x54e5,0xbc,0xd3,0xe3,0x29,0xc9,0x51,0xf5,0x95] as IID_AsyncOperationCompletedHandler_1_Windows_Security_Authentication_Web_WebAuthenticationResult } #[cfg(feature="windows-security")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0x2c16e103,0xf783,0x5dd9,0xa5,0xf3,0x33,0x62,0xbc,0xbd,0xaa,0xbd] as IID_AsyncOperationCompletedHandler_1_Windows_Security_Credentials_KeyCredentialAttestationResult } @@ -1690,12 +1704,14 @@ RT_PINTERFACE!{ for AsyncOperationCompletedHandler> => [0xe #[cfg(feature="windows-services")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0x8654a79e,0xc52f,0x5f98,0xaf,0x0a,0x52,0x24,0x66,0xc2,0x72,0x46] as IID_AsyncOperationCompletedHandler_1_Windows_Services_Maps_OfflineMaps_OfflineMapPackageStartDownloadResult } #[cfg(feature="windows-services")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0x6987c97c,0x2c19,0x5f44,0xb5,0xac,0x37,0x39,0x3f,0x3c,0x1a,0x4a] as IID_AsyncOperationCompletedHandler_1_Windows_Services_Store_StoreAcquireLicenseResult } #[cfg(feature="windows-services")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0xceff1e09,0xe506,0x50ad,0xa9,0x08,0x52,0x03,0x8c,0x25,0x65,0x52] as IID_AsyncOperationCompletedHandler_1_Windows_Services_Store_StoreAppLicense } +#[cfg(feature="windows-services")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0x572a21d0,0x7150,0x50ba,0xa5,0x58,0xd9,0x1d,0xff,0xec,0x1a,0x24] as IID_AsyncOperationCompletedHandler_1_Windows_Services_Store_StoreCanAcquireLicenseResult } #[cfg(feature="windows-services")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0x3f2bb178,0x3c4e,0x56ed,0x86,0xa5,0xad,0x13,0x79,0x7c,0xfb,0xfd] as IID_AsyncOperationCompletedHandler_1_Windows_Services_Store_StoreConsumableResult } #[cfg(feature="windows-services")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0xe786321f,0xb791,0x5e38,0x8b,0xc4,0x98,0xcb,0x28,0x7d,0x10,0x85] as IID_AsyncOperationCompletedHandler_1_Windows_Services_Store_StoreProductPagedQueryResult } #[cfg(feature="windows-services")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0x02f4a42c,0x0458,0x58d6,0x92,0x3c,0xb4,0x4b,0xa8,0xef,0x22,0x22] as IID_AsyncOperationCompletedHandler_1_Windows_Services_Store_StoreProductQueryResult } #[cfg(feature="windows-services")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0xeb93e936,0xd515,0x5414,0x9d,0x15,0xf0,0x50,0xc0,0xb8,0xf5,0x21] as IID_AsyncOperationCompletedHandler_1_Windows_Services_Store_StoreProductResult } #[cfg(feature="windows-services")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0x1d9f89ee,0x2fce,0x54e6,0xa0,0xa9,0x52,0xd0,0x0c,0x52,0xcc,0x3a] as IID_AsyncOperationCompletedHandler_1_Windows_Services_Store_StorePurchaseResult } #[cfg(feature="windows-services")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0x7800b2a3,0xbbbc,0x5a11,0x8c,0x35,0xd2,0xbd,0xe5,0x48,0x9e,0x81] as IID_AsyncOperationCompletedHandler_1_Windows_Services_Store_StoreSendRequestResult } +#[cfg(feature="windows-services")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0xc4de9fb6,0x1fd9,0x5229,0x88,0x18,0xba,0x65,0x75,0x1d,0xb0,0x46] as IID_AsyncOperationCompletedHandler_1_Windows_Services_Store_StoreUninstallStorePackageResult } #[cfg(feature="windows-services")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0x8fc6bc2a,0x26ce,0x50b5,0x97,0xbb,0xfc,0xc8,0x0c,0xa0,0x87,0x1d] as IID_AsyncOperationCompletedHandler_1_Windows_Services_TargetedContent_TargetedContentContainer } #[cfg(feature="windows-services")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0xe4188c71,0x5a8e,0x57ec,0xb0,0xde,0x1d,0x31,0x4f,0xb3,0xe2,0xcf] as IID_AsyncOperationCompletedHandler_1_Windows_Services_TargetedContent_TargetedContentSubscription } #[cfg(feature="windows-storage")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0xabafe590,0x65fe,0x520a,0x9d,0x7c,0x6a,0xb5,0xf1,0x88,0x22,0x37] as IID_AsyncOperationCompletedHandler_1_Windows_Storage_ApplicationData } @@ -1719,6 +1735,9 @@ RT_PINTERFACE!{ for AsyncOperationCompletedHandler> => [0xe #[cfg(feature="windows-storage")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0x60847289,0xea0b,0x5df6,0x89,0xdf,0xf2,0xc6,0x2c,0xba,0x96,0x93] as IID_AsyncOperationCompletedHandler_1_Windows_Storage_Streams_IRandomAccessStreamReference } #[cfg(feature="windows-storage")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0x3dddecf4,0x1d39,0x58e8,0x83,0xb1,0xdb,0xed,0x54,0x1c,0x7f,0x35] as IID_AsyncOperationCompletedHandler_1_Windows_Storage_Streams_IRandomAccessStreamWithContentType } #[cfg(feature="windows-storage")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0x3d203732,0xded7,0x5d32,0x87,0xe6,0xc1,0x79,0x78,0x1f,0x79,0x1f] as IID_AsyncOperationCompletedHandler_1_Windows_Storage_Streams_RandomAccessStreamReference } +#[cfg(feature="windows-system")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0x966e2307,0xd529,0x50ea,0x98,0x72,0x8d,0xfb,0x35,0xcf,0xef,0xfd] as IID_AsyncOperationCompletedHandler_1_Windows_System_AppActivationResult } +#[cfg(feature="windows-system")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0xc162b59a,0xbdd2,0x5e4d,0xa3,0x09,0xb4,0x76,0xeb,0x97,0xb8,0x23] as IID_AsyncOperationCompletedHandler_1_Windows_System_AppExecutionStateChangeResult } +#[cfg(feature="windows-system")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0xc2b7624c,0x9f35,0x5074,0x80,0x21,0x06,0x33,0x18,0x48,0x99,0xa7] as IID_AsyncOperationCompletedHandler_1_Windows_System_AutoUpdateTimeZoneStatus } #[cfg(feature="windows-system")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0x5d1302d7,0x5497,0x5a92,0xbf,0x43,0xeb,0x8b,0x50,0x67,0x9a,0xab] as IID_AsyncOperationCompletedHandler_1_Windows_System_DiagnosticAccessStatus } #[cfg(feature="windows-system")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0x198cac52,0xabcd,0x5529,0x93,0x3f,0x07,0x1c,0xc9,0x3f,0xd6,0x35] as IID_AsyncOperationCompletedHandler_1_Windows_System_LaunchQuerySupportStatus } #[cfg(feature="windows-system")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0x70a97bf8,0xe0a5,0x59bb,0x91,0x74,0x81,0x2a,0x13,0x1d,0x85,0xa0] as IID_AsyncOperationCompletedHandler_1_Windows_System_LaunchUriResult } @@ -1744,7 +1763,9 @@ RT_PINTERFACE!{ for AsyncOperationCompletedHandler> => [0xe #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0xf6f3b17c,0x4527,0x5528,0x86,0xaa,0x1c,0xf1,0xfb,0x78,0xa5,0xeb] as IID_AsyncOperationCompletedHandler_1_Windows_UI_Xaml_Controls_Maps_StreetsidePanorama } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0x10fb738b,0xa63b,0x506e,0x9e,0xd7,0x2e,0xab,0x37,0x91,0x52,0x21] as IID_AsyncOperationCompletedHandler_1_Windows_UI_Xaml_Data_LoadMoreItemsResult } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0xaeeb272e,0xa814,0x5981,0xa2,0xc3,0x62,0x3e,0x22,0x6e,0x4a,0x71] as IID_AsyncOperationCompletedHandler_1_Windows_UI_Xaml_Hosting_DesignerAppView } +#[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0x1ba9fb88,0xfc3d,0x5a5d,0xae,0x84,0xa7,0x45,0xcf,0xb4,0x39,0x7b] as IID_AsyncOperationCompletedHandler_1_Windows_UI_Xaml_Input_FocusMovementResult } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0x7c8bc668,0x4e0b,0x5924,0xb7,0xe7,0x23,0x4a,0x11,0xd6,0x3d,0x61] as IID_AsyncOperationCompletedHandler_1_Windows_UI_Xaml_Media_Imaging_SvgImageSourceLoadStatus } +#[cfg(feature="windows-web")] RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0xd61963d6,0x806d,0x50a8,0xa8,0x1c,0x75,0xd9,0x35,0x6a,0xd5,0xd7] as IID_AsyncOperationCompletedHandler_1_Windows_Web_UI_Interop_WebViewControl } RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0x9343b6e7,0xe3d2,0x5e4a,0xab,0x2d,0x2b,0xce,0x49,0x19,0xa6,0xa4] as IID_AsyncOperationCompletedHandler_1_System_UInt32 } RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0xee8aeb02,0xfb00,0x51fa,0x8f,0x57,0x32,0x58,0x3e,0xa2,0x41,0xf9] as IID_AsyncOperationCompletedHandler_1_System_UInt64 } RT_PINTERFACE!{ for AsyncOperationCompletedHandler => [0xad46f1cc,0x2bb0,0x585c,0x98,0x85,0x03,0xc2,0x78,0x0d,0x4d,0x58] as IID_AsyncOperationCompletedHandler_1_Windows_Foundation_Uri } @@ -1752,6 +1773,7 @@ RT_PINTERFACE!{ for AsyncOperationProgressHandler => [0xcadf3784,0x12 #[cfg(feature="windows-devices")] RT_PINTERFACE!{ for AsyncOperationProgressHandler, i32> => [0x3f9d1255,0xebf8,0x569f,0x91,0xc3,0x49,0x74,0x0d,0x59,0x44,0xce] as IID_AsyncOperationProgressHandler_2_Windows_Foundation_Collections_IVectorView_1_Windows_Devices_Sms_ISmsMessage__System_Int32 } #[cfg(feature="windows-web")] RT_PINTERFACE!{ for AsyncOperationProgressHandler => [0xcf0a03f6,0xa80a,0x5b46,0x9c,0x80,0xf4,0xad,0x9e,0xd6,0xe2,0xd6] as IID_AsyncOperationProgressHandler_2_System_String_Windows_Web_Http_HttpProgress } RT_PINTERFACE!{ for AsyncOperationProgressHandler => [0x14da7de7,0x40df,0x5d4c,0x82,0x3f,0xcf,0x31,0x06,0x25,0xad,0x39] as IID_AsyncOperationProgressHandler_2_System_String_System_UInt64 } +#[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for AsyncOperationProgressHandler => [0xa58762e7,0xfcc2,0x5b31,0x94,0x5e,0x71,0xc6,0xc9,0xbc,0x51,0x6e] as IID_AsyncOperationProgressHandler_2_Windows_ApplicationModel_PackageCatalogAddResourcePackageResult_Windows_ApplicationModel_PackageInstallProgress } #[cfg(feature="windows-devices")] RT_PINTERFACE!{ for AsyncOperationProgressHandler => [0xd1662baa,0x4f20,0x5d18,0x97,0xf1,0xa0,0x1a,0x6d,0x0d,0xd9,0x80] as IID_AsyncOperationProgressHandler_2_Windows_Devices_Scanners_ImageScannerScanResult_System_UInt32 } #[cfg(feature="windows-gaming")] RT_PINTERFACE!{ for AsyncOperationProgressHandler => [0x065c16af,0x49dc,0x5c94,0xaf,0xe2,0x93,0x85,0x93,0x7f,0xac,0xc9] as IID_AsyncOperationProgressHandler_2_Windows_Gaming_Input_Custom_GipFirmwareUpdateResult_Windows_Gaming_Input_Custom_GipFirmwareUpdateProgress } #[cfg(feature="windows-management")] RT_PINTERFACE!{ for AsyncOperationProgressHandler => [0xf1b926d1,0x1796,0x597a,0x9b,0xea,0x6c,0x64,0x49,0xd0,0x3e,0xef] as IID_AsyncOperationProgressHandler_2_Windows_Management_Deployment_DeploymentResult_Windows_Management_Deployment_DeploymentProgress } @@ -1763,6 +1785,7 @@ RT_PINTERFACE!{ for AsyncOperationProgressHandler => [0x14da7de7,0 #[cfg(feature="windows-media")] RT_PINTERFACE!{ for AsyncOperationProgressHandler => [0x009c6245,0x0e59,0x53b0,0x9f,0xd2,0xd2,0x50,0xe4,0x5a,0x00,0xa3] as IID_AsyncOperationProgressHandler_2_Windows_Media_Transcoding_TranscodeFailureReason_System_Double } #[cfg(feature="windows-networking")] RT_PINTERFACE!{ for AsyncOperationProgressHandler => [0xb2ff13f1,0xc743,0x54f4,0xbc,0xcc,0xf0,0x8e,0x16,0xa8,0x78,0x90] as IID_AsyncOperationProgressHandler_2_Windows_Networking_BackgroundTransfer_DownloadOperation_Windows_Networking_BackgroundTransfer_DownloadOperation } #[cfg(feature="windows-networking")] RT_PINTERFACE!{ for AsyncOperationProgressHandler => [0xccd13730,0xfed3,0x54e8,0x84,0x71,0x09,0x6e,0x4b,0x64,0xca,0xdd] as IID_AsyncOperationProgressHandler_2_Windows_Networking_BackgroundTransfer_UploadOperation_Windows_Networking_BackgroundTransfer_UploadOperation } +#[cfg(feature="windows-networking")] RT_PINTERFACE!{ for AsyncOperationProgressHandler => [0x67a4b8eb,0x792e,0x5683,0xb6,0x25,0x49,0x28,0x88,0x4d,0x39,0xca] as IID_AsyncOperationProgressHandler_2_Windows_Networking_NetworkOperators_ESimOperationResult_Windows_Networking_NetworkOperators_ESimProfileInstallProgress } #[cfg(feature="windows-services")] RT_PINTERFACE!{ for AsyncOperationProgressHandler => [0x961260f1,0x7352,0x5edf,0x96,0x66,0x1f,0x9a,0x0a,0x8e,0xe4,0x77] as IID_AsyncOperationProgressHandler_2_Windows_Services_Store_StorePackageUpdateResult_Windows_Services_Store_StorePackageUpdateStatus } #[cfg(all(feature="windows-storage",feature="windows-web"))] RT_PINTERFACE!{ for AsyncOperationProgressHandler => [0x9eb2b852,0xe019,0x5440,0x8f,0x88,0x0d,0xd7,0xd5,0x6f,0xea,0x47] as IID_AsyncOperationProgressHandler_2_Windows_Storage_Streams_IBuffer_Windows_Web_Http_HttpProgress } #[cfg(feature="windows-storage")] RT_PINTERFACE!{ for AsyncOperationProgressHandler => [0xbf666554,0x7605,0x5d9a,0xb1,0x4e,0x18,0xd8,0xc8,0x47,0x2a,0xfe] as IID_AsyncOperationProgressHandler_2_Windows_Storage_Streams_IBuffer_System_UInt32 } @@ -1782,6 +1805,7 @@ RT_PINTERFACE!{ for AsyncOperationWithProgressCompletedHandler => [0x #[cfg(feature="windows-devices")] RT_PINTERFACE!{ for AsyncOperationWithProgressCompletedHandler, i32> => [0xc0454cfc,0x2f2f,0x5e0c,0x8d,0xe9,0x58,0xb9,0xe8,0x2a,0x03,0xba] as IID_AsyncOperationWithProgressCompletedHandler_2_Windows_Foundation_Collections_IVectorView_1_Windows_Devices_Sms_ISmsMessage__System_Int32 } #[cfg(feature="windows-web")] RT_PINTERFACE!{ for AsyncOperationWithProgressCompletedHandler => [0x98ab9acb,0x38db,0x588f,0xa5,0xf9,0x9f,0x48,0x4b,0x22,0x00,0xcd] as IID_AsyncOperationWithProgressCompletedHandler_2_System_String_Windows_Web_Http_HttpProgress } RT_PINTERFACE!{ for AsyncOperationWithProgressCompletedHandler => [0xbd75eebe,0xe7b5,0x5af6,0x84,0x15,0xa4,0xb9,0xc9,0x04,0x52,0x02] as IID_AsyncOperationWithProgressCompletedHandler_2_System_String_System_UInt64 } +#[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for AsyncOperationWithProgressCompletedHandler => [0x76fd3482,0x764c,0x5806,0x87,0x58,0x03,0x5a,0xef,0xb6,0xa5,0x48] as IID_AsyncOperationWithProgressCompletedHandler_2_Windows_ApplicationModel_PackageCatalogAddResourcePackageResult_Windows_ApplicationModel_PackageInstallProgress } #[cfg(feature="windows-devices")] RT_PINTERFACE!{ for AsyncOperationWithProgressCompletedHandler => [0xbd8bdbd8,0x459a,0x52dc,0xb1,0x01,0x75,0xb3,0x98,0xa6,0x1a,0xef] as IID_AsyncOperationWithProgressCompletedHandler_2_Windows_Devices_Scanners_ImageScannerScanResult_System_UInt32 } #[cfg(feature="windows-gaming")] RT_PINTERFACE!{ for AsyncOperationWithProgressCompletedHandler => [0x61b95949,0xa027,0x51d8,0x9f,0x33,0x37,0x92,0x74,0x51,0x50,0x2b] as IID_AsyncOperationWithProgressCompletedHandler_2_Windows_Gaming_Input_Custom_GipFirmwareUpdateResult_Windows_Gaming_Input_Custom_GipFirmwareUpdateProgress } #[cfg(feature="windows-management")] RT_PINTERFACE!{ for AsyncOperationWithProgressCompletedHandler => [0x6e1c7129,0x61e0,0x5d88,0x9f,0xd4,0xf3,0xce,0x65,0xa0,0x57,0x19] as IID_AsyncOperationWithProgressCompletedHandler_2_Windows_Management_Deployment_DeploymentResult_Windows_Management_Deployment_DeploymentProgress } @@ -1793,6 +1817,7 @@ RT_PINTERFACE!{ for AsyncOperationWithProgressCompletedHandler => #[cfg(feature="windows-media")] RT_PINTERFACE!{ for AsyncOperationWithProgressCompletedHandler => [0x080f1890,0x4fca,0x5165,0xa9,0x89,0x4b,0x07,0xda,0x8e,0x0b,0x53] as IID_AsyncOperationWithProgressCompletedHandler_2_Windows_Media_Transcoding_TranscodeFailureReason_System_Double } #[cfg(feature="windows-networking")] RT_PINTERFACE!{ for AsyncOperationWithProgressCompletedHandler => [0x781b479c,0x0207,0x5d15,0xa4,0xe5,0x78,0x37,0xd1,0x3b,0xf9,0x3d] as IID_AsyncOperationWithProgressCompletedHandler_2_Windows_Networking_BackgroundTransfer_DownloadOperation_Windows_Networking_BackgroundTransfer_DownloadOperation } #[cfg(feature="windows-networking")] RT_PINTERFACE!{ for AsyncOperationWithProgressCompletedHandler => [0x79fcae93,0x53ec,0x5f66,0xab,0x34,0x82,0x6a,0xf7,0x8e,0xc1,0x1a] as IID_AsyncOperationWithProgressCompletedHandler_2_Windows_Networking_BackgroundTransfer_UploadOperation_Windows_Networking_BackgroundTransfer_UploadOperation } +#[cfg(feature="windows-networking")] RT_PINTERFACE!{ for AsyncOperationWithProgressCompletedHandler => [0x7b5eac5d,0xdc91,0x5071,0xa9,0x9f,0x25,0x6b,0x4f,0xb5,0x63,0x62] as IID_AsyncOperationWithProgressCompletedHandler_2_Windows_Networking_NetworkOperators_ESimOperationResult_Windows_Networking_NetworkOperators_ESimProfileInstallProgress } #[cfg(feature="windows-services")] RT_PINTERFACE!{ for AsyncOperationWithProgressCompletedHandler => [0xb3be0c8b,0xef1d,0x56dc,0x85,0x47,0x4d,0xa0,0x6e,0xa5,0x63,0xdf] as IID_AsyncOperationWithProgressCompletedHandler_2_Windows_Services_Store_StorePackageUpdateResult_Windows_Services_Store_StorePackageUpdateStatus } #[cfg(all(feature="windows-storage",feature="windows-web"))] RT_PINTERFACE!{ for AsyncOperationWithProgressCompletedHandler => [0xb0cf2f85,0x6992,0x52be,0x8f,0x0b,0x93,0x96,0x4b,0x14,0xd9,0x63] as IID_AsyncOperationWithProgressCompletedHandler_2_Windows_Storage_Streams_IBuffer_Windows_Web_Http_HttpProgress } #[cfg(feature="windows-storage")] RT_PINTERFACE!{ for AsyncOperationWithProgressCompletedHandler => [0x06386a7a,0xe009,0x5b0b,0xab,0x68,0xa8,0xe4,0x8b,0x51,0x66,0x47] as IID_AsyncOperationWithProgressCompletedHandler_2_Windows_Storage_Streams_IBuffer_System_UInt32 } @@ -1836,12 +1861,14 @@ RT_PINTERFACE!{ for EventHandler => [0xc50898f6,0xc536,0x5f47,0x85 #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for EventHandler => [0x354c0f34,0xe691,0x502a,0xa4,0x44,0xd5,0xf0,0x7a,0xee,0x31,0x0e] as IID_EventHandler_1_Windows_UI_Xaml_Controls_ScrollViewerViewChangedEventArgs } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for EventHandler => [0xe0c06ef2,0xdbc9,0x511c,0xba,0xb6,0x25,0x75,0x6d,0xd5,0x16,0xa3] as IID_EventHandler_1_Windows_UI_Xaml_Controls_ScrollViewerViewChangingEventArgs } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for EventHandler => [0xebc4d41b,0x356a,0x59ca,0xb1,0x35,0x0e,0xc3,0x4f,0x68,0xc3,0x07] as IID_EventHandler_1_Windows_UI_Xaml_Controls_TimePickerValueChangedEventArgs } +#[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for EventHandler => [0xd1780676,0x8ac2,0x5aee,0xab,0x99,0x10,0x42,0x2d,0xb5,0x1c,0x29] as IID_EventHandler_1_Windows_UI_Xaml_Media_RenderedEventArgs } RT_PINTERFACE!{ for IAsyncActionWithProgress => [0x4f1430a6,0xa825,0x56ca,0xb0,0x47,0x1a,0x9b,0xad,0x52,0xba,0x67] as IID_IAsyncActionWithProgress_1_System_Double } #[cfg(feature="windows-web")] RT_PINTERFACE!{ for IAsyncActionWithProgress => [0xb7eb83f5,0xa746,0x50f2,0xb9,0x1f,0x31,0x80,0x31,0x61,0xcc,0xc7] as IID_IAsyncActionWithProgress_1_Windows_Web_Syndication_TransferProgress } RT_PINTERFACE!{ for IAsyncActionWithProgress => [0x43f713d0,0xc49d,0x5e55,0xae,0xbf,0xaf,0x39,0x57,0x68,0x35,0x1e] as IID_IAsyncActionWithProgress_1_System_UInt64 } RT_PINTERFACE!{ for IAsyncOperation => [0xcdb5efb3,0x5788,0x509d,0x9b,0xe1,0x71,0xcc,0xb8,0xa3,0x36,0x2a] as IID_IAsyncOperation_1_System_Boolean } RT_PINTERFACE!{ for IAsyncOperation> => [0x84e30b9c,0x351d,0x5fcb,0x8b,0x0a,0xbc,0x14,0x54,0x07,0xf9,0x15] as IID_IAsyncOperation_1_Windows_Foundation_Collections_IMap_2_System_String_System_String } RT_PINTERFACE!{ for IAsyncOperation> => [0x127e39c7,0x07c1,0x58e5,0xb4,0x8e,0x3a,0x47,0x29,0x83,0x9f,0xec] as IID_IAsyncOperation_1_Windows_Foundation_Collections_IMap_2_System_String_System_Object } +RT_PINTERFACE!{ for IAsyncOperation> => [0x817944b6,0xf046,0x5391,0xbb,0x0b,0x4c,0xc3,0x4d,0x80,0x40,0xf3] as IID_IAsyncOperation_1_Windows_Foundation_Collections_IMapView_2_System_String_System_String } RT_PINTERFACE!{ for IAsyncOperation> => [0x5dcbee48,0x9965,0x51da,0xa4,0x61,0x17,0x7c,0x88,0x5b,0xe7,0xe5] as IID_IAsyncOperation_1_Windows_Foundation_Collections_IMapView_2_System_String_System_Object } #[cfg(feature="windows-perception")] RT_PINTERFACE!{ for IAsyncOperation> => [0xbbe07728,0xda33,0x52c5,0xaa,0xe0,0xa5,0xe7,0x4c,0xdf,0x04,0x71] as IID_IAsyncOperation_1_Windows_Foundation_Collections_IMapView_2_System_String_Windows_Perception_Spatial_SpatialAnchor } #[cfg(feature="windows-storage")] RT_PINTERFACE!{ for IAsyncOperation> => [0xfc012d44,0x2dcf,0x5162,0xbe,0x9a,0x76,0x68,0x67,0x5a,0xa5,0x90] as IID_IAsyncOperation_1_Windows_Foundation_Collections_IMapView_2_System_String_Windows_Storage_Streams_RandomAccessStreamReference } @@ -1850,6 +1877,7 @@ RT_PINTERFACE!{ for IAsyncOperation => [0x490b0686,0x RT_PINTERFACE!{ for IAsyncOperation> => [0x92b02cd3,0xaa6e,0x573d,0xbc,0x03,0x8d,0x23,0x09,0xcb,0xa3,0xeb] as IID_IAsyncOperation_1_Windows_Foundation_Collections_IVector_1_System_String } #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IAsyncOperation> => [0x0f0ff4e8,0xd25d,0x53a8,0xba,0x87,0x1a,0x6b,0x23,0xe4,0x31,0x5c] as IID_IAsyncOperation_1_Windows_Foundation_Collections_IVector_1_Windows_ApplicationModel_Contacts_Contact } #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IAsyncOperation> => [0x929e3c29,0xbf29,0x5594,0xbc,0x63,0x67,0xdb,0x43,0xa5,0x39,0xea] as IID_IAsyncOperation_1_Windows_Foundation_Collections_IVector_1_Windows_ApplicationModel_PackageContentGroup } +#[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IAsyncOperation> => [0xd0d0c30a,0x255c,0x5238,0xa7,0xa2,0xaa,0x90,0x5d,0x38,0x39,0x19] as IID_IAsyncOperation_1_Windows_Foundation_Collections_IVector_1_Windows_ApplicationModel_UserActivities_UserActivitySessionHistoryItem } #[cfg(feature="windows-media")] RT_PINTERFACE!{ for IAsyncOperation> => [0x37f1d7dc,0xa1a4,0x5a94,0xb3,0x3b,0x74,0x20,0x5a,0x65,0xa1,0xed] as IID_IAsyncOperation_1_Windows_Foundation_Collections_IVector_1_Windows_Media_FaceAnalysis_DetectedFace } #[cfg(feature="windows-system")] RT_PINTERFACE!{ for IAsyncOperation> => [0xd6a9d3b9,0xf63c,0x59be,0xa0,0x96,0x3e,0x95,0x57,0xc4,0x11,0x82] as IID_IAsyncOperation_1_Windows_Foundation_Collections_IVector_1_Windows_System_AppDiagnosticInfo } RT_PINTERFACE!{ for IAsyncOperation>> => [0xfc227365,0x219d,0x5d59,0x8b,0x5b,0x58,0xeb,0x0a,0x91,0xca,0x0a] as IID_IAsyncOperation_1_Windows_Foundation_Collections_IVectorView_1_Windows_Foundation_Collections_IMapView_2_System_String_System_Object } @@ -1933,6 +1961,7 @@ RT_PINTERFACE!{ for IAsyncOperation> => [ #[cfg(feature="windows-security")] RT_PINTERFACE!{ for IAsyncOperation> => [0x66b59040,0x7c93,0x5f96,0xb5,0x2f,0x2c,0x09,0x8d,0x15,0x57,0xd0] as IID_IAsyncOperation_1_Windows_Foundation_Collections_IVectorView_1_Windows_Security_Credentials_WebAccount } #[cfg(feature="windows-security")] RT_PINTERFACE!{ for IAsyncOperation> => [0x9b26648e,0xb32f,0x5909,0xa6,0x35,0x78,0xe6,0xd3,0xbb,0x40,0x67] as IID_IAsyncOperation_1_Windows_Foundation_Collections_IVectorView_1_Windows_Security_Cryptography_Certificates_Certificate } #[cfg(feature="windows-services")] RT_PINTERFACE!{ for IAsyncOperation> => [0x0ac66c33,0x45b8,0x546b,0xaa,0xaf,0xd5,0x8d,0x62,0xa4,0xc5,0xc5] as IID_IAsyncOperation_1_Windows_Foundation_Collections_IVectorView_1_Windows_Services_Store_StorePackageUpdate } +#[cfg(feature="windows-services")] RT_PINTERFACE!{ for IAsyncOperation> => [0x1346377d,0x4d6f,0x5999,0x9a,0x6e,0x9c,0x8f,0xbf,0x6f,0x38,0xa2] as IID_IAsyncOperation_1_Windows_Foundation_Collections_IVectorView_1_Windows_Services_Store_StoreQueueItem } #[cfg(feature="windows-storage")] RT_PINTERFACE!{ for IAsyncOperation> => [0x222f6bb6,0xe71e,0x55cb,0x88,0x5d,0xe0,0x51,0xe3,0x59,0x95,0xdc] as IID_IAsyncOperation_1_Windows_Foundation_Collections_IVectorView_1_Windows_Storage_BulkAccess_FileInformation } #[cfg(feature="windows-storage")] RT_PINTERFACE!{ for IAsyncOperation> => [0x7f10e569,0x2bf7,0x5752,0x8f,0x75,0x60,0x28,0x09,0xa7,0xd3,0x04] as IID_IAsyncOperation_1_Windows_Foundation_Collections_IVectorView_1_Windows_Storage_BulkAccess_FolderInformation } #[cfg(feature="windows-storage")] RT_PINTERFACE!{ for IAsyncOperation> => [0x413d160c,0x3e1a,0x5603,0xac,0xba,0x1e,0x17,0x6d,0x6a,0x60,0x82] as IID_IAsyncOperation_1_Windows_Foundation_Collections_IVectorView_1_Windows_Storage_BulkAccess_IStorageItemInformation } @@ -1941,6 +1970,7 @@ RT_PINTERFACE!{ for IAsyncOperation> => [ #[cfg(feature="windows-storage")] RT_PINTERFACE!{ for IAsyncOperation> => [0x03362e33,0xe413,0x5f29,0x97,0xd0,0x48,0xa4,0x78,0x09,0x35,0xf9] as IID_IAsyncOperation_1_Windows_Foundation_Collections_IVectorView_1_Windows_Storage_StorageFile } #[cfg(feature="windows-storage")] RT_PINTERFACE!{ for IAsyncOperation> => [0xca40b21b,0xaeb1,0x5a61,0x9e,0x08,0x3b,0xd5,0xd9,0x59,0x40,0x23] as IID_IAsyncOperation_1_Windows_Foundation_Collections_IVectorView_1_Windows_Storage_StorageFolder } #[cfg(feature="windows-storage")] RT_PINTERFACE!{ for IAsyncOperation> => [0x66e11b8a,0x9003,0x52c9,0x84,0xa8,0xae,0x5c,0xce,0xbe,0x8c,0xf9] as IID_IAsyncOperation_1_Windows_Foundation_Collections_IVectorView_1_Windows_Storage_StorageLibraryChange } +#[cfg(feature="windows-system")] RT_PINTERFACE!{ for IAsyncOperation> => [0x9ffdaf80,0x6d25,0x5e34,0x98,0x86,0x2b,0x5d,0x54,0x1d,0x83,0x24] as IID_IAsyncOperation_1_Windows_Foundation_Collections_IVectorView_1_Windows_System_Inventory_InstalledDesktopApp } #[cfg(feature="windows-system")] RT_PINTERFACE!{ for IAsyncOperation> => [0xe44ea1df,0xbb85,0x5a8c,0xbd,0xdc,0xc8,0xe9,0x60,0xc3,0x55,0xc9] as IID_IAsyncOperation_1_Windows_Foundation_Collections_IVectorView_1_Windows_System_User } #[cfg(feature="windows-ui")] RT_PINTERFACE!{ for IAsyncOperation> => [0xb1923f59,0xd674,0x5365,0xb9,0x9a,0x3f,0x1e,0x52,0x26,0x8c,0x7f] as IID_IAsyncOperation_1_Windows_Foundation_Collections_IVectorView_1_Windows_UI_Input_Inking_InkRecognitionResult } #[cfg(feature="windows-ui")] RT_PINTERFACE!{ for IAsyncOperation> => [0x34d4fa14,0x252b,0x5cb4,0xa7,0xda,0x97,0x1e,0xe5,0xda,0xec,0x7c] as IID_IAsyncOperation_1_Windows_Foundation_Collections_IVectorView_1_Windows_UI_Notifications_ToastCollection } @@ -1955,6 +1985,8 @@ RT_PINTERFACE!{ for IAsyncOperation => [0xcc468085,0x4bef,0x5584,0x90,0x7c, RT_PINTERFACE!{ for IAsyncOperation => [0xabf53c57,0xee50,0x5342,0xb5,0x2a,0x26,0xe3,0xb8,0xcc,0x02,0x4f] as IID_IAsyncOperation_1_System_Object } RT_PINTERFACE!{ for IAsyncOperation> => [0x2025b34f,0x4214,0x56ab,0xab,0xfe,0x2f,0xbe,0x65,0x95,0xda,0x9d] as IID_IAsyncOperation_1_Windows_Foundation_IReference_1_Windows_Foundation_DateTime } RT_PINTERFACE!{ for IAsyncOperation> => [0x24a901ad,0x910f,0x5c0f,0xb2,0x3c,0x67,0x00,0x75,0x77,0xa5,0x58] as IID_IAsyncOperation_1_Windows_Foundation_IReference_1_Windows_Foundation_TimeSpan } +#[cfg(feature="windows-ai")] RT_PINTERFACE!{ for IAsyncOperation => [0xc643f2b8,0xea38,0x5230,0x93,0x48,0x10,0x94,0xc0,0x6d,0x91,0x7d] as IID_IAsyncOperation_1_Windows_AI_MachineLearning_Preview_LearningModelEvaluationResultPreview } +#[cfg(feature="windows-ai")] RT_PINTERFACE!{ for IAsyncOperation => [0x86cdc6bd,0x809d,0x5a2b,0x89,0x8b,0x5c,0x2a,0x92,0xbe,0x77,0x44] as IID_IAsyncOperation_1_Windows_AI_MachineLearning_Preview_LearningModelPreview } #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IAsyncOperation => [0x0c5732f8,0x5bb9,0x5bb3,0x93,0xe5,0xb8,0x7e,0x43,0xe0,0xcd,0x6a] as IID_IAsyncOperation_1_Windows_ApplicationModel_Appointments_Appointment } #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IAsyncOperation => [0x6bb17a95,0x918e,0x5ad0,0xbb,0xc2,0xbc,0xc5,0xfa,0x1f,0xf9,0x36] as IID_IAsyncOperation_1_Windows_ApplicationModel_Appointments_AppointmentCalendar } #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IAsyncOperation => [0xb376080f,0xe5b2,0x5ae2,0x99,0x01,0x86,0xcf,0x77,0xba,0x5d,0x00] as IID_IAsyncOperation_1_Windows_ApplicationModel_Appointments_AppointmentConflictResult } @@ -2007,6 +2039,7 @@ RT_PINTERFACE!{ for IAsyncOperation> => [0x24a901ad,0x910f, #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IAsyncOperation => [0xb18ea00f,0x8c20,0x5ac2,0x92,0x46,0x3e,0xf4,0x05,0x27,0x1f,0x1a] as IID_IAsyncOperation_1_Windows_ApplicationModel_ExtendedExecution_Foreground_ExtendedExecutionForegroundResult } #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IAsyncOperation => [0x59b2497f,0x86eb,0x542f,0xbe,0xa6,0x1b,0xe5,0x3e,0x93,0xe1,0x3d] as IID_IAsyncOperation_1_Windows_ApplicationModel_PackageCatalogAddOptionalPackageResult } #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IAsyncOperation => [0xcfc179aa,0xfb98,0x54ef,0x8e,0xa8,0x64,0x49,0x93,0x47,0xb7,0xf7] as IID_IAsyncOperation_1_Windows_ApplicationModel_PackageCatalogRemoveOptionalPackagesResult } +#[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IAsyncOperation => [0x342ee07c,0x8d6e,0x53a4,0xb7,0x46,0xc5,0xb7,0x4b,0xb6,0x1f,0x6d] as IID_IAsyncOperation_1_Windows_ApplicationModel_PackageCatalogRemoveResourcePackagesResult } #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IAsyncOperation => [0xbbd292e3,0xdb9f,0x5802,0xa4,0x88,0x40,0xf1,0x56,0x33,0x2c,0x04] as IID_IAsyncOperation_1_Windows_ApplicationModel_PackageContentGroup } #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IAsyncOperation => [0xa467410a,0x11de,0x5090,0xb9,0x05,0x96,0xa5,0x62,0xd8,0x5d,0xe5] as IID_IAsyncOperation_1_Windows_ApplicationModel_Payments_PaymentCanMakePaymentResult } #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IAsyncOperation => [0x0cc32025,0xac67,0x57e2,0xa0,0xf6,0x3a,0x8e,0x11,0x6c,0xef,0x4c] as IID_IAsyncOperation_1_Windows_ApplicationModel_Payments_PaymentRequestChangedResult } @@ -2067,6 +2100,7 @@ RT_PINTERFACE!{ for IAsyncOperation> => [0x24a901ad,0x910f, #[cfg(feature="windows-devices")] RT_PINTERFACE!{ for IAsyncOperation => [0xb7f2f74d,0xbf9c,0x5721,0xbf,0x6e,0x03,0xf1,0xb4,0x40,0x95,0x88] as IID_IAsyncOperation_1_Windows_Devices_Bluetooth_Rfcomm_RfcommDeviceServicesResult } #[cfg(feature="windows-devices")] RT_PINTERFACE!{ for IAsyncOperation => [0xfed44828,0xe232,0x554d,0x85,0xd1,0x2f,0x04,0xd1,0x32,0x2e,0x69] as IID_IAsyncOperation_1_Windows_Devices_Bluetooth_Rfcomm_RfcommServiceProvider } #[cfg(feature="windows-devices")] RT_PINTERFACE!{ for IAsyncOperation => [0x2a6344aa,0x0568,0x548e,0xa1,0xa2,0xb6,0xbb,0x45,0x1d,0x22,0x8c] as IID_IAsyncOperation_1_Windows_Devices_Custom_CustomDevice } +#[cfg(feature="windows-devices")] RT_PINTERFACE!{ for IAsyncOperation => [0x28c0e623,0x4e46,0x58c3,0xad,0x82,0x50,0x2b,0xde,0xcc,0x43,0x45] as IID_IAsyncOperation_1_Windows_Devices_Display_DisplayMonitor } #[cfg(feature="windows-devices")] RT_PINTERFACE!{ for IAsyncOperation => [0xc00bc2f2,0xa7f8,0x5f3f,0x80,0xd1,0x28,0x08,0xef,0x6b,0xca,0x10] as IID_IAsyncOperation_1_Windows_Devices_Enumeration_DeviceAccessStatus } #[cfg(feature="windows-devices")] RT_PINTERFACE!{ for IAsyncOperation => [0x07faa053,0xeb2f,0x5cba,0xb2,0x5b,0xd9,0xd5,0x7b,0xe6,0x71,0x5f] as IID_IAsyncOperation_1_Windows_Devices_Enumeration_DeviceInformation } #[cfg(feature="windows-devices")] RT_PINTERFACE!{ for IAsyncOperation => [0x45180254,0x082e,0x5274,0xb2,0xe7,0xac,0x05,0x17,0xf4,0x4d,0x07] as IID_IAsyncOperation_1_Windows_Devices_Enumeration_DeviceInformationCollection } @@ -2170,6 +2204,7 @@ RT_PINTERFACE!{ for IAsyncOperation> => [0x24a901ad,0x910f, #[cfg(feature="windows-gaming")] RT_PINTERFACE!{ for IAsyncOperation => [0xcff8afeb,0x5a18,0x5f51,0xb6,0x1b,0x94,0x38,0x87,0xf7,0x29,0xee] as IID_IAsyncOperation_1_Windows_Gaming_XboxLive_Storage_GameSaveContainerInfoGetResult } #[cfg(feature="windows-gaming")] RT_PINTERFACE!{ for IAsyncOperation => [0x1c27fb97,0x1e1a,0x516f,0xab,0xb2,0x12,0xc1,0x8e,0x18,0x21,0x8d] as IID_IAsyncOperation_1_Windows_Gaming_XboxLive_Storage_GameSaveOperationResult } #[cfg(feature="windows-gaming")] RT_PINTERFACE!{ for IAsyncOperation => [0x3dc36085,0x5fec,0x541b,0x96,0xcf,0x62,0x7b,0x2a,0xd8,0x0d,0x36] as IID_IAsyncOperation_1_Windows_Gaming_XboxLive_Storage_GameSaveProviderGetResult } +#[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for IAsyncOperation => [0x01ccf2ae,0x1059,0x5d57,0xa8,0x05,0x0a,0x1d,0xfc,0x54,0xca,0xb9] as IID_IAsyncOperation_1_Windows_Graphics_Capture_GraphicsCaptureItem } #[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for IAsyncOperation => [0xaa94d8e9,0xcaef,0x53f6,0x82,0x3d,0x91,0xb6,0xe8,0x34,0x05,0x10] as IID_IAsyncOperation_1_Windows_Graphics_Imaging_BitmapDecoder } #[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for IAsyncOperation => [0x151bd1c5,0x4675,0x5af5,0xa2,0x89,0x00,0x1e,0xdc,0x66,0xb8,0x6a] as IID_IAsyncOperation_1_Windows_Graphics_Imaging_BitmapEncoder } #[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for IAsyncOperation => [0xcb1483d1,0x1464,0x5bf9,0x93,0x46,0xd5,0x37,0x73,0x5d,0xfb,0xd6] as IID_IAsyncOperation_1_Windows_Graphics_Imaging_BitmapFrame } @@ -2190,6 +2225,7 @@ RT_PINTERFACE!{ for IAsyncOperation> => [0x24a901ad,0x910f, #[cfg(feature="windows-media")] RT_PINTERFACE!{ for IAsyncOperation => [0x473b06bf,0x387b,0x56ca,0xbe,0xe1,0x52,0x74,0x80,0x27,0x2b,0x0f] as IID_IAsyncOperation_1_Windows_Media_Audio_CreateAudioFileInputNodeResult } #[cfg(feature="windows-media")] RT_PINTERFACE!{ for IAsyncOperation => [0x1164517d,0xe953,0x5415,0xa5,0xb3,0x42,0x49,0xa9,0x69,0xbe,0x7b] as IID_IAsyncOperation_1_Windows_Media_Audio_CreateAudioFileOutputNodeResult } #[cfg(feature="windows-media")] RT_PINTERFACE!{ for IAsyncOperation => [0x3e13b431,0x65ce,0x5bfb,0xb0,0xaa,0xfa,0xc8,0xdf,0x95,0x8b,0x95] as IID_IAsyncOperation_1_Windows_Media_Audio_CreateAudioGraphResult } +#[cfg(feature="windows-media")] RT_PINTERFACE!{ for IAsyncOperation => [0xc69c20f3,0x88fc,0x5f3a,0x95,0xd0,0x28,0x16,0xea,0xe4,0x59,0x68] as IID_IAsyncOperation_1_Windows_Media_Audio_CreateMediaSourceAudioInputNodeResult } #[cfg(feature="windows-media")] RT_PINTERFACE!{ for IAsyncOperation => [0x8f71b217,0x61ec,0x58ab,0xa6,0x46,0xee,0xde,0x01,0x42,0xd5,0x68] as IID_IAsyncOperation_1_Windows_Media_Capture_AdvancedCapturedPhoto } #[cfg(feature="windows-media")] RT_PINTERFACE!{ for IAsyncOperation => [0x8eb156d9,0x2ce4,0x5ecd,0x81,0xf4,0xa0,0x87,0x31,0xfb,0x74,0xcf] as IID_IAsyncOperation_1_Windows_Media_Capture_AdvancedPhotoCapture } #[cfg(feature="windows-media")] RT_PINTERFACE!{ for IAsyncOperation => [0xaf5235b1,0x4778,0x55e1,0xb4,0x9f,0x60,0x80,0x48,0xea,0x9b,0xd9] as IID_IAsyncOperation_1_Windows_Media_Capture_CapturedPhoto } @@ -2244,11 +2280,14 @@ RT_PINTERFACE!{ for IAsyncOperation> => [0x24a901ad,0x910f, #[cfg(feature="windows-networking")] RT_PINTERFACE!{ for IAsyncOperation => [0x5bf519ca,0x8adb,0x5ab5,0xab,0xb8,0xff,0x1b,0xbe,0x5d,0x2d,0xe8] as IID_IAsyncOperation_1_Windows_Networking_Connectivity_ConnectionProfile } #[cfg(feature="windows-networking")] RT_PINTERFACE!{ for IAsyncOperation => [0x94fc6211,0x4702,0x5d24,0x81,0xbf,0x17,0x0c,0xa7,0x81,0x89,0x95] as IID_IAsyncOperation_1_Windows_Networking_Connectivity_ConnectionSession } #[cfg(feature="windows-networking")] RT_PINTERFACE!{ for IAsyncOperation => [0x1e7651f6,0x6562,0x59c7,0x9a,0xf3,0x87,0x56,0x63,0x6e,0xee,0xe2] as IID_IAsyncOperation_1_Windows_Networking_Connectivity_ProxyConfiguration } +#[cfg(feature="windows-networking")] RT_PINTERFACE!{ for IAsyncOperation => [0x5efd6396,0x4690,0x5e52,0x82,0x7c,0x1b,0x52,0x5d,0x23,0xd8,0x98] as IID_IAsyncOperation_1_Windows_Networking_NetworkOperators_ESimDownloadProfileMetadataResult } +#[cfg(feature="windows-networking")] RT_PINTERFACE!{ for IAsyncOperation => [0xdd15e279,0x1276,0x588b,0xb9,0xf0,0x11,0xb9,0x7f,0x27,0x04,0x52] as IID_IAsyncOperation_1_Windows_Networking_NetworkOperators_ESimOperationResult } #[cfg(feature="windows-networking")] RT_PINTERFACE!{ for IAsyncOperation => [0x522781d8,0x29c8,0x5d89,0x89,0x37,0x1d,0x1c,0x20,0x32,0xf0,0xc8] as IID_IAsyncOperation_1_Windows_Networking_NetworkOperators_HotspotCredentialsAuthenticationResult } #[cfg(feature="windows-networking")] RT_PINTERFACE!{ for IAsyncOperation => [0xba1101d2,0x7219,0x5421,0xa0,0x87,0x4c,0xc5,0xf1,0xf2,0x5f,0xc4] as IID_IAsyncOperation_1_Windows_Networking_NetworkOperators_MobileBroadbandCellsInfo } #[cfg(feature="windows-networking")] RT_PINTERFACE!{ for IAsyncOperation => [0x2c673aa8,0x6a35,0x50fd,0x94,0x22,0x36,0x15,0xa1,0xc2,0x8c,0xcb] as IID_IAsyncOperation_1_Windows_Networking_NetworkOperators_MobileBroadbandDeviceServiceCommandResult } #[cfg(feature="windows-networking")] RT_PINTERFACE!{ for IAsyncOperation => [0xcdbe0003,0xdaaa,0x5c89,0x92,0xe6,0xa4,0x7f,0xfc,0x24,0x18,0xa2] as IID_IAsyncOperation_1_Windows_Networking_NetworkOperators_MobileBroadbandModemConfiguration } #[cfg(feature="windows-networking")] RT_PINTERFACE!{ for IAsyncOperation => [0xab0d25ab,0x68cd,0x54ab,0xb1,0x9c,0x62,0x47,0x11,0x65,0x9d,0x3d] as IID_IAsyncOperation_1_Windows_Networking_NetworkOperators_MobileBroadbandModemStatus } +#[cfg(feature="windows-networking")] RT_PINTERFACE!{ for IAsyncOperation => [0xae622260,0x0d4b,0x5b39,0x97,0x6b,0xa7,0xab,0x61,0x0a,0xc1,0x85] as IID_IAsyncOperation_1_Windows_Networking_NetworkOperators_MobileBroadbandPco } #[cfg(feature="windows-networking")] RT_PINTERFACE!{ for IAsyncOperation => [0x2f76661c,0x2f74,0x5ce2,0x99,0xf9,0x47,0xd1,0xa3,0xa1,0x36,0x33] as IID_IAsyncOperation_1_Windows_Networking_NetworkOperators_MobileBroadbandPinOperationResult } #[cfg(feature="windows-networking")] RT_PINTERFACE!{ for IAsyncOperation => [0x27fc8483,0x30d8,0x5be3,0xbc,0x1e,0x8c,0xca,0x0b,0x24,0x1d,0xf3] as IID_IAsyncOperation_1_Windows_Networking_NetworkOperators_MobileBroadbandUiccAppReadRecordResult } #[cfg(feature="windows-networking")] RT_PINTERFACE!{ for IAsyncOperation => [0x0774f4a6,0xbdbe,0x59ff,0xaa,0x1c,0xa6,0x2e,0x3c,0x6f,0x9d,0x37] as IID_IAsyncOperation_1_Windows_Networking_NetworkOperators_MobileBroadbandUiccAppRecordDetailsResult } @@ -2277,6 +2316,7 @@ RT_PINTERFACE!{ for IAsyncOperation> => [0x24a901ad,0x910f, #[cfg(feature="windows-security")] RT_PINTERFACE!{ for IAsyncOperation => [0x05da520c,0xaba4,0x584c,0xbc,0x08,0x19,0xc5,0x38,0x9a,0x70,0xe2] as IID_IAsyncOperation_1_Windows_Security_Authentication_Identity_Provider_SecondaryAuthenticationFactorRegistrationResult } #[cfg(feature="windows-security")] RT_PINTERFACE!{ for IAsyncOperation => [0x162f5870,0x5a4a,0x503c,0x98,0x7f,0xa0,0x5a,0x13,0x12,0xd8,0xe4] as IID_IAsyncOperation_1_Windows_Security_Authentication_OnlineId_OnlineIdSystemTicketResult } #[cfg(feature="windows-security")] RT_PINTERFACE!{ for IAsyncOperation => [0xb8cc25e1,0x409f,0x57f4,0xbb,0xe4,0x3b,0x95,0xb7,0x4b,0x86,0xc8] as IID_IAsyncOperation_1_Windows_Security_Authentication_OnlineId_UserIdentity } +#[cfg(feature="windows-security")] RT_PINTERFACE!{ for IAsyncOperation => [0x9affb572,0x58c3,0x5c6c,0x93,0x97,0x2b,0x77,0x04,0xaa,0x35,0xc3] as IID_IAsyncOperation_1_Windows_Security_Authentication_Web_Core_FindAllAccountsResult } #[cfg(feature="windows-security")] RT_PINTERFACE!{ for IAsyncOperation => [0x0a815852,0x7c44,0x5674,0xb3,0xd2,0xfa,0x2e,0x4c,0x1e,0x46,0xc9] as IID_IAsyncOperation_1_Windows_Security_Authentication_Web_Core_WebTokenRequestResult } #[cfg(feature="windows-security")] RT_PINTERFACE!{ for IAsyncOperation => [0xb34952ac,0x265e,0x5947,0x87,0x35,0xe9,0x31,0x8f,0x43,0x01,0xff] as IID_IAsyncOperation_1_Windows_Security_Authentication_Web_WebAuthenticationResult } #[cfg(feature="windows-security")] RT_PINTERFACE!{ for IAsyncOperation => [0xb83d29e9,0xf4e4,0x5aa4,0x92,0xd5,0xb2,0x62,0xcb,0x40,0xc6,0x22] as IID_IAsyncOperation_1_Windows_Security_Credentials_KeyCredentialAttestationResult } @@ -2307,12 +2347,14 @@ RT_PINTERFACE!{ for IAsyncOperation> => [0x24a901ad,0x910f, #[cfg(feature="windows-services")] RT_PINTERFACE!{ for IAsyncOperation => [0x911272f7,0xf5aa,0x5393,0x94,0xa1,0xe9,0x6a,0xdf,0xad,0x3d,0xa4] as IID_IAsyncOperation_1_Windows_Services_Maps_OfflineMaps_OfflineMapPackageStartDownloadResult } #[cfg(feature="windows-services")] RT_PINTERFACE!{ for IAsyncOperation => [0xdd6c4705,0xa76c,0x528e,0x99,0xa5,0xcd,0xd1,0x31,0x97,0xd4,0xcf] as IID_IAsyncOperation_1_Windows_Services_Store_StoreAcquireLicenseResult } #[cfg(feature="windows-services")] RT_PINTERFACE!{ for IAsyncOperation => [0x3866370b,0xafc6,0x5d01,0x84,0xc2,0x45,0x74,0x62,0x8d,0xe5,0x39] as IID_IAsyncOperation_1_Windows_Services_Store_StoreAppLicense } +#[cfg(feature="windows-services")] RT_PINTERFACE!{ for IAsyncOperation => [0x71ae9f6e,0x0d10,0x5bdb,0xb4,0x41,0x93,0x12,0xe3,0xd2,0xef,0xc2] as IID_IAsyncOperation_1_Windows_Services_Store_StoreCanAcquireLicenseResult } #[cfg(feature="windows-services")] RT_PINTERFACE!{ for IAsyncOperation => [0x873c497b,0xc3f7,0x5657,0xb9,0x21,0x3e,0x58,0xce,0x48,0xee,0x50] as IID_IAsyncOperation_1_Windows_Services_Store_StoreConsumableResult } #[cfg(feature="windows-services")] RT_PINTERFACE!{ for IAsyncOperation => [0x3079e7db,0x1ba4,0x5b9e,0x85,0x6a,0x65,0x76,0xbf,0x7f,0x9c,0x8a] as IID_IAsyncOperation_1_Windows_Services_Store_StoreProductPagedQueryResult } #[cfg(feature="windows-services")] RT_PINTERFACE!{ for IAsyncOperation => [0x9699e7bb,0xea1f,0x5e03,0x94,0x39,0xc8,0x0e,0x69,0x77,0xb7,0x11] as IID_IAsyncOperation_1_Windows_Services_Store_StoreProductQueryResult } #[cfg(feature="windows-services")] RT_PINTERFACE!{ for IAsyncOperation => [0x9e61e86b,0x6afb,0x50ae,0xaf,0xc1,0xc5,0x9f,0x54,0x51,0x08,0xdd] as IID_IAsyncOperation_1_Windows_Services_Store_StoreProductResult } #[cfg(feature="windows-services")] RT_PINTERFACE!{ for IAsyncOperation => [0x33d8cc30,0x78f5,0x5f81,0xaa,0x2d,0xa4,0xfa,0x2a,0x3b,0x1c,0x68] as IID_IAsyncOperation_1_Windows_Services_Store_StorePurchaseResult } #[cfg(feature="windows-services")] RT_PINTERFACE!{ for IAsyncOperation => [0x2acdffe8,0x259c,0x5eae,0x93,0xc1,0x13,0xa2,0x3c,0x74,0xdf,0xee] as IID_IAsyncOperation_1_Windows_Services_Store_StoreSendRequestResult } +#[cfg(feature="windows-services")] RT_PINTERFACE!{ for IAsyncOperation => [0x55aa82fd,0xce55,0x550a,0x95,0xec,0x05,0x54,0xb1,0x91,0x52,0x08] as IID_IAsyncOperation_1_Windows_Services_Store_StoreUninstallStorePackageResult } #[cfg(feature="windows-services")] RT_PINTERFACE!{ for IAsyncOperation => [0xe757e0fc,0x0136,0x5f63,0x97,0xb8,0x6a,0x96,0xb8,0xd0,0x60,0x1e] as IID_IAsyncOperation_1_Windows_Services_TargetedContent_TargetedContentContainer } #[cfg(feature="windows-services")] RT_PINTERFACE!{ for IAsyncOperation => [0x46f16f4b,0x8ec1,0x5c4f,0xb1,0xf5,0xa7,0xe7,0xac,0xd6,0x33,0x66] as IID_IAsyncOperation_1_Windows_Services_TargetedContent_TargetedContentSubscription } #[cfg(feature="windows-storage")] RT_PINTERFACE!{ for IAsyncOperation => [0x31456b58,0xa5cb,0x5c5b,0xbd,0x6e,0xcc,0xce,0x3a,0x7b,0xf4,0xb4] as IID_IAsyncOperation_1_Windows_Storage_ApplicationData } @@ -2336,6 +2378,9 @@ RT_PINTERFACE!{ for IAsyncOperation> => [0x24a901ad,0x910f, #[cfg(feature="windows-storage")] RT_PINTERFACE!{ for IAsyncOperation => [0x65178d50,0xe6a2,0x5d16,0xb2,0x44,0x65,0xe9,0x72,0x5e,0x5a,0x0c] as IID_IAsyncOperation_1_Windows_Storage_Streams_IRandomAccessStreamReference } #[cfg(feature="windows-storage")] RT_PINTERFACE!{ for IAsyncOperation => [0xc4a57c5e,0x32b0,0x55b3,0xad,0x13,0xce,0x1c,0x23,0x04,0x1e,0xd6] as IID_IAsyncOperation_1_Windows_Storage_Streams_IRandomAccessStreamWithContentType } #[cfg(feature="windows-storage")] RT_PINTERFACE!{ for IAsyncOperation => [0xd90442ca,0x543c,0x504b,0x9e,0xb9,0x29,0x4b,0xca,0xd8,0xa2,0x83] as IID_IAsyncOperation_1_Windows_Storage_Streams_RandomAccessStreamReference } +#[cfg(feature="windows-system")] RT_PINTERFACE!{ for IAsyncOperation => [0xb6f373b8,0xbd4d,0x50bf,0x82,0xb4,0x5b,0x1d,0x45,0x2a,0x5f,0x83] as IID_IAsyncOperation_1_Windows_System_AppActivationResult } +#[cfg(feature="windows-system")] RT_PINTERFACE!{ for IAsyncOperation => [0xc251cc22,0xaba9,0x59b8,0xbf,0x87,0x20,0x67,0x7f,0xc4,0x92,0x4e] as IID_IAsyncOperation_1_Windows_System_AppExecutionStateChangeResult } +#[cfg(feature="windows-system")] RT_PINTERFACE!{ for IAsyncOperation => [0xb69475ac,0xa5d4,0x53d7,0xa5,0x3a,0xbb,0x01,0xb6,0x96,0x20,0xfa] as IID_IAsyncOperation_1_Windows_System_AutoUpdateTimeZoneStatus } #[cfg(feature="windows-system")] RT_PINTERFACE!{ for IAsyncOperation => [0x61c11bbe,0x2618,0x588a,0xa7,0xca,0xf6,0x06,0x91,0x27,0x23,0x24] as IID_IAsyncOperation_1_Windows_System_DiagnosticAccessStatus } #[cfg(feature="windows-system")] RT_PINTERFACE!{ for IAsyncOperation => [0xe7539992,0x2220,0x5d2d,0x82,0xc4,0x3d,0x44,0xf8,0x75,0x0d,0x91] as IID_IAsyncOperation_1_Windows_System_LaunchQuerySupportStatus } #[cfg(feature="windows-system")] RT_PINTERFACE!{ for IAsyncOperation => [0x7f97fc15,0x1cd6,0x54b7,0xa2,0x90,0xac,0xb6,0x0d,0xba,0x81,0xa1] as IID_IAsyncOperation_1_Windows_System_LaunchUriResult } @@ -2361,7 +2406,9 @@ RT_PINTERFACE!{ for IAsyncOperation> => [0x24a901ad,0x910f, #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for IAsyncOperation => [0x6ad8ea47,0x6670,0x51d8,0xa1,0xdb,0x33,0xfe,0x75,0x49,0x1f,0x0c] as IID_IAsyncOperation_1_Windows_UI_Xaml_Controls_Maps_StreetsidePanorama } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for IAsyncOperation => [0xc788089d,0x37ab,0x5ba2,0xb8,0x65,0x5a,0x30,0x9a,0xcd,0xfc,0x4d] as IID_IAsyncOperation_1_Windows_UI_Xaml_Data_LoadMoreItemsResult } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for IAsyncOperation => [0x49c6c658,0x1bd2,0x581e,0xa3,0x85,0x6e,0xb3,0xfd,0x9b,0xfe,0xe3] as IID_IAsyncOperation_1_Windows_UI_Xaml_Hosting_DesignerAppView } +#[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for IAsyncOperation => [0x0ea4496b,0x37de,0x5e58,0x8b,0x0d,0x2c,0x39,0x90,0xc4,0xcb,0xb2] as IID_IAsyncOperation_1_Windows_UI_Xaml_Input_FocusMovementResult } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for IAsyncOperation => [0xf19df5c2,0x2b78,0x53a9,0x8d,0x38,0x5c,0xa8,0xdb,0xb5,0xdb,0xc6] as IID_IAsyncOperation_1_Windows_UI_Xaml_Media_Imaging_SvgImageSourceLoadStatus } +#[cfg(feature="windows-web")] RT_PINTERFACE!{ for IAsyncOperation => [0xac3d28ac,0x8362,0x51c6,0xb2,0xcc,0x16,0xf3,0x67,0x27,0x58,0xf1] as IID_IAsyncOperation_1_Windows_Web_UI_Interop_WebViewControl } RT_PINTERFACE!{ for IAsyncOperation => [0xef60385f,0xbe78,0x584b,0xaa,0xef,0x78,0x29,0xad,0xa2,0xb0,0xde] as IID_IAsyncOperation_1_System_UInt32 } RT_PINTERFACE!{ for IAsyncOperation => [0x2a70d630,0x0767,0x5f0a,0xa1,0xc2,0xde,0xb0,0x81,0x26,0xe2,0x6e] as IID_IAsyncOperation_1_System_UInt64 } RT_PINTERFACE!{ for IAsyncOperation => [0x641cb9dd,0xa28d,0x59e2,0xb8,0xdb,0xa2,0x27,0xed,0xa6,0xcf,0x2e] as IID_IAsyncOperation_1_Windows_Foundation_Uri } @@ -2369,6 +2416,7 @@ RT_PINTERFACE!{ for IAsyncOperationWithProgress => [0xaf873c66,0x2df0 #[cfg(feature="windows-devices")] RT_PINTERFACE!{ for IAsyncOperationWithProgress, i32> => [0x12f85589,0x415d,0x5b5d,0xb0,0xd0,0xfd,0xa3,0xb0,0x29,0x5a,0xdc] as IID_IAsyncOperationWithProgress_2_Windows_Foundation_Collections_IVectorView_1_Windows_Devices_Sms_ISmsMessage__System_Int32 } #[cfg(feature="windows-web")] RT_PINTERFACE!{ for IAsyncOperationWithProgress => [0x91ecbe45,0xe889,0x5518,0xbd,0x8d,0xc5,0xbd,0xe1,0x63,0x10,0x9b] as IID_IAsyncOperationWithProgress_2_System_String_Windows_Web_Http_HttpProgress } RT_PINTERFACE!{ for IAsyncOperationWithProgress => [0xc8bbcb29,0x6b64,0x5ce2,0xa8,0x31,0x03,0x8f,0x6e,0x02,0x19,0x9e] as IID_IAsyncOperationWithProgress_2_System_String_System_UInt64 } +#[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IAsyncOperationWithProgress => [0xb147e038,0xcc1f,0x567f,0xb1,0xf1,0x64,0xd5,0xd4,0x00,0x33,0x09] as IID_IAsyncOperationWithProgress_2_Windows_ApplicationModel_PackageCatalogAddResourcePackageResult_Windows_ApplicationModel_PackageInstallProgress } #[cfg(feature="windows-devices")] RT_PINTERFACE!{ for IAsyncOperationWithProgress => [0x6e6e228a,0xf618,0x5d33,0x85,0x23,0x02,0xd1,0x66,0x72,0x66,0x5b] as IID_IAsyncOperationWithProgress_2_Windows_Devices_Scanners_ImageScannerScanResult_System_UInt32 } #[cfg(feature="windows-gaming")] RT_PINTERFACE!{ for IAsyncOperationWithProgress => [0xbfaa48bd,0x155f,0x5112,0xbd,0x86,0xe0,0x1d,0x6f,0x7c,0xd4,0x05] as IID_IAsyncOperationWithProgress_2_Windows_Gaming_Input_Custom_GipFirmwareUpdateResult_Windows_Gaming_Input_Custom_GipFirmwareUpdateProgress } #[cfg(feature="windows-management")] RT_PINTERFACE!{ for IAsyncOperationWithProgress => [0x5a97aab7,0xb6ea,0x55ac,0xa5,0xdc,0xd5,0xb1,0x64,0xd9,0x4e,0x94] as IID_IAsyncOperationWithProgress_2_Windows_Management_Deployment_DeploymentResult_Windows_Management_Deployment_DeploymentProgress } @@ -2380,6 +2428,7 @@ RT_PINTERFACE!{ for IAsyncOperationWithProgress => [0xc8bbcb29,0x6 #[cfg(feature="windows-media")] RT_PINTERFACE!{ for IAsyncOperationWithProgress => [0x272eec20,0x4b64,0x5d53,0xa6,0x44,0xf9,0x91,0x7b,0x3d,0x19,0xd8] as IID_IAsyncOperationWithProgress_2_Windows_Media_Transcoding_TranscodeFailureReason_System_Double } #[cfg(feature="windows-networking")] RT_PINTERFACE!{ for IAsyncOperationWithProgress => [0xe86a4f5d,0x743a,0x5f18,0x9d,0x4c,0xbc,0x8e,0xd5,0x94,0x26,0x59] as IID_IAsyncOperationWithProgress_2_Windows_Networking_BackgroundTransfer_DownloadOperation_Windows_Networking_BackgroundTransfer_DownloadOperation } #[cfg(feature="windows-networking")] RT_PINTERFACE!{ for IAsyncOperationWithProgress => [0x35ddaefa,0xdb6a,0x5d0d,0xba,0x54,0xa0,0x72,0x84,0x01,0x17,0x1e] as IID_IAsyncOperationWithProgress_2_Windows_Networking_BackgroundTransfer_UploadOperation_Windows_Networking_BackgroundTransfer_UploadOperation } +#[cfg(feature="windows-networking")] RT_PINTERFACE!{ for IAsyncOperationWithProgress => [0xf1130ddf,0x680c,0x5594,0xa2,0xec,0xab,0xcb,0x0c,0x52,0x11,0x43] as IID_IAsyncOperationWithProgress_2_Windows_Networking_NetworkOperators_ESimOperationResult_Windows_Networking_NetworkOperators_ESimProfileInstallProgress } #[cfg(feature="windows-services")] RT_PINTERFACE!{ for IAsyncOperationWithProgress => [0x42c436ca,0x51f7,0x50b2,0x8f,0xe4,0x7b,0x75,0x40,0x62,0xe6,0xeb] as IID_IAsyncOperationWithProgress_2_Windows_Services_Store_StorePackageUpdateResult_Windows_Services_Store_StorePackageUpdateStatus } #[cfg(all(feature="windows-storage",feature="windows-web"))] RT_PINTERFACE!{ for IAsyncOperationWithProgress => [0x88d9bb75,0xafb4,0x5f32,0x9d,0x7e,0xd3,0xbf,0x37,0x85,0x35,0x4c] as IID_IAsyncOperationWithProgress_2_Windows_Storage_Streams_IBuffer_Windows_Web_Http_HttpProgress } #[cfg(feature="windows-storage")] RT_PINTERFACE!{ for IAsyncOperationWithProgress => [0xd26b2819,0x897f,0x5c7d,0x84,0xd6,0x56,0xd7,0x96,0x56,0x14,0x31] as IID_IAsyncOperationWithProgress_2_Windows_Storage_Streams_IBuffer_System_UInt32 } @@ -2421,6 +2470,7 @@ RT_PINTERFACE!{ for IReference => [0x61723086,0x8e53,0x5276,0x9f,0x36,0x2a #[cfg(feature="windows-devices")] RT_PINTERFACE!{ for IReference => [0x91c0ba96,0x9e69,0x5b82,0xbf,0x1d,0x83,0xab,0x2a,0x50,0x9c,0x53] as IID_IReference_1_Windows_Devices_Bluetooth_Advertisement_BluetoothLEAdvertisementFlags } #[cfg(feature="windows-devices")] RT_PINTERFACE!{ for IReference => [0xe4d5dda6,0xf57c,0x57cc,0xb6,0x7f,0x29,0x39,0xa9,0x01,0xda,0xbe] as IID_IReference_1_Windows_Devices_Geolocation_BasicGeoposition } #[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for IReference => [0x6e67ce78,0xcc67,0x52c0,0xb6,0x35,0x99,0x1d,0xb0,0xbf,0xf5,0xca] as IID_IReference_1_Windows_Graphics_Holographic_HolographicStereoTransform } +#[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for IReference => [0xaa19da70,0xdee6,0x5b42,0xb5,0x62,0x2f,0xcd,0x21,0x8c,0x34,0xca] as IID_IReference_1_Windows_Graphics_Imaging_BitmapBounds } #[cfg(feature="windows-media")] RT_PINTERFACE!{ for IReference => [0x79c7838a,0x39e2,0x5287,0xac,0x3b,0xb1,0x18,0xdb,0x25,0x10,0x02] as IID_IReference_1_Windows_Media_Capture_WhiteBalanceGain } #[cfg(feature="windows-media")] RT_PINTERFACE!{ for IReference => [0x2fffd101,0x16f8,0x596d,0xa8,0x8e,0x65,0x9b,0x6f,0x58,0x46,0x41] as IID_IReference_1_Windows_Media_Core_MseTimeRange } #[cfg(feature="windows-media")] RT_PINTERFACE!{ for IReference => [0xe20596aa,0x0bbe,0x5203,0xbe,0x6b,0x6b,0x71,0xff,0x5b,0x08,0x43] as IID_IReference_1_Windows_Media_Devices_CaptureSceneMode } @@ -2563,6 +2613,7 @@ RT_PINTERFACE!{ for TypedEventHandler => [ #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for TypedEventHandler => [0x3975ff72,0x971b,0x54b6,0x9b,0x5f,0xcc,0x44,0x2e,0x2a,0x87,0xf0] as IID_TypedEventHandler_2_Windows_ApplicationModel_Search_SearchPane_Windows_ApplicationModel_Search_SearchPaneVisibilityChangedEventArgs } #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for TypedEventHandler => [0x92730467,0x501e,0x5b05,0x88,0x26,0x92,0x6f,0x86,0x92,0x5b,0x03] as IID_TypedEventHandler_2_Windows_ApplicationModel_Store_Preview_InstallControl_AppInstallItem_System_Object } #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for TypedEventHandler => [0xabf1c837,0xdacd,0x5446,0xa0,0x32,0x3e,0xe9,0x02,0x88,0x02,0x44] as IID_TypedEventHandler_2_Windows_ApplicationModel_Store_Preview_InstallControl_AppInstallManager_Windows_ApplicationModel_Store_Preview_InstallControl_AppInstallManagerItemEventArgs } +#[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for TypedEventHandler => [0xb71f6fda,0x21f5,0x5bcd,0xb8,0x3b,0x6c,0x9e,0xad,0xff,0x24,0x10] as IID_TypedEventHandler_2_Windows_ApplicationModel_UserActivities_UserActivityRequestManager_Windows_ApplicationModel_UserActivities_UserActivityRequestedEventArgs } #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for TypedEventHandler => [0x7b27aec8,0x0690,0x5063,0xbe,0xb0,0xd9,0xe2,0xeb,0x1a,0x12,0x01] as IID_TypedEventHandler_2_Windows_ApplicationModel_UserDataAccounts_UserDataAccountStore_Windows_ApplicationModel_UserDataAccounts_UserDataAccountStoreChangedEventArgs } #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for TypedEventHandler => [0x6035f9f7,0xd4c5,0x5394,0xb0,0xe3,0x5d,0x60,0x69,0x87,0xba,0x47] as IID_TypedEventHandler_2_Windows_ApplicationModel_UserDataTasks_DataProvider_UserDataTaskDataProviderConnection_Windows_ApplicationModel_UserDataTasks_DataProvider_UserDataTaskListCompleteTaskRequestEventArgs } #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for TypedEventHandler => [0x28adf45c,0x6807,0x5590,0xa7,0xf1,0x93,0x47,0x47,0x93,0x75,0x92] as IID_TypedEventHandler_2_Windows_ApplicationModel_UserDataTasks_DataProvider_UserDataTaskDataProviderConnection_Windows_ApplicationModel_UserDataTasks_DataProvider_UserDataTaskListCreateOrUpdateTaskRequestEventArgs } @@ -2619,6 +2670,13 @@ RT_PINTERFACE!{ for TypedEventHandler => [ #[cfg(feature="windows-devices")] RT_PINTERFACE!{ for TypedEventHandler => [0xaf259d89,0x9e01,0x529e,0xa8,0x79,0xc6,0x76,0x31,0x42,0xd1,0x60] as IID_TypedEventHandler_2_Windows_Devices_Gpio_Provider_IGpioPinProvider_Windows_Devices_Gpio_Provider_GpioPinProviderValueChangedEventArgs } #[cfg(feature="windows-devices")] RT_PINTERFACE!{ for TypedEventHandler => [0x31e757c8,0x8f6a,0x540b,0x93,0x8b,0xab,0xa7,0x9b,0x6f,0x03,0xec] as IID_TypedEventHandler_2_Windows_Devices_HumanInterfaceDevice_HidDevice_Windows_Devices_HumanInterfaceDevice_HidInputReportReceivedEventArgs } #[cfg(feature="windows-devices")] RT_PINTERFACE!{ for TypedEventHandler => [0x5d72e594,0x28e4,0x5895,0xa3,0x4b,0xea,0x91,0x0f,0x70,0xfd,0xbb] as IID_TypedEventHandler_2_Windows_Devices_Input_MouseDevice_Windows_Devices_Input_MouseEventArgs } +#[cfg(feature="windows-devices")] RT_PINTERFACE!{ for TypedEventHandler => [0x73a19afb,0x6081,0x551b,0xbf,0x73,0xd5,0xd2,0x31,0x55,0xda,0x8e] as IID_TypedEventHandler_2_Windows_Devices_Input_Preview_GazeDeviceWatcherPreview_System_Object } +#[cfg(feature="windows-devices")] RT_PINTERFACE!{ for TypedEventHandler => [0x5bf95725,0x6889,0x544f,0xba,0x3b,0xdd,0xa9,0x86,0xad,0xd8,0xae] as IID_TypedEventHandler_2_Windows_Devices_Input_Preview_GazeDeviceWatcherPreview_Windows_Devices_Input_Preview_GazeDeviceWatcherAddedPreviewEventArgs } +#[cfg(feature="windows-devices")] RT_PINTERFACE!{ for TypedEventHandler => [0x06c67a46,0x34b3,0x53fe,0x86,0xdf,0xce,0xb5,0x2e,0x2d,0x12,0xe7] as IID_TypedEventHandler_2_Windows_Devices_Input_Preview_GazeDeviceWatcherPreview_Windows_Devices_Input_Preview_GazeDeviceWatcherRemovedPreviewEventArgs } +#[cfg(feature="windows-devices")] RT_PINTERFACE!{ for TypedEventHandler => [0xfe8090ac,0x7d5d,0x50a7,0xa3,0xd3,0xf3,0x11,0x64,0x8a,0x7b,0x89] as IID_TypedEventHandler_2_Windows_Devices_Input_Preview_GazeDeviceWatcherPreview_Windows_Devices_Input_Preview_GazeDeviceWatcherUpdatedPreviewEventArgs } +#[cfg(feature="windows-devices")] RT_PINTERFACE!{ for TypedEventHandler => [0x3876b9c5,0x36a0,0x5221,0xbe,0x04,0x4a,0xee,0xfb,0x98,0x70,0xb2] as IID_TypedEventHandler_2_Windows_Devices_Input_Preview_GazeInputSourcePreview_Windows_Devices_Input_Preview_GazeEnteredPreviewEventArgs } +#[cfg(feature="windows-devices")] RT_PINTERFACE!{ for TypedEventHandler => [0x0f19b16c,0x73d9,0x5775,0x92,0xa3,0x0f,0x6f,0x94,0x2e,0x4e,0xb0] as IID_TypedEventHandler_2_Windows_Devices_Input_Preview_GazeInputSourcePreview_Windows_Devices_Input_Preview_GazeExitedPreviewEventArgs } +#[cfg(feature="windows-devices")] RT_PINTERFACE!{ for TypedEventHandler => [0xe7c08e8f,0x1aba,0x5952,0xaf,0x5c,0xd3,0xa2,0x70,0x7f,0x4f,0xe4] as IID_TypedEventHandler_2_Windows_Devices_Input_Preview_GazeInputSourcePreview_Windows_Devices_Input_Preview_GazeMovedPreviewEventArgs } #[cfg(feature="windows-devices")] RT_PINTERFACE!{ for TypedEventHandler => [0x556a02d9,0x7685,0x576f,0x89,0xca,0xb6,0x2d,0xc4,0x81,0xd2,0x9d] as IID_TypedEventHandler_2_Windows_Devices_Lights_Lamp_Windows_Devices_Lights_LampAvailabilityChangedEventArgs } #[cfg(feature="windows-devices")] RT_PINTERFACE!{ for TypedEventHandler => [0x50017240,0xcc39,0x5775,0x8a,0x6b,0xf6,0xf2,0x23,0x86,0xbf,0xca] as IID_TypedEventHandler_2_Windows_Devices_Midi_MidiInPort_Windows_Devices_Midi_MidiMessageReceivedEventArgs } #[cfg(feature="windows-devices")] RT_PINTERFACE!{ for TypedEventHandler => [0xa4a50ea5,0x778d,0x5056,0xa1,0xcf,0x54,0x6a,0x1b,0xe2,0xc0,0x10] as IID_TypedEventHandler_2_Windows_Devices_Perception_PerceptionColorFrameReader_Windows_Devices_Perception_PerceptionColorFrameArrivedEventArgs } @@ -2658,6 +2716,14 @@ RT_PINTERFACE!{ for TypedEventHandler => [ #[cfg(feature="windows-devices")] RT_PINTERFACE!{ for TypedEventHandler => [0x31424f6f,0xcfeb,0x5031,0x8a,0x95,0xbe,0xa5,0x9b,0x09,0xe5,0x84] as IID_TypedEventHandler_2_Windows_Devices_PointOfService_ClaimedPosPrinter_Windows_Devices_PointOfService_PosPrinterReleaseDeviceRequestedEventArgs } #[cfg(feature="windows-devices")] RT_PINTERFACE!{ for TypedEventHandler => [0x722d8bfa,0xe10e,0x548d,0xaf,0x29,0x28,0xdd,0x90,0x6f,0x6f,0xc9] as IID_TypedEventHandler_2_Windows_Devices_PointOfService_MagneticStripeReader_Windows_Devices_PointOfService_MagneticStripeReaderStatusUpdatedEventArgs } #[cfg(feature="windows-devices")] RT_PINTERFACE!{ for TypedEventHandler => [0x20b0c66a,0x5f41,0x5a32,0xb4,0x5a,0x34,0x4f,0x12,0xe7,0x0a,0x34] as IID_TypedEventHandler_2_Windows_Devices_PointOfService_PosPrinter_Windows_Devices_PointOfService_PosPrinterStatusUpdatedEventArgs } +#[cfg(feature="windows-devices")] RT_PINTERFACE!{ for TypedEventHandler => [0xd801fc9f,0x851f,0x5a8a,0x95,0x58,0xa3,0xdf,0x78,0x03,0x39,0xb0] as IID_TypedEventHandler_2_Windows_Devices_PointOfService_Provider_BarcodeScannerProviderConnection_Windows_Devices_PointOfService_Provider_BarcodeScannerDisableScannerRequestEventArgs } +#[cfg(feature="windows-devices")] RT_PINTERFACE!{ for TypedEventHandler => [0x44f1a2dc,0x3f2a,0x5338,0xb5,0x8e,0xfc,0xc2,0x70,0x9d,0x07,0xa7] as IID_TypedEventHandler_2_Windows_Devices_PointOfService_Provider_BarcodeScannerProviderConnection_Windows_Devices_PointOfService_Provider_BarcodeScannerEnableScannerRequestEventArgs } +#[cfg(feature="windows-devices")] RT_PINTERFACE!{ for TypedEventHandler => [0xe590f9b4,0x1481,0x5945,0xb5,0xbd,0x0a,0xb4,0xb1,0x0a,0x4b,0x5f] as IID_TypedEventHandler_2_Windows_Devices_PointOfService_Provider_BarcodeScannerProviderConnection_Windows_Devices_PointOfService_Provider_BarcodeScannerGetSymbologyAttributesRequestEventArgs } +#[cfg(feature="windows-devices")] RT_PINTERFACE!{ for TypedEventHandler => [0xf3679d04,0xd6d9,0x5e95,0xb6,0x74,0x11,0x35,0xbf,0xd4,0xf4,0x2f] as IID_TypedEventHandler_2_Windows_Devices_PointOfService_Provider_BarcodeScannerProviderConnection_Windows_Devices_PointOfService_Provider_BarcodeScannerHideVideoPreviewRequestEventArgs } +#[cfg(feature="windows-devices")] RT_PINTERFACE!{ for TypedEventHandler => [0x9dc3de50,0xd6f6,0x58b2,0x90,0x93,0xd6,0x09,0x0b,0x83,0x23,0xfe] as IID_TypedEventHandler_2_Windows_Devices_PointOfService_Provider_BarcodeScannerProviderConnection_Windows_Devices_PointOfService_Provider_BarcodeScannerSetActiveSymbologiesRequestEventArgs } +#[cfg(feature="windows-devices")] RT_PINTERFACE!{ for TypedEventHandler => [0x0c9b13f0,0x5d9f,0x56ca,0x89,0x89,0x07,0x46,0xbd,0x81,0x1a,0x21] as IID_TypedEventHandler_2_Windows_Devices_PointOfService_Provider_BarcodeScannerProviderConnection_Windows_Devices_PointOfService_Provider_BarcodeScannerSetSymbologyAttributesRequestEventArgs } +#[cfg(feature="windows-devices")] RT_PINTERFACE!{ for TypedEventHandler => [0x16220e79,0x8b03,0x5498,0x99,0x83,0xb9,0x35,0x68,0x92,0x16,0x76] as IID_TypedEventHandler_2_Windows_Devices_PointOfService_Provider_BarcodeScannerProviderConnection_Windows_Devices_PointOfService_Provider_BarcodeScannerStartSoftwareTriggerRequestEventArgs } +#[cfg(feature="windows-devices")] RT_PINTERFACE!{ for TypedEventHandler => [0xd695be73,0xbf91,0x5036,0x95,0xd2,0x15,0x90,0x32,0xc9,0x4c,0xb3] as IID_TypedEventHandler_2_Windows_Devices_PointOfService_Provider_BarcodeScannerProviderConnection_Windows_Devices_PointOfService_Provider_BarcodeScannerStopSoftwareTriggerRequestEventArgs } #[cfg(feature="windows-devices")] RT_PINTERFACE!{ for TypedEventHandler => [0x4d4aa646,0x767f,0x5645,0xaf,0x5c,0x54,0x64,0x64,0xd3,0xec,0x09] as IID_TypedEventHandler_2_Windows_Devices_Power_Battery_System_Object } #[cfg(feature="windows-devices")] RT_PINTERFACE!{ for TypedEventHandler => [0xb4b5ddc2,0x1a74,0x5905,0x9f,0xc5,0xdd,0xaa,0xe9,0xa3,0xab,0x93] as IID_TypedEventHandler_2_Windows_Devices_Printers_Extensions_Print3DWorkflow_Windows_Devices_Printers_Extensions_Print3DWorkflowPrinterChangedEventArgs } #[cfg(feature="windows-devices")] RT_PINTERFACE!{ for TypedEventHandler => [0x5f4c6603,0x5512,0x59aa,0x8d,0x96,0xb1,0x38,0x9d,0x8b,0x57,0x96] as IID_TypedEventHandler_2_Windows_Devices_Printers_Extensions_Print3DWorkflow_Windows_Devices_Printers_Extensions_Print3DWorkflowPrintRequestedEventArgs } @@ -2700,9 +2766,14 @@ RT_PINTERFACE!{ for TypedEventHandler => [ #[cfg(feature="windows-gaming")] RT_PINTERFACE!{ for TypedEventHandler => [0x07b2f2b7,0x8825,0x5c4e,0xa0,0x52,0xfc,0xfe,0xdf,0x3a,0xee,0xa1] as IID_TypedEventHandler_2_Windows_Gaming_Input_IGameController_Windows_Gaming_Input_Headset } #[cfg(all(feature="windows-gaming",feature="windows-system"))] RT_PINTERFACE!{ for TypedEventHandler => [0xcb753f2c,0x2f36,0x5a8f,0xad,0xad,0x05,0x7b,0xea,0xe7,0x3a,0xa4] as IID_TypedEventHandler_2_Windows_Gaming_Input_IGameController_Windows_System_UserChangedEventArgs } #[cfg(feature="windows-gaming")] RT_PINTERFACE!{ for TypedEventHandler => [0xfe4f13bf,0x689c,0x5fe3,0xb7,0xad,0x55,0xbc,0x57,0xf9,0x24,0x66] as IID_TypedEventHandler_2_Windows_Gaming_UI_GameChatOverlayMessageSource_Windows_Gaming_UI_GameChatMessageReceivedEventArgs } +#[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for TypedEventHandler => [0x51a947f7,0x79cf,0x5a3e,0xa3,0xa5,0x12,0x89,0xcf,0xa6,0xdf,0xe8] as IID_TypedEventHandler_2_Windows_Graphics_Capture_Direct3D11CaptureFramePool_System_Object } +#[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for TypedEventHandler => [0xe9c610c0,0xa68c,0x5bd9,0x80,0x21,0x85,0x89,0x34,0x6e,0xee,0xe2] as IID_TypedEventHandler_2_Windows_Graphics_Capture_GraphicsCaptureItem_System_Object } #[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for TypedEventHandler => [0xa460214e,0x6620,0x521d,0x9c,0xb9,0xa0,0xa0,0xf7,0x32,0xce,0x90] as IID_TypedEventHandler_2_Windows_Graphics_Display_BrightnessOverride_System_Object } #[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for TypedEventHandler => [0xd109932b,0x9ce1,0x5cdd,0x94,0xc7,0x93,0xc6,0x0c,0x83,0x3a,0xa3] as IID_TypedEventHandler_2_Windows_Graphics_Display_Core_HdmiDisplayInformation_System_Object } +#[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for TypedEventHandler => [0x3247b54b,0x7f00,0x5555,0x81,0xdf,0xaf,0xae,0x02,0x2f,0x07,0x96] as IID_TypedEventHandler_2_Windows_Graphics_Display_DisplayEnhancementOverride_System_Object } +#[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for TypedEventHandler => [0x7e61af14,0x3e29,0x5039,0x92,0xee,0x3f,0x24,0x72,0xb9,0x9e,0x43] as IID_TypedEventHandler_2_Windows_Graphics_Display_DisplayEnhancementOverride_Windows_Graphics_Display_DisplayEnhancementOverrideCapabilitiesChangedEventArgs } #[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for TypedEventHandler => [0x86c4f619,0x67b6,0x51c7,0xb3,0x0d,0xd8,0xcf,0x13,0x62,0x53,0x27] as IID_TypedEventHandler_2_Windows_Graphics_Display_DisplayInformation_System_Object } +#[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for TypedEventHandler => [0x67aae2f2,0x42d8,0x5503,0x91,0x31,0xde,0xeb,0x45,0xa6,0xca,0x03] as IID_TypedEventHandler_2_Windows_Graphics_Holographic_HolographicSpace_System_Object } #[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for TypedEventHandler => [0x71d80b7c,0x1d27,0x5102,0x83,0xd1,0x4f,0x0e,0xfc,0x7c,0x9d,0x6f] as IID_TypedEventHandler_2_Windows_Graphics_Holographic_HolographicSpace_Windows_Graphics_Holographic_HolographicSpaceCameraAddedEventArgs } #[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for TypedEventHandler => [0xdb68cfc3,0x0874,0x502a,0xa3,0xb9,0x2b,0x1f,0xe8,0x6c,0x67,0xbe] as IID_TypedEventHandler_2_Windows_Graphics_Holographic_HolographicSpace_Windows_Graphics_Holographic_HolographicSpaceCameraRemovedEventArgs } #[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for TypedEventHandler => [0x5c88455c,0x5b59,0x557c,0x80,0x64,0x5e,0x4f,0x3d,0x59,0xa8,0xec] as IID_TypedEventHandler_2_Windows_Graphics_Printing_OptionDetails_PrintTaskOptionDetails_System_Object } @@ -2726,6 +2797,8 @@ RT_PINTERFACE!{ for TypedEventHandler => [ #[cfg(feature="windows-media")] RT_PINTERFACE!{ for TypedEventHandler => [0x4530d121,0xbb9a,0x57fe,0x92,0x2f,0xa9,0x8e,0xee,0xdf,0x59,0xaf] as IID_TypedEventHandler_2_Windows_Media_Audio_AudioFrameInputNode_Windows_Media_Audio_FrameInputNodeQuantumStartedEventArgs } #[cfg(feature="windows-media")] RT_PINTERFACE!{ for TypedEventHandler => [0xe1407134,0x09e7,0x53de,0xb5,0x4c,0x8a,0x06,0x59,0x39,0x7b,0x88] as IID_TypedEventHandler_2_Windows_Media_Audio_AudioGraph_System_Object } #[cfg(feature="windows-media")] RT_PINTERFACE!{ for TypedEventHandler => [0x899670c9,0xdd7f,0x5f12,0x98,0xcb,0x8b,0x17,0xfe,0x80,0xa4,0x7f] as IID_TypedEventHandler_2_Windows_Media_Audio_AudioGraph_Windows_Media_Audio_AudioGraphUnrecoverableErrorOccurredEventArgs } +#[cfg(feature="windows-media")] RT_PINTERFACE!{ for TypedEventHandler => [0x1333df3f,0xc55b,0x5a23,0x95,0x96,0x34,0x65,0x7c,0x2a,0x34,0x06] as IID_TypedEventHandler_2_Windows_Media_Audio_AudioStateMonitor_System_Object } +#[cfg(feature="windows-media")] RT_PINTERFACE!{ for TypedEventHandler => [0xb78980bf,0x7acf,0x5dc8,0x9f,0xcd,0x31,0xd6,0xab,0x2f,0x92,0xf1] as IID_TypedEventHandler_2_Windows_Media_Audio_MediaSourceAudioInputNode_System_Object } #[cfg(feature="windows-media")] RT_PINTERFACE!{ for TypedEventHandler => [0x5cb4a98f,0xabf1,0x5518,0x90,0x94,0x26,0xdb,0x32,0x6a,0x5f,0x4e] as IID_TypedEventHandler_2_Windows_Media_Capture_AdvancedPhotoCapture_System_Object } #[cfg(feature="windows-media")] RT_PINTERFACE!{ for TypedEventHandler => [0x843e69ba,0x5702,0x5d97,0xab,0x81,0xef,0x07,0x8d,0xe3,0xf9,0xb1] as IID_TypedEventHandler_2_Windows_Media_Capture_AdvancedPhotoCapture_Windows_Media_Capture_OptionalReferencePhotoCapturedEventArgs } #[cfg(feature="windows-media")] RT_PINTERFACE!{ for TypedEventHandler => [0x6e820f00,0xe1e0,0x5c73,0xaf,0xd8,0xa4,0x7b,0x9b,0x1c,0x1b,0xed] as IID_TypedEventHandler_2_Windows_Media_Capture_AppBroadcastBackgroundService_System_Object } @@ -2861,10 +2934,17 @@ RT_PINTERFACE!{ for TypedEventHandler => [ #[cfg(feature="windows-media")] RT_PINTERFACE!{ for TypedEventHandler => [0x0557e996,0x7b23,0x5bae,0xaa,0x81,0xea,0x0d,0x67,0x11,0x43,0xa4] as IID_TypedEventHandler_2_Windows_Media_SystemMediaTransportControls_Windows_Media_SystemMediaTransportControlsButtonPressedEventArgs } #[cfg(feature="windows-media")] RT_PINTERFACE!{ for TypedEventHandler => [0x9fd61dad,0x1746,0x5fa1,0xa9,0x08,0xef,0x7c,0xb4,0x60,0x3c,0x85] as IID_TypedEventHandler_2_Windows_Media_SystemMediaTransportControls_Windows_Media_SystemMediaTransportControlsPropertyChangedEventArgs } #[cfg(feature="windows-networking")] RT_PINTERFACE!{ for TypedEventHandler => [0x93a20d85,0xbdfc,0x5195,0x90,0xd9,0x8c,0xb5,0x6c,0xbc,0xb3,0xd8] as IID_TypedEventHandler_2_Windows_Networking_BackgroundTransfer_DownloadOperation_Windows_Networking_BackgroundTransfer_BackgroundTransferRangesDownloadedEventArgs } +#[cfg(feature="windows-networking")] RT_PINTERFACE!{ for TypedEventHandler => [0x9ca277db,0xfe42,0x53b1,0xae,0x3b,0x09,0x8e,0x51,0xfa,0x6a,0x9b] as IID_TypedEventHandler_2_Windows_Networking_NetworkOperators_ESim_System_Object } +#[cfg(feature="windows-networking")] RT_PINTERFACE!{ for TypedEventHandler => [0xf4586725,0xea85,0x5ac6,0x84,0x6e,0xa8,0x47,0xe0,0xe4,0x5a,0x0b] as IID_TypedEventHandler_2_Windows_Networking_NetworkOperators_ESimProfileMetadata_System_Object } +#[cfg(feature="windows-networking")] RT_PINTERFACE!{ for TypedEventHandler => [0xb52d4068,0x1dda,0x5baa,0xb7,0x6b,0xa7,0xbc,0x47,0x8d,0xb5,0xf2] as IID_TypedEventHandler_2_Windows_Networking_NetworkOperators_ESimWatcher_System_Object } +#[cfg(feature="windows-networking")] RT_PINTERFACE!{ for TypedEventHandler => [0xf99b94ba,0xd4d0,0x5c43,0xb1,0x74,0xff,0xd7,0xe6,0xe5,0x13,0x1c] as IID_TypedEventHandler_2_Windows_Networking_NetworkOperators_ESimWatcher_Windows_Networking_NetworkOperators_ESimAddedEventArgs } +#[cfg(feature="windows-networking")] RT_PINTERFACE!{ for TypedEventHandler => [0xa8b7e917,0x3ac3,0x54e1,0x9e,0x26,0x21,0xf8,0x3c,0x60,0x97,0xd2] as IID_TypedEventHandler_2_Windows_Networking_NetworkOperators_ESimWatcher_Windows_Networking_NetworkOperators_ESimRemovedEventArgs } +#[cfg(feature="windows-networking")] RT_PINTERFACE!{ for TypedEventHandler => [0xe93527e9,0xea10,0x5aa7,0xb8,0xaa,0xfe,0xa8,0x66,0x29,0x47,0x04] as IID_TypedEventHandler_2_Windows_Networking_NetworkOperators_ESimWatcher_Windows_Networking_NetworkOperators_ESimUpdatedEventArgs } #[cfg(feature="windows-networking")] RT_PINTERFACE!{ for TypedEventHandler => [0xe4dc9cfc,0xf462,0x5afd,0x85,0x6d,0x04,0xac,0xe2,0x29,0xd0,0x0e] as IID_TypedEventHandler_2_Windows_Networking_NetworkOperators_MobileBroadbandAccountWatcher_System_Object } #[cfg(feature="windows-networking")] RT_PINTERFACE!{ for TypedEventHandler => [0x423cc41e,0xfe8c,0x5a7d,0x9f,0xee,0xaa,0xe0,0x4e,0xf8,0x57,0x00] as IID_TypedEventHandler_2_Windows_Networking_NetworkOperators_MobileBroadbandAccountWatcher_Windows_Networking_NetworkOperators_MobileBroadbandAccountEventArgs } #[cfg(feature="windows-networking")] RT_PINTERFACE!{ for TypedEventHandler => [0x0e865096,0x1ffa,0x5792,0x8d,0x4f,0x86,0x23,0xe3,0xc7,0x7f,0x56] as IID_TypedEventHandler_2_Windows_Networking_NetworkOperators_MobileBroadbandAccountWatcher_Windows_Networking_NetworkOperators_MobileBroadbandAccountUpdatedEventArgs } #[cfg(feature="windows-networking")] RT_PINTERFACE!{ for TypedEventHandler => [0x31f89ca6,0xdd7f,0x5325,0x90,0x20,0x62,0x7d,0x8b,0x47,0xea,0x02] as IID_TypedEventHandler_2_Windows_Networking_NetworkOperators_MobileBroadbandDeviceServiceDataSession_Windows_Networking_NetworkOperators_MobileBroadbandDeviceServiceDataReceivedEventArgs } +#[cfg(feature="windows-networking")] RT_PINTERFACE!{ for TypedEventHandler => [0xf2df3c8f,0x20b5,0x555c,0xa3,0x81,0x7e,0x29,0xd5,0xab,0x51,0xd7] as IID_TypedEventHandler_2_Windows_Networking_NetworkOperators_MobileBroadbandModem_System_Object } #[cfg(feature="windows-networking")] RT_PINTERFACE!{ for TypedEventHandler => [0x540c4534,0xcd85,0x5abe,0x80,0x13,0x13,0xcb,0x14,0x0e,0xd1,0x8b] as IID_TypedEventHandler_2_Windows_Networking_NetworkOperators_MobileBroadbandSarManager_Windows_Networking_NetworkOperators_MobileBroadbandTransmissionStateChangedEventArgs } #[cfg(feature="windows-networking")] RT_PINTERFACE!{ for TypedEventHandler => [0xf4979ea1,0x7e06,0x50a8,0x88,0xdc,0x3f,0x29,0x52,0x4e,0x4f,0xdb] as IID_TypedEventHandler_2_Windows_Networking_Proximity_PeerWatcher_System_Object } #[cfg(feature="windows-networking")] RT_PINTERFACE!{ for TypedEventHandler => [0xad674bbf,0x6281,0x5943,0x97,0x72,0xe0,0xfd,0x76,0x64,0xd4,0xe1] as IID_TypedEventHandler_2_Windows_Networking_Proximity_PeerWatcher_Windows_Networking_Proximity_PeerInformation } @@ -2875,6 +2955,9 @@ RT_PINTERFACE!{ for TypedEventHandler => [ #[cfg(feature="windows-networking")] RT_PINTERFACE!{ for TypedEventHandler => [0x03cf8f90,0x1669,0x5f4d,0x94,0x04,0x2b,0x78,0x46,0x78,0xe6,0xdd] as IID_TypedEventHandler_2_Windows_Networking_Sockets_IWebSocket_Windows_Networking_Sockets_WebSocketClosedEventArgs } #[cfg(feature="windows-networking")] RT_PINTERFACE!{ for TypedEventHandler => [0xde980538,0x6dcd,0x52b0,0x80,0x2f,0x4b,0x6c,0xf5,0x9a,0x01,0xab] as IID_TypedEventHandler_2_Windows_Networking_Sockets_MessageWebSocket_Windows_Networking_Sockets_MessageWebSocketMessageReceivedEventArgs } #[cfg(feature="windows-networking")] RT_PINTERFACE!{ for TypedEventHandler => [0x2c34c585,0x9cf6,0x56c7,0x8d,0xd1,0x5d,0xa2,0x6e,0x32,0x20,0x78] as IID_TypedEventHandler_2_Windows_Networking_Sockets_MessageWebSocket_Windows_Networking_Sockets_WebSocketServerCustomValidationRequestedEventArgs } +#[cfg(feature="windows-networking")] RT_PINTERFACE!{ for TypedEventHandler => [0x6e66714b,0x94d1,0x5c08,0xb2,0xb3,0x10,0xb8,0x91,0xd0,0x87,0x47] as IID_TypedEventHandler_2_Windows_Networking_Sockets_ServerMessageWebSocket_Windows_Networking_Sockets_MessageWebSocketMessageReceivedEventArgs } +#[cfg(feature="windows-networking")] RT_PINTERFACE!{ for TypedEventHandler => [0xcae65204,0xb986,0x5cf3,0x87,0xea,0xb6,0x7b,0x00,0xfb,0xa7,0x8d] as IID_TypedEventHandler_2_Windows_Networking_Sockets_ServerMessageWebSocket_Windows_Networking_Sockets_WebSocketClosedEventArgs } +#[cfg(feature="windows-networking")] RT_PINTERFACE!{ for TypedEventHandler => [0xb51c5b3b,0x161b,0x559e,0xa5,0x53,0x00,0x59,0x33,0x63,0x29,0xcc] as IID_TypedEventHandler_2_Windows_Networking_Sockets_ServerStreamWebSocket_Windows_Networking_Sockets_WebSocketClosedEventArgs } #[cfg(feature="windows-networking")] RT_PINTERFACE!{ for TypedEventHandler => [0x33d00d41,0xc94f,0x5a61,0x9a,0xb7,0x28,0x0d,0xce,0xfa,0x0b,0x08] as IID_TypedEventHandler_2_Windows_Networking_Sockets_StreamSocketListener_Windows_Networking_Sockets_StreamSocketListenerConnectionReceivedEventArgs } #[cfg(feature="windows-networking")] RT_PINTERFACE!{ for TypedEventHandler => [0x18b143d3,0x897e,0x595e,0xac,0xc1,0xef,0x35,0x61,0x4b,0x4c,0xec] as IID_TypedEventHandler_2_Windows_Networking_Sockets_StreamWebSocket_Windows_Networking_Sockets_WebSocketServerCustomValidationRequestedEventArgs } #[cfg(feature="windows-networking")] RT_PINTERFACE!{ for TypedEventHandler => [0x39907949,0xa8cc,0x5ce5,0x9e,0x0a,0x06,0xe3,0xb2,0xd3,0x15,0x70] as IID_TypedEventHandler_2_Windows_Networking_Vpn_VpnChannel_Windows_Networking_Vpn_VpnChannelActivityEventArgs } @@ -2899,6 +2982,8 @@ RT_PINTERFACE!{ for TypedEventHandler => [ #[cfg(feature="windows-services")] RT_PINTERFACE!{ for TypedEventHandler => [0x2d2e0d20,0x826f,0x560c,0xb1,0xc1,0xb4,0xbd,0x6f,0xbf,0x32,0x9a] as IID_TypedEventHandler_2_Windows_Services_Maps_OfflineMaps_OfflineMapPackage_System_Object } #[cfg(feature="windows-services")] RT_PINTERFACE!{ for TypedEventHandler => [0xd5a00ac7,0x082d,0x547c,0xa0,0x4b,0x25,0x40,0xc1,0xcd,0xe9,0x7a] as IID_TypedEventHandler_2_Windows_Services_Store_StoreContext_System_Object } #[cfg(feature="windows-services")] RT_PINTERFACE!{ for TypedEventHandler => [0x6c59d637,0x2970,0x5f64,0x95,0x11,0xd3,0x9a,0xc2,0x45,0xbc,0x94] as IID_TypedEventHandler_2_Windows_Services_Store_StorePackageLicense_System_Object } +#[cfg(feature="windows-services")] RT_PINTERFACE!{ for TypedEventHandler => [0xf8ae3690,0xf9db,0x57e8,0x84,0x3e,0x24,0x4c,0x0a,0x6a,0x13,0xe0] as IID_TypedEventHandler_2_Windows_Services_Store_StoreQueueItem_System_Object } +#[cfg(feature="windows-services")] RT_PINTERFACE!{ for TypedEventHandler => [0x2bac2880,0x78fd,0x5cbe,0x82,0x71,0x7d,0x58,0x3e,0x4e,0xc2,0xc4] as IID_TypedEventHandler_2_Windows_Services_Store_StoreQueueItem_Windows_Services_Store_StoreQueueItemCompletedEventArgs } #[cfg(feature="windows-services")] RT_PINTERFACE!{ for TypedEventHandler => [0x99929904,0x138a,0x59ac,0xa1,0x1a,0xfe,0x00,0x42,0xf0,0xfd,0x50] as IID_TypedEventHandler_2_Windows_Services_TargetedContent_TargetedContentSubscription_Windows_Services_TargetedContent_TargetedContentAvailabilityChangedEventArgs } #[cfg(feature="windows-services")] RT_PINTERFACE!{ for TypedEventHandler => [0xef11d751,0x9d56,0x580d,0x8a,0x9f,0x51,0xae,0x7e,0x80,0x36,0xe3] as IID_TypedEventHandler_2_Windows_Services_TargetedContent_TargetedContentSubscription_Windows_Services_TargetedContent_TargetedContentChangedEventArgs } #[cfg(feature="windows-services")] RT_PINTERFACE!{ for TypedEventHandler => [0xc4d5acbe,0xf65b,0x5fa4,0x92,0x42,0xd2,0x86,0x0d,0xe8,0x5d,0x52] as IID_TypedEventHandler_2_Windows_Services_TargetedContent_TargetedContentSubscription_Windows_Services_TargetedContent_TargetedContentStateChangedEventArgs } @@ -2934,8 +3019,10 @@ RT_PINTERFACE!{ for TypedEventHandler => [ #[cfg(feature="windows-system")] RT_PINTERFACE!{ for TypedEventHandler => [0x1cbc54f0,0x0c9d,0x59cc,0x80,0x55,0x5e,0x01,0x7a,0x31,0x78,0x12] as IID_TypedEventHandler_2_Windows_System_RemoteSystems_RemoteSystemSessionWatcher_Windows_System_RemoteSystems_RemoteSystemSessionRemovedEventArgs } #[cfg(feature="windows-system")] RT_PINTERFACE!{ for TypedEventHandler => [0x040f48b7,0x0d41,0x5aa2,0x85,0xe8,0x63,0x11,0x66,0x6f,0x03,0x24] as IID_TypedEventHandler_2_Windows_System_RemoteSystems_RemoteSystemSessionWatcher_Windows_System_RemoteSystems_RemoteSystemSessionUpdatedEventArgs } #[cfg(feature="windows-system")] RT_PINTERFACE!{ for TypedEventHandler => [0xa9b98f4a,0xb63d,0x5d07,0x92,0xbb,0xe2,0xac,0xb3,0x94,0x55,0xd1] as IID_TypedEventHandler_2_Windows_System_RemoteSystems_RemoteSystemWatcher_Windows_System_RemoteSystems_RemoteSystemAddedEventArgs } +#[cfg(feature="windows-system")] RT_PINTERFACE!{ for TypedEventHandler => [0x42ae9d52,0xfd0d,0x5411,0x8c,0x8c,0xd6,0x76,0xa0,0x97,0x67,0xe9] as IID_TypedEventHandler_2_Windows_System_RemoteSystems_RemoteSystemWatcher_Windows_System_RemoteSystems_RemoteSystemEnumerationCompletedEventArgs } #[cfg(feature="windows-system")] RT_PINTERFACE!{ for TypedEventHandler => [0xc290fb5a,0x3ed0,0x5858,0xaf,0x19,0xf8,0x55,0x53,0xcb,0x96,0xb8] as IID_TypedEventHandler_2_Windows_System_RemoteSystems_RemoteSystemWatcher_Windows_System_RemoteSystems_RemoteSystemRemovedEventArgs } #[cfg(feature="windows-system")] RT_PINTERFACE!{ for TypedEventHandler => [0x88f9d23f,0x8946,0x5a1e,0x8d,0xa1,0x82,0xc6,0x69,0x82,0xa6,0xd2] as IID_TypedEventHandler_2_Windows_System_RemoteSystems_RemoteSystemWatcher_Windows_System_RemoteSystems_RemoteSystemUpdatedEventArgs } +#[cfg(feature="windows-system")] RT_PINTERFACE!{ for TypedEventHandler => [0xa4a023b4,0x567b,0x5d4b,0xa4,0xc8,0x5c,0xa4,0xf8,0x86,0xd3,0xa3] as IID_TypedEventHandler_2_Windows_System_RemoteSystems_RemoteSystemWatcher_Windows_System_RemoteSystems_RemoteSystemWatcherErrorOccurredEventArgs } #[cfg(feature="windows-system")] RT_PINTERFACE!{ for TypedEventHandler => [0xf155e0ff,0xdbb5,0x5c34,0xac,0x0c,0x7e,0x29,0x1e,0x33,0x00,0xab] as IID_TypedEventHandler_2_Windows_System_UserWatcher_System_Object } #[cfg(feature="windows-system")] RT_PINTERFACE!{ for TypedEventHandler => [0x9ec3d9d5,0xb413,0x51df,0x8c,0x64,0x64,0x0e,0x33,0x56,0xe3,0x51] as IID_TypedEventHandler_2_Windows_System_UserWatcher_Windows_System_UserAuthenticationStatusChangingEventArgs } #[cfg(feature="windows-system")] RT_PINTERFACE!{ for TypedEventHandler => [0xeb9d0454,0x25db,0x5620,0x98,0xb8,0xbe,0x4c,0x5d,0x0d,0xbc,0x67] as IID_TypedEventHandler_2_Windows_System_UserWatcher_Windows_System_UserChangedEventArgs } @@ -2943,6 +3030,7 @@ RT_PINTERFACE!{ for TypedEventHandler => [ #[cfg(feature="windows-ui")] RT_PINTERFACE!{ for TypedEventHandler => [0xf39a56a2,0x7db1,0x5c48,0x9e,0x13,0x7d,0xc4,0x85,0xa4,0xa9,0x9e] as IID_TypedEventHandler_2_Windows_UI_ApplicationSettings_SettingsPane_Windows_UI_ApplicationSettings_SettingsPaneCommandsRequestedEventArgs } #[cfg(feature="windows-ui")] RT_PINTERFACE!{ for TypedEventHandler => [0x6e8cc6f4,0x6cf5,0x5994,0x94,0x47,0x72,0x61,0x71,0x23,0x6e,0xa8] as IID_TypedEventHandler_2_Windows_UI_Composition_CompositionCapabilities_System_Object } #[cfg(feature="windows-ui")] RT_PINTERFACE!{ for TypedEventHandler => [0x259b32be,0xbd06,0x53c2,0xbd,0x51,0x89,0xe8,0xe0,0xf9,0xe2,0x39] as IID_TypedEventHandler_2_Windows_UI_Composition_CompositionGraphicsDevice_Windows_UI_Composition_RenderingDeviceReplacedEventArgs } +#[cfg(feature="windows-ui")] RT_PINTERFACE!{ for TypedEventHandler => [0xe60c8424,0x3154,0x566e,0x9a,0xa2,0xee,0xc4,0x9f,0xce,0x00,0x4a] as IID_TypedEventHandler_2_Windows_UI_Composition_Core_CompositorController_System_Object } #[cfg(feature="windows-ui")] RT_PINTERFACE!{ for TypedEventHandler => [0xe2c62d42,0x0577,0x5112,0x9e,0x59,0xea,0xe1,0x59,0xbf,0x39,0xe9] as IID_TypedEventHandler_2_Windows_UI_Core_CoreComponentInputSource_Windows_UI_Core_ClosestInteractiveBoundsRequestedEventArgs } #[cfg(feature="windows-ui")] RT_PINTERFACE!{ for TypedEventHandler => [0x136dff0d,0xf7e8,0x5153,0xb3,0x1c,0x86,0x39,0x0c,0x70,0x18,0x80] as IID_TypedEventHandler_2_Windows_UI_Core_CoreDispatcher_Windows_UI_Core_AcceleratorKeyEventArgs } #[cfg(feature="windows-ui")] RT_PINTERFACE!{ for TypedEventHandler => [0x6368ae3d,0x52d4,0x5290,0xb9,0x36,0x71,0x7a,0x9a,0xcf,0x5b,0xea] as IID_TypedEventHandler_2_Windows_UI_Core_CoreWindow_System_Object } @@ -3020,7 +3108,9 @@ RT_PINTERFACE!{ for TypedEventHandler => [ #[cfg(feature="windows-ui")] RT_PINTERFACE!{ for TypedEventHandler => [0xf5917e6f,0x5abf,0x5e65,0xb5,0xb4,0x1b,0x9c,0x8d,0x94,0xe7,0x88] as IID_TypedEventHandler_2_Windows_UI_ViewManagement_AccessibilitySettings_System_Object } #[cfg(feature="windows-ui")] RT_PINTERFACE!{ for TypedEventHandler => [0x00c1f983,0xc836,0x565c,0x8b,0xbf,0x70,0x53,0x05,0x5b,0xdb,0x4c] as IID_TypedEventHandler_2_Windows_UI_ViewManagement_ApplicationView_System_Object } #[cfg(feature="windows-ui")] RT_PINTERFACE!{ for TypedEventHandler => [0x463c606a,0x8c82,0x5a29,0xa2,0xbd,0x04,0x07,0x81,0xf2,0x53,0x48] as IID_TypedEventHandler_2_Windows_UI_ViewManagement_ApplicationView_Windows_UI_ViewManagement_ApplicationViewConsolidatedEventArgs } +#[cfg(feature="windows-ui")] RT_PINTERFACE!{ for TypedEventHandler => [0x2bc0e7f6,0xc772,0x56e0,0x94,0x39,0x65,0x06,0x66,0xc7,0x8d,0x0c] as IID_TypedEventHandler_2_Windows_UI_ViewManagement_Core_CoreInputView_System_Object } #[cfg(feature="windows-ui")] RT_PINTERFACE!{ for TypedEventHandler => [0x5adecf04,0xedd1,0x5133,0xab,0xc7,0x58,0x2a,0x02,0x7f,0x09,0xbb] as IID_TypedEventHandler_2_Windows_UI_ViewManagement_Core_CoreInputView_Windows_UI_ViewManagement_Core_CoreInputViewOcclusionsChangedEventArgs } +#[cfg(feature="windows-ui")] RT_PINTERFACE!{ for TypedEventHandler => [0x881e8198,0x7ff6,0x5cd9,0x8a,0x64,0x6d,0xd4,0x29,0x22,0x67,0xad] as IID_TypedEventHandler_2_Windows_UI_ViewManagement_Core_CoreInputView_Windows_UI_ViewManagement_Core_CoreInputViewTransferringXYFocusEventArgs } #[cfg(feature="windows-ui")] RT_PINTERFACE!{ for TypedEventHandler => [0xb813d684,0xd953,0x5a8a,0x9b,0x30,0x78,0xb7,0x9f,0xb9,0x14,0x7b] as IID_TypedEventHandler_2_Windows_UI_ViewManagement_InputPane_Windows_UI_ViewManagement_InputPaneVisibilityEventArgs } #[cfg(feature="windows-ui")] RT_PINTERFACE!{ for TypedEventHandler => [0x2dbdba9d,0x20da,0x519d,0x90,0x78,0x09,0xf8,0x35,0xbc,0x5b,0xc7] as IID_TypedEventHandler_2_Windows_UI_ViewManagement_UISettings_System_Object } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0x1fa5f243,0x7045,0x56cb,0xbf,0x2d,0xf5,0xa4,0x25,0x02,0x5c,0x21] as IID_TypedEventHandler_2_Windows_UI_Xaml_Controls_AutoSuggestBox_Windows_UI_Xaml_Controls_AutoSuggestBoxQuerySubmittedEventArgs } @@ -3038,6 +3128,8 @@ RT_PINTERFACE!{ for TypedEventHandler => [ #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0x38b4535c,0x2785,0x5122,0x96,0xfe,0xd4,0x4f,0x79,0x5b,0x9c,0xb2] as IID_TypedEventHandler_2_Windows_UI_Xaml_Controls_Control_Windows_UI_Xaml_Controls_FocusDisengagedEventArgs } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0x0c3f6433,0x66b6,0x5544,0x8b,0x9b,0x89,0x04,0xf4,0x05,0x5e,0x92] as IID_TypedEventHandler_2_Windows_UI_Xaml_Controls_Control_Windows_UI_Xaml_Controls_FocusEngagedEventArgs } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0x4d9c196f,0xcdd3,0x54d8,0x98,0xd9,0x4f,0x29,0xab,0xba,0xde,0x76] as IID_TypedEventHandler_2_Windows_UI_Xaml_Controls_DatePickerFlyout_Windows_UI_Xaml_Controls_DatePickedEventArgs } +#[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0xec197a50,0x4cf0,0x5a33,0xb0,0x68,0x39,0x7e,0x03,0xb8,0xdd,0x80] as IID_TypedEventHandler_2_Windows_UI_Xaml_Controls_HandwritingView_Windows_UI_Xaml_Controls_HandwritingPanelClosedEventArgs } +#[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0xb0c91008,0x8012,0x5652,0xb8,0xe3,0x5d,0x67,0xc6,0x21,0x5b,0x0e] as IID_TypedEventHandler_2_Windows_UI_Xaml_Controls_HandwritingView_Windows_UI_Xaml_Controls_HandwritingPanelOpenedEventArgs } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0xeea8b7be,0x9cba,0x5129,0x9b,0x75,0x49,0x30,0xdc,0x0c,0x27,0x05] as IID_TypedEventHandler_2_Windows_UI_Xaml_Controls_InkToolbar_System_Object } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0x80a45bd6,0x7b40,0x5410,0x9c,0x65,0xa8,0xe0,0x5f,0xee,0x5e,0x0f] as IID_TypedEventHandler_2_Windows_UI_Xaml_Controls_InkToolbar_Windows_UI_Xaml_Controls_InkToolbarIsStencilButtonCheckedChangedEventArgs } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0x127a421c,0xae3f,0x53df,0xb9,0xad,0x17,0x68,0x47,0xf3,0x2c,0xde] as IID_TypedEventHandler_2_Windows_UI_Xaml_Controls_InkToolbarFlyoutItem_System_Object } @@ -3075,8 +3167,11 @@ RT_PINTERFACE!{ for TypedEventHandler => [ #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0x766ed4a8,0xe810,0x5f78,0xbc,0x96,0x9a,0xff,0x9f,0x58,0xcf,0xca] as IID_TypedEventHandler_2_Windows_UI_Xaml_Controls_Maps_MapScene_Windows_UI_Xaml_Controls_Maps_MapTargetCameraChangedEventArgs } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0xb402b0ca,0xbeca,0x5537,0x81,0x92,0x8f,0x30,0xf7,0xcb,0x5d,0x0e] as IID_TypedEventHandler_2_Windows_UI_Xaml_Controls_MediaElement_Windows_UI_Xaml_Media_PartialMediaFailureDetectedEventArgs } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0xc2925ff8,0x71f0,0x59d3,0xba,0x13,0x86,0x2b,0x22,0x6e,0xeb,0xa2] as IID_TypedEventHandler_2_Windows_UI_Xaml_Controls_MediaTransportControls_Windows_UI_Xaml_Media_MediaTransportControlsThumbnailRequestedEventArgs } +#[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0xaa2752a1,0x70be,0x5e14,0x93,0xc8,0x10,0xf3,0x11,0x66,0x43,0x7b] as IID_TypedEventHandler_2_Windows_UI_Xaml_Controls_NavigationView_System_Object } +#[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0x1663a256,0x1d73,0x5318,0x91,0xf1,0xb0,0x72,0x4b,0xfa,0xb8,0x32] as IID_TypedEventHandler_2_Windows_UI_Xaml_Controls_NavigationView_Windows_UI_Xaml_Controls_NavigationViewBackRequestedEventArgs } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0x10a54ac4,0x84cf,0x580b,0xa6,0x3d,0x51,0xaa,0x3a,0x6a,0x3c,0x0a] as IID_TypedEventHandler_2_Windows_UI_Xaml_Controls_NavigationView_Windows_UI_Xaml_Controls_NavigationViewDisplayModeChangedEventArgs } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0x15ec8ec2,0xc8b3,0x53e7,0x89,0x3c,0x0c,0xfb,0x68,0x54,0x9b,0x77] as IID_TypedEventHandler_2_Windows_UI_Xaml_Controls_NavigationView_Windows_UI_Xaml_Controls_NavigationViewItemInvokedEventArgs } +#[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0x0422033a,0x2892,0x5091,0xa7,0xcb,0x6a,0x20,0x4b,0xf6,0x62,0xfd] as IID_TypedEventHandler_2_Windows_UI_Xaml_Controls_NavigationView_Windows_UI_Xaml_Controls_NavigationViewPaneClosingEventArgs } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0x17c78c17,0x2850,0x5dd4,0x83,0xd6,0xd4,0x70,0x32,0x3c,0x21,0xc7] as IID_TypedEventHandler_2_Windows_UI_Xaml_Controls_NavigationView_Windows_UI_Xaml_Controls_NavigationViewSelectionChangedEventArgs } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0xc3bc2f43,0x1d73,0x5aac,0xae,0xd4,0xb4,0xe0,0x86,0x03,0xe9,0xf0] as IID_TypedEventHandler_2_Windows_UI_Xaml_Controls_PasswordBox_Windows_UI_Xaml_Controls_PasswordBoxPasswordChangingEventArgs } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0x22cde5b7,0x4eb7,0x5ee4,0x8d,0x28,0x1f,0x1c,0xbc,0xf6,0x8f,0xb0] as IID_TypedEventHandler_2_Windows_UI_Xaml_Controls_PickerFlyout_Windows_UI_Xaml_Controls_PickerConfirmedEventArgs } @@ -3084,13 +3179,18 @@ RT_PINTERFACE!{ for TypedEventHandler => [ #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0x650cfa09,0x70c2,0x5151,0xa2,0xcd,0x27,0x57,0x0f,0xb9,0x55,0x6b] as IID_TypedEventHandler_2_Windows_UI_Xaml_Controls_Primitives_ColorSpectrum_Windows_UI_Xaml_Controls_ColorChangedEventArgs } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0x96e17fbc,0x78c7,0x5560,0xac,0x3a,0x58,0x7f,0x46,0xdb,0x70,0xd6] as IID_TypedEventHandler_2_Windows_UI_Xaml_Controls_Primitives_FlyoutBase_Windows_UI_Xaml_Controls_Primitives_FlyoutBaseClosingEventArgs } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0x180be111,0xc600,0x5e5d,0x82,0x66,0xfb,0x29,0xb9,0x65,0x6a,0xf4] as IID_TypedEventHandler_2_Windows_UI_Xaml_Controls_RatingControl_System_Object } +#[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0xfdf80fc9,0x3610,0x5649,0xb6,0x95,0xd5,0x09,0x28,0xd2,0xe5,0x09] as IID_TypedEventHandler_2_Windows_UI_Xaml_Controls_RefreshContainer_Windows_UI_Xaml_Controls_RefreshRequestedEventArgs } +#[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0x3a0bc0e0,0x6fc3,0x5489,0xab,0xec,0xeb,0x96,0x17,0x6d,0xd3,0xa7] as IID_TypedEventHandler_2_Windows_UI_Xaml_Controls_RefreshVisualizer_Windows_UI_Xaml_Controls_RefreshRequestedEventArgs } +#[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0x20110ea9,0x4b08,0x5242,0xb4,0x85,0x22,0x11,0x2f,0xe9,0x3e,0x20] as IID_TypedEventHandler_2_Windows_UI_Xaml_Controls_RefreshVisualizer_Windows_UI_Xaml_Controls_RefreshStateChangedEventArgs } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0xb0b3c248,0x7604,0x5108,0xae,0xc9,0x6f,0x3a,0xec,0xca,0x27,0x37] as IID_TypedEventHandler_2_Windows_UI_Xaml_Controls_RichEditBox_Windows_UI_Xaml_Controls_CandidateWindowBoundsChangedEventArgs } +#[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0x6ad0c1d8,0x3d49,0x53f8,0xb2,0x95,0xb3,0xa9,0x24,0x45,0x01,0x9a] as IID_TypedEventHandler_2_Windows_UI_Xaml_Controls_RichEditBox_Windows_UI_Xaml_Controls_ContentLinkChangedEventArgs } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0xfad2ffb9,0xd2d9,0x563c,0x88,0xca,0x13,0x23,0xb1,0x33,0xfb,0xf3] as IID_TypedEventHandler_2_Windows_UI_Xaml_Controls_RichEditBox_Windows_UI_Xaml_Controls_RichEditBoxTextChangingEventArgs } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0xc080b01b,0xeec0,0x542c,0xb1,0xf1,0xd0,0x0e,0x20,0x7e,0xe1,0xe0] as IID_TypedEventHandler_2_Windows_UI_Xaml_Controls_RichEditBox_Windows_UI_Xaml_Controls_TextCompositionChangedEventArgs } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0xe6750b95,0x305f,0x52fd,0xbb,0x80,0xcf,0xcf,0x72,0xbc,0x54,0x21] as IID_TypedEventHandler_2_Windows_UI_Xaml_Controls_RichEditBox_Windows_UI_Xaml_Controls_TextCompositionEndedEventArgs } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0x297dde84,0xd0c7,0x5d21,0xb1,0xed,0xf9,0x6c,0x4e,0xa4,0x77,0x2f] as IID_TypedEventHandler_2_Windows_UI_Xaml_Controls_RichEditBox_Windows_UI_Xaml_Controls_TextCompositionStartedEventArgs } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0xb8cb973a,0x91c4,0x5ae4,0x8b,0x4e,0x01,0xb9,0x68,0xdc,0x1a,0x57] as IID_TypedEventHandler_2_Windows_UI_Xaml_Controls_RichEditBox_Windows_UI_Xaml_Controls_TextControlCopyingToClipboardEventArgs } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0xc3feed97,0xc386,0x5d87,0xa3,0x20,0xe9,0x5c,0xcb,0x36,0x5a,0x6b] as IID_TypedEventHandler_2_Windows_UI_Xaml_Controls_RichEditBox_Windows_UI_Xaml_Controls_TextControlCuttingToClipboardEventArgs } +#[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0xe261fba5,0x7714,0x5e51,0xb1,0x2e,0x9c,0x0d,0x12,0xda,0x40,0x06] as IID_TypedEventHandler_2_Windows_UI_Xaml_Controls_RichEditBox_Windows_UI_Xaml_Documents_ContentLinkInvokedEventArgs } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0x1e9d65a8,0x7312,0x5d13,0xa3,0xb9,0x27,0xa9,0x1b,0x90,0x63,0x24] as IID_TypedEventHandler_2_Windows_UI_Xaml_Controls_RichTextBlock_Windows_UI_Xaml_Controls_IsTextTrimmedChangedEventArgs } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0x8f4572d1,0x9348,0x56b3,0xb0,0x45,0xcb,0x42,0xf9,0x8a,0x43,0xa4] as IID_TypedEventHandler_2_Windows_UI_Xaml_Controls_RichTextBlockOverflow_Windows_UI_Xaml_Controls_IsTextTrimmedChangedEventArgs } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0xb15ccc28,0x40f3,0x52da,0x90,0x11,0x87,0x62,0x1e,0x9c,0x60,0xea] as IID_TypedEventHandler_2_Windows_UI_Xaml_Controls_SearchBox_Windows_UI_Xaml_Controls_SearchBoxQueryChangedEventArgs } @@ -3112,6 +3212,9 @@ RT_PINTERFACE!{ for TypedEventHandler => [ #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0x50c332f2,0x58d1,0x5228,0xa3,0xa9,0x1c,0xcb,0xde,0xd7,0x05,0x37] as IID_TypedEventHandler_2_Windows_UI_Xaml_Controls_TextBox_Windows_UI_Xaml_Controls_TextControlCopyingToClipboardEventArgs } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0xc1033f73,0xf81a,0x50d8,0x8d,0x3a,0x07,0xb3,0x8d,0x8d,0x17,0x7e] as IID_TypedEventHandler_2_Windows_UI_Xaml_Controls_TextBox_Windows_UI_Xaml_Controls_TextControlCuttingToClipboardEventArgs } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0x7d77980b,0xa0df,0x51b1,0x87,0x9b,0xc2,0x3d,0x2d,0xe0,0xab,0xbe] as IID_TypedEventHandler_2_Windows_UI_Xaml_Controls_TimePickerFlyout_Windows_UI_Xaml_Controls_TimePickedEventArgs } +#[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0xcfb65e59,0x864e,0x5e43,0xa5,0xdd,0x4b,0xb9,0xda,0xb9,0x72,0x1b] as IID_TypedEventHandler_2_Windows_UI_Xaml_Controls_TreeView_Windows_UI_Xaml_Controls_TreeViewCollapsedEventArgs } +#[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0x21aa264d,0x5bc5,0x5244,0xac,0x35,0x33,0x04,0x78,0x61,0x62,0xd3] as IID_TypedEventHandler_2_Windows_UI_Xaml_Controls_TreeView_Windows_UI_Xaml_Controls_TreeViewExpandingEventArgs } +#[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0x2311df32,0xbe87,0x54cf,0xb2,0xe0,0xd5,0xa3,0x7e,0x0f,0xed,0xef] as IID_TypedEventHandler_2_Windows_UI_Xaml_Controls_TreeView_Windows_UI_Xaml_Controls_TreeViewItemInvokedEventArgs } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0xd9f52e0d,0x21fb,0x5a0b,0xb4,0xc6,0x7d,0x16,0x2a,0xf7,0xfb,0x9c] as IID_TypedEventHandler_2_Windows_UI_Xaml_Controls_WebView_System_Object } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0xe7b42a9a,0xf140,0x52ad,0xa6,0x58,0xe2,0x37,0xb9,0xa3,0xdc,0xca] as IID_TypedEventHandler_2_Windows_UI_Xaml_Controls_WebView_Windows_UI_Xaml_Controls_WebViewContentLoadingEventArgs } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0xb9cc891c,0x4745,0x5a25,0x98,0x45,0xe4,0x4d,0x13,0x42,0x5a,0x38] as IID_TypedEventHandler_2_Windows_UI_Xaml_Controls_WebView_Windows_UI_Xaml_Controls_WebViewDOMContentLoadedEventArgs } @@ -3120,8 +3223,10 @@ RT_PINTERFACE!{ for TypedEventHandler => [ #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0x98055b5a,0x36bb,0x5962,0x97,0x1f,0x8b,0x87,0x61,0x9e,0xb1,0x7e] as IID_TypedEventHandler_2_Windows_UI_Xaml_Controls_WebView_Windows_UI_Xaml_Controls_WebViewNavigationStartingEventArgs } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0xa8d0aff5,0x90e1,0x5921,0x87,0xdd,0x57,0x6a,0x4b,0x0a,0x95,0xb6] as IID_TypedEventHandler_2_Windows_UI_Xaml_Controls_WebView_Windows_UI_Xaml_Controls_WebViewNewWindowRequestedEventArgs } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0x718c7a23,0xeb9f,0x50a6,0x8c,0xf7,0xfb,0xac,0x10,0x4e,0x59,0xc3] as IID_TypedEventHandler_2_Windows_UI_Xaml_Controls_WebView_Windows_UI_Xaml_Controls_WebViewPermissionRequestedEventArgs } +#[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0xfb77d6ae,0xd38a,0x5599,0x81,0x33,0xfc,0x1e,0xed,0xe4,0x08,0x0b] as IID_TypedEventHandler_2_Windows_UI_Xaml_Controls_WebView_Windows_UI_Xaml_Controls_WebViewSeparateProcessLostEventArgs } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0xd304027c,0x5714,0x502a,0x93,0x12,0x68,0xca,0x86,0x39,0x71,0x24] as IID_TypedEventHandler_2_Windows_UI_Xaml_Controls_WebView_Windows_UI_Xaml_Controls_WebViewUnsupportedUriSchemeIdentifiedEventArgs } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0xf00e9fbf,0xd30e,0x5854,0x89,0x27,0xc9,0x51,0x2a,0xbd,0x81,0x18] as IID_TypedEventHandler_2_Windows_UI_Xaml_Controls_WebView_Windows_UI_Xaml_Controls_WebViewUnviewableContentIdentifiedEventArgs } +#[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0x51ba1af0,0x354e,0x5868,0xb1,0x0b,0x87,0x48,0xe5,0x5a,0x63,0x70] as IID_TypedEventHandler_2_Windows_UI_Xaml_Documents_ContentLink_Windows_UI_Xaml_Documents_ContentLinkInvokedEventArgs } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0x5fead0d2,0xe657,0x5aef,0xa9,0x1b,0x7f,0x52,0xea,0xd1,0x7f,0xe3] as IID_TypedEventHandler_2_Windows_UI_Xaml_Documents_Hyperlink_Windows_UI_Xaml_Documents_HyperlinkClickEventArgs } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0xa8c9544b,0x7078,0x5316,0xbe,0xb6,0xd9,0xec,0x91,0x6a,0xb8,0x8a] as IID_TypedEventHandler_2_Windows_UI_Xaml_Documents_TextElement_Windows_UI_Xaml_Input_AccessKeyDisplayDismissedEventArgs } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0x39ad7708,0x254e,0x560a,0x9e,0x2e,0x73,0xb1,0xdb,0x31,0xf9,0x35] as IID_TypedEventHandler_2_Windows_UI_Xaml_Documents_TextElement_Windows_UI_Xaml_Input_AccessKeyDisplayRequestedEventArgs } @@ -3134,6 +3239,7 @@ RT_PINTERFACE!{ for TypedEventHandler => [ #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0xd723938d,0xefee,0x5a0c,0xab,0x3e,0x1e,0x1d,0xb3,0xc9,0xa2,0x16] as IID_TypedEventHandler_2_Windows_UI_Xaml_Media_Imaging_SvgImageSource_Windows_UI_Xaml_Media_Imaging_SvgImageSourceFailedEventArgs } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0x9e321151,0x8b27,0x5e18,0x9e,0xa3,0x50,0x52,0x0a,0xce,0xb7,0xef] as IID_TypedEventHandler_2_Windows_UI_Xaml_Media_Imaging_SvgImageSource_Windows_UI_Xaml_Media_Imaging_SvgImageSourceOpenedEventArgs } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0x0aa0c46e,0x1db6,0x5850,0xae,0x17,0xec,0x31,0x0e,0xa3,0xfd,0x2d] as IID_TypedEventHandler_2_Windows_UI_Xaml_Media_LoadedImageSurface_Windows_UI_Xaml_Media_LoadedImageSourceLoadCompletedEventArgs } +#[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0x2126cf26,0x9201,0x5d6b,0x84,0x5e,0x97,0xe1,0xc4,0x4b,0x9f,0xfd] as IID_TypedEventHandler_2_Windows_UI_Xaml_UIElement_Windows_UI_Xaml_BringIntoViewRequestedEventArgs } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0xecc4b13b,0x146c,0x5963,0xb8,0xb3,0x02,0x4c,0x5b,0x9b,0x95,0xe4] as IID_TypedEventHandler_2_Windows_UI_Xaml_UIElement_Windows_UI_Xaml_DragStartingEventArgs } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0xffd72e78,0xec1f,0x5bcc,0x9d,0x13,0xff,0x5f,0xbb,0x04,0x05,0x62] as IID_TypedEventHandler_2_Windows_UI_Xaml_UIElement_Windows_UI_Xaml_DropCompletedEventArgs } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for TypedEventHandler => [0x2831903f,0x655e,0x5464,0x82,0x8c,0x56,0xa8,0xb4,0xc6,0x5f,0x1e] as IID_TypedEventHandler_2_Windows_UI_Xaml_UIElement_Windows_UI_Xaml_Input_AccessKeyDisplayDismissedEventArgs } @@ -3150,6 +3256,21 @@ RT_PINTERFACE!{ for TypedEventHandler => [ #[cfg(feature="windows-web")] RT_PINTERFACE!{ for TypedEventHandler => [0xf8e10321,0x47bd,0x526a,0xa9,0xb2,0x3b,0xf1,0x2f,0x72,0x5f,0x8b] as IID_TypedEventHandler_2_Windows_Web_Http_Diagnostics_HttpDiagnosticProvider_Windows_Web_Http_Diagnostics_HttpDiagnosticProviderRequestSentEventArgs } #[cfg(feature="windows-web")] RT_PINTERFACE!{ for TypedEventHandler => [0x2eef1846,0x8176,0x52af,0x8d,0x2b,0xe0,0xc9,0x32,0x51,0x2e,0x9f] as IID_TypedEventHandler_2_Windows_Web_Http_Diagnostics_HttpDiagnosticProvider_Windows_Web_Http_Diagnostics_HttpDiagnosticProviderResponseReceivedEventArgs } #[cfg(feature="windows-web")] RT_PINTERFACE!{ for TypedEventHandler => [0xed0260c6,0x41f2,0x5a04,0x9a,0x8b,0x29,0x30,0xd7,0xff,0x8a,0x9e] as IID_TypedEventHandler_2_Windows_Web_Http_Filters_HttpBaseProtocolFilter_Windows_Web_Http_Filters_HttpServerCustomValidationRequestedEventArgs } +#[cfg(feature="windows-web")] RT_PINTERFACE!{ for TypedEventHandler => [0xb24e7b5b,0xb804,0x5346,0x97,0xb5,0x02,0xe6,0xd9,0xb6,0xcb,0xa8] as IID_TypedEventHandler_2_Windows_Web_UI_Interop_WebViewControl_Windows_Web_UI_Interop_WebViewControlAcceleratorKeyPressedEventArgs } +#[cfg(feature="windows-web")] RT_PINTERFACE!{ for TypedEventHandler => [0x234d40c0,0x2c51,0x5128,0xb9,0x19,0x00,0x3f,0x1c,0x0a,0x8a,0x26] as IID_TypedEventHandler_2_Windows_Web_UI_Interop_WebViewControl_Windows_Web_UI_Interop_WebViewControlMoveFocusRequestedEventArgs } +#[cfg(feature="windows-web")] RT_PINTERFACE!{ for TypedEventHandler => [0x0c4182f4,0xcc4c,0x55f3,0xb4,0x21,0xd4,0xe7,0x49,0xeb,0x80,0xa1] as IID_TypedEventHandler_2_Windows_Web_UI_Interop_WebViewControlProcess_System_Object } +#[cfg(feature="windows-web")] RT_PINTERFACE!{ for TypedEventHandler => [0xb5089479,0xabd8,0x5985,0x8a,0x93,0x4c,0x20,0x8a,0x85,0xe3,0xa4] as IID_TypedEventHandler_2_Windows_Web_UI_IWebViewControl_System_Object } +#[cfg(feature="windows-web")] RT_PINTERFACE!{ for TypedEventHandler => [0x357154fe,0xec1a,0x5fca,0xb8,0x60,0x62,0xf0,0x3d,0xec,0xe4,0x9d] as IID_TypedEventHandler_2_Windows_Web_UI_IWebViewControl_Windows_Web_UI_WebViewControlContentLoadingEventArgs } +#[cfg(feature="windows-web")] RT_PINTERFACE!{ for TypedEventHandler => [0xd7dc333e,0xb521,0x5b76,0xa7,0xff,0x48,0xb4,0x54,0xf5,0x97,0xe5] as IID_TypedEventHandler_2_Windows_Web_UI_IWebViewControl_Windows_Web_UI_WebViewControlDOMContentLoadedEventArgs } +#[cfg(feature="windows-web")] RT_PINTERFACE!{ for TypedEventHandler => [0xbd29249e,0x4112,0x533d,0x96,0xa2,0x0a,0x1c,0x01,0x51,0x9c,0xaf] as IID_TypedEventHandler_2_Windows_Web_UI_IWebViewControl_Windows_Web_UI_WebViewControlLongRunningScriptDetectedEventArgs } +#[cfg(feature="windows-web")] RT_PINTERFACE!{ for TypedEventHandler => [0x57a87c53,0x47a5,0x5864,0x98,0x81,0xfd,0x4c,0x00,0xf2,0x30,0xa9] as IID_TypedEventHandler_2_Windows_Web_UI_IWebViewControl_Windows_Web_UI_WebViewControlNavigationCompletedEventArgs } +#[cfg(feature="windows-web")] RT_PINTERFACE!{ for TypedEventHandler => [0xe92e0bcc,0x9ae9,0x5b9b,0xa6,0x84,0x83,0xdd,0x8e,0xe5,0x77,0x75] as IID_TypedEventHandler_2_Windows_Web_UI_IWebViewControl_Windows_Web_UI_WebViewControlNavigationStartingEventArgs } +#[cfg(feature="windows-web")] RT_PINTERFACE!{ for TypedEventHandler => [0x317111df,0x10c6,0x559c,0x85,0xa1,0x84,0x7e,0xb0,0xa1,0xb2,0xd5] as IID_TypedEventHandler_2_Windows_Web_UI_IWebViewControl_Windows_Web_UI_WebViewControlNewWindowRequestedEventArgs } +#[cfg(feature="windows-web")] RT_PINTERFACE!{ for TypedEventHandler => [0xe5cacc26,0x2a68,0x5e0a,0xb8,0x2b,0xb3,0xd7,0x56,0xe1,0x0a,0x56] as IID_TypedEventHandler_2_Windows_Web_UI_IWebViewControl_Windows_Web_UI_WebViewControlPermissionRequestedEventArgs } +#[cfg(feature="windows-web")] RT_PINTERFACE!{ for TypedEventHandler => [0xee8b81d3,0xbbc2,0x55b0,0x87,0x7b,0x6b,0xa8,0x6e,0x3a,0xd8,0x99] as IID_TypedEventHandler_2_Windows_Web_UI_IWebViewControl_Windows_Web_UI_WebViewControlScriptNotifyEventArgs } +#[cfg(feature="windows-web")] RT_PINTERFACE!{ for TypedEventHandler => [0x8658050c,0x5e47,0x5516,0xb2,0x5b,0x57,0xfa,0xe2,0x2c,0x4b,0x88] as IID_TypedEventHandler_2_Windows_Web_UI_IWebViewControl_Windows_Web_UI_WebViewControlUnsupportedUriSchemeIdentifiedEventArgs } +#[cfg(feature="windows-web")] RT_PINTERFACE!{ for TypedEventHandler => [0x571626e3,0x9780,0x5b37,0xbe,0x8a,0xab,0x8e,0x4e,0x78,0x98,0xcf] as IID_TypedEventHandler_2_Windows_Web_UI_IWebViewControl_Windows_Web_UI_WebViewControlUnviewableContentIdentifiedEventArgs } +#[cfg(feature="windows-web")] RT_PINTERFACE!{ for TypedEventHandler => [0x3a6ed2bc,0x032b,0x5ec7,0xa2,0x0a,0xc1,0xef,0x49,0x25,0x0c,0x3c] as IID_TypedEventHandler_2_Windows_Web_UI_IWebViewControl_Windows_Web_UI_WebViewControlWebResourceRequestedEventArgs } pub mod collections { // Windows.Foundation.Collections use ::prelude::*; RT_ENUM! { enum CollectionChange: i32 { @@ -3493,6 +3614,7 @@ RT_PINTERFACE!{ for IIterable => [0xc738964e,0x9c64,0x5bce,0xb5,0xce,0x61,0 RT_PINTERFACE!{ for IIterable => [0xf4ca3045,0x5dd7,0x54be,0x98,0x2e,0xd8,0x8d,0x8c,0xa0,0x87,0x6e] as IID_IIterable_1_System_Guid } RT_PINTERFACE!{ for IIterable => [0xe2fcc7c1,0x3bfc,0x5a0b,0xb2,0xb0,0x72,0xe7,0x69,0xd1,0xcb,0x7e] as IID_IIterable_1_System_String } RT_PINTERFACE!{ for IIterable => [0x81a643fb,0xf51c,0x5565,0x83,0xc4,0xf9,0x64,0x25,0x77,0x7b,0x66] as IID_IIterable_1_System_Int32 } +RT_PINTERFACE!{ for IIterable => [0x7784427e,0xf9cc,0x518d,0x96,0x4b,0xe5,0x0d,0x5c,0xe7,0x27,0xf1] as IID_IIterable_1_System_Int64 } RT_PINTERFACE!{ for IIterable => [0x092b849b,0x60b1,0x52be,0xa4,0x4a,0x6f,0xe8,0xe9,0x33,0xcb,0xe4] as IID_IIterable_1_System_Object } RT_PINTERFACE!{ for IIterable> => [0xae44597e,0xd411,0x5b7f,0xbb,0xec,0x6a,0x96,0xc9,0x4a,0x10,0x7a] as IID_IIterable_1_Windows_Foundation_Collections_IIterable_1_Windows_Foundation_Point } RT_PINTERFACE!{ for IIterable> => [0xf3b20528,0xe3b3,0x5331,0xb2,0xd0,0x0c,0x26,0x23,0xae,0xe7,0x85] as IID_IIterable_1_Windows_Foundation_Collections_IKeyValuePair_2_System_Guid_System_Object } @@ -3534,8 +3656,10 @@ RT_PINTERFACE!{ for IIterable> => [0xe1670fae,0x RT_PINTERFACE!{ for IIterable => [0x576a207d,0x977c,0x5b36,0xb5,0x4d,0x62,0x4e,0xc8,0x6c,0x53,0xa3] as IID_IIterable_1_Windows_Foundation_DateTime } RT_PINTERFACE!{ for IIterable => [0xc192280d,0x3a09,0x5423,0x9d,0xc5,0x67,0xb8,0x3e,0xbd,0xe4,0x1d] as IID_IIterable_1_Windows_Foundation_Point } RT_PINTERFACE!{ for IIterable => [0xc9df55c3,0x4d41,0x5e90,0xba,0x76,0xe8,0x9e,0xd5,0x64,0x44,0x6b] as IID_IIterable_1_Windows_Foundation_Size } +#[cfg(feature="windows-ai")] RT_PINTERFACE!{ for IIterable => [0xdf23db35,0xf789,0x51a1,0x85,0x6d,0x87,0xcd,0x7c,0xd0,0x42,0xf1] as IID_IIterable_1_Windows_AI_MachineLearning_Preview_ILearningModelVariableDescriptorPreview } #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IIterable => [0x3b4fe356,0x1b13,0x59cb,0xab,0x1f,0xc4,0x66,0x7a,0x74,0x75,0x6b] as IID_IIterable_1_Windows_ApplicationModel_AppExtensions_AppExtension } #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IIterable => [0x63d0bffe,0x0e34,0x55b3,0x83,0xd5,0x31,0x4c,0xaf,0xf2,0xb1,0x37] as IID_IIterable_1_Windows_ApplicationModel_AppInfo } +#[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IIterable => [0x2c28b4c9,0x6378,0x5382,0xa1,0xa6,0x79,0xbd,0x6e,0xed,0x96,0x7a] as IID_IIterable_1_Windows_ApplicationModel_AppInstance } #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IIterable => [0xb9802bba,0xff53,0x5d37,0x8c,0xd7,0xe5,0x61,0x62,0xf1,0x21,0x56] as IID_IIterable_1_Windows_ApplicationModel_Appointments_Appointment } #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IIterable => [0xd3fb010b,0xb692,0x5130,0x9d,0x16,0x2c,0xfd,0xab,0xcb,0x6d,0xec] as IID_IIterable_1_Windows_ApplicationModel_Appointments_AppointmentCalendar } #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IIterable => [0xcaac41d6,0x6c65,0x5fd8,0xb7,0x83,0xeb,0x9d,0x9a,0x42,0x72,0xb8] as IID_IIterable_1_Windows_ApplicationModel_Appointments_AppointmentException } @@ -3607,6 +3731,8 @@ RT_PINTERFACE!{ for IIterable => [0xc9df55c3,0x4d41,0x5e90,0xba,0x7 #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IIterable => [0x2c0d85d9,0x0df7,0x5de6,0x96,0x2e,0xbc,0x8f,0x14,0x9f,0xaf,0x19] as IID_IIterable_1_Windows_ApplicationModel_Store_Preview_StorePreviewSkuInfo } #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IIterable => [0x98a8577a,0xb128,0x5400,0x8d,0x3d,0x58,0x65,0x4e,0xaa,0xf9,0x57] as IID_IIterable_1_Windows_ApplicationModel_Store_Preview_StoreSystemFeature } #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IIterable => [0x2f4d1483,0xdd86,0x5fdb,0x8c,0x44,0x06,0xc9,0x88,0x44,0xbf,0x3d] as IID_IIterable_1_Windows_ApplicationModel_Store_UnfulfilledConsumable } +#[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IIterable => [0x37e6ab55,0x1f30,0x5622,0x97,0x78,0x1b,0xdc,0x07,0xac,0x79,0x9f] as IID_IIterable_1_Windows_ApplicationModel_UserActivities_UserActivity } +#[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IIterable => [0x29439e38,0x9cf0,0x51c7,0xa5,0x49,0x44,0x69,0x03,0x9c,0xaf,0x79] as IID_IIterable_1_Windows_ApplicationModel_UserActivities_UserActivitySessionHistoryItem } #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IIterable => [0x5cdb425e,0xda5a,0x55fa,0xb3,0x49,0x54,0x67,0x99,0x6c,0xab,0x32] as IID_IIterable_1_Windows_ApplicationModel_UserDataAccounts_Provider_UserDataAccountPartnerAccountInfo } #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IIterable => [0xa9c3ea6e,0x9dd9,0x52fe,0x9d,0x27,0xf9,0xe4,0xde,0xdd,0x4d,0x3f] as IID_IIterable_1_Windows_ApplicationModel_UserDataAccounts_SystemAccess_DeviceAccountConfiguration } #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IIterable => [0x1bc7f1ff,0x26b4,0x5440,0x96,0x29,0xcb,0x4c,0xd8,0xc8,0x79,0x87] as IID_IIterable_1_Windows_ApplicationModel_UserDataAccounts_UserDataAccount } @@ -3662,6 +3788,7 @@ RT_PINTERFACE!{ for IIterable => [0xc9df55c3,0x4d41,0x5e90,0xba,0x7 #[cfg(feature="windows-devices")] RT_PINTERFACE!{ for IIterable => [0x11341a6c,0x3a02,0x5f73,0x9d,0xb8,0xc3,0xec,0x58,0x23,0xe3,0x5d] as IID_IIterable_1_Windows_Devices_I2c_Provider_II2cControllerProvider } #[cfg(feature="windows-devices")] RT_PINTERFACE!{ for IIterable => [0xad26662c,0x845b,0x5c6d,0xae,0xaa,0x40,0x6f,0x48,0xc2,0x1a,0xe9] as IID_IIterable_1_Windows_Devices_Input_PointerDevice } #[cfg(feature="windows-devices")] RT_PINTERFACE!{ for IIterable => [0x592d6618,0xeaab,0x5a79,0xa4,0x7a,0xc7,0xfc,0x0b,0x74,0x9a,0x4e] as IID_IIterable_1_Windows_Devices_Input_PointerDeviceUsage } +#[cfg(feature="windows-devices")] RT_PINTERFACE!{ for IIterable => [0x1cf68266,0x3eb7,0x5336,0x84,0x0a,0x3c,0x1d,0x9f,0xdf,0x53,0x49] as IID_IIterable_1_Windows_Devices_Input_Preview_GazePointPreview } #[cfg(feature="windows-devices")] RT_PINTERFACE!{ for IIterable => [0xdb18069e,0x7b5a,0x54c3,0xa6,0x27,0xd5,0x6f,0x95,0x17,0xfd,0xf5] as IID_IIterable_1_Windows_Devices_Perception_PerceptionColorFrameSource } #[cfg(feature="windows-devices")] RT_PINTERFACE!{ for IIterable => [0x8a07e1e8,0x5a02,0x585b,0xa2,0x6e,0xad,0x79,0xbe,0xaa,0x94,0xcf] as IID_IIterable_1_Windows_Devices_Perception_PerceptionDepthFrameSource } #[cfg(feature="windows-devices")] RT_PINTERFACE!{ for IIterable => [0x9309d0db,0x338d,0x5adf,0x8b,0x3e,0x50,0x9b,0xfd,0xfc,0xce,0xf3] as IID_IIterable_1_Windows_Devices_Perception_PerceptionInfraredFrameSource } @@ -3727,13 +3854,16 @@ RT_PINTERFACE!{ for IIterable => [0xc9df55c3,0x4d41,0x5e90,0xba,0x7 #[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for IIterable => [0xcc63bf9c,0xe16a,0x5a75,0xa5,0xaa,0x2b,0x53,0xf9,0x75,0xb0,0xb0] as IID_IIterable_1_Windows_Graphics_DirectX_Direct3D11_IDirect3DSurface } #[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for IIterable => [0x3908f2c6,0x1aee,0x5129,0xb9,0xa6,0x2a,0x6e,0x01,0xd9,0x50,0x7e] as IID_IIterable_1_Windows_Graphics_DirectX_DirectXPixelFormat } #[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for IIterable => [0x497e3d51,0x0ea1,0x5be0,0x8d,0xba,0x8f,0x7f,0x4c,0xe4,0xfb,0x33] as IID_IIterable_1_Windows_Graphics_Display_Core_HdmiDisplayMode } +#[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for IIterable => [0x7fb7a783,0xce2d,0x552d,0xbe,0xe3,0xbc,0x14,0x42,0xdb,0x04,0x09] as IID_IIterable_1_Windows_Graphics_Display_NitRange } #[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for IIterable => [0xb2afd154,0x8db0,0x5bb2,0xad,0x7a,0x68,0x4a,0xfd,0x47,0x92,0x64] as IID_IIterable_1_Windows_Graphics_Holographic_HolographicCamera } #[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for IIterable => [0x92111aff,0x8dcc,0x538e,0xae,0x3d,0x31,0xfd,0x25,0x2a,0x0a,0xd5] as IID_IIterable_1_Windows_Graphics_Holographic_HolographicCameraPose } +#[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for IIterable => [0xd0fe1cdf,0x33ad,0x5051,0x8c,0x5b,0xab,0x9a,0x2b,0x2c,0x24,0xbf] as IID_IIterable_1_Windows_Graphics_Holographic_HolographicFramePresentationReport } #[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for IIterable => [0x84744661,0x94de,0x5866,0xa1,0x5d,0x9e,0xfb,0x19,0xa9,0x9a,0x54] as IID_IIterable_1_Windows_Graphics_Holographic_HolographicQuadLayer } #[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for IIterable => [0x2b6bdb90,0xa4eb,0x5142,0xb5,0x82,0x3c,0xcb,0x1e,0xdc,0x57,0x89] as IID_IIterable_1_Windows_Graphics_Imaging_BitmapCodecInformation } #[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for IIterable => [0xe924d9ed,0xa13e,0x5bdb,0x9e,0xd8,0x65,0xa1,0x47,0x4d,0xc2,0x74] as IID_IIterable_1_Windows_Graphics_Imaging_BitmapPixelFormat } #[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for IIterable => [0x034ea0c4,0xc20e,0x5c0c,0xba,0x31,0x64,0x21,0x2f,0x28,0xe6,0x50] as IID_IIterable_1_Windows_Graphics_Imaging_ImageStream } #[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for IIterable => [0x22d3a30f,0x0898,0x5e94,0x99,0xa3,0xaf,0xa5,0x95,0x1d,0xfc,0xd4] as IID_IIterable_1_Windows_Graphics_Imaging_SoftwareBitmap } +#[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for IIterable => [0xed6ddf38,0x34cf,0x5a2f,0xb9,0xac,0x41,0x3d,0xff,0xce,0x7f,0x81] as IID_IIterable_1_Windows_Graphics_Printing_PrintPageRange } #[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for IIterable => [0x5c7e6676,0x9046,0x5b6a,0x9e,0xb0,0xc6,0xa9,0x54,0xe8,0x22,0x6b] as IID_IIterable_1_Windows_Graphics_Printing_PrintTicket_PrintTicketOption } #[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for IIterable => [0x9a6bd130,0x6f22,0x559c,0xb9,0x2c,0x14,0xf9,0xf8,0xdd,0xda,0x47] as IID_IIterable_1_Windows_Graphics_Printing3D_Printing3DBaseMaterial } #[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for IIterable => [0xc08f8e70,0xf6ef,0x5469,0x80,0x6a,0x7c,0xb6,0x01,0xdd,0xdb,0x67] as IID_IIterable_1_Windows_Graphics_Printing3D_Printing3DBaseMaterialGroup } @@ -3770,6 +3900,7 @@ RT_PINTERFACE!{ for IIterable => [0xc9df55c3,0x4d41,0x5e90,0xba,0x7 #[cfg(feature="windows-media")] RT_PINTERFACE!{ for IIterable => [0x737a2098,0x41bf,0x5d9f,0xa1,0xd2,0x2f,0x17,0x1c,0x57,0x8b,0x3c] as IID_IIterable_1_Windows_Media_Core_IMediaCue } #[cfg(feature="windows-media")] RT_PINTERFACE!{ for IIterable => [0x5ca0da86,0x6307,0x558a,0x86,0x5f,0x3a,0x1e,0xf9,0xfe,0x56,0xb3] as IID_IIterable_1_Windows_Media_Core_MseSourceBuffer } #[cfg(feature="windows-media")] RT_PINTERFACE!{ for IIterable => [0xed0c6e08,0xe22f,0x5ac2,0xba,0x14,0xe0,0xff,0x1d,0xf3,0x46,0x7f] as IID_IIterable_1_Windows_Media_Core_MseTimeRange } +#[cfg(feature="windows-media")] RT_PINTERFACE!{ for IIterable => [0xf3d07841,0x3852,0x509d,0xa1,0x2b,0xa9,0xf2,0xac,0x89,0xda,0x93] as IID_IIterable_1_Windows_Media_Core_TimedMetadataStreamDescriptor } #[cfg(feature="windows-media")] RT_PINTERFACE!{ for IIterable => [0x150a4454,0x03bb,0x5dd1,0x81,0x53,0x6a,0x60,0x0e,0x85,0x1f,0x71] as IID_IIterable_1_Windows_Media_Core_TimedMetadataTrack } #[cfg(feature="windows-media")] RT_PINTERFACE!{ for IIterable => [0xaec710ad,0x3bd8,0x5a59,0xae,0x77,0xe7,0xfc,0x46,0xfb,0x10,0x5b] as IID_IIterable_1_Windows_Media_Core_TimedTextLine } #[cfg(feature="windows-media")] RT_PINTERFACE!{ for IIterable => [0x4fc57282,0x0edf,0x5d85,0x9d,0x89,0xdd,0xc2,0xa5,0x69,0x2c,0x13] as IID_IIterable_1_Windows_Media_Core_TimedTextSource } @@ -3788,6 +3919,7 @@ RT_PINTERFACE!{ for IIterable => [0xc9df55c3,0x4d41,0x5e90,0xba,0x7 #[cfg(feature="windows-media")] RT_PINTERFACE!{ for IIterable => [0xcf8cbeb1,0x2a4c,0x522d,0x96,0x2f,0x84,0xc3,0x1a,0x59,0x8d,0x68] as IID_IIterable_1_Windows_Media_Devices_ManualFocusDistance } #[cfg(feature="windows-media")] RT_PINTERFACE!{ for IIterable => [0x323d7734,0x94c2,0x544d,0xa5,0x60,0x56,0x56,0x0f,0xe6,0x88,0x19] as IID_IIterable_1_Windows_Media_Devices_OpticalImageStabilizationMode } #[cfg(feature="windows-media")] RT_PINTERFACE!{ for IIterable => [0xd73144c7,0x9d75,0x5dfb,0x80,0x40,0x62,0x62,0x02,0xdc,0xf4,0x54] as IID_IIterable_1_Windows_Media_Devices_RegionOfInterest } +#[cfg(feature="windows-media")] RT_PINTERFACE!{ for IIterable => [0xcaf26629,0xee84,0x5d4c,0xae,0x37,0x9d,0xc4,0xb2,0x69,0x78,0xeb] as IID_IIterable_1_Windows_Media_Devices_VideoTemporalDenoisingMode } #[cfg(feature="windows-media")] RT_PINTERFACE!{ for IIterable => [0xdb656915,0x8fac,0x5fb2,0x98,0xe0,0x0e,0x97,0x42,0x16,0x56,0xc5] as IID_IIterable_1_Windows_Media_Devices_ZoomTransitionMode } #[cfg(feature="windows-media")] RT_PINTERFACE!{ for IIterable => [0x3fc05ba2,0x30f6,0x5219,0x90,0x47,0x11,0x97,0xff,0xae,0x8d,0xba] as IID_IIterable_1_Windows_Media_Editing_BackgroundAudioTrack } #[cfg(feature="windows-media")] RT_PINTERFACE!{ for IIterable => [0x32fabed0,0xe1e6,0x578e,0x86,0xe5,0xb4,0xe6,0xab,0xeb,0x22,0xd6] as IID_IIterable_1_Windows_Media_Editing_EmbeddedAudioTrack } @@ -3832,6 +3964,7 @@ RT_PINTERFACE!{ for IIterable => [0xc9df55c3,0x4d41,0x5e90,0xba,0x7 #[cfg(feature="windows-networking")] RT_PINTERFACE!{ for IIterable => [0xf79bc7ba,0x01df,0x51ec,0xbf,0xaf,0xfd,0x88,0x3f,0x69,0x8e,0x07] as IID_IIterable_1_Windows_Networking_Connectivity_ProviderNetworkUsage } #[cfg(feature="windows-networking")] RT_PINTERFACE!{ for IIterable => [0xd7ec83c4,0xa17b,0x51bf,0x89,0x97,0xaa,0x33,0xb9,0x10,0x2d,0xc9] as IID_IIterable_1_Windows_Networking_EndpointPair } #[cfg(feature="windows-networking")] RT_PINTERFACE!{ for IIterable => [0x9e5f3ed0,0xcf1c,0x5d38,0x83,0x2c,0xac,0xea,0x61,0x64,0xbf,0x5c] as IID_IIterable_1_Windows_Networking_HostName } +#[cfg(feature="windows-networking")] RT_PINTERFACE!{ for IIterable => [0x2ce4dd28,0x5154,0x57da,0x8e,0x92,0xc1,0xc9,0xc9,0x64,0x42,0x7b] as IID_IIterable_1_Windows_Networking_NetworkOperators_ESimProfile } #[cfg(feature="windows-networking")] RT_PINTERFACE!{ for IIterable => [0xfd66b9ac,0x40dc,0x5ac7,0xaa,0xf1,0x2d,0x34,0x03,0xe5,0xfc,0xbb] as IID_IIterable_1_Windows_Networking_NetworkOperators_MobileBroadbandAntennaSar } #[cfg(feature="windows-networking")] RT_PINTERFACE!{ for IIterable => [0x46e83a22,0x4c40,0x5f27,0xbb,0xcd,0x25,0x5d,0xfd,0x97,0xea,0x93] as IID_IIterable_1_Windows_Networking_NetworkOperators_MobileBroadbandCellCdma } #[cfg(feature="windows-networking")] RT_PINTERFACE!{ for IIterable => [0x83e5eae8,0x3887,0x599e,0xbe,0xbf,0x8c,0x51,0x36,0x2d,0xb4,0x4c] as IID_IIterable_1_Windows_Networking_NetworkOperators_MobileBroadbandCellGsm } @@ -3893,6 +4026,7 @@ RT_PINTERFACE!{ for IIterable => [0xc9df55c3,0x4d41,0x5e90,0xba,0x7 #[cfg(feature="windows-services")] RT_PINTERFACE!{ for IIterable => [0xb2da6de8,0xad55,0x56ce,0x87,0x54,0x2c,0x96,0xf4,0xfe,0x1c,0x2e] as IID_IIterable_1_Windows_Services_Store_StoreImage } #[cfg(feature="windows-services")] RT_PINTERFACE!{ for IIterable => [0x6b076c51,0x849e,0x5ec5,0xae,0xd5,0x9b,0x05,0x85,0x59,0x19,0x02] as IID_IIterable_1_Windows_Services_Store_StorePackageUpdate } #[cfg(feature="windows-services")] RT_PINTERFACE!{ for IIterable => [0x60832223,0x7eb4,0x5cd7,0x83,0x40,0xf5,0x07,0x71,0x73,0xd3,0x64] as IID_IIterable_1_Windows_Services_Store_StorePackageUpdateStatus } +#[cfg(feature="windows-services")] RT_PINTERFACE!{ for IIterable => [0x68eb92e6,0x3cc6,0x5259,0x9a,0x05,0xbd,0x7f,0x8d,0x9f,0xb8,0xda] as IID_IIterable_1_Windows_Services_Store_StoreQueueItem } #[cfg(feature="windows-services")] RT_PINTERFACE!{ for IIterable => [0x522d34ef,0x4b5a,0x5b44,0xa0,0x46,0x7a,0x16,0x05,0x1d,0x01,0x1e] as IID_IIterable_1_Windows_Services_Store_StoreSku } #[cfg(feature="windows-services")] RT_PINTERFACE!{ for IIterable => [0x46be61e4,0x7173,0x565e,0xae,0xd5,0x4a,0x21,0x52,0xf1,0xce,0x69] as IID_IIterable_1_Windows_Services_Store_StoreVideo } #[cfg(feature="windows-services")] RT_PINTERFACE!{ for IIterable => [0xcf05b497,0x3afd,0x5d00,0x85,0x9e,0x9f,0xbd,0x1a,0x36,0xd5,0x76] as IID_IIterable_1_Windows_Services_TargetedContent_TargetedContentAction } @@ -3922,6 +4056,7 @@ RT_PINTERFACE!{ for IIterable => [0xc9df55c3,0x4d41,0x5e90,0xba,0x7 #[cfg(feature="windows-system")] RT_PINTERFACE!{ for IIterable => [0x8b640948,0xc0d3,0x5b7e,0xa9,0x9c,0x59,0x56,0x19,0x0d,0x54,0x08] as IID_IIterable_1_Windows_System_AppResourceGroupInfo } #[cfg(feature="windows-system")] RT_PINTERFACE!{ for IIterable => [0x97b73627,0xb296,0x5076,0xb8,0xcd,0x6b,0xd8,0xa2,0x40,0xe9,0x66] as IID_IIterable_1_Windows_System_Diagnostics_ProcessDiagnosticInfo } #[cfg(feature="windows-system")] RT_PINTERFACE!{ for IIterable => [0xecb0c107,0xc97b,0x52fe,0xa5,0xe6,0xa3,0x3e,0x93,0x49,0x37,0x69] as IID_IIterable_1_Windows_System_Diagnostics_TraceReporting_PlatformDiagnosticTraceInfo } +#[cfg(feature="windows-system")] RT_PINTERFACE!{ for IIterable => [0xb64037f2,0xdc1a,0x57de,0x8b,0x03,0x18,0xa1,0x6f,0x9d,0xdb,0xdf] as IID_IIterable_1_Windows_System_Inventory_InstalledDesktopApp } #[cfg(feature="windows-system")] RT_PINTERFACE!{ for IIterable => [0x13966c92,0xa8de,0x50c0,0xb1,0x6b,0x00,0xc2,0xc4,0x8f,0x5f,0x37] as IID_IIterable_1_Windows_System_RemoteSystems_IRemoteSystemFilter } #[cfg(feature="windows-system")] RT_PINTERFACE!{ for IIterable => [0x00189d10,0x16ec,0x5d1a,0x83,0x69,0x48,0x70,0xc6,0x9e,0x52,0xb3] as IID_IIterable_1_Windows_System_RemoteSystems_RemoteSystemSessionParticipant } #[cfg(feature="windows-system")] RT_PINTERFACE!{ for IIterable => [0xd1bacd1f,0x0376,0x5823,0x8c,0x29,0x1d,0x45,0xb9,0xf4,0xc1,0x91] as IID_IIterable_1_Windows_System_User } @@ -3930,6 +4065,7 @@ RT_PINTERFACE!{ for IIterable => [0xc9df55c3,0x4d41,0x5e90,0xba,0x7 #[cfg(feature="windows-ui")] RT_PINTERFACE!{ for IIterable => [0xbd0d999c,0xb2ba,0x51b2,0xbc,0xc0,0xd4,0xa5,0xcd,0x82,0x15,0x55] as IID_IIterable_1_Windows_UI_ApplicationSettings_WebAccountCommand } #[cfg(feature="windows-ui")] RT_PINTERFACE!{ for IIterable => [0x15165367,0x2e93,0x59a6,0xb5,0xc7,0x16,0xd3,0xb5,0x8f,0xd2,0xe7] as IID_IIterable_1_Windows_UI_ApplicationSettings_WebAccountProviderCommand } #[cfg(feature="windows-ui")] RT_PINTERFACE!{ for IIterable => [0x932eef5e,0x2c2f,0x5eae,0x92,0x9a,0x74,0xe9,0x73,0xb5,0x7c,0x27] as IID_IIterable_1_Windows_UI_Color } +#[cfg(feature="windows-ui")] RT_PINTERFACE!{ for IIterable => [0x1135adf5,0xdb12,0x55e8,0xae,0x0f,0xbd,0x8d,0x91,0x4b,0xd3,0x99] as IID_IIterable_1_Windows_UI_Composition_CompositionShape } #[cfg(feature="windows-ui")] RT_PINTERFACE!{ for IIterable => [0xb268447b,0xf519,0x5ce5,0x89,0xcd,0xb7,0xe1,0xbc,0x56,0x52,0xee] as IID_IIterable_1_Windows_UI_Composition_Interactions_CompositionConditionalValue } #[cfg(feature="windows-ui")] RT_PINTERFACE!{ for IIterable => [0x9a245c40,0xaae6,0x59fb,0x87,0xf5,0x4b,0xb0,0x55,0x99,0xf0,0xb1] as IID_IIterable_1_Windows_UI_Composition_Interactions_InteractionTrackerInertiaModifier } #[cfg(feature="windows-ui")] RT_PINTERFACE!{ for IIterable => [0x3aeacfd8,0xc7f1,0x580c,0xa2,0x3b,0x99,0x66,0x6e,0x42,0xe6,0x2b] as IID_IIterable_1_Windows_UI_Composition_Interactions_InteractionTrackerVector2InertiaModifier } @@ -3976,6 +4112,7 @@ RT_PINTERFACE!{ for IIterable => [0xc9df55c3,0x4d41,0x5e90,0xba,0x7 #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for IIterable => [0x0bb14d64,0xcc9a,0x58ae,0xb8,0x81,0x73,0xfe,0x0e,0xcb,0x99,0xeb] as IID_IIterable_1_Windows_UI_Xaml_Controls_MenuFlyoutItemBase } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for IIterable => [0x0af05ce9,0x3b0f,0x5a6d,0xa0,0x53,0xd0,0x1a,0x1a,0x55,0x4f,0x8c] as IID_IIterable_1_Windows_UI_Xaml_Controls_Primitives_Popup } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for IIterable => [0xabef522a,0x7378,0x504f,0x94,0x06,0x97,0xd9,0xf4,0x26,0x43,0xa7] as IID_IIterable_1_Windows_UI_Xaml_Controls_RowDefinition } +#[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for IIterable => [0x54a8a9b3,0xfb4d,0x593e,0x81,0xa2,0xb4,0x0c,0x68,0xcb,0x24,0xb2] as IID_IIterable_1_Windows_UI_Xaml_Controls_TreeViewNode } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for IIterable => [0x3981a977,0xda6c,0x5450,0x82,0x3e,0x7d,0xd2,0x3b,0x91,0xf2,0xbc] as IID_IIterable_1_Windows_UI_Xaml_Controls_WebViewDeferredPermissionRequest } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for IIterable => [0x273b8073,0x8c16,0x59c2,0xa6,0x16,0x0a,0x53,0x44,0x83,0xc6,0x12] as IID_IIterable_1_Windows_UI_Xaml_Data_ItemIndexRange } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for IIterable => [0xf66c6bd3,0x55b4,0x5bbb,0xb8,0x2a,0x6d,0x9c,0xe3,0x83,0x09,0x1a] as IID_IIterable_1_Windows_UI_Xaml_DependencyObject } @@ -4020,6 +4157,8 @@ RT_PINTERFACE!{ for IIterable => [0xc9df55c3,0x4d41,0x5e90,0xba,0x7 #[cfg(feature="windows-web")] RT_PINTERFACE!{ for IIterable => [0x55463eef,0xecb8,0x59cd,0x8d,0x6b,0x74,0xda,0xac,0xbe,0x7d,0x19] as IID_IIterable_1_Windows_Web_Syndication_SyndicationItem } #[cfg(feature="windows-web")] RT_PINTERFACE!{ for IIterable => [0xc6919f6a,0x66d9,0x556a,0x96,0x32,0x87,0xd3,0x9a,0xf1,0x46,0x38] as IID_IIterable_1_Windows_Web_Syndication_SyndicationLink } #[cfg(feature="windows-web")] RT_PINTERFACE!{ for IIterable => [0xe58e7844,0xeb34,0x5284,0xb0,0x9e,0xde,0x67,0x62,0xd5,0x48,0xca] as IID_IIterable_1_Windows_Web_Syndication_SyndicationPerson } +#[cfg(feature="windows-web")] RT_PINTERFACE!{ for IIterable => [0xf1028969,0xd7aa,0x59d8,0x88,0x26,0x4e,0x02,0xa8,0x06,0x45,0x15] as IID_IIterable_1_Windows_Web_UI_Interop_WebViewControl } +#[cfg(feature="windows-web")] RT_PINTERFACE!{ for IIterable => [0x91805f3f,0x13cb,0x5483,0xb5,0x92,0xb9,0xae,0x0e,0x33,0x4f,0x17] as IID_IIterable_1_Windows_Web_UI_WebViewControlDeferredPermissionRequest } #[cfg(feature="windows-web")] RT_PINTERFACE!{ for IIterable => [0x7b7f182e,0xa6ce,0x556b,0x9a,0x2e,0xef,0x97,0x66,0x2f,0x2a,0xee] as IID_IIterable_1_Windows_Web_WebErrorStatus } RT_PINTERFACE!{ for IIterable => [0xe9f78726,0x829a,0x5f67,0x8d,0x19,0x95,0xef,0x15,0x4b,0x77,0x42] as IID_IIterable_1_Windows_Foundation_TimeSpan } RT_PINTERFACE!{ for IIterable => [0xb0d63b78,0x78ad,0x5e31,0xb6,0xd8,0xe3,0x2a,0x0e,0x16,0xc4,0x47] as IID_IIterable_1_Windows_Foundation_Uri } @@ -4031,6 +4170,7 @@ RT_PINTERFACE!{ for IIterator => [0x638a2cf4,0xf474,0x5318,0x90,0x55,0x14,0 RT_PINTERFACE!{ for IIterator => [0xd3d64048,0x82b3,0x53c7,0x92,0x85,0xb0,0xbe,0x18,0x36,0x84,0x82] as IID_IIterator_1_System_Guid } RT_PINTERFACE!{ for IIterator => [0x8c304ebb,0x6615,0x50a4,0x88,0x29,0x87,0x9e,0xcd,0x44,0x32,0x36] as IID_IIterator_1_System_String } RT_PINTERFACE!{ for IIterator => [0xbfea7f78,0x50c2,0x5f1d,0xa6,0xea,0x9e,0x97,0x8d,0x26,0x99,0xff] as IID_IIterator_1_System_Int32 } +RT_PINTERFACE!{ for IIterator => [0xfb98034c,0x86b7,0x581f,0x8c,0xd9,0x5a,0xd0,0x69,0x22,0x01,0xa9] as IID_IIterator_1_System_Int64 } RT_PINTERFACE!{ for IIterator => [0x44a94f2d,0x04f8,0x5091,0xb3,0x36,0xbe,0x78,0x92,0xdd,0x10,0xbe] as IID_IIterator_1_System_Object } RT_PINTERFACE!{ for IIterator> => [0x377f6162,0x6e4d,0x574e,0xbf,0x01,0x77,0xf4,0xfd,0x02,0x1d,0x0e] as IID_IIterator_1_Windows_Foundation_Collections_IIterable_1_Windows_Foundation_Point } RT_PINTERFACE!{ for IIterator> => [0x4f25059a,0x0b9a,0x5f25,0x9b,0x9e,0x4b,0x9f,0x1d,0x22,0xff,0x65] as IID_IIterator_1_Windows_Foundation_Collections_IKeyValuePair_2_System_Guid_System_Object } @@ -4073,8 +4213,10 @@ RT_PINTERFACE!{ for IIterator> => [0x53a2e825,0x RT_PINTERFACE!{ for IIterator => [0xf56158df,0x8947,0x5480,0x96,0xed,0x36,0xc1,0x05,0x78,0x77,0xea] as IID_IIterator_1_Windows_Foundation_DateTime } RT_PINTERFACE!{ for IIterator => [0xc602b59e,0x0a8e,0x5e99,0xb4,0x78,0x2b,0x56,0x45,0x85,0x27,0x8d] as IID_IIterator_1_Windows_Foundation_Point } RT_PINTERFACE!{ for IIterator => [0xa3508ee0,0x3527,0x5144,0x89,0x4d,0x42,0x2e,0xad,0xef,0x43,0xd7] as IID_IIterator_1_Windows_Foundation_Size } +#[cfg(feature="windows-ai")] RT_PINTERFACE!{ for IIterator => [0xe9696f7b,0x99cf,0x57ea,0x99,0xca,0x63,0xe1,0xff,0x9f,0x49,0x19] as IID_IIterator_1_Windows_AI_MachineLearning_Preview_ILearningModelVariableDescriptorPreview } #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IIterator => [0x8e80ca83,0x3cd3,0x5f9c,0x83,0xe4,0x84,0x34,0x7c,0xa5,0x49,0x8c] as IID_IIterator_1_Windows_ApplicationModel_AppExtensions_AppExtension } #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IIterator => [0x69cec62c,0x41eb,0x5d69,0xa4,0x75,0x29,0xee,0x22,0x32,0x3d,0xd8] as IID_IIterator_1_Windows_ApplicationModel_AppInfo } +#[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IIterator => [0x14c94628,0x7938,0x56d5,0x89,0x5a,0x8f,0xc5,0x2e,0xd3,0xbb,0x7e] as IID_IIterator_1_Windows_ApplicationModel_AppInstance } #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IIterator => [0x386a5922,0x49fc,0x53b6,0x8b,0xed,0x4c,0x9f,0xf9,0xfe,0x6e,0x01] as IID_IIterator_1_Windows_ApplicationModel_Appointments_Appointment } #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IIterator => [0xf40a879d,0xb6b7,0x5f92,0xbe,0xb1,0x6a,0x8e,0x7c,0xe5,0x41,0x20] as IID_IIterator_1_Windows_ApplicationModel_Appointments_AppointmentCalendar } #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IIterator => [0xe58c63db,0xd9d5,0x5fa5,0x87,0x90,0x29,0x84,0x6d,0xe5,0x4f,0xa4] as IID_IIterator_1_Windows_ApplicationModel_Appointments_AppointmentException } @@ -4146,6 +4288,8 @@ RT_PINTERFACE!{ for IIterator => [0xa3508ee0,0x3527,0x5144,0x89,0x4 #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IIterator => [0xb6f9b421,0x7f54,0x5d26,0x9c,0x37,0x9f,0x9d,0x7a,0xc8,0x93,0xeb] as IID_IIterator_1_Windows_ApplicationModel_Store_Preview_StorePreviewSkuInfo } #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IIterator => [0xd0455b2d,0xd8aa,0x557e,0x89,0xa3,0x63,0xc3,0x3e,0x8c,0xee,0x99] as IID_IIterator_1_Windows_ApplicationModel_Store_Preview_StoreSystemFeature } #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IIterator => [0xcb77cf2e,0xef57,0x5256,0x97,0x53,0x21,0x4b,0xaa,0xda,0x23,0x01] as IID_IIterator_1_Windows_ApplicationModel_Store_UnfulfilledConsumable } +#[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IIterator => [0x2ca0633b,0x0505,0x5f88,0xa9,0x8f,0x8e,0x7c,0x5b,0x08,0xf2,0x5b] as IID_IIterator_1_Windows_ApplicationModel_UserActivities_UserActivity } +#[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IIterator => [0x88c0e720,0x7442,0x553a,0x86,0xd7,0x43,0xdf,0xe7,0xd2,0x19,0x29] as IID_IIterator_1_Windows_ApplicationModel_UserActivities_UserActivitySessionHistoryItem } #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IIterator => [0xac401b26,0x3ebf,0x5cbf,0x96,0x43,0xc9,0x6a,0x40,0xab,0x40,0xa2] as IID_IIterator_1_Windows_ApplicationModel_UserDataAccounts_Provider_UserDataAccountPartnerAccountInfo } #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IIterator => [0x51705a87,0x8dcb,0x5971,0x8d,0x6b,0xca,0x8a,0xe6,0xa9,0x55,0xad] as IID_IIterator_1_Windows_ApplicationModel_UserDataAccounts_SystemAccess_DeviceAccountConfiguration } #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IIterator => [0xe38246ab,0xdf01,0x5d16,0x92,0x3a,0x17,0xc8,0x8c,0xdb,0xac,0x29] as IID_IIterator_1_Windows_ApplicationModel_UserDataAccounts_UserDataAccount } @@ -4201,6 +4345,7 @@ RT_PINTERFACE!{ for IIterator => [0xa3508ee0,0x3527,0x5144,0x89,0x4 #[cfg(feature="windows-devices")] RT_PINTERFACE!{ for IIterator => [0xf6232961,0xc660,0x50a1,0x82,0xe8,0x12,0x89,0x2f,0xcd,0x91,0xf7] as IID_IIterator_1_Windows_Devices_I2c_Provider_II2cControllerProvider } #[cfg(feature="windows-devices")] RT_PINTERFACE!{ for IIterator => [0xde94641c,0x7960,0x5fcd,0xab,0xe8,0xd6,0xba,0x60,0x9e,0xf7,0xd3] as IID_IIterator_1_Windows_Devices_Input_PointerDevice } #[cfg(feature="windows-devices")] RT_PINTERFACE!{ for IIterator => [0x9ab2160d,0x11ef,0x5eca,0x8d,0xd9,0x3e,0x13,0xaa,0x4e,0x5f,0x99] as IID_IIterator_1_Windows_Devices_Input_PointerDeviceUsage } +#[cfg(feature="windows-devices")] RT_PINTERFACE!{ for IIterator => [0xad015c81,0x2d80,0x501e,0xbc,0x9a,0xa6,0x3f,0x05,0xf9,0x3b,0xac] as IID_IIterator_1_Windows_Devices_Input_Preview_GazePointPreview } #[cfg(feature="windows-devices")] RT_PINTERFACE!{ for IIterator => [0x24089f00,0xba6d,0x50d4,0xac,0x46,0xf2,0x88,0x75,0x5e,0x41,0x81] as IID_IIterator_1_Windows_Devices_Perception_PerceptionColorFrameSource } #[cfg(feature="windows-devices")] RT_PINTERFACE!{ for IIterator => [0x20cff8c2,0x7844,0x54e5,0xae,0x4f,0x57,0xe7,0x76,0x8f,0x9b,0x69] as IID_IIterator_1_Windows_Devices_Perception_PerceptionDepthFrameSource } #[cfg(feature="windows-devices")] RT_PINTERFACE!{ for IIterator => [0xb22b294f,0xa4d2,0x5726,0xa7,0xfc,0x5e,0x33,0x14,0x32,0xd9,0xb4] as IID_IIterator_1_Windows_Devices_Perception_PerceptionInfraredFrameSource } @@ -4266,13 +4411,16 @@ RT_PINTERFACE!{ for IIterator => [0xa3508ee0,0x3527,0x5144,0x89,0x4 #[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for IIterator => [0xbdfb6d0b,0xe785,0x5d5a,0xab,0xd2,0xfe,0x1b,0x18,0xc4,0x32,0x57] as IID_IIterator_1_Windows_Graphics_DirectX_Direct3D11_IDirect3DSurface } #[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for IIterator => [0xea016190,0xac80,0x5840,0x8f,0x58,0xff,0x43,0x4c,0x7b,0x29,0x07] as IID_IIterator_1_Windows_Graphics_DirectX_DirectXPixelFormat } #[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for IIterator => [0xd66eb831,0xe22c,0x5ee3,0xaf,0x45,0xe1,0xc0,0x3d,0xe4,0xbc,0x62] as IID_IIterator_1_Windows_Graphics_Display_Core_HdmiDisplayMode } +#[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for IIterator => [0x6be92993,0xd069,0x5a99,0xb9,0xe8,0x20,0x0c,0xf5,0xc8,0xa0,0x60] as IID_IIterator_1_Windows_Graphics_Display_NitRange } #[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for IIterator => [0x6acc8576,0x2fea,0x561d,0x84,0xdd,0x4a,0x1a,0xb0,0x5f,0xc7,0xed] as IID_IIterator_1_Windows_Graphics_Holographic_HolographicCamera } #[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for IIterator => [0x93e27fb4,0x332b,0x591e,0xae,0x6b,0x61,0x92,0xfa,0x0a,0x10,0x09] as IID_IIterator_1_Windows_Graphics_Holographic_HolographicCameraPose } +#[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for IIterator => [0xf81cb835,0xd690,0x55d7,0xad,0xfb,0x7b,0x92,0xb9,0x6e,0x29,0xa0] as IID_IIterator_1_Windows_Graphics_Holographic_HolographicFramePresentationReport } #[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for IIterator => [0x85765170,0x495b,0x541c,0xae,0xf0,0x74,0x92,0x85,0x6d,0xe3,0xdf] as IID_IIterator_1_Windows_Graphics_Holographic_HolographicQuadLayer } #[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for IIterator => [0x4ff2b2db,0x9326,0x537f,0xb8,0xdc,0x4c,0x93,0xd7,0x7f,0xbb,0x84] as IID_IIterator_1_Windows_Graphics_Imaging_BitmapCodecInformation } #[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for IIterator => [0x7fc2e293,0x1084,0x5d45,0xb8,0xb8,0x93,0xe1,0x06,0x92,0xbc,0xc8] as IID_IIterator_1_Windows_Graphics_Imaging_BitmapPixelFormat } #[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for IIterator => [0x4a10752d,0x6b1a,0x5fec,0xa5,0x9c,0x70,0x38,0x9b,0xf1,0x62,0xa2] as IID_IIterator_1_Windows_Graphics_Imaging_ImageStream } #[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for IIterator => [0xcd12e4c3,0x8ca8,0x5be6,0xb6,0x4b,0x20,0x4a,0x01,0x4f,0xc6,0x20] as IID_IIterator_1_Windows_Graphics_Imaging_SoftwareBitmap } +#[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for IIterator => [0x38f75665,0xfb40,0x53e2,0xa9,0x16,0x15,0xba,0x75,0x4a,0x6a,0x9e] as IID_IIterator_1_Windows_Graphics_Printing_PrintPageRange } #[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for IIterator => [0xc92a35e2,0x829d,0x5adf,0x87,0x4e,0x4d,0x74,0x5b,0x4e,0xf0,0xaa] as IID_IIterator_1_Windows_Graphics_Printing_PrintTicket_PrintTicketOption } #[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for IIterator => [0xdad4dd0d,0x59ab,0x501f,0x9d,0x6b,0xa2,0x09,0xc7,0xd5,0x46,0x49] as IID_IIterator_1_Windows_Graphics_Printing3D_Printing3DBaseMaterial } #[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for IIterator => [0xa34dc709,0xe2a7,0x5254,0x9d,0xc1,0xcd,0x47,0xe8,0x5e,0x25,0x04] as IID_IIterator_1_Windows_Graphics_Printing3D_Printing3DBaseMaterialGroup } @@ -4309,6 +4457,7 @@ RT_PINTERFACE!{ for IIterator => [0xa3508ee0,0x3527,0x5144,0x89,0x4 #[cfg(feature="windows-media")] RT_PINTERFACE!{ for IIterator => [0x1a594dc8,0xa64b,0x55ed,0x9b,0x34,0x7b,0x27,0x4e,0x1d,0x5c,0x70] as IID_IIterator_1_Windows_Media_Core_IMediaCue } #[cfg(feature="windows-media")] RT_PINTERFACE!{ for IIterator => [0x53076581,0x01a9,0x51b9,0x98,0xcc,0x52,0x65,0x50,0x4c,0xd3,0x52] as IID_IIterator_1_Windows_Media_Core_MseSourceBuffer } #[cfg(feature="windows-media")] RT_PINTERFACE!{ for IIterator => [0x92a36852,0xfbb3,0x5b48,0xb4,0xec,0x01,0xdd,0xa0,0x97,0x2a,0x5c] as IID_IIterator_1_Windows_Media_Core_MseTimeRange } +#[cfg(feature="windows-media")] RT_PINTERFACE!{ for IIterator => [0x68475671,0xf53b,0x57ff,0x92,0xac,0x28,0xbf,0xd4,0x65,0x73,0xd7] as IID_IIterator_1_Windows_Media_Core_TimedMetadataStreamDescriptor } #[cfg(feature="windows-media")] RT_PINTERFACE!{ for IIterator => [0x859354e5,0x077b,0x5d53,0xb2,0x97,0x1a,0x07,0xb9,0x7f,0x09,0xc3] as IID_IIterator_1_Windows_Media_Core_TimedMetadataTrack } #[cfg(feature="windows-media")] RT_PINTERFACE!{ for IIterator => [0x84c4fcac,0x86d8,0x5c74,0xa1,0x38,0xd9,0xbf,0x37,0xb7,0x49,0xec] as IID_IIterator_1_Windows_Media_Core_TimedTextLine } #[cfg(feature="windows-media")] RT_PINTERFACE!{ for IIterator => [0xbdded7c0,0x5c73,0x57f5,0x9b,0x08,0x65,0x29,0x33,0x58,0x6d,0xd5] as IID_IIterator_1_Windows_Media_Core_TimedTextSource } @@ -4327,6 +4476,7 @@ RT_PINTERFACE!{ for IIterator => [0xa3508ee0,0x3527,0x5144,0x89,0x4 #[cfg(feature="windows-media")] RT_PINTERFACE!{ for IIterator => [0xb02944e1,0xf649,0x511e,0x80,0xdd,0x2e,0x2b,0x20,0x37,0x9d,0xeb] as IID_IIterator_1_Windows_Media_Devices_ManualFocusDistance } #[cfg(feature="windows-media")] RT_PINTERFACE!{ for IIterator => [0x4a165d46,0xcf19,0x5a03,0xbb,0x54,0x63,0xfc,0x2b,0x4e,0xd3,0x9b] as IID_IIterator_1_Windows_Media_Devices_OpticalImageStabilizationMode } #[cfg(feature="windows-media")] RT_PINTERFACE!{ for IIterator => [0x8eb80e4e,0x9691,0x594f,0x8b,0x3d,0xf5,0x2e,0xcc,0x0f,0x78,0x37] as IID_IIterator_1_Windows_Media_Devices_RegionOfInterest } +#[cfg(feature="windows-media")] RT_PINTERFACE!{ for IIterator => [0x9b062552,0xe75c,0x515e,0xa2,0xa4,0x1b,0x08,0x1b,0x64,0x06,0x14] as IID_IIterator_1_Windows_Media_Devices_VideoTemporalDenoisingMode } #[cfg(feature="windows-media")] RT_PINTERFACE!{ for IIterator => [0x80eb468a,0xfdc4,0x5c89,0x99,0xb8,0x8d,0x47,0x62,0x64,0xe2,0x11] as IID_IIterator_1_Windows_Media_Devices_ZoomTransitionMode } #[cfg(feature="windows-media")] RT_PINTERFACE!{ for IIterator => [0x18b0f692,0x8635,0x577a,0x9e,0xfa,0xcb,0x90,0x47,0x70,0xd6,0xe5] as IID_IIterator_1_Windows_Media_Editing_BackgroundAudioTrack } #[cfg(feature="windows-media")] RT_PINTERFACE!{ for IIterator => [0xc9fa7f51,0xb52c,0x578e,0x99,0xf9,0x01,0x2c,0xd5,0x64,0x12,0x47] as IID_IIterator_1_Windows_Media_Editing_EmbeddedAudioTrack } @@ -4371,6 +4521,7 @@ RT_PINTERFACE!{ for IIterator => [0xa3508ee0,0x3527,0x5144,0x89,0x4 #[cfg(feature="windows-networking")] RT_PINTERFACE!{ for IIterator => [0xd7090752,0xab5f,0x506f,0x8f,0x15,0x56,0xb3,0x75,0x52,0xfb,0xea] as IID_IIterator_1_Windows_Networking_Connectivity_ProviderNetworkUsage } #[cfg(feature="windows-networking")] RT_PINTERFACE!{ for IIterator => [0xc899ff9f,0xe6f5,0x5673,0x81,0x0c,0x04,0xe2,0xff,0x98,0x70,0x4f] as IID_IIterator_1_Windows_Networking_EndpointPair } #[cfg(feature="windows-networking")] RT_PINTERFACE!{ for IIterator => [0x557bf83c,0xa428,0x5dbd,0xa0,0xfe,0x05,0xf6,0xee,0x54,0x3d,0x45] as IID_IIterator_1_Windows_Networking_HostName } +#[cfg(feature="windows-networking")] RT_PINTERFACE!{ for IIterator => [0xc480cd48,0x5922,0x5ab1,0xbb,0x58,0xf1,0x49,0xae,0x51,0x54,0x31] as IID_IIterator_1_Windows_Networking_NetworkOperators_ESimProfile } #[cfg(feature="windows-networking")] RT_PINTERFACE!{ for IIterator => [0x03327f15,0xe40f,0x52d1,0xbb,0x6c,0xbe,0xbb,0xd8,0x15,0x51,0x34] as IID_IIterator_1_Windows_Networking_NetworkOperators_MobileBroadbandAntennaSar } #[cfg(feature="windows-networking")] RT_PINTERFACE!{ for IIterator => [0xb86379f2,0x5369,0x508f,0xa2,0xdf,0xde,0xb3,0xb7,0x2c,0x33,0x78] as IID_IIterator_1_Windows_Networking_NetworkOperators_MobileBroadbandCellCdma } #[cfg(feature="windows-networking")] RT_PINTERFACE!{ for IIterator => [0x8be60634,0x4021,0x5ac2,0xbd,0x8a,0xa9,0x69,0xb0,0x90,0xb5,0x8d] as IID_IIterator_1_Windows_Networking_NetworkOperators_MobileBroadbandCellGsm } @@ -4432,6 +4583,7 @@ RT_PINTERFACE!{ for IIterator => [0xa3508ee0,0x3527,0x5144,0x89,0x4 #[cfg(feature="windows-services")] RT_PINTERFACE!{ for IIterator => [0xfbe076f6,0xc3d2,0x5df7,0x83,0x9f,0x01,0x2a,0xc0,0xf9,0x51,0xc5] as IID_IIterator_1_Windows_Services_Store_StoreImage } #[cfg(feature="windows-services")] RT_PINTERFACE!{ for IIterator => [0xb75dd77b,0x87ca,0x5956,0x89,0x02,0x84,0xe9,0xff,0xc9,0x7d,0x83] as IID_IIterator_1_Windows_Services_Store_StorePackageUpdate } #[cfg(feature="windows-services")] RT_PINTERFACE!{ for IIterator => [0x6181d84f,0xf731,0x57b8,0x9a,0x6b,0x8a,0x12,0xfc,0xd5,0x8d,0x04] as IID_IIterator_1_Windows_Services_Store_StorePackageUpdateStatus } +#[cfg(feature="windows-services")] RT_PINTERFACE!{ for IIterator => [0x907dd469,0x85b9,0x52e7,0xb5,0x2f,0x73,0x10,0xa4,0x47,0x45,0xef] as IID_IIterator_1_Windows_Services_Store_StoreQueueItem } #[cfg(feature="windows-services")] RT_PINTERFACE!{ for IIterator => [0x365cde92,0x7fe3,0x59d5,0xb8,0xf8,0x8f,0x05,0xac,0xf5,0x09,0x47] as IID_IIterator_1_Windows_Services_Store_StoreSku } #[cfg(feature="windows-services")] RT_PINTERFACE!{ for IIterator => [0x91b0b554,0xa537,0x5e22,0xb3,0x9f,0x6a,0x93,0x5d,0x0b,0xef,0x45] as IID_IIterator_1_Windows_Services_Store_StoreVideo } #[cfg(feature="windows-services")] RT_PINTERFACE!{ for IIterator => [0x79656935,0x5813,0x5aa6,0x8e,0x69,0x62,0x7a,0x0d,0x85,0x08,0x8f] as IID_IIterator_1_Windows_Services_TargetedContent_TargetedContentAction } @@ -4461,6 +4613,7 @@ RT_PINTERFACE!{ for IIterator => [0xa3508ee0,0x3527,0x5144,0x89,0x4 #[cfg(feature="windows-system")] RT_PINTERFACE!{ for IIterator => [0xe44d5851,0xe4bc,0x50b9,0xa8,0x98,0x69,0x03,0x13,0x7d,0x8a,0x99] as IID_IIterator_1_Windows_System_AppResourceGroupInfo } #[cfg(feature="windows-system")] RT_PINTERFACE!{ for IIterator => [0xa89b4418,0x4c3b,0x5f49,0xb9,0x57,0x78,0x56,0x97,0xc9,0x9a,0xbf] as IID_IIterator_1_Windows_System_Diagnostics_ProcessDiagnosticInfo } #[cfg(feature="windows-system")] RT_PINTERFACE!{ for IIterator => [0x1af4598d,0x98bb,0x5e51,0x84,0x2b,0xcf,0x69,0x19,0x25,0xb6,0xc2] as IID_IIterator_1_Windows_System_Diagnostics_TraceReporting_PlatformDiagnosticTraceInfo } +#[cfg(feature="windows-system")] RT_PINTERFACE!{ for IIterator => [0xaf3da06d,0x0a82,0x5213,0x9c,0xb5,0xf8,0xd2,0xda,0x12,0xfb,0xe9] as IID_IIterator_1_Windows_System_Inventory_InstalledDesktopApp } #[cfg(feature="windows-system")] RT_PINTERFACE!{ for IIterator => [0x6a2c5aef,0x9f30,0x58ae,0xa6,0xcb,0x9a,0xc9,0xc8,0x09,0x2a,0x41] as IID_IIterator_1_Windows_System_RemoteSystems_IRemoteSystemFilter } #[cfg(feature="windows-system")] RT_PINTERFACE!{ for IIterator => [0x05fec44b,0x3dd9,0x5cf1,0xa1,0x00,0xbe,0xdc,0x92,0x33,0x29,0x2d] as IID_IIterator_1_Windows_System_RemoteSystems_RemoteSystemSessionParticipant } #[cfg(feature="windows-system")] RT_PINTERFACE!{ for IIterator => [0x326fe162,0x582b,0x5659,0xb8,0xa4,0x68,0xff,0x0f,0x52,0x57,0x45] as IID_IIterator_1_Windows_System_User } @@ -4469,6 +4622,7 @@ RT_PINTERFACE!{ for IIterator => [0xa3508ee0,0x3527,0x5144,0x89,0x4 #[cfg(feature="windows-ui")] RT_PINTERFACE!{ for IIterator => [0x8cbb62b6,0xbd9c,0x5486,0x9d,0x14,0x9c,0xc4,0x62,0x7b,0x32,0xd4] as IID_IIterator_1_Windows_UI_ApplicationSettings_WebAccountCommand } #[cfg(feature="windows-ui")] RT_PINTERFACE!{ for IIterator => [0x82d7cd74,0x8e33,0x5f06,0x92,0xfc,0x91,0x51,0x38,0xaa,0xcb,0xde] as IID_IIterator_1_Windows_UI_ApplicationSettings_WebAccountProviderCommand } #[cfg(feature="windows-ui")] RT_PINTERFACE!{ for IIterator => [0xc4310b12,0x7ac2,0x5e5b,0xb5,0x11,0xe5,0x46,0xee,0xa4,0x73,0xb4] as IID_IIterator_1_Windows_UI_Color } +#[cfg(feature="windows-ui")] RT_PINTERFACE!{ for IIterator => [0xff8d5b3b,0xab18,0x5307,0x9f,0xfe,0xe3,0xb5,0xd6,0x34,0x52,0xa4] as IID_IIterator_1_Windows_UI_Composition_CompositionShape } #[cfg(feature="windows-ui")] RT_PINTERFACE!{ for IIterator => [0x8a75b02d,0x3991,0x55a6,0xbf,0xe2,0x82,0xcb,0x7d,0xd6,0x5b,0x98] as IID_IIterator_1_Windows_UI_Composition_Interactions_CompositionConditionalValue } #[cfg(feature="windows-ui")] RT_PINTERFACE!{ for IIterator => [0x46617d87,0x2cd2,0x5e31,0x9a,0x30,0xea,0x86,0xf8,0xaa,0x7c,0xa1] as IID_IIterator_1_Windows_UI_Composition_Interactions_InteractionTrackerInertiaModifier } #[cfg(feature="windows-ui")] RT_PINTERFACE!{ for IIterator => [0x7762caab,0x5b42,0x5958,0x9f,0x49,0x06,0xae,0xfd,0x43,0xad,0x75] as IID_IIterator_1_Windows_UI_Composition_Interactions_InteractionTrackerVector2InertiaModifier } @@ -4515,6 +4669,7 @@ RT_PINTERFACE!{ for IIterator => [0xa3508ee0,0x3527,0x5144,0x89,0x4 #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for IIterator => [0x2a8a81ef,0xf351,0x50a7,0xbc,0xdc,0x83,0x68,0xdf,0x21,0x52,0x80] as IID_IIterator_1_Windows_UI_Xaml_Controls_MenuFlyoutItemBase } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for IIterator => [0x5bcb0970,0x5472,0x56e8,0xb1,0x84,0xd0,0x1f,0xb8,0x1e,0x40,0x8a] as IID_IIterator_1_Windows_UI_Xaml_Controls_Primitives_Popup } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for IIterator => [0x2655d45d,0x38c6,0x53f0,0x87,0x19,0xf3,0xc3,0xa7,0x39,0xc1,0xf9] as IID_IIterator_1_Windows_UI_Xaml_Controls_RowDefinition } +#[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for IIterator => [0x876b445c,0xd4e3,0x5637,0x98,0x35,0xb4,0x90,0x96,0x0e,0x0e,0xd8] as IID_IIterator_1_Windows_UI_Xaml_Controls_TreeViewNode } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for IIterator => [0xa6ed0a56,0x801b,0x5301,0x95,0xba,0xdf,0x84,0xd0,0x27,0xa9,0x77] as IID_IIterator_1_Windows_UI_Xaml_Controls_WebViewDeferredPermissionRequest } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for IIterator => [0x9c223a26,0x0c81,0x59f6,0xa9,0x09,0xba,0x49,0x66,0xb4,0xcf,0x24] as IID_IIterator_1_Windows_UI_Xaml_Data_ItemIndexRange } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for IIterator => [0x29f8d454,0x905d,0x587e,0xb9,0xd8,0xbf,0xd4,0x18,0x80,0x5a,0x65] as IID_IIterator_1_Windows_UI_Xaml_DependencyObject } @@ -4559,6 +4714,8 @@ RT_PINTERFACE!{ for IIterator => [0xa3508ee0,0x3527,0x5144,0x89,0x4 #[cfg(feature="windows-web")] RT_PINTERFACE!{ for IIterator => [0xd5692aa3,0xd785,0x5db4,0xac,0x5c,0xb3,0x83,0x20,0x82,0xe6,0x29] as IID_IIterator_1_Windows_Web_Syndication_SyndicationItem } #[cfg(feature="windows-web")] RT_PINTERFACE!{ for IIterator => [0x901642b7,0x6ca4,0x5b57,0xb8,0xf1,0x73,0x20,0x83,0x42,0xba,0x4a] as IID_IIterator_1_Windows_Web_Syndication_SyndicationLink } #[cfg(feature="windows-web")] RT_PINTERFACE!{ for IIterator => [0x1745e807,0xf209,0x5da6,0x88,0x55,0x7f,0x99,0xe2,0x5e,0xb1,0xfc] as IID_IIterator_1_Windows_Web_Syndication_SyndicationPerson } +#[cfg(feature="windows-web")] RT_PINTERFACE!{ for IIterator => [0x3e183be4,0x37d8,0x5239,0xb1,0xf0,0xc0,0x6c,0x76,0x29,0x6a,0x16] as IID_IIterator_1_Windows_Web_UI_Interop_WebViewControl } +#[cfg(feature="windows-web")] RT_PINTERFACE!{ for IIterator => [0x277a80bd,0x3e2a,0x5fe8,0x95,0xd2,0xcc,0x86,0xf7,0x23,0xbf,0x42] as IID_IIterator_1_Windows_Web_UI_WebViewControlDeferredPermissionRequest } #[cfg(feature="windows-web")] RT_PINTERFACE!{ for IIterator => [0xfa704929,0x0761,0x5dd6,0x96,0x75,0x05,0x2a,0x8c,0x61,0xe2,0xc2] as IID_IIterator_1_Windows_Web_WebErrorStatus } RT_PINTERFACE!{ for IIterator => [0x67e9eadb,0x324b,0x5661,0xa4,0x05,0xde,0xd8,0x44,0x5b,0x1e,0xea] as IID_IIterator_1_Windows_Foundation_TimeSpan } RT_PINTERFACE!{ for IIterator => [0x1c157d0f,0x5efe,0x5cec,0xbb,0xd6,0x0c,0x6c,0xe9,0xaf,0x07,0xa5] as IID_IIterator_1_Windows_Foundation_Uri } @@ -4667,6 +4824,7 @@ RT_PINTERFACE!{ for IVector => [0xb939af5b,0xb45d,0x5489,0x91,0x49,0x61,0x4 RT_PINTERFACE!{ for IVector => [0xb32bdca4,0x5e52,0x5b27,0xbc,0x5d,0xd6,0x6a,0x1a,0x26,0x8c,0x2a] as IID_IVector_1_System_Object } RT_PINTERFACE!{ for IVector => [0x94390dc5,0xe442,0x5870,0x88,0xb6,0x00,0x7e,0x23,0x2f,0x90,0x2c] as IID_IVector_1_Windows_Foundation_DateTime } RT_PINTERFACE!{ for IVector => [0xc0d513a9,0xec4a,0x5a5d,0xb6,0xd5,0xb7,0x07,0xde,0xfd,0xb9,0xf7] as IID_IVector_1_Windows_Foundation_Point } +#[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IVector => [0x7ff85c5e,0x7752,0x5ef0,0xbf,0x29,0x02,0x06,0x48,0xc1,0x99,0xe4] as IID_IVector_1_Windows_ApplicationModel_AppInstance } #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IVector => [0x70f4b32e,0xf91e,0x55bb,0x9a,0x92,0x02,0x46,0xda,0x73,0x4b,0xb0] as IID_IVector_1_Windows_ApplicationModel_Appointments_AppointmentInvitee } #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IVector => [0xad2127f1,0x3216,0x58fb,0x81,0x54,0xb2,0x41,0xa6,0x0b,0x42,0x52] as IID_IVector_1_Windows_ApplicationModel_Chat_ChatMessageAttachment } #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IVector => [0x14640361,0x3f8d,0x5606,0x8f,0xcb,0x97,0x32,0x08,0xb7,0x6d,0x72] as IID_IVector_1_Windows_ApplicationModel_Chat_ChatRecipientDeliveryInfo } @@ -4690,6 +4848,8 @@ RT_PINTERFACE!{ for IVector => [0xc0d513a9,0xec4a,0x5a5d,0xb6,0xd5 #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IVector => [0x1cc36c46,0x19be,0x5d6b,0xa5,0x6d,0x04,0x74,0x13,0x25,0x2c,0x69] as IID_IVector_1_Windows_ApplicationModel_Search_Core_SearchSuggestion } #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IVector => [0x36cd5297,0x36c3,0x56a7,0x96,0x56,0xec,0x9d,0x5b,0xde,0x7a,0xba] as IID_IVector_1_Windows_ApplicationModel_SocialInfo_SocialFeedItem } #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IVector => [0xc210bbd7,0x2f56,0x5076,0xbb,0x0e,0xb7,0x49,0x77,0x26,0xcf,0x95] as IID_IVector_1_Windows_ApplicationModel_SocialInfo_SocialItemThumbnail } +#[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IVector => [0xe3004e95,0x0b05,0x55dc,0xbf,0x3b,0xbe,0x06,0xfa,0xe0,0x31,0x52] as IID_IVector_1_Windows_ApplicationModel_UserActivities_UserActivity } +#[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IVector => [0x8765461c,0x2f90,0x586e,0x83,0xec,0x58,0xb3,0xe4,0x30,0x94,0x80] as IID_IVector_1_Windows_ApplicationModel_UserActivities_UserActivitySessionHistoryItem } #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IVector => [0xe45fe700,0xea08,0x5172,0xb8,0x8c,0xc4,0xb3,0xe0,0x48,0xc3,0xe8] as IID_IVector_1_Windows_ApplicationModel_VoiceCommands_VoiceCommandContentTile } #[cfg(feature="windows-devices")] RT_PINTERFACE!{ for IVector => [0x19c16b93,0xf9ca,0x5c05,0xbf,0x73,0xe7,0x4c,0xd0,0x54,0xc5,0x87] as IID_IVector_1_Windows_Devices_AllJoyn_AllJoynAuthenticationMechanism } #[cfg(feature="windows-devices")] RT_PINTERFACE!{ for IVector => [0x8dd461b7,0x9775,0x5e82,0xa0,0xa6,0x66,0x27,0xab,0xd0,0xd0,0x10] as IID_IVector_1_Windows_Devices_Bluetooth_Advertisement_BluetoothLEAdvertisementBytePattern } @@ -4700,6 +4860,7 @@ RT_PINTERFACE!{ for IVector => [0xc0d513a9,0xec4a,0x5a5d,0xb6,0xd5 #[cfg(feature="windows-devices")] RT_PINTERFACE!{ for IVector => [0x096dc936,0x5f66,0x5c6e,0x95,0xce,0xef,0x55,0x41,0xfb,0xf4,0xc4] as IID_IVector_1_Windows_Devices_Geolocation_Geofencing_Geofence } #[cfg(feature="windows-devices")] RT_PINTERFACE!{ for IVector => [0x7ca97e6d,0x6893,0x5672,0xa0,0xc7,0x62,0x5c,0x50,0x90,0x38,0x1e] as IID_IVector_1_Windows_Devices_Geolocation_Geopath } #[cfg(feature="windows-devices")] RT_PINTERFACE!{ for IVector => [0xc8c443c2,0xf7d4,0x5386,0xad,0x15,0x31,0x83,0x88,0x82,0xbd,0x9e] as IID_IVector_1_Windows_Devices_Gpio_GpioChangeRecord } +#[cfg(feature="windows-devices")] RT_PINTERFACE!{ for IVector => [0x446a643d,0x387c,0x5ef6,0xa8,0xac,0xcc,0xa9,0xd8,0xa7,0x93,0xb4] as IID_IVector_1_Windows_Devices_Input_Preview_GazePointPreview } #[cfg(feature="windows-devices")] RT_PINTERFACE!{ for IVector => [0xe3e660d6,0xd041,0x5ecd,0xb1,0x8b,0xfa,0x25,0x4e,0x4a,0x86,0x0f] as IID_IVector_1_Windows_Devices_Sensors_ActivityType } #[cfg(feature="windows-devices")] RT_PINTERFACE!{ for IVector => [0xd76bef0b,0x1358,0x5895,0xbd,0x42,0xf1,0x7f,0x6f,0x33,0xee,0xd1] as IID_IVector_1_Windows_Devices_Sms_SmsBroadcastType } #[cfg(feature="windows-devices")] RT_PINTERFACE!{ for IVector => [0x8e72fa52,0x4867,0x5696,0xb4,0xd9,0x4c,0xa2,0x3f,0x19,0xe1,0x77] as IID_IVector_1_Windows_Devices_Sms_SmsFilterRule } @@ -4707,6 +4868,7 @@ RT_PINTERFACE!{ for IVector => [0xc0d513a9,0xec4a,0x5a5d,0xb6,0xd5 #[cfg(feature="windows-devices")] RT_PINTERFACE!{ for IVector => [0x9b498bc0,0xb474,0x5587,0xb6,0x5c,0xe6,0x00,0x96,0x5f,0x8f,0xd0] as IID_IVector_1_Windows_Devices_WiFiDirect_WiFiDirectConfigurationMethod } #[cfg(feature="windows-devices")] RT_PINTERFACE!{ for IVector => [0xb8c55492,0xe4de,0x5ba7,0x84,0x76,0xd3,0xba,0xb5,0x57,0xcd,0xd6] as IID_IVector_1_Windows_Devices_WiFiDirect_WiFiDirectInformationElement } #[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for IVector => [0xda24dfcc,0x4c54,0x5193,0x92,0x1d,0xc6,0x85,0xb5,0x7d,0xe5,0x59] as IID_IVector_1_Windows_Graphics_Holographic_HolographicQuadLayer } +#[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for IVector => [0x1d314a18,0x2a16,0x542f,0xa9,0x86,0x1b,0x78,0x41,0xb8,0x78,0xaa] as IID_IVector_1_Windows_Graphics_Printing_PrintPageRange } #[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for IVector => [0x6a5aa59f,0xfe10,0x517b,0xb1,0xa9,0xc6,0x85,0xec,0xce,0x16,0x44] as IID_IVector_1_Windows_Graphics_Printing3D_Printing3DBaseMaterial } #[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for IVector => [0x2b80d2cf,0x5449,0x5c81,0x82,0x26,0xeb,0xfc,0x7d,0x72,0xf5,0x79] as IID_IVector_1_Windows_Graphics_Printing3D_Printing3DBaseMaterialGroup } #[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for IVector => [0x606166fd,0x6bf5,0x53a1,0xb1,0xae,0xc3,0x48,0x92,0xef,0x16,0x63] as IID_IVector_1_Windows_Graphics_Printing3D_Printing3DColorMaterial } @@ -4724,6 +4886,7 @@ RT_PINTERFACE!{ for IVector => [0xc0d513a9,0xec4a,0x5a5d,0xb6,0xd5 #[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for IVector => [0x120948c9,0xaaa5,0x5ee5,0xa1,0x33,0x32,0x15,0xd0,0x56,0x14,0x04] as IID_IVector_1_Windows_Graphics_Printing3D_Printing3DTextureResource } #[cfg(feature="windows-media")] RT_PINTERFACE!{ for IVector => [0xc2e3dea8,0x92e0,0x50af,0x9c,0x93,0x83,0xb3,0xe8,0x6b,0x73,0xb4] as IID_IVector_1_Windows_Media_Casting_CastingSource } #[cfg(feature="windows-media")] RT_PINTERFACE!{ for IVector => [0x45afc129,0x988c,0x5f1e,0x9c,0x17,0x6e,0x34,0xb9,0x17,0xcd,0x1b] as IID_IVector_1_Windows_Media_Core_AudioStreamDescriptor } +#[cfg(feature="windows-media")] RT_PINTERFACE!{ for IVector => [0x1ebdbbcf,0x4f75,0x5645,0xb8,0xbc,0x31,0xa7,0x16,0x97,0x8b,0xcc] as IID_IVector_1_Windows_Media_Core_TimedMetadataStreamDescriptor } #[cfg(feature="windows-media")] RT_PINTERFACE!{ for IVector => [0xc46d9e34,0xea11,0x5bb2,0x97,0x44,0x16,0x17,0x41,0x7e,0xf0,0x16] as IID_IVector_1_Windows_Media_Core_TimedMetadataTrack } #[cfg(feature="windows-media")] RT_PINTERFACE!{ for IVector => [0x284f0441,0xe96d,0x58ad,0x91,0x88,0x7b,0xf4,0x65,0x14,0xdf,0xcc] as IID_IVector_1_Windows_Media_Core_TimedTextLine } #[cfg(feature="windows-media")] RT_PINTERFACE!{ for IVector => [0xd0a72378,0x5432,0x50bf,0x93,0xc3,0xc5,0xf3,0x5f,0xc9,0x35,0x17] as IID_IVector_1_Windows_Media_Core_TimedTextSource } @@ -4768,6 +4931,7 @@ RT_PINTERFACE!{ for IVector => [0xc0d513a9,0xec4a,0x5a5d,0xb6,0xd5 #[cfg(feature="windows-ui")] RT_PINTERFACE!{ for IVector => [0x10bd9cdd,0x3767,0x5e96,0x90,0x22,0xf0,0x0f,0x9c,0xbd,0x62,0x41] as IID_IVector_1_Windows_UI_ApplicationSettings_SettingsCommand } #[cfg(feature="windows-ui")] RT_PINTERFACE!{ for IVector => [0x64e864c8,0x7fef,0x5df5,0xa6,0x24,0x50,0xb5,0x77,0xf4,0x85,0x54] as IID_IVector_1_Windows_UI_ApplicationSettings_WebAccountCommand } #[cfg(feature="windows-ui")] RT_PINTERFACE!{ for IVector => [0xd376abf3,0xf0c1,0x5233,0x9f,0x42,0xde,0x53,0x18,0x84,0x96,0x3e] as IID_IVector_1_Windows_UI_ApplicationSettings_WebAccountProviderCommand } +#[cfg(feature="windows-ui")] RT_PINTERFACE!{ for IVector => [0x42d4219a,0xbe1b,0x5091,0x8f,0x1e,0x90,0x27,0x08,0x40,0xfc,0x2d] as IID_IVector_1_Windows_UI_Composition_CompositionShape } #[cfg(feature="windows-ui")] RT_PINTERFACE!{ for IVector => [0x10c47202,0x47ab,0x58bc,0x91,0xde,0xd5,0x00,0x0f,0x1a,0x74,0xc0] as IID_IVector_1_Windows_UI_Input_Inking_InkPoint } #[cfg(feature="windows-ui")] RT_PINTERFACE!{ for IVector => [0xdfa655cf,0xfde7,0x5048,0xb4,0xbf,0xc9,0x09,0x23,0x1b,0x7e,0xdb] as IID_IVector_1_Windows_UI_Input_PointerPoint } #[cfg(feature="windows-ui")] RT_PINTERFACE!{ for IVector => [0xbfde94e7,0x70f8,0x5cc0,0x98,0xe2,0x8c,0x0f,0x8c,0xe5,0x24,0xab] as IID_IVector_1_Windows_UI_Input_RadialControllerMenuItem } @@ -4787,6 +4951,7 @@ RT_PINTERFACE!{ for IVector => [0xc0d513a9,0xec4a,0x5a5d,0xb6,0xd5 #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for IVector => [0x19f78a46,0x2c65,0x5f94,0xbf,0x5b,0x96,0x33,0x47,0xa0,0xa3,0x18] as IID_IVector_1_Windows_UI_Xaml_Controls_Maps_MapTileSource } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for IVector => [0xf7f1c37b,0xb4df,0x5128,0xa4,0x76,0xfc,0x83,0x99,0xbc,0x10,0xaf] as IID_IVector_1_Windows_UI_Xaml_Controls_MenuFlyoutItemBase } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for IVector => [0x62225981,0x7a0d,0x5d38,0x80,0x88,0x7c,0x6b,0xb6,0xd9,0x59,0xbe] as IID_IVector_1_Windows_UI_Xaml_Controls_RowDefinition } +#[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for IVector => [0x4ff347c9,0x9738,0x560d,0xb2,0x14,0xdd,0x7c,0x23,0x63,0xc0,0xed] as IID_IVector_1_Windows_UI_Xaml_Controls_TreeViewNode } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for IVector => [0xee0e5bc7,0x4440,0x5970,0xa8,0x78,0x2d,0x35,0x1e,0x00,0x93,0x1a] as IID_IVector_1_Windows_UI_Xaml_Controls_WebViewDeferredPermissionRequest } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for IVector => [0x771b857e,0xab5c,0x5db8,0xa0,0x21,0x39,0x7c,0x92,0xcd,0xc4,0x4c] as IID_IVector_1_Windows_UI_Xaml_DependencyObject } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for IVector => [0x3ee78a34,0x160e,0x50ff,0xb5,0xaa,0x09,0xf2,0x63,0xa6,0x69,0xf8] as IID_IVector_1_Windows_UI_Xaml_Documents_Block } @@ -4842,6 +5007,7 @@ RT_PINTERFACE!{ for IVectorView => [0x0b7b4c9d,0x182f,0x582a,0xbd, RT_PINTERFACE!{ for IVectorView => [0xcb5037fd,0x660b,0x51f5,0x9d,0x28,0x87,0xf4,0x08,0x78,0x26,0x8d] as IID_IVectorView_1_Windows_Foundation_Size } #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IVectorView => [0x94520810,0x7e9b,0x5efd,0xb7,0x4d,0xe9,0xd4,0x17,0x5f,0xd9,0x4a] as IID_IVectorView_1_Windows_ApplicationModel_AppExtensions_AppExtension } #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IVectorView => [0x8246ed12,0x33e8,0x52b3,0xa5,0xc5,0x19,0x77,0x9d,0xe9,0x99,0x9e] as IID_IVectorView_1_Windows_ApplicationModel_AppInfo } +#[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IVectorView => [0xd1864e26,0xb62b,0x5085,0x8e,0x93,0x60,0xcb,0xb6,0xeb,0x20,0xd1] as IID_IVectorView_1_Windows_ApplicationModel_AppInstance } #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IVectorView => [0x61021758,0x9e37,0x5a86,0xa8,0x32,0xaa,0xb3,0x1f,0x32,0x69,0x2b] as IID_IVectorView_1_Windows_ApplicationModel_Appointments_Appointment } #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IVectorView => [0x774512d3,0xa564,0x5f8d,0xb1,0x04,0x3e,0xc8,0xf2,0xa1,0x10,0x4f] as IID_IVectorView_1_Windows_ApplicationModel_Appointments_AppointmentCalendar } #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IVectorView => [0xe5030866,0x08d8,0x56be,0xa2,0x1b,0xc5,0xbf,0x80,0xd7,0x03,0x60] as IID_IVectorView_1_Windows_ApplicationModel_Appointments_AppointmentException } @@ -4913,6 +5079,8 @@ RT_PINTERFACE!{ for IVectorView => [0xcb5037fd,0x660b,0x51f5,0x9d,0 #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IVectorView => [0x47418723,0xa671,0x5fdc,0x86,0x47,0x68,0xf7,0xd8,0xc3,0x14,0x16] as IID_IVectorView_1_Windows_ApplicationModel_Store_Preview_StorePreviewSkuInfo } #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IVectorView => [0xc8f90757,0xebcf,0x5f2c,0xb9,0x18,0x64,0x87,0x10,0x5b,0x0c,0xa1] as IID_IVectorView_1_Windows_ApplicationModel_Store_Preview_StoreSystemFeature } #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IVectorView => [0xf0ae5962,0xe039,0x5105,0xbc,0xc5,0x9b,0x55,0x2f,0x13,0xb1,0x02] as IID_IVectorView_1_Windows_ApplicationModel_Store_UnfulfilledConsumable } +#[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IVectorView => [0x192a5116,0x61d6,0x5e18,0x86,0x79,0x0a,0xf4,0xf7,0x09,0x08,0x16] as IID_IVectorView_1_Windows_ApplicationModel_UserActivities_UserActivity } +#[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IVectorView => [0x006a83c1,0x59ff,0x5870,0x8d,0x8d,0x05,0x83,0x81,0x4a,0xf1,0x60] as IID_IVectorView_1_Windows_ApplicationModel_UserActivities_UserActivitySessionHistoryItem } #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IVectorView => [0xb730f093,0xe2fb,0x5b20,0x9d,0x9e,0x4f,0x9d,0xef,0xe6,0x47,0xb0] as IID_IVectorView_1_Windows_ApplicationModel_UserDataAccounts_Provider_UserDataAccountPartnerAccountInfo } #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IVectorView => [0x65f4f73e,0x3271,0x5999,0x93,0xd8,0x5a,0x3d,0x78,0xbe,0x13,0xa6] as IID_IVectorView_1_Windows_ApplicationModel_UserDataAccounts_UserDataAccount } #[cfg(feature="windows-applicationmodel")] RT_PINTERFACE!{ for IVectorView => [0x0cfeaf9b,0x8758,0x5aa6,0x98,0x06,0x32,0xb0,0xea,0x40,0xd4,0xb8] as IID_IVectorView_1_Windows_ApplicationModel_UserDataTasks_UserDataTask } @@ -4965,6 +5133,7 @@ RT_PINTERFACE!{ for IVectorView => [0xcb5037fd,0x660b,0x51f5,0x9d,0 #[cfg(feature="windows-devices")] RT_PINTERFACE!{ for IVectorView => [0x511f8a39,0x98ca,0x550d,0xaf,0x25,0x1d,0xf2,0xc1,0x19,0x3c,0x01] as IID_IVectorView_1_Windows_Devices_I2c_Provider_II2cControllerProvider } #[cfg(feature="windows-devices")] RT_PINTERFACE!{ for IVectorView => [0xcf5674f1,0x9808,0x5a2b,0x80,0xb8,0x56,0x84,0xed,0x0e,0xa8,0x16] as IID_IVectorView_1_Windows_Devices_Input_PointerDevice } #[cfg(feature="windows-devices")] RT_PINTERFACE!{ for IVectorView => [0x8e5a2c7e,0x3830,0x50d5,0x92,0xba,0x31,0x63,0xc8,0x9c,0xbb,0xd0] as IID_IVectorView_1_Windows_Devices_Input_PointerDeviceUsage } +#[cfg(feature="windows-devices")] RT_PINTERFACE!{ for IVectorView => [0x3d3d6148,0xad02,0x56eb,0xac,0xaf,0x0e,0xa9,0xe4,0x7c,0x02,0x98] as IID_IVectorView_1_Windows_Devices_Input_Preview_GazePointPreview } #[cfg(feature="windows-devices")] RT_PINTERFACE!{ for IVectorView => [0xcbf2f698,0x31a0,0x53c7,0x92,0x7b,0x8e,0x16,0x75,0xf7,0x43,0xbc] as IID_IVectorView_1_Windows_Devices_Perception_PerceptionColorFrameSource } #[cfg(feature="windows-devices")] RT_PINTERFACE!{ for IVectorView => [0x574d3642,0x9f78,0x5125,0x85,0x1f,0x8b,0x67,0xe0,0x31,0x3e,0x2f] as IID_IVectorView_1_Windows_Devices_Perception_PerceptionDepthFrameSource } #[cfg(feature="windows-devices")] RT_PINTERFACE!{ for IVectorView => [0xf272ae7a,0xc5c4,0x5712,0x85,0x52,0x01,0xde,0xb8,0xb7,0x0e,0x07] as IID_IVectorView_1_Windows_Devices_Perception_PerceptionInfraredFrameSource } @@ -5028,12 +5197,15 @@ RT_PINTERFACE!{ for IVectorView => [0xcb5037fd,0x660b,0x51f5,0x9d,0 #[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for IVectorView => [0x1a81ec3e,0x5afb,0x5e10,0x92,0xbb,0xc8,0x43,0xfe,0xc7,0x08,0x87] as IID_IVectorView_1_Windows_Graphics_DirectX_Direct3D11_IDirect3DSurface } #[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for IVectorView => [0x1edda1c2,0x0f6e,0x516c,0x80,0xb8,0x76,0x87,0xdc,0xd1,0x28,0x0e] as IID_IVectorView_1_Windows_Graphics_DirectX_DirectXPixelFormat } #[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for IVectorView => [0x7d0e7c64,0xdf0e,0x539a,0xab,0x5f,0x3c,0x26,0x00,0x26,0xc5,0xce] as IID_IVectorView_1_Windows_Graphics_Display_Core_HdmiDisplayMode } +#[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for IVectorView => [0xcc8ef226,0x50c1,0x5efa,0x98,0xc4,0x10,0x43,0xd0,0xbf,0x5b,0x35] as IID_IVectorView_1_Windows_Graphics_Display_NitRange } #[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for IVectorView => [0x01d6c0ae,0xada5,0x50b0,0x85,0x62,0x41,0xfb,0x12,0x05,0xbb,0x4a] as IID_IVectorView_1_Windows_Graphics_Holographic_HolographicCamera } #[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for IVectorView => [0x17c5dfb1,0x6e87,0x5a17,0xa7,0x91,0xac,0x07,0xf8,0xee,0x92,0x92] as IID_IVectorView_1_Windows_Graphics_Holographic_HolographicCameraPose } +#[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for IVectorView => [0x014f37ba,0xabc1,0x5d85,0x85,0x5e,0xec,0x05,0x31,0x83,0xa6,0x35] as IID_IVectorView_1_Windows_Graphics_Holographic_HolographicFramePresentationReport } #[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for IVectorView => [0x1f51ecdf,0xcf2d,0x5b7e,0xaa,0xe9,0xd6,0x62,0x8a,0x51,0x8d,0xbe] as IID_IVectorView_1_Windows_Graphics_Holographic_HolographicQuadLayer } #[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for IVectorView => [0x97dfde96,0xff1d,0x5aa1,0x86,0x3a,0x90,0x11,0x6a,0x31,0xb8,0x6b] as IID_IVectorView_1_Windows_Graphics_Imaging_BitmapCodecInformation } #[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for IVectorView => [0x76ac4bc2,0xc19c,0x559c,0xb2,0x87,0x16,0x94,0xc0,0xdc,0x3a,0x0d] as IID_IVectorView_1_Windows_Graphics_Imaging_BitmapPixelFormat } #[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for IVectorView => [0xab10f3e5,0x2a3e,0x5f81,0xb5,0xe8,0x8d,0xdd,0xdc,0x23,0xcc,0xa2] as IID_IVectorView_1_Windows_Graphics_Imaging_ImageStream } +#[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for IVectorView => [0x0063b11e,0x2098,0x5eff,0x96,0x52,0x08,0xa3,0x51,0x6c,0x99,0xa6] as IID_IVectorView_1_Windows_Graphics_Printing_PrintPageRange } #[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for IVectorView => [0xc80b48ef,0x2a4c,0x5685,0xb7,0xa4,0x88,0xcc,0x79,0x6c,0xa2,0x74] as IID_IVectorView_1_Windows_Graphics_Printing_PrintTicket_PrintTicketOption } #[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for IVectorView => [0xccc6f0a2,0x4dd9,0x550d,0x85,0x78,0x33,0x0e,0x13,0x8a,0xda,0x07] as IID_IVectorView_1_Windows_Graphics_Printing3D_Printing3DBaseMaterial } #[cfg(feature="windows-graphics")] RT_PINTERFACE!{ for IVectorView => [0x5c686c2e,0xcd88,0x5255,0xa9,0x61,0x5b,0x4f,0x2b,0xf1,0x3c,0x70] as IID_IVectorView_1_Windows_Graphics_Printing3D_Printing3DBaseMaterialGroup } @@ -5068,6 +5240,7 @@ RT_PINTERFACE!{ for IVectorView => [0xcb5037fd,0x660b,0x51f5,0x9d,0 #[cfg(feature="windows-media")] RT_PINTERFACE!{ for IVectorView => [0x996421a1,0x625c,0x5d92,0xad,0x68,0x8b,0x39,0x11,0xd2,0x94,0xb0] as IID_IVectorView_1_Windows_Media_Core_IMediaCue } #[cfg(feature="windows-media")] RT_PINTERFACE!{ for IVectorView => [0x85318263,0x1360,0x5c78,0xb0,0xad,0x52,0xd6,0xb4,0x5b,0x19,0xf3] as IID_IVectorView_1_Windows_Media_Core_MseSourceBuffer } #[cfg(feature="windows-media")] RT_PINTERFACE!{ for IVectorView => [0x87ff1dd1,0x7ec3,0x5bc5,0xb5,0x58,0x04,0x25,0xd8,0x06,0xbf,0x4b] as IID_IVectorView_1_Windows_Media_Core_MseTimeRange } +#[cfg(feature="windows-media")] RT_PINTERFACE!{ for IVectorView => [0x62e7b4ed,0x0c95,0x5743,0xa1,0x42,0x05,0x4f,0x4b,0xde,0xa0,0xa4] as IID_IVectorView_1_Windows_Media_Core_TimedMetadataStreamDescriptor } #[cfg(feature="windows-media")] RT_PINTERFACE!{ for IVectorView => [0x0313ae7a,0x2803,0x5d45,0xb5,0xa1,0xa0,0xfc,0x5c,0xd5,0x5e,0x7c] as IID_IVectorView_1_Windows_Media_Core_TimedMetadataTrack } #[cfg(feature="windows-media")] RT_PINTERFACE!{ for IVectorView => [0x9532b5cc,0x73fc,0x5e3a,0x85,0x31,0x79,0x4c,0x30,0xd7,0xa1,0xae] as IID_IVectorView_1_Windows_Media_Core_TimedTextLine } #[cfg(feature="windows-media")] RT_PINTERFACE!{ for IVectorView => [0xedcd634e,0xb7e4,0x5ff8,0xb8,0xc2,0x84,0x93,0x84,0x9b,0x2c,0x0d] as IID_IVectorView_1_Windows_Media_Core_TimedTextSource } @@ -5085,6 +5258,7 @@ RT_PINTERFACE!{ for IVectorView => [0xcb5037fd,0x660b,0x51f5,0x9d,0 #[cfg(feature="windows-media")] RT_PINTERFACE!{ for IVectorView => [0xef6c9fe3,0x06f9,0x5eff,0x98,0xa8,0x91,0x7d,0x96,0x44,0xc9,0x46] as IID_IVectorView_1_Windows_Media_Devices_IsoSpeedPreset } #[cfg(feature="windows-media")] RT_PINTERFACE!{ for IVectorView => [0x85f7663b,0x5467,0x5736,0x8d,0x34,0x34,0x39,0x5a,0xa6,0xd1,0x23] as IID_IVectorView_1_Windows_Media_Devices_ManualFocusDistance } #[cfg(feature="windows-media")] RT_PINTERFACE!{ for IVectorView => [0x8c2658d8,0xacaa,0x5a80,0xb2,0x59,0x1b,0xa0,0x69,0x7c,0x61,0x38] as IID_IVectorView_1_Windows_Media_Devices_OpticalImageStabilizationMode } +#[cfg(feature="windows-media")] RT_PINTERFACE!{ for IVectorView => [0x094d5da9,0x91cc,0x55d8,0xb7,0xb7,0x52,0xe5,0x97,0x15,0x69,0x87] as IID_IVectorView_1_Windows_Media_Devices_VideoTemporalDenoisingMode } #[cfg(feature="windows-media")] RT_PINTERFACE!{ for IVectorView => [0x4d556155,0xd021,0x5a46,0x9a,0x1c,0xf4,0x01,0xd6,0x1b,0x85,0x29] as IID_IVectorView_1_Windows_Media_Devices_ZoomTransitionMode } #[cfg(feature="windows-media")] RT_PINTERFACE!{ for IVectorView => [0x7fe52e32,0x867c,0x52a3,0xb3,0xb7,0xd4,0xdd,0x4d,0x57,0x37,0x94] as IID_IVectorView_1_Windows_Media_Editing_BackgroundAudioTrack } #[cfg(feature="windows-media")] RT_PINTERFACE!{ for IVectorView => [0x63d85bd5,0x4365,0x5e56,0x9e,0x40,0xe7,0xcd,0x30,0x51,0xae,0xbf] as IID_IVectorView_1_Windows_Media_Editing_EmbeddedAudioTrack } @@ -5125,6 +5299,7 @@ RT_PINTERFACE!{ for IVectorView => [0xcb5037fd,0x660b,0x51f5,0x9d,0 #[cfg(feature="windows-networking")] RT_PINTERFACE!{ for IVectorView => [0xe66ad09c,0xeb37,0x54c7,0x9b,0x2d,0x73,0x4e,0x0e,0x93,0x93,0x05] as IID_IVectorView_1_Windows_Networking_Connectivity_ProviderNetworkUsage } #[cfg(feature="windows-networking")] RT_PINTERFACE!{ for IVectorView => [0x8780a851,0x6d48,0x5006,0x92,0x88,0x81,0xf3,0xd7,0x04,0x5a,0x96] as IID_IVectorView_1_Windows_Networking_EndpointPair } #[cfg(feature="windows-networking")] RT_PINTERFACE!{ for IVectorView => [0xf4706ab1,0x55a3,0x5270,0xaf,0xb2,0x73,0x29,0x88,0xfe,0x82,0x27] as IID_IVectorView_1_Windows_Networking_HostName } +#[cfg(feature="windows-networking")] RT_PINTERFACE!{ for IVectorView => [0xc776f3a9,0x6e7f,0x5144,0x89,0xf7,0x8f,0x5e,0xc1,0x16,0x5b,0xa4] as IID_IVectorView_1_Windows_Networking_NetworkOperators_ESimProfile } #[cfg(feature="windows-networking")] RT_PINTERFACE!{ for IVectorView => [0x8a4ad36c,0x8b24,0x5f2c,0xad,0x6f,0x6a,0x93,0x6a,0x17,0xbf,0xc6] as IID_IVectorView_1_Windows_Networking_NetworkOperators_MobileBroadbandAntennaSar } #[cfg(feature="windows-networking")] RT_PINTERFACE!{ for IVectorView => [0x2896bc34,0x7401,0x5d22,0xbf,0x9f,0xdb,0x82,0x5d,0x09,0xc9,0x51] as IID_IVectorView_1_Windows_Networking_NetworkOperators_MobileBroadbandCellCdma } #[cfg(feature="windows-networking")] RT_PINTERFACE!{ for IVectorView => [0xf77a0168,0x0396,0x5111,0xa4,0x87,0xa7,0x95,0xf2,0x46,0x46,0xb7] as IID_IVectorView_1_Windows_Networking_NetworkOperators_MobileBroadbandCellGsm } @@ -5182,6 +5357,7 @@ RT_PINTERFACE!{ for IVectorView => [0xcb5037fd,0x660b,0x51f5,0x9d,0 #[cfg(feature="windows-services")] RT_PINTERFACE!{ for IVectorView => [0x7e1ceace,0x82bd,0x5db3,0x8f,0x35,0x9b,0xf0,0xc8,0x8e,0xf8,0x39] as IID_IVectorView_1_Windows_Services_Store_StoreImage } #[cfg(feature="windows-services")] RT_PINTERFACE!{ for IVectorView => [0x971c3ea6,0x4388,0x5a38,0xae,0x13,0x49,0x29,0xb6,0xd6,0xd7,0x80] as IID_IVectorView_1_Windows_Services_Store_StorePackageUpdate } #[cfg(feature="windows-services")] RT_PINTERFACE!{ for IVectorView => [0x68e2f036,0x4982,0x55e3,0x8c,0x0f,0x9b,0xf4,0xe6,0x9a,0xa4,0x5a] as IID_IVectorView_1_Windows_Services_Store_StorePackageUpdateStatus } +#[cfg(feature="windows-services")] RT_PINTERFACE!{ for IVectorView => [0xb2d3e99f,0xd3ac,0x577d,0xb9,0x77,0xfd,0xb6,0x67,0xd2,0x0d,0xef] as IID_IVectorView_1_Windows_Services_Store_StoreQueueItem } #[cfg(feature="windows-services")] RT_PINTERFACE!{ for IVectorView => [0x407c4593,0x063d,0x5c9b,0xb8,0xe0,0x94,0x9f,0xe1,0x38,0x79,0x63] as IID_IVectorView_1_Windows_Services_Store_StoreSku } #[cfg(feature="windows-services")] RT_PINTERFACE!{ for IVectorView => [0x6e31fca5,0x119e,0x5799,0xa5,0x1b,0xcd,0x6a,0xdd,0xec,0xd8,0x70] as IID_IVectorView_1_Windows_Services_Store_StoreVideo } #[cfg(feature="windows-services")] RT_PINTERFACE!{ for IVectorView => [0x4299bd84,0xe44e,0x5fcb,0xa4,0x65,0xe1,0xbd,0x43,0x4a,0x31,0x7c] as IID_IVectorView_1_Windows_Services_TargetedContent_TargetedContentAction } @@ -5208,11 +5384,13 @@ RT_PINTERFACE!{ for IVectorView => [0xcb5037fd,0x660b,0x51f5,0x9d,0 #[cfg(feature="windows-system")] RT_PINTERFACE!{ for IVectorView => [0x0480079c,0xfd03,0x59e3,0xab,0xa3,0x96,0xf9,0xf9,0x20,0x60,0x70] as IID_IVectorView_1_Windows_System_AppResourceGroupInfo } #[cfg(feature="windows-system")] RT_PINTERFACE!{ for IVectorView => [0x74ab2473,0x9624,0x5a06,0x90,0x25,0x6d,0x91,0xe6,0x22,0xbf,0x8e] as IID_IVectorView_1_Windows_System_Diagnostics_ProcessDiagnosticInfo } #[cfg(feature="windows-system")] RT_PINTERFACE!{ for IVectorView => [0x8f1b3397,0x4dc3,0x5b72,0x91,0xfa,0x0f,0xdc,0x91,0x5d,0x95,0x0c] as IID_IVectorView_1_Windows_System_Diagnostics_TraceReporting_PlatformDiagnosticTraceInfo } +#[cfg(feature="windows-system")] RT_PINTERFACE!{ for IVectorView => [0xba3a2146,0x42dd,0x5fa8,0xa7,0xf0,0x36,0xb6,0x97,0x38,0x03,0xb5] as IID_IVectorView_1_Windows_System_Inventory_InstalledDesktopApp } #[cfg(feature="windows-system")] RT_PINTERFACE!{ for IVectorView => [0x8cbd762a,0x1222,0x5ee5,0xb7,0x45,0x48,0x9e,0x7a,0x42,0xc6,0xec] as IID_IVectorView_1_Windows_System_User } #[cfg(feature="windows-ui")] RT_PINTERFACE!{ for IVectorView => [0x95cc1bba,0xc279,0x5ee5,0xa5,0x24,0x78,0x01,0x2b,0x7f,0xe1,0x7e] as IID_IVectorView_1_Windows_UI_ApplicationSettings_CredentialCommand } #[cfg(feature="windows-ui")] RT_PINTERFACE!{ for IVectorView => [0x67b64d17,0x4245,0x5d7c,0xbf,0xb4,0x6b,0x68,0xdd,0x52,0x58,0x77] as IID_IVectorView_1_Windows_UI_ApplicationSettings_SettingsCommand } #[cfg(feature="windows-ui")] RT_PINTERFACE!{ for IVectorView => [0x207eaa3e,0x5ec9,0x5bd4,0xa1,0xd2,0x73,0x17,0x9a,0x81,0x28,0xa8] as IID_IVectorView_1_Windows_UI_ApplicationSettings_WebAccountCommand } #[cfg(feature="windows-ui")] RT_PINTERFACE!{ for IVectorView => [0xb2d19260,0x1827,0x5d88,0xb9,0x48,0x96,0x88,0xcf,0xcd,0x63,0xae] as IID_IVectorView_1_Windows_UI_ApplicationSettings_WebAccountProviderCommand } +#[cfg(feature="windows-ui")] RT_PINTERFACE!{ for IVectorView => [0xe7e27ef4,0x4ec6,0x5b8a,0xa8,0x58,0x56,0x1b,0x95,0x34,0xa8,0x85] as IID_IVectorView_1_Windows_UI_Composition_CompositionShape } #[cfg(feature="windows-ui")] RT_PINTERFACE!{ for IVectorView => [0x3a6ed95d,0x6a50,0x5ead,0xa4,0xc6,0x09,0xf8,0xba,0xbc,0x63,0x2c] as IID_IVectorView_1_Windows_UI_Core_AnimationMetrics_IPropertyAnimation } #[cfg(feature="windows-ui")] RT_PINTERFACE!{ for IVectorView => [0x2b3fee11,0x53b5,0x55b0,0x8d,0x71,0xc4,0x0b,0x42,0x7d,0xe0,0x29] as IID_IVectorView_1_Windows_UI_Input_Inking_Analysis_IInkAnalysisNode } #[cfg(feature="windows-ui")] RT_PINTERFACE!{ for IVectorView => [0xd1ac414b,0xc87d,0x540f,0x8a,0xb1,0x4e,0x0d,0x09,0xd9,0xd2,0x83] as IID_IVectorView_1_Windows_UI_Input_Inking_InkPoint } @@ -5251,6 +5429,7 @@ RT_PINTERFACE!{ for IVectorView => [0xcb5037fd,0x660b,0x51f5,0x9d,0 #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for IVectorView => [0xa59e9e24,0xf5a6,0x5272,0xa9,0x7b,0x7d,0xd0,0x1a,0x3e,0xfd,0xd0] as IID_IVectorView_1_Windows_UI_Xaml_Controls_MenuFlyoutItemBase } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for IVectorView => [0x7d899fb2,0x4666,0x5a3e,0xb3,0x6c,0x98,0x86,0xbc,0xbc,0x46,0x63] as IID_IVectorView_1_Windows_UI_Xaml_Controls_Primitives_Popup } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for IVectorView => [0x27b5c835,0xb5ac,0x5f58,0xa7,0x70,0xc7,0x39,0xf9,0xe6,0x66,0x5c] as IID_IVectorView_1_Windows_UI_Xaml_Controls_RowDefinition } +#[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for IVectorView => [0xa8b48eda,0xbcbd,0x5f53,0x94,0x3f,0x5f,0x5d,0x4e,0x77,0x15,0x58] as IID_IVectorView_1_Windows_UI_Xaml_Controls_TreeViewNode } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for IVectorView => [0x2065ae49,0x5ad7,0x5a34,0x9f,0x78,0xba,0xd1,0x30,0x8f,0x4e,0x5d] as IID_IVectorView_1_Windows_UI_Xaml_Controls_WebViewDeferredPermissionRequest } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for IVectorView => [0xd0b26b06,0x16e8,0x5767,0xa6,0x0b,0xee,0x3e,0x32,0xe4,0x3d,0xfb] as IID_IVectorView_1_Windows_UI_Xaml_Data_ItemIndexRange } #[cfg(feature="windows-ui-xaml")] RT_PINTERFACE!{ for IVectorView => [0xfe750d77,0x1307,0x5df2,0xa0,0x21,0x1c,0x7a,0x8d,0x6b,0x80,0xad] as IID_IVectorView_1_Windows_UI_Xaml_DependencyObject } @@ -5295,6 +5474,8 @@ RT_PINTERFACE!{ for IVectorView => [0xcb5037fd,0x660b,0x51f5,0x9d,0 #[cfg(feature="windows-web")] RT_PINTERFACE!{ for IVectorView => [0x9496279b,0x567e,0x5652,0xb9,0x42,0xf6,0xfb,0x70,0xc3,0x41,0x73] as IID_IVectorView_1_Windows_Web_Syndication_SyndicationItem } #[cfg(feature="windows-web")] RT_PINTERFACE!{ for IVectorView => [0xeb8b7ff6,0xfa64,0x576a,0x8b,0xe4,0xa0,0x55,0xf7,0xa0,0x4a,0x73] as IID_IVectorView_1_Windows_Web_Syndication_SyndicationLink } #[cfg(feature="windows-web")] RT_PINTERFACE!{ for IVectorView => [0x0e450d3d,0xe750,0x5787,0x88,0x5b,0x48,0x8a,0xbc,0x72,0xb5,0xb9] as IID_IVectorView_1_Windows_Web_Syndication_SyndicationPerson } +#[cfg(feature="windows-web")] RT_PINTERFACE!{ for IVectorView => [0x5ecbd5c0,0x8282,0x5fe1,0xad,0x39,0x37,0x4c,0xde,0x70,0xe0,0xcd] as IID_IVectorView_1_Windows_Web_UI_Interop_WebViewControl } +#[cfg(feature="windows-web")] RT_PINTERFACE!{ for IVectorView => [0xbffd3dcf,0x1974,0x53a2,0x8d,0x88,0x96,0x6d,0x84,0xba,0x98,0xe0] as IID_IVectorView_1_Windows_Web_UI_WebViewControlDeferredPermissionRequest } #[cfg(feature="windows-web")] RT_PINTERFACE!{ for IVectorView => [0xf5d10d42,0xa776,0x533a,0x8f,0x4b,0x2e,0x1c,0x6e,0x5b,0xbf,0x24] as IID_IVectorView_1_Windows_Web_WebErrorStatus } RT_PINTERFACE!{ for IVectorView => [0x4b8385bd,0xa2cd,0x5ff1,0xbf,0x74,0x7e,0xa5,0x80,0x42,0x3e,0x50] as IID_IVectorView_1_Windows_Foundation_Uri } RT_PINTERFACE!{ for IVectorView => [0xe5ce1a07,0x8d33,0x5007,0xba,0x64,0x7d,0x25,0x08,0xcc,0xf8,0x5c] as IID_IVectorView_1_System_UInt32 } @@ -6707,6 +6888,9 @@ RT_STRUCT! { struct Plane { RT_STRUCT! { struct Quaternion { X: f32, Y: f32, Z: f32, W: f32, }} +RT_STRUCT! { struct Rational { + Numerator: u32, Denominator: u32, +}} RT_STRUCT! { struct Vector2 { X: f32, Y: f32, }} diff --git a/src/rt/gen/windows/globalization.rs b/src/rt/gen/windows/globalization.rs index d2fe851..21fcdc9 100644 --- a/src/rt/gen/windows/globalization.rs +++ b/src/rt/gen/windows/globalization.rs @@ -1,6 +1,7 @@ use ::prelude::*; RT_CLASS!{static class ApplicationLanguages} impl RtActivatable for ApplicationLanguages {} +impl RtActivatable for ApplicationLanguages {} impl ApplicationLanguages { #[inline] pub fn get_primary_language_override() -> Result { >::get_activation_factory().get_primary_language_override() @@ -14,6 +15,9 @@ impl ApplicationLanguages { #[inline] pub fn get_manifest_languages() -> Result>>> { >::get_activation_factory().get_manifest_languages() } + #[cfg(feature="windows-system")] #[inline] pub fn get_languages_for_user(user: &super::system::User) -> Result>>> { + >::get_activation_factory().get_languages_for_user(user) + } } DEFINE_CLSID!(ApplicationLanguages(&[87,105,110,100,111,119,115,46,71,108,111,98,97,108,105,122,97,116,105,111,110,46,65,112,112,108,105,99,97,116,105,111,110,76,97,110,103,117,97,103,101,115,0]) [CLSID_ApplicationLanguages]); DEFINE_IID!(IID_IApplicationLanguagesStatics, 1974732871, 2636, 19090, 149, 101, 253, 99, 201, 95, 122, 237); @@ -44,6 +48,17 @@ impl IApplicationLanguagesStatics { if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IApplicationLanguagesStatics2, 502324815, 1835, 19835, 143, 6, 203, 45, 180, 15, 43, 181); +RT_INTERFACE!{static interface IApplicationLanguagesStatics2(IApplicationLanguagesStatics2Vtbl): IInspectable(IInspectableVtbl) [IID_IApplicationLanguagesStatics2] { + #[cfg(feature="windows-system")] fn GetLanguagesForUser(&self, user: *mut super::system::User, out: *mut *mut foundation::collections::IVectorView) -> HRESULT +}} +impl IApplicationLanguagesStatics2 { + #[cfg(feature="windows-system")] #[inline] pub fn get_languages_for_user(&self, user: &super::system::User) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetLanguagesForUser)(self as *const _ as *mut _, user as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_ICalendar, 3392152093, 34521, 16635, 162, 107, 212, 78, 183, 207, 8, 234); RT_INTERFACE!{interface ICalendar(ICalendarVtbl): IInspectable(IInspectableVtbl) [IID_ICalendar] { fn Clone(&self, out: *mut *mut Calendar) -> HRESULT, @@ -2462,6 +2477,17 @@ impl Language { } } DEFINE_CLSID!(Language(&[87,105,110,100,111,119,115,46,71,108,111,98,97,108,105,122,97,116,105,111,110,46,76,97,110,103,117,97,103,101,0]) [CLSID_Language]); +DEFINE_IID!(IID_ILanguage2, 1783096757, 55629, 18566, 164, 4, 165, 165, 185, 213, 180, 148); +RT_INTERFACE!{interface ILanguage2(ILanguage2Vtbl): IInspectable(IInspectableVtbl) [IID_ILanguage2] { + fn get_LayoutDirection(&self, out: *mut LanguageLayoutDirection) -> HRESULT +}} +impl ILanguage2 { + #[inline] pub fn get_layout_direction(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_LayoutDirection)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} DEFINE_IID!(IID_ILanguageExtensionSubtags, 2105388869, 13965, 17252, 133, 43, 222, 201, 39, 3, 123, 133); RT_INTERFACE!{interface ILanguageExtensionSubtags(ILanguageExtensionSubtagsVtbl): IInspectable(IInspectableVtbl) [IID_ILanguageExtensionSubtags] { fn GetExtensionSubtags(&self, singleton: HSTRING, out: *mut *mut foundation::collections::IVectorView) -> HRESULT @@ -2484,6 +2510,9 @@ impl ILanguageFactory { if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } +RT_ENUM! { enum LanguageLayoutDirection: i32 { + Ltr (LanguageLayoutDirection_Ltr) = 0, Rtl (LanguageLayoutDirection_Rtl) = 1, TtbLtr (LanguageLayoutDirection_TtbLtr) = 2, TtbRtl (LanguageLayoutDirection_TtbRtl) = 3, +}} DEFINE_IID!(IID_ILanguageStatics, 2990331223, 2149, 18132, 137, 184, 213, 155, 232, 153, 15, 13); RT_INTERFACE!{static interface ILanguageStatics(ILanguageStaticsVtbl): IInspectable(IInspectableVtbl) [IID_ILanguageStatics] { fn IsWellFormed(&self, languageTag: HSTRING, out: *mut bool) -> HRESULT, diff --git a/src/rt/gen/windows/graphics.rs b/src/rt/gen/windows/graphics.rs index 7d8679d..e42536f 100644 --- a/src/rt/gen/windows/graphics.rs +++ b/src/rt/gen/windows/graphics.rs @@ -1,4 +1,11 @@ use ::prelude::*; +RT_STRUCT! { struct DisplayAdapterId { + LowPart: u32, HighPart: i32, +}} +DEFINE_IID!(IID_IGeometrySource2D, 3405740290, 26380, 16769, 166, 36, 218, 151, 114, 3, 184, 69); +RT_INTERFACE!{interface IGeometrySource2D(IGeometrySource2DVtbl): IInspectable(IInspectableVtbl) [IID_IGeometrySource2D] { + +}} RT_STRUCT! { struct PointInt32 { X: i32, Y: i32, }} @@ -1242,6 +1249,81 @@ DEFINE_CLSID!(Printing3DTextureResource(&[87,105,110,100,111,119,115,46,71,114,9 } // Windows.Graphics.Printing3D pub mod display { // Windows.Graphics.Display use ::prelude::*; +DEFINE_IID!(IID_IAdvancedColorInfo, 2274876667, 45609, 16513, 174, 154, 44, 200, 94, 52, 173, 106); +RT_INTERFACE!{interface IAdvancedColorInfo(IAdvancedColorInfoVtbl): IInspectable(IInspectableVtbl) [IID_IAdvancedColorInfo] { + fn get_CurrentAdvancedColorKind(&self, out: *mut AdvancedColorKind) -> HRESULT, + fn get_RedPrimary(&self, out: *mut foundation::Point) -> HRESULT, + fn get_GreenPrimary(&self, out: *mut foundation::Point) -> HRESULT, + fn get_BluePrimary(&self, out: *mut foundation::Point) -> HRESULT, + fn get_WhitePoint(&self, out: *mut foundation::Point) -> HRESULT, + fn get_MaxLuminanceInNits(&self, out: *mut f32) -> HRESULT, + fn get_MinLuminanceInNits(&self, out: *mut f32) -> HRESULT, + fn get_MaxAverageFullFrameLuminanceInNits(&self, out: *mut f32) -> HRESULT, + fn get_SdrWhiteLevelInNits(&self, out: *mut f32) -> HRESULT, + fn IsHdrMetadataFormatCurrentlySupported(&self, format: HdrMetadataFormat, out: *mut bool) -> HRESULT, + fn IsAdvancedColorKindAvailable(&self, kind: AdvancedColorKind, out: *mut bool) -> HRESULT +}} +impl IAdvancedColorInfo { + #[inline] pub fn get_current_advanced_color_kind(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_CurrentAdvancedColorKind)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_red_primary(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_RedPrimary)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_green_primary(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_GreenPrimary)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_blue_primary(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_BluePrimary)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_white_point(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_WhitePoint)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_max_luminance_in_nits(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_MaxLuminanceInNits)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_min_luminance_in_nits(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_MinLuminanceInNits)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_max_average_full_frame_luminance_in_nits(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_MaxAverageFullFrameLuminanceInNits)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_sdr_white_level_in_nits(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_SdrWhiteLevelInNits)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn is_hdr_metadata_format_currently_supported(&self, format: HdrMetadataFormat) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).IsHdrMetadataFormatCurrentlySupported)(self as *const _ as *mut _, format, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn is_advanced_color_kind_available(&self, kind: AdvancedColorKind) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).IsAdvancedColorKindAvailable)(self as *const _ as *mut _, kind, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} +RT_CLASS!{class AdvancedColorInfo: IAdvancedColorInfo} +RT_ENUM! { enum AdvancedColorKind: i32 { + StandardDynamicRange (AdvancedColorKind_StandardDynamicRange) = 0, WideColorGamut (AdvancedColorKind_WideColorGamut) = 1, HighDynamicRange (AdvancedColorKind_HighDynamicRange) = 2, +}} DEFINE_IID!(IID_IBrightnessOverride, 2529780250, 49475, 17298, 190, 221, 74, 126, 149, 116, 200, 253); RT_INTERFACE!{interface IBrightnessOverride(IBrightnessOverrideVtbl): IInspectable(IInspectableVtbl) [IID_IBrightnessOverride] { fn get_IsSupported(&self, out: *mut bool) -> HRESULT, @@ -1338,6 +1420,60 @@ impl BrightnessOverride { } } DEFINE_CLSID!(BrightnessOverride(&[87,105,110,100,111,119,115,46,71,114,97,112,104,105,99,115,46,68,105,115,112,108,97,121,46,66,114,105,103,104,116,110,101,115,115,79,118,101,114,114,105,100,101,0]) [CLSID_BrightnessOverride]); +DEFINE_IID!(IID_IBrightnessOverrideSettings, 3507661610, 30212, 19898, 188, 248, 75, 111, 73, 80, 44, 176); +RT_INTERFACE!{interface IBrightnessOverrideSettings(IBrightnessOverrideSettingsVtbl): IInspectable(IInspectableVtbl) [IID_IBrightnessOverrideSettings] { + fn get_DesiredLevel(&self, out: *mut f64) -> HRESULT, + fn get_DesiredNits(&self, out: *mut f32) -> HRESULT +}} +impl IBrightnessOverrideSettings { + #[inline] pub fn get_desired_level(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_DesiredLevel)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_desired_nits(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_DesiredNits)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} +RT_CLASS!{class BrightnessOverrideSettings: IBrightnessOverrideSettings} +impl RtActivatable for BrightnessOverrideSettings {} +impl BrightnessOverrideSettings { + #[inline] pub fn create_from_level(level: f64) -> Result>> { + >::get_activation_factory().create_from_level(level) + } + #[inline] pub fn create_from_nits(nits: f32) -> Result>> { + >::get_activation_factory().create_from_nits(nits) + } + #[inline] pub fn create_from_display_brightness_override_scenario(overrideScenario: DisplayBrightnessOverrideScenario) -> Result>> { + >::get_activation_factory().create_from_display_brightness_override_scenario(overrideScenario) + } +} +DEFINE_CLSID!(BrightnessOverrideSettings(&[87,105,110,100,111,119,115,46,71,114,97,112,104,105,99,115,46,68,105,115,112,108,97,121,46,66,114,105,103,104,116,110,101,115,115,79,118,101,114,114,105,100,101,83,101,116,116,105,110,103,115,0]) [CLSID_BrightnessOverrideSettings]); +DEFINE_IID!(IID_IBrightnessOverrideSettingsStatics, 3565673616, 28532, 17419, 179, 131, 95, 233, 108, 240, 11, 15); +RT_INTERFACE!{static interface IBrightnessOverrideSettingsStatics(IBrightnessOverrideSettingsStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IBrightnessOverrideSettingsStatics] { + fn CreateFromLevel(&self, level: f64, out: *mut *mut BrightnessOverrideSettings) -> HRESULT, + fn CreateFromNits(&self, nits: f32, out: *mut *mut BrightnessOverrideSettings) -> HRESULT, + fn CreateFromDisplayBrightnessOverrideScenario(&self, overrideScenario: DisplayBrightnessOverrideScenario, out: *mut *mut BrightnessOverrideSettings) -> HRESULT +}} +impl IBrightnessOverrideSettingsStatics { + #[inline] pub fn create_from_level(&self, level: f64) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreateFromLevel)(self as *const _ as *mut _, level, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn create_from_nits(&self, nits: f32) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreateFromNits)(self as *const _ as *mut _, nits, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn create_from_display_brightness_override_scenario(&self, overrideScenario: DisplayBrightnessOverrideScenario) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreateFromDisplayBrightnessOverrideScenario)(self as *const _ as *mut _, overrideScenario, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IBrightnessOverrideStatics, 61323757, 57841, 19048, 161, 31, 148, 106, 216, 206, 83, 147); RT_INTERFACE!{static interface IBrightnessOverrideStatics(IBrightnessOverrideStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IBrightnessOverrideStatics] { fn GetDefaultForSystem(&self, out: *mut *mut BrightnessOverride) -> HRESULT, @@ -1361,12 +1497,191 @@ impl IBrightnessOverrideStatics { if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IColorOverrideSettings, 4226785588, 19073, 19533, 165, 182, 125, 27, 92, 75, 208, 11); +RT_INTERFACE!{interface IColorOverrideSettings(IColorOverrideSettingsVtbl): IInspectable(IInspectableVtbl) [IID_IColorOverrideSettings] { + fn get_DesiredDisplayColorOverrideScenario(&self, out: *mut DisplayColorOverrideScenario) -> HRESULT +}} +impl IColorOverrideSettings { + #[inline] pub fn get_desired_display_color_override_scenario(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_DesiredDisplayColorOverrideScenario)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} +RT_CLASS!{class ColorOverrideSettings: IColorOverrideSettings} +impl RtActivatable for ColorOverrideSettings {} +impl ColorOverrideSettings { + #[inline] pub fn create_from_display_color_override_scenario(overrideScenario: DisplayColorOverrideScenario) -> Result>> { + >::get_activation_factory().create_from_display_color_override_scenario(overrideScenario) + } +} +DEFINE_CLSID!(ColorOverrideSettings(&[87,105,110,100,111,119,115,46,71,114,97,112,104,105,99,115,46,68,105,115,112,108,97,121,46,67,111,108,111,114,79,118,101,114,114,105,100,101,83,101,116,116,105,110,103,115,0]) [CLSID_ColorOverrideSettings]); +DEFINE_IID!(IID_IColorOverrideSettingsStatics, 2959663199, 50207, 19145, 175, 171, 130, 122, 182, 36, 143, 154); +RT_INTERFACE!{static interface IColorOverrideSettingsStatics(IColorOverrideSettingsStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IColorOverrideSettingsStatics] { + fn CreateFromDisplayColorOverrideScenario(&self, overrideScenario: DisplayColorOverrideScenario, out: *mut *mut ColorOverrideSettings) -> HRESULT +}} +impl IColorOverrideSettingsStatics { + #[inline] pub fn create_from_display_color_override_scenario(&self, overrideScenario: DisplayColorOverrideScenario) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreateFromDisplayColorOverrideScenario)(self as *const _ as *mut _, overrideScenario, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} RT_ENUM! { enum DisplayBrightnessOverrideOptions: u32 { None (DisplayBrightnessOverrideOptions_None) = 0, UseDimmedPolicyWhenBatteryIsLow (DisplayBrightnessOverrideOptions_UseDimmedPolicyWhenBatteryIsLow) = 1, }} +RT_ENUM! { enum DisplayBrightnessOverrideScenario: i32 { + IdleBrightness (DisplayBrightnessOverrideScenario_IdleBrightness) = 0, BarcodeReadingBrightness (DisplayBrightnessOverrideScenario_BarcodeReadingBrightness) = 1, FullBrightness (DisplayBrightnessOverrideScenario_FullBrightness) = 2, +}} RT_ENUM! { enum DisplayBrightnessScenario: i32 { DefaultBrightness (DisplayBrightnessScenario_DefaultBrightness) = 0, IdleBrightness (DisplayBrightnessScenario_IdleBrightness) = 1, BarcodeReadingBrightness (DisplayBrightnessScenario_BarcodeReadingBrightness) = 2, FullBrightness (DisplayBrightnessScenario_FullBrightness) = 3, }} +RT_ENUM! { enum DisplayColorOverrideScenario: i32 { + Accurate (DisplayColorOverrideScenario_Accurate) = 0, +}} +DEFINE_IID!(IID_IDisplayEnhancementOverride, 1117099215, 55674, 19202, 164, 40, 92, 66, 146, 247, 245, 34); +RT_INTERFACE!{interface IDisplayEnhancementOverride(IDisplayEnhancementOverrideVtbl): IInspectable(IInspectableVtbl) [IID_IDisplayEnhancementOverride] { + fn get_ColorOverrideSettings(&self, out: *mut *mut ColorOverrideSettings) -> HRESULT, + fn put_ColorOverrideSettings(&self, value: *mut ColorOverrideSettings) -> HRESULT, + fn get_BrightnessOverrideSettings(&self, out: *mut *mut BrightnessOverrideSettings) -> HRESULT, + fn put_BrightnessOverrideSettings(&self, value: *mut BrightnessOverrideSettings) -> HRESULT, + fn get_CanOverride(&self, out: *mut bool) -> HRESULT, + fn get_IsOverrideActive(&self, out: *mut bool) -> HRESULT, + fn GetCurrentDisplayEnhancementOverrideCapabilities(&self, out: *mut *mut DisplayEnhancementOverrideCapabilities) -> HRESULT, + fn RequestOverride(&self) -> HRESULT, + fn StopOverride(&self) -> HRESULT, + fn add_CanOverrideChanged(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_CanOverrideChanged(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn add_IsOverrideActiveChanged(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_IsOverrideActiveChanged(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn add_DisplayEnhancementOverrideCapabilitiesChanged(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_DisplayEnhancementOverrideCapabilitiesChanged(&self, token: foundation::EventRegistrationToken) -> HRESULT +}} +impl IDisplayEnhancementOverride { + #[inline] pub fn get_color_override_settings(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ColorOverrideSettings)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn set_color_override_settings(&self, value: &ColorOverrideSettings) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_ColorOverrideSettings)(self as *const _ as *mut _, value as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_brightness_override_settings(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_BrightnessOverrideSettings)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn set_brightness_override_settings(&self, value: &BrightnessOverrideSettings) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_BrightnessOverrideSettings)(self as *const _ as *mut _, value as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_can_override(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_CanOverride)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_is_override_active(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_IsOverrideActive)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_current_display_enhancement_override_capabilities(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetCurrentDisplayEnhancementOverrideCapabilities)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn request_override(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).RequestOverride)(self as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn stop_override(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).StopOverride)(self as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_can_override_changed(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_CanOverrideChanged)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_can_override_changed(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_CanOverrideChanged)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_is_override_active_changed(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_IsOverrideActiveChanged)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_is_override_active_changed(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_IsOverrideActiveChanged)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_display_enhancement_override_capabilities_changed(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_DisplayEnhancementOverrideCapabilitiesChanged)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_display_enhancement_override_capabilities_changed(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_DisplayEnhancementOverrideCapabilitiesChanged)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class DisplayEnhancementOverride: IDisplayEnhancementOverride} +impl RtActivatable for DisplayEnhancementOverride {} +impl DisplayEnhancementOverride { + #[inline] pub fn get_for_current_view() -> Result>> { + >::get_activation_factory().get_for_current_view() + } +} +DEFINE_CLSID!(DisplayEnhancementOverride(&[87,105,110,100,111,119,115,46,71,114,97,112,104,105,99,115,46,68,105,115,112,108,97,121,46,68,105,115,112,108,97,121,69,110,104,97,110,99,101,109,101,110,116,79,118,101,114,114,105,100,101,0]) [CLSID_DisplayEnhancementOverride]); +DEFINE_IID!(IID_IDisplayEnhancementOverrideCapabilities, 1164992734, 61018, 18359, 153, 24, 30, 81, 232, 18, 204, 200); +RT_INTERFACE!{interface IDisplayEnhancementOverrideCapabilities(IDisplayEnhancementOverrideCapabilitiesVtbl): IInspectable(IInspectableVtbl) [IID_IDisplayEnhancementOverrideCapabilities] { + fn get_IsBrightnessControlSupported(&self, out: *mut bool) -> HRESULT, + fn get_IsBrightnessNitsControlSupported(&self, out: *mut bool) -> HRESULT, + fn GetSupportedNitRanges(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT +}} +impl IDisplayEnhancementOverrideCapabilities { + #[inline] pub fn get_is_brightness_control_supported(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_IsBrightnessControlSupported)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_is_brightness_nits_control_supported(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_IsBrightnessNitsControlSupported)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_supported_nit_ranges(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetSupportedNitRanges)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +RT_CLASS!{class DisplayEnhancementOverrideCapabilities: IDisplayEnhancementOverrideCapabilities} +DEFINE_IID!(IID_IDisplayEnhancementOverrideCapabilitiesChangedEventArgs, 3680626276, 5626, 18906, 139, 119, 7, 219, 210, 175, 88, 93); +RT_INTERFACE!{interface IDisplayEnhancementOverrideCapabilitiesChangedEventArgs(IDisplayEnhancementOverrideCapabilitiesChangedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IDisplayEnhancementOverrideCapabilitiesChangedEventArgs] { + fn get_Capabilities(&self, out: *mut *mut DisplayEnhancementOverrideCapabilities) -> HRESULT +}} +impl IDisplayEnhancementOverrideCapabilitiesChangedEventArgs { + #[inline] pub fn get_capabilities(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Capabilities)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +RT_CLASS!{class DisplayEnhancementOverrideCapabilitiesChangedEventArgs: IDisplayEnhancementOverrideCapabilitiesChangedEventArgs} +DEFINE_IID!(IID_IDisplayEnhancementOverrideStatics, 3478879937, 38801, 17491, 176, 19, 41, 182, 247, 120, 229, 25); +RT_INTERFACE!{static interface IDisplayEnhancementOverrideStatics(IDisplayEnhancementOverrideStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IDisplayEnhancementOverrideStatics] { + fn GetForCurrentView(&self, out: *mut *mut DisplayEnhancementOverride) -> HRESULT +}} +impl IDisplayEnhancementOverrideStatics { + #[inline] pub fn get_for_current_view(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetForCurrentView)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IDisplayInformation, 3201372846, 44483, 19913, 174, 101, 133, 31, 77, 125, 71, 153); RT_INTERFACE!{interface IDisplayInformation(IDisplayInformationVtbl): IInspectable(IInspectableVtbl) [IID_IDisplayInformation] { fn get_CurrentOrientation(&self, out: *mut DisplayOrientations) -> HRESULT, @@ -1524,6 +1839,28 @@ impl IDisplayInformation4 { if hr == S_OK { Ok(out) } else { err(hr) } }} } +DEFINE_IID!(IID_IDisplayInformation5, 978600668, 11486, 19085, 128, 209, 33, 220, 90, 220, 193, 170); +RT_INTERFACE!{interface IDisplayInformation5(IDisplayInformation5Vtbl): IInspectable(IInspectableVtbl) [IID_IDisplayInformation5] { + fn GetAdvancedColorInfo(&self, out: *mut *mut AdvancedColorInfo) -> HRESULT, + fn add_AdvancedColorInfoChanged(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_AdvancedColorInfoChanged(&self, token: foundation::EventRegistrationToken) -> HRESULT +}} +impl IDisplayInformation5 { + #[inline] pub fn get_advanced_color_info(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetAdvancedColorInfo)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn add_advanced_color_info_changed(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_AdvancedColorInfoChanged)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_advanced_color_info_changed(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_AdvancedColorInfoChanged)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} DEFINE_IID!(IID_IDisplayInformationStatics, 3332385388, 54354, 17628, 186, 7, 150, 243, 198, 173, 249, 209); RT_INTERFACE!{static interface IDisplayInformationStatics(IDisplayInformationStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IDisplayInformationStatics] { fn GetForCurrentView(&self, out: *mut *mut DisplayInformation) -> HRESULT, @@ -1737,6 +2074,12 @@ impl IDisplayPropertiesStatics { if hr == S_OK { Ok(()) } else { err(hr) } }} } +RT_ENUM! { enum HdrMetadataFormat: i32 { + Hdr10 (HdrMetadataFormat_Hdr10) = 0, Hdr10Plus (HdrMetadataFormat_Hdr10Plus) = 1, +}} +RT_STRUCT! { struct NitRange { + MinNits: f32, MaxNits: f32, StepSizeNits: f32, +}} RT_ENUM! { enum ResolutionScale: i32 { Invalid (ResolutionScale_Invalid) = 0, Scale100Percent (ResolutionScale_Scale100Percent) = 100, Scale120Percent (ResolutionScale_Scale120Percent) = 120, Scale125Percent (ResolutionScale_Scale125Percent) = 125, Scale140Percent (ResolutionScale_Scale140Percent) = 140, Scale150Percent (ResolutionScale_Scale150Percent) = 150, Scale160Percent (ResolutionScale_Scale160Percent) = 160, Scale175Percent (ResolutionScale_Scale175Percent) = 175, Scale180Percent (ResolutionScale_Scale180Percent) = 180, Scale200Percent (ResolutionScale_Scale200Percent) = 200, Scale225Percent (ResolutionScale_Scale225Percent) = 225, Scale250Percent (ResolutionScale_Scale250Percent) = 250, Scale300Percent (ResolutionScale_Scale300Percent) = 300, Scale350Percent (ResolutionScale_Scale350Percent) = 350, Scale400Percent (ResolutionScale_Scale400Percent) = 400, Scale450Percent (ResolutionScale_Scale450Percent) = 450, Scale500Percent (ResolutionScale_Scale500Percent) = 500, }} @@ -2408,7 +2751,7 @@ RT_ENUM! { enum BitmapInterpolationMode: i32 { NearestNeighbor (BitmapInterpolationMode_NearestNeighbor) = 0, Linear (BitmapInterpolationMode_Linear) = 1, Cubic (BitmapInterpolationMode_Cubic) = 2, Fant (BitmapInterpolationMode_Fant) = 3, }} RT_ENUM! { enum BitmapPixelFormat: i32 { - Unknown (BitmapPixelFormat_Unknown) = 0, Rgba16 (BitmapPixelFormat_Rgba16) = 12, Rgba8 (BitmapPixelFormat_Rgba8) = 30, Gray16 (BitmapPixelFormat_Gray16) = 57, Gray8 (BitmapPixelFormat_Gray8) = 62, Bgra8 (BitmapPixelFormat_Bgra8) = 87, Nv12 (BitmapPixelFormat_Nv12) = 103, Yuy2 (BitmapPixelFormat_Yuy2) = 107, + Unknown (BitmapPixelFormat_Unknown) = 0, Rgba16 (BitmapPixelFormat_Rgba16) = 12, Rgba8 (BitmapPixelFormat_Rgba8) = 30, Gray16 (BitmapPixelFormat_Gray16) = 57, Gray8 (BitmapPixelFormat_Gray8) = 62, Bgra8 (BitmapPixelFormat_Bgra8) = 87, Nv12 (BitmapPixelFormat_Nv12) = 103, P010 (BitmapPixelFormat_P010) = 104, Yuy2 (BitmapPixelFormat_Yuy2) = 107, }} RT_STRUCT! { struct BitmapPlaneDescription { StartIndex: i32, Width: i32, Height: i32, Stride: i32, @@ -2771,6 +3114,163 @@ RT_ENUM! { enum TiffCompressionMode: i32 { Automatic (TiffCompressionMode_Automatic) = 0, None (TiffCompressionMode_None) = 1, Ccitt3 (TiffCompressionMode_Ccitt3) = 2, Ccitt4 (TiffCompressionMode_Ccitt4) = 3, Lzw (TiffCompressionMode_Lzw) = 4, Rle (TiffCompressionMode_Rle) = 5, Zip (TiffCompressionMode_Zip) = 6, LzwhDifferencing (TiffCompressionMode_LzwhDifferencing) = 7, }} } // Windows.Graphics.Imaging +pub mod capture { // Windows.Graphics.Capture +use ::prelude::*; +DEFINE_IID!(IID_IDirect3D11CaptureFrame, 4199597603, 14554, 19250, 172, 243, 250, 151, 52, 173, 128, 14); +RT_INTERFACE!{interface IDirect3D11CaptureFrame(IDirect3D11CaptureFrameVtbl): IInspectable(IInspectableVtbl) [IID_IDirect3D11CaptureFrame] { + fn get_Surface(&self, out: *mut *mut super::directx::direct3d11::IDirect3DSurface) -> HRESULT, + fn get_SystemRelativeTime(&self, out: *mut foundation::TimeSpan) -> HRESULT, + fn get_ContentSize(&self, out: *mut super::SizeInt32) -> HRESULT +}} +impl IDirect3D11CaptureFrame { + #[inline] pub fn get_surface(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Surface)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_system_relative_time(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_SystemRelativeTime)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_content_size(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_ContentSize)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} +RT_CLASS!{class Direct3D11CaptureFrame: IDirect3D11CaptureFrame} +DEFINE_IID!(IID_IDirect3D11CaptureFramePool, 619408674, 6517, 16942, 130, 231, 120, 13, 189, 141, 223, 36); +RT_INTERFACE!{interface IDirect3D11CaptureFramePool(IDirect3D11CaptureFramePoolVtbl): IInspectable(IInspectableVtbl) [IID_IDirect3D11CaptureFramePool] { + fn Recreate(&self, device: *mut super::directx::direct3d11::IDirect3DDevice, pixelFormat: super::directx::DirectXPixelFormat, numberOfBuffers: i32, size: super::SizeInt32) -> HRESULT, + fn TryGetNextFrame(&self, out: *mut *mut Direct3D11CaptureFrame) -> HRESULT, + fn add_FrameArrived(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_FrameArrived(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn CreateCaptureSession(&self, item: *mut GraphicsCaptureItem, out: *mut *mut GraphicsCaptureSession) -> HRESULT, + #[cfg(feature="windows-system")] fn get_DispatcherQueue(&self, out: *mut *mut super::super::system::DispatcherQueue) -> HRESULT +}} +impl IDirect3D11CaptureFramePool { + #[inline] pub fn recreate(&self, device: &super::directx::direct3d11::IDirect3DDevice, pixelFormat: super::directx::DirectXPixelFormat, numberOfBuffers: i32, size: super::SizeInt32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).Recreate)(self as *const _ as *mut _, device as *const _ as *mut _, pixelFormat, numberOfBuffers, size); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn try_get_next_frame(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).TryGetNextFrame)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn add_frame_arrived(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_FrameArrived)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_frame_arrived(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_FrameArrived)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn create_capture_session(&self, item: &GraphicsCaptureItem) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreateCaptureSession)(self as *const _ as *mut _, item as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[cfg(feature="windows-system")] #[inline] pub fn get_dispatcher_queue(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_DispatcherQueue)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +RT_CLASS!{class Direct3D11CaptureFramePool: IDirect3D11CaptureFramePool} +impl RtActivatable for Direct3D11CaptureFramePool {} +impl Direct3D11CaptureFramePool { + #[inline] pub fn create(device: &super::directx::direct3d11::IDirect3DDevice, pixelFormat: super::directx::DirectXPixelFormat, numberOfBuffers: i32, size: super::SizeInt32) -> Result>> { + >::get_activation_factory().create(device, pixelFormat, numberOfBuffers, size) + } +} +DEFINE_CLSID!(Direct3D11CaptureFramePool(&[87,105,110,100,111,119,115,46,71,114,97,112,104,105,99,115,46,67,97,112,116,117,114,101,46,68,105,114,101,99,116,51,68,49,49,67,97,112,116,117,114,101,70,114,97,109,101,80,111,111,108,0]) [CLSID_Direct3D11CaptureFramePool]); +DEFINE_IID!(IID_IDirect3D11CaptureFramePoolStatics, 2005140842, 26538, 19795, 174, 84, 16, 136, 213, 168, 202, 33); +RT_INTERFACE!{static interface IDirect3D11CaptureFramePoolStatics(IDirect3D11CaptureFramePoolStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IDirect3D11CaptureFramePoolStatics] { + fn Create(&self, device: *mut super::directx::direct3d11::IDirect3DDevice, pixelFormat: super::directx::DirectXPixelFormat, numberOfBuffers: i32, size: super::SizeInt32, out: *mut *mut Direct3D11CaptureFramePool) -> HRESULT +}} +impl IDirect3D11CaptureFramePoolStatics { + #[inline] pub fn create(&self, device: &super::directx::direct3d11::IDirect3DDevice, pixelFormat: super::directx::DirectXPixelFormat, numberOfBuffers: i32, size: super::SizeInt32) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, device as *const _ as *mut _, pixelFormat, numberOfBuffers, size, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +DEFINE_IID!(IID_IGraphicsCaptureItem, 2042886491, 12791, 20162, 164, 100, 99, 46, 245, 211, 7, 96); +RT_INTERFACE!{interface IGraphicsCaptureItem(IGraphicsCaptureItemVtbl): IInspectable(IInspectableVtbl) [IID_IGraphicsCaptureItem] { + fn get_DisplayName(&self, out: *mut HSTRING) -> HRESULT, + fn get_Size(&self, out: *mut super::SizeInt32) -> HRESULT, + fn add_Closed(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_Closed(&self, token: foundation::EventRegistrationToken) -> HRESULT +}} +impl IGraphicsCaptureItem { + #[inline] pub fn get_display_name(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_DisplayName)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_size(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Size)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn add_closed(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_Closed)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_closed(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_Closed)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class GraphicsCaptureItem: IGraphicsCaptureItem} +DEFINE_IID!(IID_IGraphicsCapturePicker, 1511461299, 44409, 19274, 147, 54, 19, 24, 253, 222, 53, 57); +RT_INTERFACE!{interface IGraphicsCapturePicker(IGraphicsCapturePickerVtbl): IInspectable(IInspectableVtbl) [IID_IGraphicsCapturePicker] { + fn PickSingleItemAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT +}} +impl IGraphicsCapturePicker { + #[inline] pub fn pick_single_item_async(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).PickSingleItemAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} +} +RT_CLASS!{class GraphicsCapturePicker: IGraphicsCapturePicker} +impl RtActivatable for GraphicsCapturePicker {} +DEFINE_CLSID!(GraphicsCapturePicker(&[87,105,110,100,111,119,115,46,71,114,97,112,104,105,99,115,46,67,97,112,116,117,114,101,46,71,114,97,112,104,105,99,115,67,97,112,116,117,114,101,80,105,99,107,101,114,0]) [CLSID_GraphicsCapturePicker]); +DEFINE_IID!(IID_IGraphicsCaptureSession, 2169389737, 63247, 19159, 147, 155, 253, 220, 198, 235, 136, 13); +RT_INTERFACE!{interface IGraphicsCaptureSession(IGraphicsCaptureSessionVtbl): IInspectable(IInspectableVtbl) [IID_IGraphicsCaptureSession] { + fn StartCapture(&self) -> HRESULT +}} +impl IGraphicsCaptureSession { + #[inline] pub fn start_capture(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).StartCapture)(self as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class GraphicsCaptureSession: IGraphicsCaptureSession} +impl RtActivatable for GraphicsCaptureSession {} +impl GraphicsCaptureSession { + #[inline] pub fn is_supported() -> Result { + >::get_activation_factory().is_supported() + } +} +DEFINE_CLSID!(GraphicsCaptureSession(&[87,105,110,100,111,119,115,46,71,114,97,112,104,105,99,115,46,67,97,112,116,117,114,101,46,71,114,97,112,104,105,99,115,67,97,112,116,117,114,101,83,101,115,115,105,111,110,0]) [CLSID_GraphicsCaptureSession]); +DEFINE_IID!(IID_IGraphicsCaptureSessionStatics, 572826944, 22900, 18858, 178, 50, 8, 130, 83, 111, 76, 181); +RT_INTERFACE!{static interface IGraphicsCaptureSessionStatics(IGraphicsCaptureSessionStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IGraphicsCaptureSessionStatics] { + fn IsSupported(&self, out: *mut bool) -> HRESULT +}} +impl IGraphicsCaptureSessionStatics { + #[inline] pub fn is_supported(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).IsSupported)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} +} // Windows.Graphics.Capture pub mod effects { // Windows.Graphics.Effects use ::prelude::*; DEFINE_IID!(IID_IGraphicsEffect, 3411132622, 36838, 17974, 178, 2, 134, 31, 170, 7, 216, 243); @@ -2952,17 +3452,101 @@ impl IPrintPageInfo { RT_CLASS!{class PrintPageInfo: IPrintPageInfo} impl RtActivatable for PrintPageInfo {} DEFINE_CLSID!(PrintPageInfo(&[87,105,110,100,111,119,115,46,71,114,97,112,104,105,99,115,46,80,114,105,110,116,105,110,103,46,80,114,105,110,116,80,97,103,101,73,110,102,111,0]) [CLSID_PrintPageInfo]); -RT_ENUM! { enum PrintQuality: i32 { - Default (PrintQuality_Default) = 0, NotAvailable (PrintQuality_NotAvailable) = 1, PrinterCustom (PrintQuality_PrinterCustom) = 2, Automatic (PrintQuality_Automatic) = 3, Draft (PrintQuality_Draft) = 4, Fax (PrintQuality_Fax) = 5, High (PrintQuality_High) = 6, Normal (PrintQuality_Normal) = 7, Photographic (PrintQuality_Photographic) = 8, Text (PrintQuality_Text) = 9, +DEFINE_IID!(IID_IPrintPageRange, 4171263060, 28284, 20933, 87, 253, 6, 96, 194, 215, 21, 19); +RT_INTERFACE!{interface IPrintPageRange(IPrintPageRangeVtbl): IInspectable(IInspectableVtbl) [IID_IPrintPageRange] { + fn get_FirstPageNumber(&self, out: *mut i32) -> HRESULT, + fn get_LastPageNumber(&self, out: *mut i32) -> HRESULT }} -RT_ENUM! { enum PrintStaple: i32 { - Default (PrintStaple_Default) = 0, NotAvailable (PrintStaple_NotAvailable) = 1, PrinterCustom (PrintStaple_PrinterCustom) = 2, None (PrintStaple_None) = 3, StapleTopLeft (PrintStaple_StapleTopLeft) = 4, StapleTopRight (PrintStaple_StapleTopRight) = 5, StapleBottomLeft (PrintStaple_StapleBottomLeft) = 6, StapleBottomRight (PrintStaple_StapleBottomRight) = 7, StapleDualLeft (PrintStaple_StapleDualLeft) = 8, StapleDualRight (PrintStaple_StapleDualRight) = 9, StapleDualTop (PrintStaple_StapleDualTop) = 10, StapleDualBottom (PrintStaple_StapleDualBottom) = 11, SaddleStitch (PrintStaple_SaddleStitch) = 12, +impl IPrintPageRange { + #[inline] pub fn get_first_page_number(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_FirstPageNumber)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_last_page_number(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_LastPageNumber)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} +RT_CLASS!{class PrintPageRange: IPrintPageRange} +impl RtActivatable for PrintPageRange {} +impl PrintPageRange { + #[inline] pub fn create(firstPage: i32, lastPage: i32) -> Result> { + >::get_activation_factory().create(firstPage, lastPage) + } + #[inline] pub fn create_with_single_page(page: i32) -> Result> { + >::get_activation_factory().create_with_single_page(page) + } +} +DEFINE_CLSID!(PrintPageRange(&[87,105,110,100,111,119,115,46,71,114,97,112,104,105,99,115,46,80,114,105,110,116,105,110,103,46,80,114,105,110,116,80,97,103,101,82,97,110,103,101,0]) [CLSID_PrintPageRange]); +DEFINE_IID!(IID_IPrintPageRangeFactory, 1083167839, 57415, 24453, 113, 41, 251, 8, 90, 79, 173, 20); +RT_INTERFACE!{static interface IPrintPageRangeFactory(IPrintPageRangeFactoryVtbl): IInspectable(IInspectableVtbl) [IID_IPrintPageRangeFactory] { + fn Create(&self, firstPage: i32, lastPage: i32, out: *mut *mut PrintPageRange) -> HRESULT, + fn CreateWithSinglePage(&self, page: i32, out: *mut *mut PrintPageRange) -> HRESULT }} -DEFINE_IID!(IID_IPrintTask, 1641546311, 27894, 20397, 132, 226, 165, 232, 46, 45, 76, 235); -RT_INTERFACE!{interface IPrintTask(IPrintTaskVtbl): IInspectable(IInspectableVtbl) [IID_IPrintTask] { - #[cfg(not(feature="windows-applicationmodel"))] fn __Dummy0(&self) -> (), - #[cfg(feature="windows-applicationmodel")] fn get_Properties(&self, out: *mut *mut super::super::applicationmodel::datatransfer::DataPackagePropertySet) -> HRESULT, - fn get_Source(&self, out: *mut *mut IPrintDocumentSource) -> HRESULT, +impl IPrintPageRangeFactory { + #[inline] pub fn create(&self, firstPage: i32, lastPage: i32) -> Result> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, firstPage, lastPage, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn create_with_single_page(&self, page: i32) -> Result> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreateWithSinglePage)(self as *const _ as *mut _, page, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} +} +DEFINE_IID!(IID_IPrintPageRangeOptions, 3463296808, 4951, 18098, 169, 35, 121, 249, 149, 244, 72, 252); +RT_INTERFACE!{interface IPrintPageRangeOptions(IPrintPageRangeOptionsVtbl): IInspectable(IInspectableVtbl) [IID_IPrintPageRangeOptions] { + fn put_AllowAllPages(&self, value: bool) -> HRESULT, + fn get_AllowAllPages(&self, out: *mut bool) -> HRESULT, + fn put_AllowCurrentPage(&self, value: bool) -> HRESULT, + fn get_AllowCurrentPage(&self, out: *mut bool) -> HRESULT, + fn put_AllowCustomSetOfPages(&self, value: bool) -> HRESULT, + fn get_AllowCustomSetOfPages(&self, out: *mut bool) -> HRESULT +}} +impl IPrintPageRangeOptions { + #[inline] pub fn set_allow_all_pages(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_AllowAllPages)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_allow_all_pages(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_AllowAllPages)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_allow_current_page(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_AllowCurrentPage)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_allow_current_page(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_AllowCurrentPage)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_allow_custom_set_of_pages(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_AllowCustomSetOfPages)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_allow_custom_set_of_pages(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_AllowCustomSetOfPages)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} +RT_CLASS!{class PrintPageRangeOptions: IPrintPageRangeOptions} +RT_ENUM! { enum PrintQuality: i32 { + Default (PrintQuality_Default) = 0, NotAvailable (PrintQuality_NotAvailable) = 1, PrinterCustom (PrintQuality_PrinterCustom) = 2, Automatic (PrintQuality_Automatic) = 3, Draft (PrintQuality_Draft) = 4, Fax (PrintQuality_Fax) = 5, High (PrintQuality_High) = 6, Normal (PrintQuality_Normal) = 7, Photographic (PrintQuality_Photographic) = 8, Text (PrintQuality_Text) = 9, +}} +RT_ENUM! { enum PrintStaple: i32 { + Default (PrintStaple_Default) = 0, NotAvailable (PrintStaple_NotAvailable) = 1, PrinterCustom (PrintStaple_PrinterCustom) = 2, None (PrintStaple_None) = 3, StapleTopLeft (PrintStaple_StapleTopLeft) = 4, StapleTopRight (PrintStaple_StapleTopRight) = 5, StapleBottomLeft (PrintStaple_StapleBottomLeft) = 6, StapleBottomRight (PrintStaple_StapleBottomRight) = 7, StapleDualLeft (PrintStaple_StapleDualLeft) = 8, StapleDualRight (PrintStaple_StapleDualRight) = 9, StapleDualTop (PrintStaple_StapleDualTop) = 10, StapleDualBottom (PrintStaple_StapleDualBottom) = 11, SaddleStitch (PrintStaple_SaddleStitch) = 12, +}} +DEFINE_IID!(IID_IPrintTask, 1641546311, 27894, 20397, 132, 226, 165, 232, 46, 45, 76, 235); +RT_INTERFACE!{interface IPrintTask(IPrintTaskVtbl): IInspectable(IInspectableVtbl) [IID_IPrintTask] { + #[cfg(not(feature="windows-applicationmodel"))] fn __Dummy0(&self) -> (), + #[cfg(feature="windows-applicationmodel")] fn get_Properties(&self, out: *mut *mut super::super::applicationmodel::datatransfer::DataPackagePropertySet) -> HRESULT, + fn get_Source(&self, out: *mut *mut IPrintDocumentSource) -> HRESULT, fn get_Options(&self, out: *mut *mut PrintTaskOptions) -> HRESULT, fn add_Previewing(&self, eventHandler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, fn remove_Previewing(&self, eventCookie: foundation::EventRegistrationToken) -> HRESULT, @@ -3081,6 +3665,23 @@ impl IPrintTaskOptions { }} } RT_CLASS!{class PrintTaskOptions: IPrintTaskOptionsCore} +DEFINE_IID!(IID_IPrintTaskOptions2, 3952809478, 39478, 19289, 134, 23, 178, 23, 132, 146, 98, 225); +RT_INTERFACE!{interface IPrintTaskOptions2(IPrintTaskOptions2Vtbl): IInspectable(IInspectableVtbl) [IID_IPrintTaskOptions2] { + fn get_PageRangeOptions(&self, out: *mut *mut PrintPageRangeOptions) -> HRESULT, + fn get_CustomPageRanges(&self, out: *mut *mut foundation::collections::IVector) -> HRESULT +}} +impl IPrintTaskOptions2 { + #[inline] pub fn get_page_range_options(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_PageRangeOptions)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_custom_page_ranges(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_CustomPageRanges)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IPrintTaskOptionsCore, 467383412, 20177, 16875, 190, 60, 114, 209, 142, 214, 115, 55); RT_INTERFACE!{interface IPrintTaskOptionsCore(IPrintTaskOptionsCoreVtbl): IInspectable(IInspectableVtbl) [IID_IPrintTaskOptionsCore] { fn GetPageDescription(&self, jobPageNumber: u32, out: *mut PrintPageDescription) -> HRESULT @@ -3374,6 +3975,7 @@ impl IPrintTaskTargetDeviceSupport { RT_CLASS!{static class StandardPrintTaskOptions} impl RtActivatable for StandardPrintTaskOptions {} impl RtActivatable for StandardPrintTaskOptions {} +impl RtActivatable for StandardPrintTaskOptions {} impl StandardPrintTaskOptions { #[inline] pub fn get_media_size() -> Result { >::get_activation_factory().get_media_size() @@ -3417,6 +4019,9 @@ impl StandardPrintTaskOptions { #[inline] pub fn get_bordering() -> Result { >::get_activation_factory().get_bordering() } + #[inline] pub fn get_custom_page_ranges() -> Result { + >::get_activation_factory().get_custom_page_ranges() + } } DEFINE_CLSID!(StandardPrintTaskOptions(&[87,105,110,100,111,119,115,46,71,114,97,112,104,105,99,115,46,80,114,105,110,116,105,110,103,46,83,116,97,110,100,97,114,100,80,114,105,110,116,84,97,115,107,79,112,116,105,111,110,115,0]) [CLSID_StandardPrintTaskOptions]); DEFINE_IID!(IID_IStandardPrintTaskOptionsStatic, 3024633126, 3536, 19668, 186, 255, 147, 15, 199, 214, 165, 116); @@ -3513,12 +4118,158 @@ impl IStandardPrintTaskOptionsStatic2 { if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IStandardPrintTaskOptionsStatic3, 3153497734, 14424, 16819, 167, 153, 85, 221, 152, 136, 212, 117); +RT_INTERFACE!{static interface IStandardPrintTaskOptionsStatic3(IStandardPrintTaskOptionsStatic3Vtbl): IInspectable(IInspectableVtbl) [IID_IStandardPrintTaskOptionsStatic3] { + fn get_CustomPageRanges(&self, out: *mut HSTRING) -> HRESULT +}} +impl IStandardPrintTaskOptionsStatic3 { + #[inline] pub fn get_custom_page_ranges(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_CustomPageRanges)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} +} pub mod optiondetails { // Windows.Graphics.Printing.OptionDetails use ::prelude::*; +DEFINE_IID!(IID_IPrintBindingOptionDetails, 3287600280, 38244, 20246, 160, 85, 169, 139, 154, 73, 233, 211); +RT_INTERFACE!{interface IPrintBindingOptionDetails(IPrintBindingOptionDetailsVtbl): IInspectable(IInspectableVtbl) [IID_IPrintBindingOptionDetails] { + fn put_WarningText(&self, value: HSTRING) -> HRESULT, + fn get_WarningText(&self, out: *mut HSTRING) -> HRESULT, + fn put_Description(&self, value: HSTRING) -> HRESULT, + fn get_Description(&self, out: *mut HSTRING) -> HRESULT +}} +impl IPrintBindingOptionDetails { + #[inline] pub fn set_warning_text(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_WarningText)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_warning_text(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_WarningText)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn set_description(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Description)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_description(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Description)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} +} RT_CLASS!{class PrintBindingOptionDetails: IPrintOptionDetails} +DEFINE_IID!(IID_IPrintBorderingOptionDetails, 1299430543, 64339, 20146, 152, 95, 29, 145, 222, 11, 118, 57); +RT_INTERFACE!{interface IPrintBorderingOptionDetails(IPrintBorderingOptionDetailsVtbl): IInspectable(IInspectableVtbl) [IID_IPrintBorderingOptionDetails] { + fn put_WarningText(&self, value: HSTRING) -> HRESULT, + fn get_WarningText(&self, out: *mut HSTRING) -> HRESULT, + fn put_Description(&self, value: HSTRING) -> HRESULT, + fn get_Description(&self, out: *mut HSTRING) -> HRESULT +}} +impl IPrintBorderingOptionDetails { + #[inline] pub fn set_warning_text(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_WarningText)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_warning_text(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_WarningText)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn set_description(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Description)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_description(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Description)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} +} RT_CLASS!{class PrintBorderingOptionDetails: IPrintOptionDetails} +DEFINE_IID!(IID_IPrintCollationOptionDetails, 3601576294, 42406, 16604, 172, 195, 115, 159, 40, 241, 229, 211); +RT_INTERFACE!{interface IPrintCollationOptionDetails(IPrintCollationOptionDetailsVtbl): IInspectable(IInspectableVtbl) [IID_IPrintCollationOptionDetails] { + fn put_WarningText(&self, value: HSTRING) -> HRESULT, + fn get_WarningText(&self, out: *mut HSTRING) -> HRESULT, + fn put_Description(&self, value: HSTRING) -> HRESULT, + fn get_Description(&self, out: *mut HSTRING) -> HRESULT +}} +impl IPrintCollationOptionDetails { + #[inline] pub fn set_warning_text(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_WarningText)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_warning_text(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_WarningText)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn set_description(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Description)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_description(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Description)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} +} RT_CLASS!{class PrintCollationOptionDetails: IPrintOptionDetails} +DEFINE_IID!(IID_IPrintColorModeOptionDetails, 3685316356, 61910, 18499, 164, 132, 155, 68, 124, 220, 243, 182); +RT_INTERFACE!{interface IPrintColorModeOptionDetails(IPrintColorModeOptionDetailsVtbl): IInspectable(IInspectableVtbl) [IID_IPrintColorModeOptionDetails] { + fn put_WarningText(&self, value: HSTRING) -> HRESULT, + fn get_WarningText(&self, out: *mut HSTRING) -> HRESULT, + fn put_Description(&self, value: HSTRING) -> HRESULT, + fn get_Description(&self, out: *mut HSTRING) -> HRESULT +}} +impl IPrintColorModeOptionDetails { + #[inline] pub fn set_warning_text(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_WarningText)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_warning_text(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_WarningText)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn set_description(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Description)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_description(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Description)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} +} RT_CLASS!{class PrintColorModeOptionDetails: IPrintOptionDetails} +DEFINE_IID!(IID_IPrintCopiesOptionDetails, 1107636377, 17209, 17219, 137, 141, 44, 71, 181, 224, 195, 65); +RT_INTERFACE!{interface IPrintCopiesOptionDetails(IPrintCopiesOptionDetailsVtbl): IInspectable(IInspectableVtbl) [IID_IPrintCopiesOptionDetails] { + fn put_WarningText(&self, value: HSTRING) -> HRESULT, + fn get_WarningText(&self, out: *mut HSTRING) -> HRESULT, + fn put_Description(&self, value: HSTRING) -> HRESULT, + fn get_Description(&self, out: *mut HSTRING) -> HRESULT +}} +impl IPrintCopiesOptionDetails { + #[inline] pub fn set_warning_text(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_WarningText)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_warning_text(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_WarningText)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn set_description(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Description)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_description(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Description)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} +} RT_CLASS!{class PrintCopiesOptionDetails: IPrintOptionDetails} DEFINE_IID!(IID_IPrintCustomItemDetails, 1459926583, 23610, 17562, 170, 54, 179, 41, 27, 17, 146, 253); RT_INTERFACE!{interface IPrintCustomItemDetails(IPrintCustomItemDetailsVtbl): IInspectable(IInspectableVtbl) [IID_IPrintCustomItemDetails] { @@ -3554,6 +4305,43 @@ impl IPrintCustomItemListOptionDetails { }} } RT_CLASS!{class PrintCustomItemListOptionDetails: IPrintOptionDetails} +DEFINE_IID!(IID_IPrintCustomItemListOptionDetails2, 3386258749, 25884, 19001, 144, 110, 16, 145, 161, 128, 27, 241); +RT_INTERFACE!{interface IPrintCustomItemListOptionDetails2(IPrintCustomItemListOptionDetails2Vtbl): IInspectable(IInspectableVtbl) [IID_IPrintCustomItemListOptionDetails2] { + #[cfg(feature="windows-storage")] fn AddItem(&self, itemId: HSTRING, displayName: HSTRING, description: HSTRING, icon: *mut ::rt::gen::windows::storage::streams::IRandomAccessStreamWithContentType) -> HRESULT +}} +impl IPrintCustomItemListOptionDetails2 { + #[cfg(feature="windows-storage")] #[inline] pub fn add_item(&self, itemId: &HStringArg, displayName: &HStringArg, description: &HStringArg, icon: &::rt::gen::windows::storage::streams::IRandomAccessStreamWithContentType) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).AddItem)(self as *const _ as *mut _, itemId.get(), displayName.get(), description.get(), icon as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +DEFINE_IID!(IID_IPrintCustomItemListOptionDetails3, 1335997759, 15412, 18536, 164, 7, 252, 94, 171, 37, 155, 33); +RT_INTERFACE!{interface IPrintCustomItemListOptionDetails3(IPrintCustomItemListOptionDetails3Vtbl): IInspectable(IInspectableVtbl) [IID_IPrintCustomItemListOptionDetails3] { + fn put_WarningText(&self, value: HSTRING) -> HRESULT, + fn get_WarningText(&self, out: *mut HSTRING) -> HRESULT, + fn put_Description(&self, value: HSTRING) -> HRESULT, + fn get_Description(&self, out: *mut HSTRING) -> HRESULT +}} +impl IPrintCustomItemListOptionDetails3 { + #[inline] pub fn set_warning_text(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_WarningText)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_warning_text(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_WarningText)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn set_description(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Description)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_description(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Description)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IPrintCustomOptionDetails, 3811302940, 10415, 19344, 149, 218, 163, 172, 243, 32, 185, 41); RT_INTERFACE!{interface IPrintCustomOptionDetails(IPrintCustomOptionDetailsVtbl): IInspectable(IInspectableVtbl) [IID_IPrintCustomOptionDetails] { fn put_DisplayName(&self, value: HSTRING) -> HRESULT, @@ -3587,7 +4375,116 @@ impl IPrintCustomTextOptionDetails { }} } RT_CLASS!{class PrintCustomTextOptionDetails: IPrintOptionDetails} +DEFINE_IID!(IID_IPrintCustomTextOptionDetails2, 3467053908, 47479, 18200, 131, 56, 126, 210, 176, 216, 111, 227); +RT_INTERFACE!{interface IPrintCustomTextOptionDetails2(IPrintCustomTextOptionDetails2Vtbl): IInspectable(IInspectableVtbl) [IID_IPrintCustomTextOptionDetails2] { + fn put_WarningText(&self, value: HSTRING) -> HRESULT, + fn get_WarningText(&self, out: *mut HSTRING) -> HRESULT, + fn put_Description(&self, value: HSTRING) -> HRESULT, + fn get_Description(&self, out: *mut HSTRING) -> HRESULT +}} +impl IPrintCustomTextOptionDetails2 { + #[inline] pub fn set_warning_text(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_WarningText)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_warning_text(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_WarningText)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn set_description(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Description)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_description(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Description)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} +} +DEFINE_IID!(IID_IPrintCustomToggleOptionDetails, 2645873940, 58465, 17928, 142, 233, 219, 111, 94, 208, 115, 198); +RT_INTERFACE!{interface IPrintCustomToggleOptionDetails(IPrintCustomToggleOptionDetailsVtbl): IInspectable(IInspectableVtbl) [IID_IPrintCustomToggleOptionDetails] { + fn put_WarningText(&self, value: HSTRING) -> HRESULT, + fn get_WarningText(&self, out: *mut HSTRING) -> HRESULT, + fn put_Description(&self, value: HSTRING) -> HRESULT, + fn get_Description(&self, out: *mut HSTRING) -> HRESULT +}} +impl IPrintCustomToggleOptionDetails { + #[inline] pub fn set_warning_text(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_WarningText)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_warning_text(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_WarningText)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn set_description(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Description)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_description(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Description)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} +} +RT_CLASS!{class PrintCustomToggleOptionDetails: IPrintOptionDetails} +DEFINE_IID!(IID_IPrintDuplexOptionDetails, 4242097553, 54436, 17658, 179, 254, 66, 224, 186, 40, 213, 173); +RT_INTERFACE!{interface IPrintDuplexOptionDetails(IPrintDuplexOptionDetailsVtbl): IInspectable(IInspectableVtbl) [IID_IPrintDuplexOptionDetails] { + fn put_WarningText(&self, value: HSTRING) -> HRESULT, + fn get_WarningText(&self, out: *mut HSTRING) -> HRESULT, + fn put_Description(&self, value: HSTRING) -> HRESULT, + fn get_Description(&self, out: *mut HSTRING) -> HRESULT +}} +impl IPrintDuplexOptionDetails { + #[inline] pub fn set_warning_text(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_WarningText)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_warning_text(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_WarningText)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn set_description(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Description)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_description(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Description)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} +} RT_CLASS!{class PrintDuplexOptionDetails: IPrintOptionDetails} +DEFINE_IID!(IID_IPrintHolePunchOptionDetails, 2799574808, 18476, 18007, 157, 113, 141, 221, 219, 234, 30, 30); +RT_INTERFACE!{interface IPrintHolePunchOptionDetails(IPrintHolePunchOptionDetailsVtbl): IInspectable(IInspectableVtbl) [IID_IPrintHolePunchOptionDetails] { + fn put_WarningText(&self, value: HSTRING) -> HRESULT, + fn get_WarningText(&self, out: *mut HSTRING) -> HRESULT, + fn put_Description(&self, value: HSTRING) -> HRESULT, + fn get_Description(&self, out: *mut HSTRING) -> HRESULT +}} +impl IPrintHolePunchOptionDetails { + #[inline] pub fn set_warning_text(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_WarningText)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_warning_text(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_WarningText)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn set_description(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Description)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_description(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Description)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} +} RT_CLASS!{class PrintHolePunchOptionDetails: IPrintOptionDetails} DEFINE_IID!(IID_IPrintItemListOptionDetails, 2585941951, 65121, 17368, 162, 79, 163, 246, 171, 115, 32, 231); RT_INTERFACE!{interface IPrintItemListOptionDetails(IPrintItemListOptionDetailsVtbl): IInspectable(IInspectableVtbl) [IID_IPrintItemListOptionDetails] { @@ -3600,7 +4497,61 @@ impl IPrintItemListOptionDetails { if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IPrintMediaSizeOptionDetails, 1821203407, 49343, 18376, 184, 74, 98, 142, 125, 13, 26, 29); +RT_INTERFACE!{interface IPrintMediaSizeOptionDetails(IPrintMediaSizeOptionDetailsVtbl): IInspectable(IInspectableVtbl) [IID_IPrintMediaSizeOptionDetails] { + fn put_WarningText(&self, value: HSTRING) -> HRESULT, + fn get_WarningText(&self, out: *mut HSTRING) -> HRESULT, + fn put_Description(&self, value: HSTRING) -> HRESULT, + fn get_Description(&self, out: *mut HSTRING) -> HRESULT +}} +impl IPrintMediaSizeOptionDetails { + #[inline] pub fn set_warning_text(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_WarningText)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_warning_text(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_WarningText)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn set_description(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Description)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_description(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Description)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} +} RT_CLASS!{class PrintMediaSizeOptionDetails: IPrintOptionDetails} +DEFINE_IID!(IID_IPrintMediaTypeOptionDetails, 4173791243, 44019, 19132, 142, 134, 34, 171, 197, 116, 74, 67); +RT_INTERFACE!{interface IPrintMediaTypeOptionDetails(IPrintMediaTypeOptionDetailsVtbl): IInspectable(IInspectableVtbl) [IID_IPrintMediaTypeOptionDetails] { + fn put_WarningText(&self, value: HSTRING) -> HRESULT, + fn get_WarningText(&self, out: *mut HSTRING) -> HRESULT, + fn put_Description(&self, value: HSTRING) -> HRESULT, + fn get_Description(&self, out: *mut HSTRING) -> HRESULT +}} +impl IPrintMediaTypeOptionDetails { + #[inline] pub fn set_warning_text(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_WarningText)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_warning_text(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_WarningText)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn set_description(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Description)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_description(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Description)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} +} RT_CLASS!{class PrintMediaTypeOptionDetails: IPrintOptionDetails} DEFINE_IID!(IID_IPrintNumberOptionDetails, 1291959215, 25692, 19945, 150, 95, 111, 198, 187, 196, 124, 171); RT_INTERFACE!{interface IPrintNumberOptionDetails(IPrintNumberOptionDetailsVtbl): IInspectable(IInspectableVtbl) [IID_IPrintNumberOptionDetails] { @@ -3674,10 +4625,119 @@ RT_ENUM! { enum PrintOptionStates: u32 { None (PrintOptionStates_None) = 0, Enabled (PrintOptionStates_Enabled) = 1, Constrained (PrintOptionStates_Constrained) = 2, }} RT_ENUM! { enum PrintOptionType: i32 { - Unknown (PrintOptionType_Unknown) = 0, Number (PrintOptionType_Number) = 1, Text (PrintOptionType_Text) = 2, ItemList (PrintOptionType_ItemList) = 3, + Unknown (PrintOptionType_Unknown) = 0, Number (PrintOptionType_Number) = 1, Text (PrintOptionType_Text) = 2, ItemList (PrintOptionType_ItemList) = 3, Toggle (PrintOptionType_Toggle) = 4, }} +DEFINE_IID!(IID_IPrintOrientationOptionDetails, 1187219577, 26336, 19872, 135, 180, 210, 84, 87, 130, 78, 183); +RT_INTERFACE!{interface IPrintOrientationOptionDetails(IPrintOrientationOptionDetailsVtbl): IInspectable(IInspectableVtbl) [IID_IPrintOrientationOptionDetails] { + fn put_WarningText(&self, value: HSTRING) -> HRESULT, + fn get_WarningText(&self, out: *mut HSTRING) -> HRESULT, + fn put_Description(&self, value: HSTRING) -> HRESULT, + fn get_Description(&self, out: *mut HSTRING) -> HRESULT +}} +impl IPrintOrientationOptionDetails { + #[inline] pub fn set_warning_text(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_WarningText)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_warning_text(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_WarningText)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn set_description(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Description)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_description(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Description)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} +} RT_CLASS!{class PrintOrientationOptionDetails: IPrintOptionDetails} +DEFINE_IID!(IID_IPrintPageRangeOptionDetails, 1511646391, 11240, 19111, 158, 165, 222, 251, 232, 113, 59, 78); +RT_INTERFACE!{interface IPrintPageRangeOptionDetails(IPrintPageRangeOptionDetailsVtbl): IInspectable(IInspectableVtbl) [IID_IPrintPageRangeOptionDetails] { + fn put_WarningText(&self, value: HSTRING) -> HRESULT, + fn get_WarningText(&self, out: *mut HSTRING) -> HRESULT, + fn put_Description(&self, value: HSTRING) -> HRESULT, + fn get_Description(&self, out: *mut HSTRING) -> HRESULT +}} +impl IPrintPageRangeOptionDetails { + #[inline] pub fn set_warning_text(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_WarningText)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_warning_text(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_WarningText)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn set_description(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Description)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_description(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Description)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} +} +RT_CLASS!{class PrintPageRangeOptionDetails: IPrintOptionDetails} +DEFINE_IID!(IID_IPrintQualityOptionDetails, 768633761, 52762, 17638, 132, 249, 58, 146, 234, 30, 48, 68); +RT_INTERFACE!{interface IPrintQualityOptionDetails(IPrintQualityOptionDetailsVtbl): IInspectable(IInspectableVtbl) [IID_IPrintQualityOptionDetails] { + fn put_WarningText(&self, value: HSTRING) -> HRESULT, + fn get_WarningText(&self, out: *mut HSTRING) -> HRESULT, + fn put_Description(&self, value: HSTRING) -> HRESULT, + fn get_Description(&self, out: *mut HSTRING) -> HRESULT +}} +impl IPrintQualityOptionDetails { + #[inline] pub fn set_warning_text(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_WarningText)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_warning_text(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_WarningText)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn set_description(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Description)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_description(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Description)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} +} RT_CLASS!{class PrintQualityOptionDetails: IPrintOptionDetails} +DEFINE_IID!(IID_IPrintStapleOptionDetails, 3560011197, 39947, 17632, 132, 246, 206, 235, 206, 101, 56, 0); +RT_INTERFACE!{interface IPrintStapleOptionDetails(IPrintStapleOptionDetailsVtbl): IInspectable(IInspectableVtbl) [IID_IPrintStapleOptionDetails] { + fn put_WarningText(&self, value: HSTRING) -> HRESULT, + fn get_WarningText(&self, out: *mut HSTRING) -> HRESULT, + fn put_Description(&self, value: HSTRING) -> HRESULT, + fn get_Description(&self, out: *mut HSTRING) -> HRESULT +}} +impl IPrintStapleOptionDetails { + #[inline] pub fn set_warning_text(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_WarningText)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_warning_text(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_WarningText)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn set_description(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Description)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_description(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Description)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} +} RT_CLASS!{class PrintStapleOptionDetails: IPrintOptionDetails} DEFINE_IID!(IID_IPrintTaskOptionChangedEventArgs, 1696169221, 42478, 17159, 148, 7, 154, 202, 209, 71, 103, 156); RT_INTERFACE!{interface IPrintTaskOptionChangedEventArgs(IPrintTaskOptionChangedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IPrintTaskOptionChangedEventArgs] { @@ -3744,6 +4804,17 @@ impl PrintTaskOptionDetails { } } DEFINE_CLSID!(PrintTaskOptionDetails(&[87,105,110,100,111,119,115,46,71,114,97,112,104,105,99,115,46,80,114,105,110,116,105,110,103,46,79,112,116,105,111,110,68,101,116,97,105,108,115,46,80,114,105,110,116,84,97,115,107,79,112,116,105,111,110,68,101,116,97,105,108,115,0]) [CLSID_PrintTaskOptionDetails]); +DEFINE_IID!(IID_IPrintTaskOptionDetails2, 1400048137, 63848, 18066, 161, 119, 192, 116, 89, 113, 134, 219); +RT_INTERFACE!{interface IPrintTaskOptionDetails2(IPrintTaskOptionDetails2Vtbl): IInspectable(IInspectableVtbl) [IID_IPrintTaskOptionDetails2] { + fn CreateToggleOption(&self, optionId: HSTRING, displayName: HSTRING, out: *mut *mut PrintCustomToggleOptionDetails) -> HRESULT +}} +impl IPrintTaskOptionDetails2 { + #[inline] pub fn create_toggle_option(&self, optionId: &HStringArg, displayName: &HStringArg) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreateToggleOption)(self as *const _ as *mut _, optionId.get(), displayName.get(), &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IPrintTaskOptionDetailsStatic, 324903315, 2401, 19310, 135, 102, 241, 59, 127, 188, 205, 88); RT_INTERFACE!{static interface IPrintTaskOptionDetailsStatic(IPrintTaskOptionDetailsStaticVtbl): IInspectable(IInspectableVtbl) [IID_IPrintTaskOptionDetailsStatic] { fn GetFromPrintTaskOptions(&self, printTaskOptions: *mut super::PrintTaskOptions, out: *mut *mut PrintTaskOptionDetails) -> HRESULT @@ -4744,6 +5815,17 @@ impl IHolographicCamera3 { if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IHolographicCamera4, 2586128854, 18211, 20281, 169, 165, 157, 5, 24, 29, 155, 68); +RT_INTERFACE!{interface IHolographicCamera4(IHolographicCamera4Vtbl): IInspectable(IInspectableVtbl) [IID_IHolographicCamera4] { + fn get_CanOverrideViewport(&self, out: *mut bool) -> HRESULT +}} +impl IHolographicCamera4 { + #[inline] pub fn get_can_override_viewport(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_CanOverrideViewport)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} DEFINE_IID!(IID_IHolographicCameraPose, 226328112, 4830, 17853, 145, 43, 199, 246, 86, 21, 153, 209); RT_INTERFACE!{interface IHolographicCameraPose(IHolographicCameraPoseVtbl): IInspectable(IInspectableVtbl) [IID_IHolographicCameraPose] { fn get_HolographicCamera(&self, out: *mut *mut HolographicCamera) -> HRESULT, @@ -4801,6 +5883,27 @@ impl IHolographicCameraPose { }} } RT_CLASS!{class HolographicCameraPose: IHolographicCameraPose} +DEFINE_IID!(IID_IHolographicCameraPose2, 590078067, 23853, 17760, 129, 78, 38, 151, 196, 252, 225, 107); +RT_INTERFACE!{interface IHolographicCameraPose2(IHolographicCameraPose2Vtbl): IInspectable(IInspectableVtbl) [IID_IHolographicCameraPose2] { + #[cfg(not(feature="windows-perception"))] fn __Dummy0(&self) -> (), + #[cfg(feature="windows-perception")] fn OverrideViewTransform(&self, coordinateSystem: *mut super::super::perception::spatial::SpatialCoordinateSystem, coordinateSystemToViewTransform: HolographicStereoTransform) -> HRESULT, + fn OverrideProjectionTransform(&self, projectionTransform: HolographicStereoTransform) -> HRESULT, + fn OverrideViewport(&self, leftViewport: foundation::Rect, rightViewport: foundation::Rect) -> HRESULT +}} +impl IHolographicCameraPose2 { + #[cfg(feature="windows-perception")] #[inline] pub fn override_view_transform(&self, coordinateSystem: &super::super::perception::spatial::SpatialCoordinateSystem, coordinateSystemToViewTransform: HolographicStereoTransform) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).OverrideViewTransform)(self as *const _ as *mut _, coordinateSystem as *const _ as *mut _, coordinateSystemToViewTransform); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn override_projection_transform(&self, projectionTransform: HolographicStereoTransform) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).OverrideProjectionTransform)(self as *const _ as *mut _, projectionTransform); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn override_viewport(&self, leftViewport: foundation::Rect, rightViewport: foundation::Rect) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).OverrideViewport)(self as *const _ as *mut _, leftViewport, rightViewport); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} DEFINE_IID!(IID_IHolographicCameraRenderingParameters, 2393648849, 23540, 19990, 130, 54, 174, 8, 0, 193, 29, 13); RT_INTERFACE!{interface IHolographicCameraRenderingParameters(IHolographicCameraRenderingParametersVtbl): IInspectable(IInspectableVtbl) [IID_IHolographicCameraRenderingParameters] { #[cfg(not(feature="windows-perception"))] fn __Dummy0(&self) -> (), @@ -5050,6 +6153,54 @@ impl IHolographicFramePrediction { }} } RT_CLASS!{class HolographicFramePrediction: IHolographicFramePrediction} +DEFINE_IID!(IID_IHolographicFramePresentationMonitor, 3397854572, 28590, 17038, 187, 131, 37, 223, 238, 81, 19, 107); +RT_INTERFACE!{interface IHolographicFramePresentationMonitor(IHolographicFramePresentationMonitorVtbl): IInspectable(IInspectableVtbl) [IID_IHolographicFramePresentationMonitor] { + fn ReadReports(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT +}} +impl IHolographicFramePresentationMonitor { + #[inline] pub fn read_reports(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).ReadReports)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +RT_CLASS!{class HolographicFramePresentationMonitor: IHolographicFramePresentationMonitor} +DEFINE_IID!(IID_IHolographicFramePresentationReport, 2159736340, 62196, 19594, 141, 227, 6, 92, 120, 246, 213, 222); +RT_INTERFACE!{interface IHolographicFramePresentationReport(IHolographicFramePresentationReportVtbl): IInspectable(IInspectableVtbl) [IID_IHolographicFramePresentationReport] { + fn get_CompositorGpuDuration(&self, out: *mut foundation::TimeSpan) -> HRESULT, + fn get_AppGpuDuration(&self, out: *mut foundation::TimeSpan) -> HRESULT, + fn get_AppGpuOverrun(&self, out: *mut foundation::TimeSpan) -> HRESULT, + fn get_MissedPresentationOpportunityCount(&self, out: *mut u32) -> HRESULT, + fn get_PresentationCount(&self, out: *mut u32) -> HRESULT +}} +impl IHolographicFramePresentationReport { + #[inline] pub fn get_compositor_gpu_duration(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_CompositorGpuDuration)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_app_gpu_duration(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_AppGpuDuration)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_app_gpu_overrun(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_AppGpuOverrun)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_missed_presentation_opportunity_count(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_MissedPresentationOpportunityCount)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_presentation_count(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_PresentationCount)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} +RT_CLASS!{class HolographicFramePresentationReport: IHolographicFramePresentationReport} RT_ENUM! { enum HolographicFramePresentResult: i32 { Success (HolographicFramePresentResult_Success) = 0, DeviceRemoved (HolographicFramePresentResult_DeviceRemoved) = 1, }} @@ -5211,6 +6362,44 @@ impl HolographicSpace { } } DEFINE_CLSID!(HolographicSpace(&[87,105,110,100,111,119,115,46,71,114,97,112,104,105,99,115,46,72,111,108,111,103,114,97,112,104,105,99,46,72,111,108,111,103,114,97,112,104,105,99,83,112,97,99,101,0]) [CLSID_HolographicSpace]); +DEFINE_IID!(IID_IHolographicSpace2, 1333897640, 47103, 18563, 152, 39, 125, 103, 114, 135, 234, 112); +RT_INTERFACE!{interface IHolographicSpace2(IHolographicSpace2Vtbl): IInspectable(IInspectableVtbl) [IID_IHolographicSpace2] { + fn get_UserPresence(&self, out: *mut HolographicSpaceUserPresence) -> HRESULT, + fn add_UserPresenceChanged(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_UserPresenceChanged(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn WaitForNextFrameReady(&self) -> HRESULT, + fn WaitForNextFrameReadyWithHeadStart(&self, requestedHeadStartDuration: foundation::TimeSpan) -> HRESULT, + fn CreateFramePresentationMonitor(&self, maxQueuedReports: u32, out: *mut *mut HolographicFramePresentationMonitor) -> HRESULT +}} +impl IHolographicSpace2 { + #[inline] pub fn get_user_presence(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_UserPresence)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn add_user_presence_changed(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_UserPresenceChanged)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_user_presence_changed(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_UserPresenceChanged)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn wait_for_next_frame_ready(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).WaitForNextFrameReady)(self as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn wait_for_next_frame_ready_with_head_start(&self, requestedHeadStartDuration: foundation::TimeSpan) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).WaitForNextFrameReadyWithHeadStart)(self as *const _ as *mut _, requestedHeadStartDuration); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn create_frame_presentation_monitor(&self, maxQueuedReports: u32) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreateFramePresentationMonitor)(self as *const _ as *mut _, maxQueuedReports, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IHolographicSpaceCameraAddedEventArgs, 1492245045, 48051, 15503, 153, 61, 108, 128, 231, 254, 185, 159); RT_INTERFACE!{interface IHolographicSpaceCameraAddedEventArgs(IHolographicSpaceCameraAddedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IHolographicSpaceCameraAddedEventArgs] { fn get_Camera(&self, out: *mut *mut HolographicCamera) -> HRESULT, @@ -5291,6 +6480,9 @@ impl IHolographicSpaceStatics3 { if hr == S_OK { Ok(out) } else { err(hr) } }} } +RT_ENUM! { enum HolographicSpaceUserPresence: i32 { + Absent (HolographicSpaceUserPresence_Absent) = 0, PresentPassive (HolographicSpaceUserPresence_PresentPassive) = 1, PresentActive (HolographicSpaceUserPresence_PresentActive) = 2, +}} RT_STRUCT! { struct HolographicStereoTransform { Left: foundation::numerics::Matrix4x4, Right: foundation::numerics::Matrix4x4, }} @@ -5300,6 +6492,9 @@ use ::prelude::*; RT_ENUM! { enum DirectXAlphaMode: i32 { Unspecified (DirectXAlphaMode_Unspecified) = 0, Premultiplied (DirectXAlphaMode_Premultiplied) = 1, Straight (DirectXAlphaMode_Straight) = 2, Ignore (DirectXAlphaMode_Ignore) = 3, }} +RT_ENUM! { enum DirectXColorSpace: i32 { + RgbFullG22NoneP709 (DirectXColorSpace_RgbFullG22NoneP709) = 0, RgbFullG10NoneP709 (DirectXColorSpace_RgbFullG10NoneP709) = 1, RgbStudioG22NoneP709 (DirectXColorSpace_RgbStudioG22NoneP709) = 2, RgbStudioG22NoneP2020 (DirectXColorSpace_RgbStudioG22NoneP2020) = 3, Reserved (DirectXColorSpace_Reserved) = 4, YccFullG22NoneP709X601 (DirectXColorSpace_YccFullG22NoneP709X601) = 5, YccStudioG22LeftP601 (DirectXColorSpace_YccStudioG22LeftP601) = 6, YccFullG22LeftP601 (DirectXColorSpace_YccFullG22LeftP601) = 7, YccStudioG22LeftP709 (DirectXColorSpace_YccStudioG22LeftP709) = 8, YccFullG22LeftP709 (DirectXColorSpace_YccFullG22LeftP709) = 9, YccStudioG22LeftP2020 (DirectXColorSpace_YccStudioG22LeftP2020) = 10, YccFullG22LeftP2020 (DirectXColorSpace_YccFullG22LeftP2020) = 11, RgbFullG2084NoneP2020 (DirectXColorSpace_RgbFullG2084NoneP2020) = 12, YccStudioG2084LeftP2020 (DirectXColorSpace_YccStudioG2084LeftP2020) = 13, RgbStudioG2084NoneP2020 (DirectXColorSpace_RgbStudioG2084NoneP2020) = 14, YccStudioG22TopLeftP2020 (DirectXColorSpace_YccStudioG22TopLeftP2020) = 15, YccStudioG2084TopLeftP2020 (DirectXColorSpace_YccStudioG2084TopLeftP2020) = 16, RgbFullG22NoneP2020 (DirectXColorSpace_RgbFullG22NoneP2020) = 17, YccStudioGHlgTopLeftP2020 (DirectXColorSpace_YccStudioGHlgTopLeftP2020) = 18, YccFullGHlgTopLeftP2020 (DirectXColorSpace_YccFullGHlgTopLeftP2020) = 19, RgbStudioG24NoneP709 (DirectXColorSpace_RgbStudioG24NoneP709) = 20, RgbStudioG24NoneP2020 (DirectXColorSpace_RgbStudioG24NoneP2020) = 21, YccStudioG24LeftP709 (DirectXColorSpace_YccStudioG24LeftP709) = 22, YccStudioG24LeftP2020 (DirectXColorSpace_YccStudioG24LeftP2020) = 23, YccStudioG24TopLeftP2020 (DirectXColorSpace_YccStudioG24TopLeftP2020) = 24, +}} RT_ENUM! { enum DirectXPixelFormat: i32 { Unknown (DirectXPixelFormat_Unknown) = 0, R32G32B32A32Typeless (DirectXPixelFormat_R32G32B32A32Typeless) = 1, R32G32B32A32Float (DirectXPixelFormat_R32G32B32A32Float) = 2, R32G32B32A32UInt (DirectXPixelFormat_R32G32B32A32UInt) = 3, R32G32B32A32Int (DirectXPixelFormat_R32G32B32A32Int) = 4, R32G32B32Typeless (DirectXPixelFormat_R32G32B32Typeless) = 5, R32G32B32Float (DirectXPixelFormat_R32G32B32Float) = 6, R32G32B32UInt (DirectXPixelFormat_R32G32B32UInt) = 7, R32G32B32Int (DirectXPixelFormat_R32G32B32Int) = 8, R16G16B16A16Typeless (DirectXPixelFormat_R16G16B16A16Typeless) = 9, R16G16B16A16Float (DirectXPixelFormat_R16G16B16A16Float) = 10, R16G16B16A16UIntNormalized (DirectXPixelFormat_R16G16B16A16UIntNormalized) = 11, R16G16B16A16UInt (DirectXPixelFormat_R16G16B16A16UInt) = 12, R16G16B16A16IntNormalized (DirectXPixelFormat_R16G16B16A16IntNormalized) = 13, R16G16B16A16Int (DirectXPixelFormat_R16G16B16A16Int) = 14, R32G32Typeless (DirectXPixelFormat_R32G32Typeless) = 15, R32G32Float (DirectXPixelFormat_R32G32Float) = 16, R32G32UInt (DirectXPixelFormat_R32G32UInt) = 17, R32G32Int (DirectXPixelFormat_R32G32Int) = 18, R32G8X24Typeless (DirectXPixelFormat_R32G8X24Typeless) = 19, D32FloatS8X24UInt (DirectXPixelFormat_D32FloatS8X24UInt) = 20, R32FloatX8X24Typeless (DirectXPixelFormat_R32FloatX8X24Typeless) = 21, X32TypelessG8X24UInt (DirectXPixelFormat_X32TypelessG8X24UInt) = 22, R10G10B10A2Typeless (DirectXPixelFormat_R10G10B10A2Typeless) = 23, R10G10B10A2UIntNormalized (DirectXPixelFormat_R10G10B10A2UIntNormalized) = 24, R10G10B10A2UInt (DirectXPixelFormat_R10G10B10A2UInt) = 25, R11G11B10Float (DirectXPixelFormat_R11G11B10Float) = 26, R8G8B8A8Typeless (DirectXPixelFormat_R8G8B8A8Typeless) = 27, R8G8B8A8UIntNormalized (DirectXPixelFormat_R8G8B8A8UIntNormalized) = 28, R8G8B8A8UIntNormalizedSrgb (DirectXPixelFormat_R8G8B8A8UIntNormalizedSrgb) = 29, R8G8B8A8UInt (DirectXPixelFormat_R8G8B8A8UInt) = 30, R8G8B8A8IntNormalized (DirectXPixelFormat_R8G8B8A8IntNormalized) = 31, R8G8B8A8Int (DirectXPixelFormat_R8G8B8A8Int) = 32, R16G16Typeless (DirectXPixelFormat_R16G16Typeless) = 33, R16G16Float (DirectXPixelFormat_R16G16Float) = 34, R16G16UIntNormalized (DirectXPixelFormat_R16G16UIntNormalized) = 35, R16G16UInt (DirectXPixelFormat_R16G16UInt) = 36, R16G16IntNormalized (DirectXPixelFormat_R16G16IntNormalized) = 37, R16G16Int (DirectXPixelFormat_R16G16Int) = 38, R32Typeless (DirectXPixelFormat_R32Typeless) = 39, D32Float (DirectXPixelFormat_D32Float) = 40, R32Float (DirectXPixelFormat_R32Float) = 41, R32UInt (DirectXPixelFormat_R32UInt) = 42, R32Int (DirectXPixelFormat_R32Int) = 43, R24G8Typeless (DirectXPixelFormat_R24G8Typeless) = 44, D24UIntNormalizedS8UInt (DirectXPixelFormat_D24UIntNormalizedS8UInt) = 45, R24UIntNormalizedX8Typeless (DirectXPixelFormat_R24UIntNormalizedX8Typeless) = 46, X24TypelessG8UInt (DirectXPixelFormat_X24TypelessG8UInt) = 47, R8G8Typeless (DirectXPixelFormat_R8G8Typeless) = 48, R8G8UIntNormalized (DirectXPixelFormat_R8G8UIntNormalized) = 49, R8G8UInt (DirectXPixelFormat_R8G8UInt) = 50, R8G8IntNormalized (DirectXPixelFormat_R8G8IntNormalized) = 51, R8G8Int (DirectXPixelFormat_R8G8Int) = 52, R16Typeless (DirectXPixelFormat_R16Typeless) = 53, R16Float (DirectXPixelFormat_R16Float) = 54, D16UIntNormalized (DirectXPixelFormat_D16UIntNormalized) = 55, R16UIntNormalized (DirectXPixelFormat_R16UIntNormalized) = 56, R16UInt (DirectXPixelFormat_R16UInt) = 57, R16IntNormalized (DirectXPixelFormat_R16IntNormalized) = 58, R16Int (DirectXPixelFormat_R16Int) = 59, R8Typeless (DirectXPixelFormat_R8Typeless) = 60, R8UIntNormalized (DirectXPixelFormat_R8UIntNormalized) = 61, R8UInt (DirectXPixelFormat_R8UInt) = 62, R8IntNormalized (DirectXPixelFormat_R8IntNormalized) = 63, R8Int (DirectXPixelFormat_R8Int) = 64, A8UIntNormalized (DirectXPixelFormat_A8UIntNormalized) = 65, R1UIntNormalized (DirectXPixelFormat_R1UIntNormalized) = 66, R9G9B9E5SharedExponent (DirectXPixelFormat_R9G9B9E5SharedExponent) = 67, R8G8B8G8UIntNormalized (DirectXPixelFormat_R8G8B8G8UIntNormalized) = 68, G8R8G8B8UIntNormalized (DirectXPixelFormat_G8R8G8B8UIntNormalized) = 69, BC1Typeless (DirectXPixelFormat_BC1Typeless) = 70, BC1UIntNormalized (DirectXPixelFormat_BC1UIntNormalized) = 71, BC1UIntNormalizedSrgb (DirectXPixelFormat_BC1UIntNormalizedSrgb) = 72, BC2Typeless (DirectXPixelFormat_BC2Typeless) = 73, BC2UIntNormalized (DirectXPixelFormat_BC2UIntNormalized) = 74, BC2UIntNormalizedSrgb (DirectXPixelFormat_BC2UIntNormalizedSrgb) = 75, BC3Typeless (DirectXPixelFormat_BC3Typeless) = 76, BC3UIntNormalized (DirectXPixelFormat_BC3UIntNormalized) = 77, BC3UIntNormalizedSrgb (DirectXPixelFormat_BC3UIntNormalizedSrgb) = 78, BC4Typeless (DirectXPixelFormat_BC4Typeless) = 79, BC4UIntNormalized (DirectXPixelFormat_BC4UIntNormalized) = 80, BC4IntNormalized (DirectXPixelFormat_BC4IntNormalized) = 81, BC5Typeless (DirectXPixelFormat_BC5Typeless) = 82, BC5UIntNormalized (DirectXPixelFormat_BC5UIntNormalized) = 83, BC5IntNormalized (DirectXPixelFormat_BC5IntNormalized) = 84, B5G6R5UIntNormalized (DirectXPixelFormat_B5G6R5UIntNormalized) = 85, B5G5R5A1UIntNormalized (DirectXPixelFormat_B5G5R5A1UIntNormalized) = 86, B8G8R8A8UIntNormalized (DirectXPixelFormat_B8G8R8A8UIntNormalized) = 87, B8G8R8X8UIntNormalized (DirectXPixelFormat_B8G8R8X8UIntNormalized) = 88, R10G10B10XRBiasA2UIntNormalized (DirectXPixelFormat_R10G10B10XRBiasA2UIntNormalized) = 89, B8G8R8A8Typeless (DirectXPixelFormat_B8G8R8A8Typeless) = 90, B8G8R8A8UIntNormalizedSrgb (DirectXPixelFormat_B8G8R8A8UIntNormalizedSrgb) = 91, B8G8R8X8Typeless (DirectXPixelFormat_B8G8R8X8Typeless) = 92, B8G8R8X8UIntNormalizedSrgb (DirectXPixelFormat_B8G8R8X8UIntNormalizedSrgb) = 93, BC6HTypeless (DirectXPixelFormat_BC6HTypeless) = 94, BC6H16UnsignedFloat (DirectXPixelFormat_BC6H16UnsignedFloat) = 95, BC6H16Float (DirectXPixelFormat_BC6H16Float) = 96, BC7Typeless (DirectXPixelFormat_BC7Typeless) = 97, BC7UIntNormalized (DirectXPixelFormat_BC7UIntNormalized) = 98, BC7UIntNormalizedSrgb (DirectXPixelFormat_BC7UIntNormalizedSrgb) = 99, Ayuv (DirectXPixelFormat_Ayuv) = 100, Y410 (DirectXPixelFormat_Y410) = 101, Y416 (DirectXPixelFormat_Y416) = 102, NV12 (DirectXPixelFormat_NV12) = 103, P010 (DirectXPixelFormat_P010) = 104, P016 (DirectXPixelFormat_P016) = 105, Opaque420 (DirectXPixelFormat_Opaque420) = 106, Yuy2 (DirectXPixelFormat_Yuy2) = 107, Y210 (DirectXPixelFormat_Y210) = 108, Y216 (DirectXPixelFormat_Y216) = 109, NV11 (DirectXPixelFormat_NV11) = 110, AI44 (DirectXPixelFormat_AI44) = 111, IA44 (DirectXPixelFormat_IA44) = 112, P8 (DirectXPixelFormat_P8) = 113, A8P8 (DirectXPixelFormat_A8P8) = 114, B4G4R4A4UIntNormalized (DirectXPixelFormat_B4G4R4A4UIntNormalized) = 115, P208 (DirectXPixelFormat_P208) = 130, V208 (DirectXPixelFormat_V208) = 131, V408 (DirectXPixelFormat_V408) = 132, }} diff --git a/src/rt/gen/windows/management.rs b/src/rt/gen/windows/management.rs index a2c13c3..d463a16 100644 --- a/src/rt/gen/windows/management.rs +++ b/src/rt/gen/windows/management.rs @@ -585,6 +585,17 @@ impl IPackageManager6 { if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IPackageManager7, 4068889844, 11175, 19328, 136, 214, 190, 21, 249, 162, 63, 186); +RT_INTERFACE!{interface IPackageManager7(IPackageManager7Vtbl): IInspectable(IInspectableVtbl) [IID_IPackageManager7] { + fn RequestAddPackageAndRelatedSetAsync(&self, packageUri: *mut foundation::Uri, dependencyPackageUris: *mut foundation::collections::IIterable, deploymentOptions: DeploymentOptions, targetVolume: *mut PackageVolume, optionalPackageFamilyNames: *mut foundation::collections::IIterable, relatedPackageUris: *mut foundation::collections::IIterable, packageUrisToInstall: *mut foundation::collections::IIterable, out: *mut *mut foundation::IAsyncOperationWithProgress) -> HRESULT +}} +impl IPackageManager7 { + #[inline] pub fn request_add_package_and_related_set_async(&self, packageUri: &foundation::Uri, dependencyPackageUris: &foundation::collections::IIterable, deploymentOptions: DeploymentOptions, targetVolume: &PackageVolume, optionalPackageFamilyNames: &foundation::collections::IIterable, relatedPackageUris: &foundation::collections::IIterable, packageUrisToInstall: &foundation::collections::IIterable) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).RequestAddPackageAndRelatedSetAsync)(self as *const _ as *mut _, packageUri as *const _ as *mut _, dependencyPackageUris as *const _ as *mut _, deploymentOptions, targetVolume as *const _ as *mut _, optionalPackageFamilyNames as *const _ as *mut _, relatedPackageUris as *const _ as *mut _, packageUrisToInstall as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IPackageManagerDebugSettings, 442570371, 43400, 20431, 143, 15, 206, 23, 88, 152, 232, 235); RT_INTERFACE!{interface IPackageManagerDebugSettings(IPackageManagerDebugSettingsVtbl): IInspectable(IInspectableVtbl) [IID_IPackageManagerDebugSettings] { #[cfg(feature="windows-applicationmodel")] fn SetContentGroupStateAsync(&self, package: *mut super::super::applicationmodel::Package, contentGroupName: HSTRING, state: super::super::applicationmodel::PackageContentGroupState, out: *mut *mut foundation::IAsyncAction) -> HRESULT, @@ -823,6 +834,77 @@ impl IInstalledClassicAppInfo { RT_CLASS!{class InstalledClassicAppInfo: IInstalledClassicAppInfo} } // Windows.Management.Deployment.Preview } // Windows.Management.Deployment +pub mod update { // Windows.Management.Update +use ::prelude::*; +DEFINE_IID!(IID_IPreviewBuildsManager, 4194819425, 32335, 23031, 124, 159, 222, 249, 5, 28, 95, 98); +RT_INTERFACE!{interface IPreviewBuildsManager(IPreviewBuildsManagerVtbl): IInspectable(IInspectableVtbl) [IID_IPreviewBuildsManager] { + fn get_ArePreviewBuildsAllowed(&self, out: *mut bool) -> HRESULT, + fn put_ArePreviewBuildsAllowed(&self, value: bool) -> HRESULT, + fn GetCurrentState(&self, out: *mut *mut PreviewBuildsState) -> HRESULT, + fn SyncAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT +}} +impl IPreviewBuildsManager { + #[inline] pub fn get_are_preview_builds_allowed(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_ArePreviewBuildsAllowed)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_are_preview_builds_allowed(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_ArePreviewBuildsAllowed)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_current_state(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetCurrentState)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn sync_async(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).SyncAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} +} +RT_CLASS!{class PreviewBuildsManager: IPreviewBuildsManager} +impl RtActivatable for PreviewBuildsManager {} +impl PreviewBuildsManager { + #[inline] pub fn get_default() -> Result>> { + >::get_activation_factory().get_default() + } + #[inline] pub fn is_supported() -> Result { + >::get_activation_factory().is_supported() + } +} +DEFINE_CLSID!(PreviewBuildsManager(&[87,105,110,100,111,119,115,46,77,97,110,97,103,101,109,101,110,116,46,85,112,100,97,116,101,46,80,114,101,118,105,101,119,66,117,105,108,100,115,77,97,110,97,103,101,114,0]) [CLSID_PreviewBuildsManager]); +DEFINE_IID!(IID_IPreviewBuildsManagerStatics, 1044523143, 45330, 23152, 125, 161, 151, 215, 141, 50, 170, 41); +RT_INTERFACE!{static interface IPreviewBuildsManagerStatics(IPreviewBuildsManagerStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IPreviewBuildsManagerStatics] { + fn GetDefault(&self, out: *mut *mut PreviewBuildsManager) -> HRESULT, + fn IsSupported(&self, out: *mut bool) -> HRESULT +}} +impl IPreviewBuildsManagerStatics { + #[inline] pub fn get_default(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetDefault)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn is_supported(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).IsSupported)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} +DEFINE_IID!(IID_IPreviewBuildsState, 2733805630, 45603, 24419, 117, 70, 62, 142, 172, 7, 10, 46); +RT_INTERFACE!{interface IPreviewBuildsState(IPreviewBuildsStateVtbl): IInspectable(IInspectableVtbl) [IID_IPreviewBuildsState] { + fn get_Properties(&self, out: *mut *mut foundation::collections::ValueSet) -> HRESULT +}} +impl IPreviewBuildsState { + #[inline] pub fn get_properties(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Properties)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +RT_CLASS!{class PreviewBuildsState: IPreviewBuildsState} +} // Windows.Management.Update pub mod core { // Windows.Management.Core use ::prelude::*; DEFINE_IID!(IID_IApplicationDataManager, 1959855154, 11929, 16384, 154, 58, 100, 48, 126, 133, 129, 41); diff --git a/src/rt/gen/windows/media.rs b/src/rt/gen/windows/media.rs index 97bbaf1..092ece1 100644 --- a/src/rt/gen/windows/media.rs +++ b/src/rt/gen/windows/media.rs @@ -1414,6 +1414,7 @@ impl IVideoFrame { } RT_CLASS!{class VideoFrame: IVideoFrame} impl RtActivatable for VideoFrame {} +impl RtActivatable for VideoFrame {} impl VideoFrame { #[cfg(feature="windows-graphics")] #[inline] pub fn create(format: super::graphics::imaging::BitmapPixelFormat, width: i32, height: i32) -> Result> { >::get_activation_factory().create(format, width, height) @@ -1421,8 +1422,31 @@ impl VideoFrame { #[cfg(feature="windows-graphics")] #[inline] pub fn create_with_alpha(format: super::graphics::imaging::BitmapPixelFormat, width: i32, height: i32, alpha: super::graphics::imaging::BitmapAlphaMode) -> Result> { >::get_activation_factory().create_with_alpha(format, width, height, alpha) } + #[cfg(feature="windows-graphics")] #[inline] pub fn create_as_direct3_d11_surface_backed(format: super::graphics::directx::DirectXPixelFormat, width: i32, height: i32) -> Result>> { + >::get_activation_factory().create_as_direct3_d11_surface_backed(format, width, height) + } + #[cfg(feature="windows-graphics")] #[inline] pub fn create_as_direct3_d11_surface_backed_with_device(format: super::graphics::directx::DirectXPixelFormat, width: i32, height: i32, device: &super::graphics::directx::direct3d11::IDirect3DDevice) -> Result>> { + >::get_activation_factory().create_as_direct3_d11_surface_backed_with_device(format, width, height, device) + } + #[cfg(feature="windows-graphics")] #[inline] pub fn create_with_software_bitmap(bitmap: &super::graphics::imaging::SoftwareBitmap) -> Result>> { + >::get_activation_factory().create_with_software_bitmap(bitmap) + } + #[cfg(feature="windows-graphics")] #[inline] pub fn create_with_direct3_d11_surface(surface: &super::graphics::directx::direct3d11::IDirect3DSurface) -> Result>> { + >::get_activation_factory().create_with_direct3_d11_surface(surface) + } } DEFINE_CLSID!(VideoFrame(&[87,105,110,100,111,119,115,46,77,101,100,105,97,46,86,105,100,101,111,70,114,97,109,101,0]) [CLSID_VideoFrame]); +DEFINE_IID!(IID_IVideoFrame2, 943162381, 13164, 17254, 141, 70, 6, 7, 152, 115, 108, 93); +RT_INTERFACE!{interface IVideoFrame2(IVideoFrame2Vtbl): IInspectable(IInspectableVtbl) [IID_IVideoFrame2] { + #[cfg(feature="windows-graphics")] fn CopyToWithBoundsAsync(&self, frame: *mut VideoFrame, sourceBounds: *mut foundation::IReference, destinationBounds: *mut foundation::IReference, out: *mut *mut foundation::IAsyncAction) -> HRESULT +}} +impl IVideoFrame2 { + #[cfg(feature="windows-graphics")] #[inline] pub fn copy_to_with_bounds_async(&self, frame: &VideoFrame, sourceBounds: &foundation::IReference, destinationBounds: &foundation::IReference) -> Result> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).CopyToWithBoundsAsync)(self as *const _ as *mut _, frame as *const _ as *mut _, sourceBounds as *const _ as *mut _, destinationBounds as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IVideoFrameFactory, 21720425, 8744, 19602, 146, 255, 80, 195, 128, 211, 231, 118); RT_INTERFACE!{static interface IVideoFrameFactory(IVideoFrameFactoryVtbl): IInspectable(IInspectableVtbl) [IID_IVideoFrameFactory] { #[cfg(feature="windows-graphics")] fn Create(&self, format: super::graphics::imaging::BitmapPixelFormat, width: i32, height: i32, out: *mut *mut VideoFrame) -> HRESULT, @@ -1440,6 +1464,35 @@ impl IVideoFrameFactory { if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IVideoFrameStatics, 2871678319, 24849, 19251, 142, 195, 43, 32, 154, 2, 225, 122); +RT_INTERFACE!{static interface IVideoFrameStatics(IVideoFrameStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IVideoFrameStatics] { + #[cfg(feature="windows-graphics")] fn CreateAsDirect3D11SurfaceBacked(&self, format: super::graphics::directx::DirectXPixelFormat, width: i32, height: i32, out: *mut *mut VideoFrame) -> HRESULT, + #[cfg(feature="windows-graphics")] fn CreateAsDirect3D11SurfaceBackedWithDevice(&self, format: super::graphics::directx::DirectXPixelFormat, width: i32, height: i32, device: *mut super::graphics::directx::direct3d11::IDirect3DDevice, out: *mut *mut VideoFrame) -> HRESULT, + #[cfg(feature="windows-graphics")] fn CreateWithSoftwareBitmap(&self, bitmap: *mut super::graphics::imaging::SoftwareBitmap, out: *mut *mut VideoFrame) -> HRESULT, + #[cfg(feature="windows-graphics")] fn CreateWithDirect3D11Surface(&self, surface: *mut super::graphics::directx::direct3d11::IDirect3DSurface, out: *mut *mut VideoFrame) -> HRESULT +}} +impl IVideoFrameStatics { + #[cfg(feature="windows-graphics")] #[inline] pub fn create_as_direct3_d11_surface_backed(&self, format: super::graphics::directx::DirectXPixelFormat, width: i32, height: i32) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreateAsDirect3D11SurfaceBacked)(self as *const _ as *mut _, format, width, height, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[cfg(feature="windows-graphics")] #[inline] pub fn create_as_direct3_d11_surface_backed_with_device(&self, format: super::graphics::directx::DirectXPixelFormat, width: i32, height: i32, device: &super::graphics::directx::direct3d11::IDirect3DDevice) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreateAsDirect3D11SurfaceBackedWithDevice)(self as *const _ as *mut _, format, width, height, device as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[cfg(feature="windows-graphics")] #[inline] pub fn create_with_software_bitmap(&self, bitmap: &super::graphics::imaging::SoftwareBitmap) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreateWithSoftwareBitmap)(self as *const _ as *mut _, bitmap as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[cfg(feature="windows-graphics")] #[inline] pub fn create_with_direct3_d11_surface(&self, surface: &super::graphics::directx::direct3d11::IDirect3DSurface) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreateWithDirect3D11Surface)(self as *const _ as *mut _, surface as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} pub mod capture { // Windows.Media.Capture use ::prelude::*; DEFINE_IID!(IID_IAdvancedCapturedPhoto, 4034032267, 45714, 17553, 157, 65, 153, 128, 122, 85, 11, 191); @@ -4120,6 +4173,23 @@ impl ICapturedFrame { }} } RT_CLASS!{class CapturedFrame: ICapturedFrame} +DEFINE_IID!(IID_ICapturedFrame2, 1413457617, 48504, 18534, 173, 218, 36, 49, 75, 198, 93, 234); +RT_INTERFACE!{interface ICapturedFrame2(ICapturedFrame2Vtbl): IInspectable(IInspectableVtbl) [IID_ICapturedFrame2] { + fn get_ControlValues(&self, out: *mut *mut CapturedFrameControlValues) -> HRESULT, + #[cfg(feature="windows-graphics")] fn get_BitmapProperties(&self, out: *mut *mut super::super::graphics::imaging::BitmapPropertySet) -> HRESULT +}} +impl ICapturedFrame2 { + #[inline] pub fn get_control_values(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ControlValues)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[cfg(feature="windows-graphics")] #[inline] pub fn get_bitmap_properties(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_BitmapProperties)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_ICapturedFrameControlValues, 2428918655, 19981, 19620, 136, 45, 122, 20, 79, 237, 10, 144); RT_INTERFACE!{interface ICapturedFrameControlValues(ICapturedFrameControlValuesVtbl): IInspectable(IInspectableVtbl) [IID_ICapturedFrameControlValues] { fn get_Exposure(&self, out: *mut *mut foundation::IReference) -> HRESULT, @@ -4412,7 +4482,7 @@ RT_ENUM! { enum GameBarTargetCapturePolicy: i32 { EnabledBySystem (GameBarTargetCapturePolicy_EnabledBySystem) = 0, EnabledByUser (GameBarTargetCapturePolicy_EnabledByUser) = 1, NotEnabled (GameBarTargetCapturePolicy_NotEnabled) = 2, ProhibitedBySystem (GameBarTargetCapturePolicy_ProhibitedBySystem) = 3, ProhibitedByPublisher (GameBarTargetCapturePolicy_ProhibitedByPublisher) = 4, }} RT_ENUM! { enum KnownVideoProfile: i32 { - VideoRecording (KnownVideoProfile_VideoRecording) = 0, HighQualityPhoto (KnownVideoProfile_HighQualityPhoto) = 1, BalancedVideoAndPhoto (KnownVideoProfile_BalancedVideoAndPhoto) = 2, VideoConferencing (KnownVideoProfile_VideoConferencing) = 3, PhotoSequence (KnownVideoProfile_PhotoSequence) = 4, + VideoRecording (KnownVideoProfile_VideoRecording) = 0, HighQualityPhoto (KnownVideoProfile_HighQualityPhoto) = 1, BalancedVideoAndPhoto (KnownVideoProfile_BalancedVideoAndPhoto) = 2, VideoConferencing (KnownVideoProfile_VideoConferencing) = 3, PhotoSequence (KnownVideoProfile_PhotoSequence) = 4, HighFrameRate (KnownVideoProfile_HighFrameRate) = 5, VariablePhotoSequence (KnownVideoProfile_VariablePhotoSequence) = 6, HdrWithWcgVideo (KnownVideoProfile_HdrWithWcgVideo) = 7, HdrWithWcgPhoto (KnownVideoProfile_HdrWithWcgPhoto) = 8, VideoHdr8 (KnownVideoProfile_VideoHdr8) = 9, }} DEFINE_IID!(IID_ILowLagMediaRecording, 1103674103, 65343, 18928, 164, 119, 241, 149, 227, 206, 81, 8); RT_INTERFACE!{interface ILowLagMediaRecording(ILowLagMediaRecordingVtbl): IInspectable(IInspectableVtbl) [IID_ILowLagMediaRecording] { @@ -5314,6 +5384,17 @@ impl IMediaCaptureSettings2 { if hr == S_OK { Ok(out) } else { err(hr) } }} } +DEFINE_IID!(IID_IMediaCaptureSettings3, 809265090, 32856, 19227, 184, 119, 140, 46, 243, 82, 132, 64); +RT_INTERFACE!{interface IMediaCaptureSettings3(IMediaCaptureSettings3Vtbl): IInspectable(IInspectableVtbl) [IID_IMediaCaptureSettings3] { + #[cfg(feature="windows-graphics")] fn get_Direct3D11Device(&self, out: *mut *mut super::super::graphics::directx::direct3d11::IDirect3DDevice) -> HRESULT +}} +impl IMediaCaptureSettings3 { + #[cfg(feature="windows-graphics")] #[inline] pub fn get_direct3_d11_device(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Direct3D11Device)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} RT_ENUM! { enum MediaCaptureSharingMode: i32 { ExclusiveControl (MediaCaptureSharingMode_ExclusiveControl) = 0, SharedReadOnly (MediaCaptureSharingMode_SharedReadOnly) = 1, }} @@ -5438,6 +5519,23 @@ impl IMediaCaptureVideoProfile { }} } RT_CLASS!{class MediaCaptureVideoProfile: IMediaCaptureVideoProfile} +DEFINE_IID!(IID_IMediaCaptureVideoProfile2, 2547894623, 38094, 18063, 147, 22, 252, 91, 194, 99, 143, 107); +RT_INTERFACE!{interface IMediaCaptureVideoProfile2(IMediaCaptureVideoProfile2Vtbl): IInspectable(IInspectableVtbl) [IID_IMediaCaptureVideoProfile2] { + fn get_FrameSourceInfos(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT, + fn get_Properties(&self, out: *mut *mut foundation::collections::IMapView) -> HRESULT +}} +impl IMediaCaptureVideoProfile2 { + #[inline] pub fn get_frame_source_infos(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_FrameSourceInfos)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_properties(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Properties)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IMediaCaptureVideoProfileMediaDescription, 2148708335, 46737, 18943, 131, 242, 193, 231, 110, 170, 234, 27); RT_INTERFACE!{interface IMediaCaptureVideoProfileMediaDescription(IMediaCaptureVideoProfileMediaDescriptionVtbl): IInspectable(IInspectableVtbl) [IID_IMediaCaptureVideoProfileMediaDescription] { fn get_Width(&self, out: *mut u32) -> HRESULT, @@ -5474,6 +5572,23 @@ impl IMediaCaptureVideoProfileMediaDescription { }} } RT_CLASS!{class MediaCaptureVideoProfileMediaDescription: IMediaCaptureVideoProfileMediaDescription} +DEFINE_IID!(IID_IMediaCaptureVideoProfileMediaDescription2, 3332828947, 12845, 16698, 184, 90, 104, 168, 142, 2, 244, 233); +RT_INTERFACE!{interface IMediaCaptureVideoProfileMediaDescription2(IMediaCaptureVideoProfileMediaDescription2Vtbl): IInspectable(IInspectableVtbl) [IID_IMediaCaptureVideoProfileMediaDescription2] { + fn get_Subtype(&self, out: *mut HSTRING) -> HRESULT, + fn get_Properties(&self, out: *mut *mut foundation::collections::IMapView) -> HRESULT +}} +impl IMediaCaptureVideoProfileMediaDescription2 { + #[inline] pub fn get_subtype(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Subtype)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_properties(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Properties)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} RT_ENUM! { enum MediaCategory: i32 { Other (MediaCategory_Other) = 0, Communications (MediaCategory_Communications) = 1, Media (MediaCategory_Media) = 2, GameChat (MediaCategory_GameChat) = 3, Speech (MediaCategory_Speech) = 4, }} @@ -5588,6 +5703,30 @@ RT_STRUCT! { struct WhiteBalanceGain { }} pub mod frames { // Windows.Media.Capture.Frames use ::prelude::*; +DEFINE_IID!(IID_IAudioMediaFrame, 2745827071, 32801, 17435, 154, 70, 231, 240, 19, 123, 121, 129); +RT_INTERFACE!{interface IAudioMediaFrame(IAudioMediaFrameVtbl): IInspectable(IInspectableVtbl) [IID_IAudioMediaFrame] { + fn get_FrameReference(&self, out: *mut *mut MediaFrameReference) -> HRESULT, + fn get_AudioEncodingProperties(&self, out: *mut *mut super::super::mediaproperties::AudioEncodingProperties) -> HRESULT, + fn GetAudioFrame(&self, out: *mut *mut super::super::AudioFrame) -> HRESULT +}} +impl IAudioMediaFrame { + #[inline] pub fn get_frame_reference(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_FrameReference)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_audio_encoding_properties(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_AudioEncodingProperties)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_audio_frame(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetAudioFrame)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +RT_CLASS!{class AudioMediaFrame: IAudioMediaFrame} DEFINE_IID!(IID_IBufferMediaFrame, 3048297415, 39812, 16482, 183, 156, 163, 101, 178, 89, 104, 84); RT_INTERFACE!{interface IBufferMediaFrame(IBufferMediaFrameVtbl): IInspectable(IInspectableVtbl) [IID_IBufferMediaFrame] { fn get_FrameReference(&self, out: *mut *mut MediaFrameReference) -> HRESULT, @@ -5736,6 +5875,17 @@ impl IMediaFrameFormat { }} } RT_CLASS!{class MediaFrameFormat: IMediaFrameFormat} +DEFINE_IID!(IID_IMediaFrameFormat2, 1669686080, 24199, 19472, 134, 209, 109, 240, 151, 166, 198, 168); +RT_INTERFACE!{interface IMediaFrameFormat2(IMediaFrameFormat2Vtbl): IInspectable(IInspectableVtbl) [IID_IMediaFrameFormat2] { + fn get_AudioEncodingProperties(&self, out: *mut *mut super::super::mediaproperties::AudioEncodingProperties) -> HRESULT +}} +impl IMediaFrameFormat2 { + #[inline] pub fn get_audio_encoding_properties(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_AudioEncodingProperties)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IMediaFrameReader, 3838395285, 8232, 18669, 144, 176, 209, 193, 177, 98, 226, 76); RT_INTERFACE!{interface IMediaFrameReader(IMediaFrameReaderVtbl): IInspectable(IInspectableVtbl) [IID_IMediaFrameReader] { fn add_FrameArrived(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, @@ -5847,6 +5997,17 @@ impl IMediaFrameReference { }} } RT_CLASS!{class MediaFrameReference: IMediaFrameReference} +DEFINE_IID!(IID_IMediaFrameReference2, 3720101580, 54706, 18927, 131, 106, 148, 125, 152, 155, 128, 193); +RT_INTERFACE!{interface IMediaFrameReference2(IMediaFrameReference2Vtbl): IInspectable(IInspectableVtbl) [IID_IMediaFrameReference2] { + fn get_AudioMediaFrame(&self, out: *mut *mut AudioMediaFrame) -> HRESULT +}} +impl IMediaFrameReference2 { + #[inline] pub fn get_audio_media_frame(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_AudioMediaFrame)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IMediaFrameSource, 3598199123, 37083, 18088, 138, 221, 42, 168, 132, 168, 210, 83); RT_INTERFACE!{interface IMediaFrameSource(IMediaFrameSourceVtbl): IInspectable(IInspectableVtbl) [IID_IMediaFrameSource] { fn get_Info(&self, out: *mut *mut MediaFrameSourceInfo) -> HRESULT, @@ -5941,6 +6102,17 @@ impl IMediaFrameSourceController2 { if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IMediaFrameSourceController3, 520943637, 9316, 18001, 177, 232, 74, 130, 219, 219, 84, 222); +RT_INTERFACE!{interface IMediaFrameSourceController3(IMediaFrameSourceController3Vtbl): IInspectable(IInspectableVtbl) [IID_IMediaFrameSourceController3] { + fn get_AudioDeviceController(&self, out: *mut *mut super::super::devices::AudioDeviceController) -> HRESULT +}} +impl IMediaFrameSourceController3 { + #[inline] pub fn get_audio_device_controller(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_AudioDeviceController)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IMediaFrameSourceGetPropertyResult, 143005378, 14948, 19413, 189, 43, 231, 200, 152, 210, 243, 122); RT_INTERFACE!{interface IMediaFrameSourceGetPropertyResult(IMediaFrameSourceGetPropertyResultVtbl): IInspectable(IInspectableVtbl) [IID_IMediaFrameSourceGetPropertyResult] { fn get_Status(&self, out: *mut MediaFrameSourceGetPropertyStatus) -> HRESULT, @@ -6071,8 +6243,25 @@ impl IMediaFrameSourceInfo { }} } RT_CLASS!{class MediaFrameSourceInfo: IMediaFrameSourceInfo} +DEFINE_IID!(IID_IMediaFrameSourceInfo2, 425359445, 25687, 17094, 167, 105, 25, 182, 91, 211, 46, 110); +RT_INTERFACE!{interface IMediaFrameSourceInfo2(IMediaFrameSourceInfo2Vtbl): IInspectable(IInspectableVtbl) [IID_IMediaFrameSourceInfo2] { + fn get_ProfileId(&self, out: *mut HSTRING) -> HRESULT, + fn get_VideoProfileMediaDescription(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT +}} +impl IMediaFrameSourceInfo2 { + #[inline] pub fn get_profile_id(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ProfileId)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_video_profile_media_description(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_VideoProfileMediaDescription)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} RT_ENUM! { enum MediaFrameSourceKind: i32 { - Custom (MediaFrameSourceKind_Custom) = 0, Color (MediaFrameSourceKind_Color) = 1, Infrared (MediaFrameSourceKind_Infrared) = 2, Depth (MediaFrameSourceKind_Depth) = 3, + Custom (MediaFrameSourceKind_Custom) = 0, Color (MediaFrameSourceKind_Color) = 1, Infrared (MediaFrameSourceKind_Infrared) = 2, Depth (MediaFrameSourceKind_Depth) = 3, Audio (MediaFrameSourceKind_Audio) = 4, Image (MediaFrameSourceKind_Image) = 5, }} RT_ENUM! { enum MediaFrameSourceSetPropertyStatus: i32 { Success (MediaFrameSourceSetPropertyStatus_Success) = 0, UnknownFailure (MediaFrameSourceSetPropertyStatus_UnknownFailure) = 1, NotSupported (MediaFrameSourceSetPropertyStatus_NotSupported) = 2, InvalidValue (MediaFrameSourceSetPropertyStatus_InvalidValue) = 3, DeviceNotAvailable (MediaFrameSourceSetPropertyStatus_DeviceNotAvailable) = 4, NotInControl (MediaFrameSourceSetPropertyStatus_NotInControl) = 5, @@ -7131,6 +7320,23 @@ impl IAudioGraph2 { if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IAudioGraph3, 3721209262, 4485, 17063, 131, 29, 106, 155, 15, 200, 104, 32); +RT_INTERFACE!{interface IAudioGraph3(IAudioGraph3Vtbl): IInspectable(IInspectableVtbl) [IID_IAudioGraph3] { + fn CreateMediaSourceAudioInputNodeAsync(&self, mediaSource: *mut super::core::MediaSource, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn CreateMediaSourceAudioInputNodeWithEmitterAsync(&self, mediaSource: *mut super::core::MediaSource, emitter: *mut AudioNodeEmitter, out: *mut *mut foundation::IAsyncOperation) -> HRESULT +}} +impl IAudioGraph3 { + #[inline] pub fn create_media_source_audio_input_node_async(&self, mediaSource: &super::core::MediaSource) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreateMediaSourceAudioInputNodeAsync)(self as *const _ as *mut _, mediaSource as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn create_media_source_audio_input_node_with_emitter_async(&self, mediaSource: &super::core::MediaSource, emitter: &AudioNodeEmitter) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreateMediaSourceAudioInputNodeWithEmitterAsync)(self as *const _ as *mut _, mediaSource as *const _ as *mut _, emitter as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} +} RT_CLASS!{class AudioGraphBatchUpdater: foundation::IClosable} DEFINE_IID!(IID_IAudioGraphConnection, 1982886125, 53326, 20396, 178, 51, 96, 11, 66, 237, 212, 105); RT_INTERFACE!{interface IAudioGraphConnection(IAudioGraphConnectionVtbl): IInspectable(IInspectableVtbl) [IID_IAudioGraphConnection] { @@ -7239,6 +7445,22 @@ impl AudioGraphSettings { } } DEFINE_CLSID!(AudioGraphSettings(&[87,105,110,100,111,119,115,46,77,101,100,105,97,46,65,117,100,105,111,46,65,117,100,105,111,71,114,97,112,104,83,101,116,116,105,110,103,115,0]) [CLSID_AudioGraphSettings]); +DEFINE_IID!(IID_IAudioGraphSettings2, 1922144135, 19883, 18147, 180, 201, 216, 225, 162, 99, 96, 98); +RT_INTERFACE!{interface IAudioGraphSettings2(IAudioGraphSettings2Vtbl): IInspectable(IInspectableVtbl) [IID_IAudioGraphSettings2] { + fn put_MaxPlaybackSpeedFactor(&self, value: f64) -> HRESULT, + fn get_MaxPlaybackSpeedFactor(&self, out: *mut f64) -> HRESULT +}} +impl IAudioGraphSettings2 { + #[inline] pub fn set_max_playback_speed_factor(&self, value: f64) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_MaxPlaybackSpeedFactor)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_max_playback_speed_factor(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_MaxPlaybackSpeedFactor)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} DEFINE_IID!(IID_IAudioGraphSettingsFactory, 2782469318, 49899, 19041, 162, 20, 29, 102, 215, 95, 131, 218); RT_INTERFACE!{static interface IAudioGraphSettingsFactory(IAudioGraphSettingsFactoryVtbl): IInspectable(IInspectableVtbl) [IID_IAudioGraphSettingsFactory] { fn Create(&self, audioRenderCategory: super::render::AudioRenderCategory, out: *mut *mut AudioGraphSettings) -> HRESULT @@ -7723,6 +7945,110 @@ impl IAudioNodeWithListener { if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IAudioStateMonitor, 487838006, 409, 19676, 184, 78, 231, 44, 43, 88, 30, 206); +RT_INTERFACE!{interface IAudioStateMonitor(IAudioStateMonitorVtbl): IInspectable(IInspectableVtbl) [IID_IAudioStateMonitor] { + fn add_SoundLevelChanged(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_SoundLevelChanged(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn get_SoundLevel(&self, out: *mut super::SoundLevel) -> HRESULT +}} +impl IAudioStateMonitor { + #[inline] pub fn add_sound_level_changed(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_SoundLevelChanged)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_sound_level_changed(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_SoundLevelChanged)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_sound_level(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_SoundLevel)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} +RT_CLASS!{class AudioStateMonitor: IAudioStateMonitor} +impl RtActivatable for AudioStateMonitor {} +impl AudioStateMonitor { + #[inline] pub fn create_for_render_monitoring() -> Result>> { + >::get_activation_factory().create_for_render_monitoring() + } + #[inline] pub fn create_for_render_monitoring_with_category(category: super::render::AudioRenderCategory) -> Result>> { + >::get_activation_factory().create_for_render_monitoring_with_category(category) + } + #[inline] pub fn create_for_render_monitoring_with_category_and_device_role(category: super::render::AudioRenderCategory, role: super::devices::AudioDeviceRole) -> Result>> { + >::get_activation_factory().create_for_render_monitoring_with_category_and_device_role(category, role) + } + #[inline] pub fn create_for_render_monitoring_with_category_and_device_id(category: super::render::AudioRenderCategory, deviceId: &HStringArg) -> Result>> { + >::get_activation_factory().create_for_render_monitoring_with_category_and_device_id(category, deviceId) + } + #[inline] pub fn create_for_capture_monitoring() -> Result>> { + >::get_activation_factory().create_for_capture_monitoring() + } + #[inline] pub fn create_for_capture_monitoring_with_category(category: super::capture::MediaCategory) -> Result>> { + >::get_activation_factory().create_for_capture_monitoring_with_category(category) + } + #[inline] pub fn create_for_capture_monitoring_with_category_and_device_role(category: super::capture::MediaCategory, role: super::devices::AudioDeviceRole) -> Result>> { + >::get_activation_factory().create_for_capture_monitoring_with_category_and_device_role(category, role) + } + #[inline] pub fn create_for_capture_monitoring_with_category_and_device_id(category: super::capture::MediaCategory, deviceId: &HStringArg) -> Result>> { + >::get_activation_factory().create_for_capture_monitoring_with_category_and_device_id(category, deviceId) + } +} +DEFINE_CLSID!(AudioStateMonitor(&[87,105,110,100,111,119,115,46,77,101,100,105,97,46,65,117,100,105,111,46,65,117,100,105,111,83,116,97,116,101,77,111,110,105,116,111,114,0]) [CLSID_AudioStateMonitor]); +DEFINE_IID!(IID_IAudioStateMonitorStatics, 1668606540, 6971, 16385, 148, 217, 221, 34, 83, 48, 250, 64); +RT_INTERFACE!{static interface IAudioStateMonitorStatics(IAudioStateMonitorStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IAudioStateMonitorStatics] { + fn CreateForRenderMonitoring(&self, out: *mut *mut AudioStateMonitor) -> HRESULT, + fn CreateForRenderMonitoringWithCategory(&self, category: super::render::AudioRenderCategory, out: *mut *mut AudioStateMonitor) -> HRESULT, + fn CreateForRenderMonitoringWithCategoryAndDeviceRole(&self, category: super::render::AudioRenderCategory, role: super::devices::AudioDeviceRole, out: *mut *mut AudioStateMonitor) -> HRESULT, + fn CreateForRenderMonitoringWithCategoryAndDeviceId(&self, category: super::render::AudioRenderCategory, deviceId: HSTRING, out: *mut *mut AudioStateMonitor) -> HRESULT, + fn CreateForCaptureMonitoring(&self, out: *mut *mut AudioStateMonitor) -> HRESULT, + fn CreateForCaptureMonitoringWithCategory(&self, category: super::capture::MediaCategory, out: *mut *mut AudioStateMonitor) -> HRESULT, + fn CreateForCaptureMonitoringWithCategoryAndDeviceRole(&self, category: super::capture::MediaCategory, role: super::devices::AudioDeviceRole, out: *mut *mut AudioStateMonitor) -> HRESULT, + fn CreateForCaptureMonitoringWithCategoryAndDeviceId(&self, category: super::capture::MediaCategory, deviceId: HSTRING, out: *mut *mut AudioStateMonitor) -> HRESULT +}} +impl IAudioStateMonitorStatics { + #[inline] pub fn create_for_render_monitoring(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreateForRenderMonitoring)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn create_for_render_monitoring_with_category(&self, category: super::render::AudioRenderCategory) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreateForRenderMonitoringWithCategory)(self as *const _ as *mut _, category, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn create_for_render_monitoring_with_category_and_device_role(&self, category: super::render::AudioRenderCategory, role: super::devices::AudioDeviceRole) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreateForRenderMonitoringWithCategoryAndDeviceRole)(self as *const _ as *mut _, category, role, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn create_for_render_monitoring_with_category_and_device_id(&self, category: super::render::AudioRenderCategory, deviceId: &HStringArg) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreateForRenderMonitoringWithCategoryAndDeviceId)(self as *const _ as *mut _, category, deviceId.get(), &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn create_for_capture_monitoring(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreateForCaptureMonitoring)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn create_for_capture_monitoring_with_category(&self, category: super::capture::MediaCategory) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreateForCaptureMonitoringWithCategory)(self as *const _ as *mut _, category, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn create_for_capture_monitoring_with_category_and_device_role(&self, category: super::capture::MediaCategory, role: super::devices::AudioDeviceRole) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreateForCaptureMonitoringWithCategoryAndDeviceRole)(self as *const _ as *mut _, category, role, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn create_for_capture_monitoring_with_category_and_device_id(&self, category: super::capture::MediaCategory, deviceId: &HStringArg) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreateForCaptureMonitoringWithCategoryAndDeviceId)(self as *const _ as *mut _, category, deviceId.get(), &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} RT_CLASS!{class AudioSubmixNode: IAudioInputNode} DEFINE_IID!(IID_ICreateAudioDeviceInputNodeResult, 384747432, 7335, 16623, 145, 164, 211, 70, 224, 170, 27, 186); RT_INTERFACE!{interface ICreateAudioDeviceInputNodeResult(ICreateAudioDeviceInputNodeResultVtbl): IInspectable(IInspectableVtbl) [IID_ICreateAudioDeviceInputNodeResult] { @@ -7814,6 +8140,24 @@ impl ICreateAudioGraphResult { }} } RT_CLASS!{class CreateAudioGraphResult: ICreateAudioGraphResult} +DEFINE_IID!(IID_ICreateMediaSourceAudioInputNodeResult, 1185306787, 21440, 19801, 158, 81, 204, 29, 16, 68, 164, 196); +RT_INTERFACE!{interface ICreateMediaSourceAudioInputNodeResult(ICreateMediaSourceAudioInputNodeResultVtbl): IInspectable(IInspectableVtbl) [IID_ICreateMediaSourceAudioInputNodeResult] { + fn get_Status(&self, out: *mut MediaSourceAudioInputNodeCreationStatus) -> HRESULT, + fn get_Node(&self, out: *mut *mut MediaSourceAudioInputNode) -> HRESULT +}} +impl ICreateMediaSourceAudioInputNodeResult { + #[inline] pub fn get_status(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Status)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_node(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Node)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +RT_CLASS!{class CreateMediaSourceAudioInputNodeResult: ICreateMediaSourceAudioInputNodeResult} DEFINE_IID!(IID_IEchoEffectDefinition, 239943594, 14008, 19601, 185, 218, 17, 244, 74, 138, 102, 16); RT_INTERFACE!{interface IEchoEffectDefinition(IEchoEffectDefinitionVtbl): IInspectable(IInspectableVtbl) [IID_IEchoEffectDefinition] { fn put_WetDryMix(&self, value: f64) -> HRESULT, @@ -7998,6 +8342,93 @@ impl ILimiterEffectDefinitionFactory { if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IMediaSourceAudioInputNode, 2581108795, 43146, 16449, 142, 79, 221, 186, 192, 201, 31, 211); +RT_INTERFACE!{interface IMediaSourceAudioInputNode(IMediaSourceAudioInputNodeVtbl): IInspectable(IInspectableVtbl) [IID_IMediaSourceAudioInputNode] { + fn put_PlaybackSpeedFactor(&self, value: f64) -> HRESULT, + fn get_PlaybackSpeedFactor(&self, out: *mut f64) -> HRESULT, + fn get_Position(&self, out: *mut foundation::TimeSpan) -> HRESULT, + fn Seek(&self, position: foundation::TimeSpan) -> HRESULT, + fn get_StartTime(&self, out: *mut *mut foundation::IReference) -> HRESULT, + fn put_StartTime(&self, value: *mut foundation::IReference) -> HRESULT, + fn get_EndTime(&self, out: *mut *mut foundation::IReference) -> HRESULT, + fn put_EndTime(&self, value: *mut foundation::IReference) -> HRESULT, + fn get_LoopCount(&self, out: *mut *mut foundation::IReference) -> HRESULT, + fn put_LoopCount(&self, value: *mut foundation::IReference) -> HRESULT, + fn get_Duration(&self, out: *mut foundation::TimeSpan) -> HRESULT, + fn get_MediaSource(&self, out: *mut *mut super::core::MediaSource) -> HRESULT, + fn add_MediaSourceCompleted(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_MediaSourceCompleted(&self, token: foundation::EventRegistrationToken) -> HRESULT +}} +impl IMediaSourceAudioInputNode { + #[inline] pub fn set_playback_speed_factor(&self, value: f64) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_PlaybackSpeedFactor)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_playback_speed_factor(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_PlaybackSpeedFactor)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_position(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Position)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn seek(&self, position: foundation::TimeSpan) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).Seek)(self as *const _ as *mut _, position); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_start_time(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_StartTime)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn set_start_time(&self, value: &foundation::IReference) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_StartTime)(self as *const _ as *mut _, value as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_end_time(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_EndTime)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn set_end_time(&self, value: &foundation::IReference) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_EndTime)(self as *const _ as *mut _, value as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_loop_count(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_LoopCount)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn set_loop_count(&self, value: &foundation::IReference) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_LoopCount)(self as *const _ as *mut _, value as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_duration(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Duration)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_media_source(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_MediaSource)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn add_media_source_completed(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_MediaSourceCompleted)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_media_source_completed(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_MediaSourceCompleted)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class MediaSourceAudioInputNode: IMediaSourceAudioInputNode} +RT_ENUM! { enum MediaSourceAudioInputNodeCreationStatus: i32 { + Success (MediaSourceAudioInputNodeCreationStatus_Success) = 0, FormatNotSupported (MediaSourceAudioInputNodeCreationStatus_FormatNotSupported) = 1, NetworkError (MediaSourceAudioInputNodeCreationStatus_NetworkError) = 2, UnknownFailure (MediaSourceAudioInputNodeCreationStatus_UnknownFailure) = 3, +}} RT_ENUM! { enum QuantumSizeSelectionMode: i32 { SystemDefault (QuantumSizeSelectionMode_SystemDefault) = 0, LowestLatency (QuantumSizeSelectionMode_LowestLatency) = 1, ClosestToDesired (QuantumSizeSelectionMode_ClosestToDesired) = 2, }} @@ -8644,6 +9075,17 @@ impl IAudioStreamDescriptor2 { if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IAudioStreamDescriptor3, 1294077345, 36483, 17647, 137, 115, 47, 99, 233, 147, 243, 107); +RT_INTERFACE!{interface IAudioStreamDescriptor3(IAudioStreamDescriptor3Vtbl): IInspectable(IInspectableVtbl) [IID_IAudioStreamDescriptor3] { + fn Copy(&self, out: *mut *mut AudioStreamDescriptor) -> HRESULT +}} +impl IAudioStreamDescriptor3 { + #[inline] pub fn copy(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).Copy)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IAudioStreamDescriptorFactory, 1250348702, 19633, 17280, 142, 12, 131, 80, 75, 127, 91, 243); RT_INTERFACE!{static interface IAudioStreamDescriptorFactory(IAudioStreamDescriptorFactoryVtbl): IInspectable(IInspectableVtbl) [IID_IAudioStreamDescriptorFactory] { fn Create(&self, encodingProperties: *mut super::mediaproperties::AudioEncodingProperties, out: *mut *mut AudioStreamDescriptor) -> HRESULT @@ -9653,6 +10095,16 @@ impl IMediaBindingEventArgs2 { if hr == S_OK { Ok(()) } else { err(hr) } }} } +DEFINE_IID!(IID_IMediaBindingEventArgs3, 4176168798, 6590, 17660, 165, 237, 122, 186, 49, 80, 55, 249); +RT_INTERFACE!{interface IMediaBindingEventArgs3(IMediaBindingEventArgs3Vtbl): IInspectable(IInspectableVtbl) [IID_IMediaBindingEventArgs3] { + #[cfg(feature="windows-networking")] fn SetDownloadOperation(&self, downloadOperation: *mut super::super::networking::backgroundtransfer::DownloadOperation) -> HRESULT +}} +impl IMediaBindingEventArgs3 { + #[cfg(feature="windows-networking")] #[inline] pub fn set_download_operation(&self, downloadOperation: &super::super::networking::backgroundtransfer::DownloadOperation) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).SetDownloadOperation)(self as *const _ as *mut _, downloadOperation as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} DEFINE_IID!(IID_IMediaCue, 3352387165, 23004, 17183, 160, 238, 39, 116, 67, 35, 179, 109); RT_INTERFACE!{interface IMediaCue(IMediaCueVtbl): IInspectable(IInspectableVtbl) [IID_IMediaCue] { fn put_StartTime(&self, value: foundation::TimeSpan) -> HRESULT, @@ -9714,6 +10166,7 @@ RT_CLASS!{class MediaSource: IMediaSource2} impl RtActivatable for MediaSource {} impl RtActivatable for MediaSource {} impl RtActivatable for MediaSource {} +impl RtActivatable for MediaSource {} impl MediaSource { #[inline] pub fn create_from_adaptive_media_source(mediaSource: &super::streaming::adaptive::AdaptiveMediaSource) -> Result>> { >::get_activation_factory().create_from_adaptive_media_source(mediaSource) @@ -9745,6 +10198,9 @@ impl MediaSource { #[inline] pub fn create_from_media_frame_source(frameSource: &super::capture::frames::MediaFrameSource) -> Result>> { >::get_activation_factory().create_from_media_frame_source(frameSource) } + #[cfg(feature="windows-networking")] #[inline] pub fn create_from_download_operation(downloadOperation: &super::super::networking::backgroundtransfer::DownloadOperation) -> Result>> { + >::get_activation_factory().create_from_download_operation(downloadOperation) + } } DEFINE_CLSID!(MediaSource(&[87,105,110,100,111,119,115,46,77,101,100,105,97,46,67,111,114,101,46,77,101,100,105,97,83,111,117,114,99,101,0]) [CLSID_MediaSource]); DEFINE_IID!(IID_IMediaSource2, 783683656, 25951, 19511, 184, 19, 180, 228, 93, 250, 10, 190); @@ -9855,6 +10311,17 @@ impl IMediaSource4 { if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IMediaSource5, 857350830, 60718, 18978, 148, 200, 183, 67, 169, 43, 48, 34); +RT_INTERFACE!{interface IMediaSource5(IMediaSource5Vtbl): IInspectable(IInspectableVtbl) [IID_IMediaSource5] { + #[cfg(feature="windows-networking")] fn get_DownloadOperation(&self, out: *mut *mut super::super::networking::backgroundtransfer::DownloadOperation) -> HRESULT +}} +impl IMediaSource5 { + #[cfg(feature="windows-networking")] #[inline] pub fn get_download_operation(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_DownloadOperation)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IMediaSourceAppServiceConnection, 1642195607, 6422, 18448, 183, 244, 182, 66, 190, 130, 149, 150); RT_INTERFACE!{interface IMediaSourceAppServiceConnection(IMediaSourceAppServiceConnectionVtbl): IInspectable(IInspectableVtbl) [IID_IMediaSourceAppServiceConnection] { fn add_InitializeMediaStreamSourceRequested(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, @@ -10018,6 +10485,17 @@ impl IMediaSourceStatics3 { if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IMediaSourceStatics4, 672873468, 58634, 17448, 165, 0, 156, 78, 217, 24, 211, 240); +RT_INTERFACE!{static interface IMediaSourceStatics4(IMediaSourceStatics4Vtbl): IInspectable(IInspectableVtbl) [IID_IMediaSourceStatics4] { + #[cfg(feature="windows-networking")] fn CreateFromDownloadOperation(&self, downloadOperation: *mut super::super::networking::backgroundtransfer::DownloadOperation, out: *mut *mut MediaSource) -> HRESULT +}} +impl IMediaSourceStatics4 { + #[cfg(feature="windows-networking")] #[inline] pub fn create_from_download_operation(&self, downloadOperation: &super::super::networking::backgroundtransfer::DownloadOperation) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreateFromDownloadOperation)(self as *const _ as *mut _, downloadOperation as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} RT_ENUM! { enum MediaSourceStatus: i32 { FullySupported (MediaSourceStatus_FullySupported) = 0, Unknown (MediaSourceStatus_Unknown) = 1, }} @@ -11141,6 +11619,42 @@ DEFINE_CLSID!(SpeechCue(&[87,105,110,100,111,119,115,46,77,101,100,105,97,46,67, RT_ENUM! { enum TimedMetadataKind: i32 { Caption (TimedMetadataKind_Caption) = 0, Chapter (TimedMetadataKind_Chapter) = 1, Custom (TimedMetadataKind_Custom) = 2, Data (TimedMetadataKind_Data) = 3, Description (TimedMetadataKind_Description) = 4, Subtitle (TimedMetadataKind_Subtitle) = 5, ImageSubtitle (TimedMetadataKind_ImageSubtitle) = 6, Speech (TimedMetadataKind_Speech) = 7, }} +DEFINE_IID!(IID_ITimedMetadataStreamDescriptor, 322123455, 10602, 17982, 159, 249, 1, 205, 37, 105, 20, 8); +RT_INTERFACE!{interface ITimedMetadataStreamDescriptor(ITimedMetadataStreamDescriptorVtbl): IInspectable(IInspectableVtbl) [IID_ITimedMetadataStreamDescriptor] { + fn get_EncodingProperties(&self, out: *mut *mut super::mediaproperties::TimedMetadataEncodingProperties) -> HRESULT, + fn Copy(&self, out: *mut *mut TimedMetadataStreamDescriptor) -> HRESULT +}} +impl ITimedMetadataStreamDescriptor { + #[inline] pub fn get_encoding_properties(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_EncodingProperties)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn copy(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).Copy)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +RT_CLASS!{class TimedMetadataStreamDescriptor: IMediaStreamDescriptor} +impl RtActivatable for TimedMetadataStreamDescriptor {} +impl TimedMetadataStreamDescriptor { + #[inline] pub fn create(encodingProperties: &super::mediaproperties::TimedMetadataEncodingProperties) -> Result> { + >::get_activation_factory().create(encodingProperties) + } +} +DEFINE_CLSID!(TimedMetadataStreamDescriptor(&[87,105,110,100,111,119,115,46,77,101,100,105,97,46,67,111,114,101,46,84,105,109,101,100,77,101,116,97,100,97,116,97,83,116,114,101,97,109,68,101,115,99,114,105,112,116,111,114,0]) [CLSID_TimedMetadataStreamDescriptor]); +DEFINE_IID!(IID_ITimedMetadataStreamDescriptorFactory, 3223838256, 29538, 20473, 152, 177, 45, 253, 11, 141, 28, 174); +RT_INTERFACE!{static interface ITimedMetadataStreamDescriptorFactory(ITimedMetadataStreamDescriptorFactoryVtbl): IInspectable(IInspectableVtbl) [IID_ITimedMetadataStreamDescriptorFactory] { + fn Create(&self, encodingProperties: *mut super::mediaproperties::TimedMetadataEncodingProperties, out: *mut *mut TimedMetadataStreamDescriptor) -> HRESULT +}} +impl ITimedMetadataStreamDescriptorFactory { + #[inline] pub fn create(&self, encodingProperties: &super::mediaproperties::TimedMetadataEncodingProperties) -> Result> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, encodingProperties as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_ITimedMetadataTrack, 2657807774, 63098, 18857, 179, 48, 207, 3, 176, 233, 207, 7); RT_INTERFACE!{interface ITimedMetadataTrack(ITimedMetadataTrackVtbl): IInspectable(IInspectableVtbl) [IID_ITimedMetadataTrack] { fn add_CueEntered(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, @@ -11968,6 +12482,17 @@ impl VideoStreamDescriptor { } } DEFINE_CLSID!(VideoStreamDescriptor(&[87,105,110,100,111,119,115,46,77,101,100,105,97,46,67,111,114,101,46,86,105,100,101,111,83,116,114,101,97,109,68,101,115,99,114,105,112,116,111,114,0]) [CLSID_VideoStreamDescriptor]); +DEFINE_IID!(IID_IVideoStreamDescriptor2, 2335206928, 17726, 16520, 131, 45, 195, 111, 164, 249, 74, 243); +RT_INTERFACE!{interface IVideoStreamDescriptor2(IVideoStreamDescriptor2Vtbl): IInspectable(IInspectableVtbl) [IID_IVideoStreamDescriptor2] { + fn Copy(&self, out: *mut *mut VideoStreamDescriptor) -> HRESULT +}} +impl IVideoStreamDescriptor2 { + #[inline] pub fn copy(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).Copy)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IVideoStreamDescriptorFactory, 1229911761, 47989, 17362, 158, 94, 123, 121, 163, 175, 206, 212); RT_INTERFACE!{static interface IVideoStreamDescriptorFactory(IVideoStreamDescriptorFactoryVtbl): IInspectable(IInspectableVtbl) [IID_IVideoStreamDescriptorFactory] { fn Create(&self, encodingProperties: *mut super::mediaproperties::VideoEncodingProperties, out: *mut *mut VideoStreamDescriptor) -> HRESULT @@ -12339,6 +12864,17 @@ impl IAdvancedVideoCaptureDeviceController5 { if hr == S_OK { Ok(out) } else { err(hr) } }} } +DEFINE_IID!(IID_IAdvancedVideoCaptureDeviceController6, 3059104339, 26785, 17591, 159, 137, 181, 250, 151, 172, 12, 190); +RT_INTERFACE!{interface IAdvancedVideoCaptureDeviceController6(IAdvancedVideoCaptureDeviceController6Vtbl): IInspectable(IInspectableVtbl) [IID_IAdvancedVideoCaptureDeviceController6] { + fn get_VideoTemporalDenoisingControl(&self, out: *mut *mut VideoTemporalDenoisingControl) -> HRESULT +}} +impl IAdvancedVideoCaptureDeviceController6 { + #[inline] pub fn get_video_temporal_denoising_control(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_VideoTemporalDenoisingControl)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IAudioDeviceController, 3990135688, 31175, 20348, 144, 232, 239, 147, 75, 33, 88, 10); RT_INTERFACE!{interface IAudioDeviceController(IAudioDeviceControllerVtbl): IInspectable(IInspectableVtbl) [IID_IAudioDeviceController] { fn put_Muted(&self, value: bool) -> HRESULT, @@ -14014,6 +14550,38 @@ RT_ENUM! { enum VideoDeviceControllerGetDevicePropertyStatus: i32 { RT_ENUM! { enum VideoDeviceControllerSetDevicePropertyStatus: i32 { Success (VideoDeviceControllerSetDevicePropertyStatus_Success) = 0, UnknownFailure (VideoDeviceControllerSetDevicePropertyStatus_UnknownFailure) = 1, NotSupported (VideoDeviceControllerSetDevicePropertyStatus_NotSupported) = 2, InvalidValue (VideoDeviceControllerSetDevicePropertyStatus_InvalidValue) = 3, DeviceNotAvailable (VideoDeviceControllerSetDevicePropertyStatus_DeviceNotAvailable) = 4, NotInControl (VideoDeviceControllerSetDevicePropertyStatus_NotInControl) = 5, }} +DEFINE_IID!(IID_IVideoTemporalDenoisingControl, 2058569525, 15914, 18994, 186, 255, 67, 88, 196, 251, 221, 87); +RT_INTERFACE!{interface IVideoTemporalDenoisingControl(IVideoTemporalDenoisingControlVtbl): IInspectable(IInspectableVtbl) [IID_IVideoTemporalDenoisingControl] { + fn get_Supported(&self, out: *mut bool) -> HRESULT, + fn get_SupportedModes(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT, + fn get_Mode(&self, out: *mut VideoTemporalDenoisingMode) -> HRESULT, + fn put_Mode(&self, value: VideoTemporalDenoisingMode) -> HRESULT +}} +impl IVideoTemporalDenoisingControl { + #[inline] pub fn get_supported(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Supported)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_supported_modes(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_SupportedModes)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_mode(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Mode)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_mode(&self, value: VideoTemporalDenoisingMode) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Mode)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class VideoTemporalDenoisingControl: IVideoTemporalDenoisingControl} +RT_ENUM! { enum VideoTemporalDenoisingMode: i32 { + Off (VideoTemporalDenoisingMode_Off) = 0, On (VideoTemporalDenoisingMode_On) = 1, Auto (VideoTemporalDenoisingMode_Auto) = 2, +}} DEFINE_IID!(IID_IWhiteBalanceControl, 2015298686, 29026, 18888, 168, 249, 148, 129, 197, 101, 54, 62); RT_INTERFACE!{interface IWhiteBalanceControl(IWhiteBalanceControlVtbl): IInspectable(IInspectableVtbl) [IID_IWhiteBalanceControl] { fn get_Supported(&self, out: *mut bool) -> HRESULT, @@ -15027,6 +15595,17 @@ impl DialReceiverApp { } } DEFINE_CLSID!(DialReceiverApp(&[87,105,110,100,111,119,115,46,77,101,100,105,97,46,68,105,97,108,80,114,111,116,111,99,111,108,46,68,105,97,108,82,101,99,101,105,118,101,114,65,112,112,0]) [CLSID_DialReceiverApp]); +DEFINE_IID!(IID_IDialReceiverApp2, 1393317893, 37168, 17068, 165, 4, 25, 119, 220, 178, 234, 138); +RT_INTERFACE!{interface IDialReceiverApp2(IDialReceiverApp2Vtbl): IInspectable(IInspectableVtbl) [IID_IDialReceiverApp2] { + fn GetUniqueDeviceNameAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT +}} +impl IDialReceiverApp2 { + #[inline] pub fn get_unique_device_name_async(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetUniqueDeviceNameAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IDialReceiverAppStatics, 1394096700, 19510, 19714, 178, 138, 242, 169, 218, 56, 236, 82); RT_INTERFACE!{static interface IDialReceiverAppStatics(IDialReceiverAppStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IDialReceiverAppStatics] { fn get_Current(&self, out: *mut *mut DialReceiverApp) -> HRESULT @@ -15573,6 +16152,78 @@ impl IVideoTransformEffectDefinition { RT_CLASS!{class VideoTransformEffectDefinition: IVideoEffectDefinition} impl RtActivatable for VideoTransformEffectDefinition {} DEFINE_CLSID!(VideoTransformEffectDefinition(&[87,105,110,100,111,119,115,46,77,101,100,105,97,46,69,102,102,101,99,116,115,46,86,105,100,101,111,84,114,97,110,115,102,111,114,109,69,102,102,101,99,116,68,101,102,105,110,105,116,105,111,110,0]) [CLSID_VideoTransformEffectDefinition]); +DEFINE_IID!(IID_IVideoTransformEffectDefinition2, 4037544095, 26312, 18068, 159, 217, 17, 54, 171, 247, 68, 74); +RT_INTERFACE!{interface IVideoTransformEffectDefinition2(IVideoTransformEffectDefinition2Vtbl): IInspectable(IInspectableVtbl) [IID_IVideoTransformEffectDefinition2] { + fn get_SphericalProjection(&self, out: *mut *mut VideoTransformSphericalProjection) -> HRESULT +}} +impl IVideoTransformEffectDefinition2 { + #[inline] pub fn get_spherical_projection(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_SphericalProjection)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +DEFINE_IID!(IID_IVideoTransformSphericalProjection, 3477340656, 39922, 19513, 159, 65, 224, 34, 81, 74, 132, 104); +RT_INTERFACE!{interface IVideoTransformSphericalProjection(IVideoTransformSphericalProjectionVtbl): IInspectable(IInspectableVtbl) [IID_IVideoTransformSphericalProjection] { + fn get_IsEnabled(&self, out: *mut bool) -> HRESULT, + fn put_IsEnabled(&self, value: bool) -> HRESULT, + fn get_FrameFormat(&self, out: *mut super::mediaproperties::SphericalVideoFrameFormat) -> HRESULT, + fn put_FrameFormat(&self, value: super::mediaproperties::SphericalVideoFrameFormat) -> HRESULT, + fn get_ProjectionMode(&self, out: *mut super::playback::SphericalVideoProjectionMode) -> HRESULT, + fn put_ProjectionMode(&self, value: super::playback::SphericalVideoProjectionMode) -> HRESULT, + fn get_HorizontalFieldOfViewInDegrees(&self, out: *mut f64) -> HRESULT, + fn put_HorizontalFieldOfViewInDegrees(&self, value: f64) -> HRESULT, + fn get_ViewOrientation(&self, out: *mut foundation::numerics::Quaternion) -> HRESULT, + fn put_ViewOrientation(&self, value: foundation::numerics::Quaternion) -> HRESULT +}} +impl IVideoTransformSphericalProjection { + #[inline] pub fn get_is_enabled(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_IsEnabled)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_is_enabled(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_IsEnabled)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_frame_format(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_FrameFormat)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_frame_format(&self, value: super::mediaproperties::SphericalVideoFrameFormat) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_FrameFormat)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_projection_mode(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_ProjectionMode)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_projection_mode(&self, value: super::playback::SphericalVideoProjectionMode) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_ProjectionMode)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_horizontal_field_of_view_in_degrees(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_HorizontalFieldOfViewInDegrees)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_horizontal_field_of_view_in_degrees(&self, value: f64) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_HorizontalFieldOfViewInDegrees)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_view_orientation(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_ViewOrientation)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_view_orientation(&self, value: foundation::numerics::Quaternion) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_ViewOrientation)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class VideoTransformSphericalProjection: IVideoTransformSphericalProjection} } // Windows.Media.Effects pub mod editing { // Windows.Media.Editing use ::prelude::*; @@ -16134,12 +16785,6 @@ RT_ENUM! { enum VideoFramePrecision: i32 { NearestFrame (VideoFramePrecision_NearestFrame) = 0, NearestKeyFrame (VideoFramePrecision_NearestKeyFrame) = 1, }} } // Windows.Media.Editing -pub mod render { // Windows.Media.Render -use ::prelude::*; -RT_ENUM! { enum AudioRenderCategory: i32 { - Other (AudioRenderCategory_Other) = 0, ForegroundOnlyMedia (AudioRenderCategory_ForegroundOnlyMedia) = 1, BackgroundCapableMedia (AudioRenderCategory_BackgroundCapableMedia) = 2, Communications (AudioRenderCategory_Communications) = 3, Alerts (AudioRenderCategory_Alerts) = 4, SoundEffects (AudioRenderCategory_SoundEffects) = 5, GameEffects (AudioRenderCategory_GameEffects) = 6, GameMedia (AudioRenderCategory_GameMedia) = 7, GameChat (AudioRenderCategory_GameChat) = 8, Speech (AudioRenderCategory_Speech) = 9, Movie (AudioRenderCategory_Movie) = 10, Media (AudioRenderCategory_Media) = 11, -}} -} // Windows.Media.Render pub mod faceanalysis { // Windows.Media.FaceAnalysis use ::prelude::*; DEFINE_IID!(IID_IDetectedFace, 2181092436, 26300, 13535, 148, 16, 232, 148, 0, 25, 84, 20); @@ -19070,6 +19715,28 @@ impl IMediaPlaybackSession2 { if hr == S_OK { Ok(out) } else { err(hr) } }} } +DEFINE_IID!(IID_IMediaPlaybackSession3, 2074260506, 41954, 16479, 183, 123, 164, 129, 44, 35, 139, 102); +RT_INTERFACE!{interface IMediaPlaybackSession3(IMediaPlaybackSession3Vtbl): IInspectable(IInspectableVtbl) [IID_IMediaPlaybackSession3] { + fn get_PlaybackRotation(&self, out: *mut super::mediaproperties::MediaRotation) -> HRESULT, + fn put_PlaybackRotation(&self, value: super::mediaproperties::MediaRotation) -> HRESULT, + fn GetOutputDegradationPolicyState(&self, out: *mut *mut MediaPlaybackSessionOutputDegradationPolicyState) -> HRESULT +}} +impl IMediaPlaybackSession3 { + #[inline] pub fn get_playback_rotation(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_PlaybackRotation)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_playback_rotation(&self, value: super::mediaproperties::MediaRotation) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_PlaybackRotation)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_output_degradation_policy_state(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetOutputDegradationPolicyState)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IMediaPlaybackSessionBufferingStartedEventArgs, 3446321133, 29922, 17333, 177, 21, 118, 35, 108, 51, 121, 26); RT_INTERFACE!{interface IMediaPlaybackSessionBufferingStartedEventArgs(IMediaPlaybackSessionBufferingStartedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IMediaPlaybackSessionBufferingStartedEventArgs] { fn get_IsPlaybackInterruption(&self, out: *mut bool) -> HRESULT @@ -19082,6 +19749,21 @@ impl IMediaPlaybackSessionBufferingStartedEventArgs { }} } RT_CLASS!{class MediaPlaybackSessionBufferingStartedEventArgs: IMediaPlaybackSessionBufferingStartedEventArgs} +DEFINE_IID!(IID_IMediaPlaybackSessionOutputDegradationPolicyState, 1435398781, 63027, 18937, 150, 90, 171, 170, 29, 183, 9, 190); +RT_INTERFACE!{interface IMediaPlaybackSessionOutputDegradationPolicyState(IMediaPlaybackSessionOutputDegradationPolicyStateVtbl): IInspectable(IInspectableVtbl) [IID_IMediaPlaybackSessionOutputDegradationPolicyState] { + fn get_VideoConstrictionReason(&self, out: *mut MediaPlaybackSessionVideoConstrictionReason) -> HRESULT +}} +impl IMediaPlaybackSessionOutputDegradationPolicyState { + #[inline] pub fn get_video_constriction_reason(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_VideoConstrictionReason)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} +RT_CLASS!{class MediaPlaybackSessionOutputDegradationPolicyState: IMediaPlaybackSessionOutputDegradationPolicyState} +RT_ENUM! { enum MediaPlaybackSessionVideoConstrictionReason: i32 { + None (MediaPlaybackSessionVideoConstrictionReason_None) = 0, VirtualMachine (MediaPlaybackSessionVideoConstrictionReason_VirtualMachine) = 1, UnsupportedDisplayAdapter (MediaPlaybackSessionVideoConstrictionReason_UnsupportedDisplayAdapter) = 2, UnsignedDriver (MediaPlaybackSessionVideoConstrictionReason_UnsignedDriver) = 3, FrameServerEnabled (MediaPlaybackSessionVideoConstrictionReason_FrameServerEnabled) = 4, OutputProtectionFailed (MediaPlaybackSessionVideoConstrictionReason_OutputProtectionFailed) = 5, Unknown (MediaPlaybackSessionVideoConstrictionReason_Unknown) = 6, +}} DEFINE_IID!(IID_IMediaPlaybackSource, 4020093628, 37655, 18070, 176, 81, 43, 173, 100, 49, 119, 181); RT_INTERFACE!{interface IMediaPlaybackSource(IMediaPlaybackSourceVtbl): IInspectable(IInspectableVtbl) [IID_IMediaPlaybackSource] { @@ -19668,6 +20350,17 @@ impl IMediaPlayer6 { if hr == S_OK { Ok(out) } else { err(hr) } }} } +DEFINE_IID!(IID_IMediaPlayer7, 1562231928, 17664, 17713, 179, 244, 119, 122, 113, 73, 31, 127); +RT_INTERFACE!{interface IMediaPlayer7(IMediaPlayer7Vtbl): IInspectable(IInspectableVtbl) [IID_IMediaPlayer7] { + fn get_AudioStateMonitor(&self, out: *mut *mut super::audio::AudioStateMonitor) -> HRESULT +}} +impl IMediaPlayer7 { + #[inline] pub fn get_audio_state_monitor(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_AudioStateMonitor)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} RT_ENUM! { enum MediaPlayerAudioCategory: i32 { Other (MediaPlayerAudioCategory_Other) = 0, Communications (MediaPlayerAudioCategory_Communications) = 3, Alerts (MediaPlayerAudioCategory_Alerts) = 4, SoundEffects (MediaPlayerAudioCategory_SoundEffects) = 5, GameEffects (MediaPlayerAudioCategory_GameEffects) = 6, GameMedia (MediaPlayerAudioCategory_GameMedia) = 7, GameChat (MediaPlayerAudioCategory_GameChat) = 8, Speech (MediaPlayerAudioCategory_Speech) = 9, Movie (MediaPlayerAudioCategory_Movie) = 10, Media (MediaPlayerAudioCategory_Media) = 11, }} @@ -22384,6 +23077,12 @@ impl IPlayReadyStatics4 { } } // Windows.Media.Protection.PlayReady } // Windows.Media.Protection +pub mod render { // Windows.Media.Render +use ::prelude::*; +RT_ENUM! { enum AudioRenderCategory: i32 { + Other (AudioRenderCategory_Other) = 0, ForegroundOnlyMedia (AudioRenderCategory_ForegroundOnlyMedia) = 1, BackgroundCapableMedia (AudioRenderCategory_BackgroundCapableMedia) = 2, Communications (AudioRenderCategory_Communications) = 3, Alerts (AudioRenderCategory_Alerts) = 4, SoundEffects (AudioRenderCategory_SoundEffects) = 5, GameEffects (AudioRenderCategory_GameEffects) = 6, GameMedia (AudioRenderCategory_GameMedia) = 7, GameChat (AudioRenderCategory_GameChat) = 8, Speech (AudioRenderCategory_Speech) = 9, Movie (AudioRenderCategory_Movie) = 10, Media (AudioRenderCategory_Media) = 11, +}} +} // Windows.Media.Render pub mod speechrecognition { // Windows.Media.SpeechRecognition use ::prelude::*; DEFINE_IID!(IID_ISpeechContinuousRecognitionCompletedEventArgs, 3822086587, 58124, 24088, 66, 75, 127, 190, 129, 248, 251, 208); @@ -23115,6 +23814,12 @@ impl IInstalledVoicesStatic2 { if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } +RT_ENUM! { enum SpeechAppendedSilence: i32 { + Default (SpeechAppendedSilence_Default) = 0, Min (SpeechAppendedSilence_Min) = 1, +}} +RT_ENUM! { enum SpeechPunctuationSilence: i32 { + Default (SpeechPunctuationSilence_Default) = 0, Min (SpeechPunctuationSilence_Min) = 1, +}} DEFINE_IID!(IID_ISpeechSynthesisStream, 2212785811, 9292, 17954, 186, 11, 98, 41, 196, 208, 214, 93); RT_INTERFACE!{interface ISpeechSynthesisStream(ISpeechSynthesisStreamVtbl): IInspectable(IInspectableVtbl) [IID_ISpeechSynthesisStream] { fn get_Markers(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT @@ -23248,6 +23953,33 @@ impl ISpeechSynthesizerOptions2 { if hr == S_OK { Ok(()) } else { err(hr) } }} } +DEFINE_IID!(IID_ISpeechSynthesizerOptions3, 1075763319, 36908, 18452, 165, 130, 165, 208, 192, 118, 159, 168); +RT_INTERFACE!{interface ISpeechSynthesizerOptions3(ISpeechSynthesizerOptions3Vtbl): IInspectable(IInspectableVtbl) [IID_ISpeechSynthesizerOptions3] { + fn get_AppendedSilence(&self, out: *mut SpeechAppendedSilence) -> HRESULT, + fn put_AppendedSilence(&self, value: SpeechAppendedSilence) -> HRESULT, + fn get_PunctuationSilence(&self, out: *mut SpeechPunctuationSilence) -> HRESULT, + fn put_PunctuationSilence(&self, value: SpeechPunctuationSilence) -> HRESULT +}} +impl ISpeechSynthesizerOptions3 { + #[inline] pub fn get_appended_silence(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_AppendedSilence)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_appended_silence(&self, value: SpeechAppendedSilence) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_AppendedSilence)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_punctuation_silence(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_PunctuationSilence)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_punctuation_silence(&self, value: SpeechPunctuationSilence) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_PunctuationSilence)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} RT_ENUM! { enum VoiceGender: i32 { Male (VoiceGender_Male) = 0, Female (VoiceGender_Female) = 1, }} @@ -23523,6 +24255,17 @@ impl IAudioEncodingProperties2 { if hr == S_OK { Ok(out) } else { err(hr) } }} } +DEFINE_IID!(IID_IAudioEncodingProperties3, 2271216449, 29836, 20365, 176, 253, 16, 202, 240, 143, 240, 135); +RT_INTERFACE!{interface IAudioEncodingProperties3(IAudioEncodingProperties3Vtbl): IInspectable(IInspectableVtbl) [IID_IAudioEncodingProperties3] { + fn Copy(&self, out: *mut *mut AudioEncodingProperties) -> HRESULT +}} +impl IAudioEncodingProperties3 { + #[inline] pub fn copy(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).Copy)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IAudioEncodingPropertiesStatics, 212677420, 60393, 17703, 179, 109, 228, 42, 19, 207, 56, 219); RT_INTERFACE!{static interface IAudioEncodingPropertiesStatics(IAudioEncodingPropertiesStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IAudioEncodingPropertiesStatics] { fn CreateAac(&self, sampleRate: u32, channelCount: u32, bitrate: u32, out: *mut *mut AudioEncodingProperties) -> HRESULT, @@ -23601,6 +24344,17 @@ RT_INTERFACE!{interface IContainerEncodingProperties(IContainerEncodingPropertie RT_CLASS!{class ContainerEncodingProperties: IContainerEncodingProperties} impl RtActivatable for ContainerEncodingProperties {} DEFINE_CLSID!(ContainerEncodingProperties(&[87,105,110,100,111,119,115,46,77,101,100,105,97,46,77,101,100,105,97,80,114,111,112,101,114,116,105,101,115,46,67,111,110,116,97,105,110,101,114,69,110,99,111,100,105,110,103,80,114,111,112,101,114,116,105,101,115,0]) [CLSID_ContainerEncodingProperties]); +DEFINE_IID!(IID_IContainerEncodingProperties2, 2993864745, 44582, 18457, 186, 173, 173, 122, 73, 176, 168, 118); +RT_INTERFACE!{interface IContainerEncodingProperties2(IContainerEncodingProperties2Vtbl): IInspectable(IInspectableVtbl) [IID_IContainerEncodingProperties2] { + fn Copy(&self, out: *mut *mut ContainerEncodingProperties) -> HRESULT +}} +impl IContainerEncodingProperties2 { + #[inline] pub fn copy(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).Copy)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} RT_CLASS!{static class H264ProfileIds} impl RtActivatable for H264ProfileIds {} impl H264ProfileIds { @@ -23750,6 +24504,17 @@ impl ImageEncodingProperties { } } DEFINE_CLSID!(ImageEncodingProperties(&[87,105,110,100,111,119,115,46,77,101,100,105,97,46,77,101,100,105,97,80,114,111,112,101,114,116,105,101,115,46,73,109,97,103,101,69,110,99,111,100,105,110,103,80,114,111,112,101,114,116,105,101,115,0]) [CLSID_ImageEncodingProperties]); +DEFINE_IID!(IID_IImageEncodingProperties2, 3360989919, 51491, 18075, 172, 142, 106, 159, 60, 28, 217, 227); +RT_INTERFACE!{interface IImageEncodingProperties2(IImageEncodingProperties2Vtbl): IInspectable(IInspectableVtbl) [IID_IImageEncodingProperties2] { + fn Copy(&self, out: *mut *mut ImageEncodingProperties) -> HRESULT +}} +impl IImageEncodingProperties2 { + #[inline] pub fn copy(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).Copy)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IImageEncodingPropertiesStatics, 628910300, 35737, 17310, 170, 89, 145, 58, 54, 22, 18, 151); RT_INTERFACE!{static interface IImageEncodingPropertiesStatics(IImageEncodingPropertiesStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IImageEncodingPropertiesStatics] { fn CreateJpeg(&self, out: *mut *mut ImageEncodingProperties) -> HRESULT, @@ -23899,6 +24664,22 @@ impl IMediaEncodingProfile2 { if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IMediaEncodingProfile3, 3127819912, 30064, 20073, 172, 207, 86, 17, 173, 1, 95, 136); +RT_INTERFACE!{interface IMediaEncodingProfile3(IMediaEncodingProfile3Vtbl): IInspectable(IInspectableVtbl) [IID_IMediaEncodingProfile3] { + fn SetTimedMetadataTracks(&self, value: *mut foundation::collections::IIterable) -> HRESULT, + fn GetTimedMetadataTracks(&self, out: *mut *mut foundation::collections::IVector) -> HRESULT +}} +impl IMediaEncodingProfile3 { + #[inline] pub fn set_timed_metadata_tracks(&self, value: &foundation::collections::IIterable) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).SetTimedMetadataTracks)(self as *const _ as *mut _, value as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_timed_metadata_tracks(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetTimedMetadataTracks)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IMediaEncodingProfileStatics, 427767084, 11998, 19013, 168, 150, 129, 122, 72, 84, 248, 254); RT_INTERFACE!{static interface IMediaEncodingProfileStatics(IMediaEncodingProfileStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IMediaEncodingProfileStatics] { fn CreateM4a(&self, quality: AudioEncodingQuality, out: *mut *mut MediaEncodingProfile) -> HRESULT, @@ -24018,6 +24799,7 @@ RT_CLASS!{static class MediaEncodingSubtypes} impl RtActivatable for MediaEncodingSubtypes {} impl RtActivatable for MediaEncodingSubtypes {} impl RtActivatable for MediaEncodingSubtypes {} +impl RtActivatable for MediaEncodingSubtypes {} impl MediaEncodingSubtypes { #[inline] pub fn get_aac() -> Result { >::get_activation_factory().get_aac() @@ -24157,6 +24939,9 @@ impl MediaEncodingSubtypes { #[inline] pub fn get_flac() -> Result { >::get_activation_factory().get_flac() } + #[inline] pub fn get_p010() -> Result { + >::get_activation_factory().get_p010() + } } DEFINE_CLSID!(MediaEncodingSubtypes(&[87,105,110,100,111,119,115,46,77,101,100,105,97,46,77,101,100,105,97,80,114,111,112,101,114,116,105,101,115,46,77,101,100,105,97,69,110,99,111,100,105,110,103,83,117,98,116,121,112,101,115,0]) [CLSID_MediaEncodingSubtypes]); DEFINE_IID!(IID_IMediaEncodingSubtypesStatics, 934696974, 41329, 17508, 186, 90, 83, 24, 158, 72, 193, 200); @@ -24450,11 +25235,22 @@ impl IMediaEncodingSubtypesStatics3 { if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IMediaEncodingSubtypesStatics4, 3723289994, 14665, 17988, 138, 44, 89, 239, 2, 198, 66, 250); +RT_INTERFACE!{static interface IMediaEncodingSubtypesStatics4(IMediaEncodingSubtypesStatics4Vtbl): IInspectable(IInspectableVtbl) [IID_IMediaEncodingSubtypesStatics4] { + fn get_P010(&self, out: *mut HSTRING) -> HRESULT +}} +impl IMediaEncodingSubtypesStatics4 { + #[inline] pub fn get_p010(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_P010)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} +} RT_ENUM! { enum MediaMirroringOptions: u32 { None (MediaMirroringOptions_None) = 0, Horizontal (MediaMirroringOptions_Horizontal) = 1, Vertical (MediaMirroringOptions_Vertical) = 2, }} RT_ENUM! { enum MediaPixelFormat: i32 { - Nv12 (MediaPixelFormat_Nv12) = 0, Bgra8 (MediaPixelFormat_Bgra8) = 1, + Nv12 (MediaPixelFormat_Nv12) = 0, Bgra8 (MediaPixelFormat_Bgra8) = 1, P010 (MediaPixelFormat_P010) = 2, }} RT_CLASS!{class MediaPropertySet: foundation::collections::IMap} impl RtActivatable for MediaPropertySet {} @@ -24554,6 +25350,31 @@ RT_ENUM! { enum SphericalVideoFrameFormat: i32 { RT_ENUM! { enum StereoscopicVideoPackingMode: i32 { None (StereoscopicVideoPackingMode_None) = 0, SideBySide (StereoscopicVideoPackingMode_SideBySide) = 1, TopBottom (StereoscopicVideoPackingMode_TopBottom) = 2, }} +DEFINE_IID!(IID_ITimedMetadataEncodingProperties, 1372401875, 54928, 19706, 151, 244, 74, 57, 142, 157, 180, 32); +RT_INTERFACE!{interface ITimedMetadataEncodingProperties(ITimedMetadataEncodingPropertiesVtbl): IInspectable(IInspectableVtbl) [IID_ITimedMetadataEncodingProperties] { + fn SetFormatUserData(&self, valueSize: u32, value: *mut u8) -> HRESULT, + fn GetFormatUserData(&self, valueSize: *mut u32, value: *mut *mut u8) -> HRESULT, + fn Copy(&self, out: *mut *mut TimedMetadataEncodingProperties) -> HRESULT +}} +impl ITimedMetadataEncodingProperties { + #[inline] pub fn set_format_user_data(&self, value: &[u8]) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).SetFormatUserData)(self as *const _ as *mut _, value.len() as u32, value.as_ptr() as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_format_user_data(&self) -> Result> { unsafe { + let mut valueSize = 0; let mut value = null_mut(); + let hr = ((*self.lpVtbl).GetFormatUserData)(self as *const _ as *mut _, &mut valueSize, &mut value); + if hr == S_OK { Ok(ComArray::from_raw(valueSize, value)) } else { err(hr) } + }} + #[inline] pub fn copy(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).Copy)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +RT_CLASS!{class TimedMetadataEncodingProperties: IMediaEncodingProperties} +impl RtActivatable for TimedMetadataEncodingProperties {} +DEFINE_CLSID!(TimedMetadataEncodingProperties(&[87,105,110,100,111,119,115,46,77,101,100,105,97,46,77,101,100,105,97,80,114,111,112,101,114,116,105,101,115,46,84,105,109,101,100,77,101,116,97,100,97,116,97,69,110,99,111,100,105,110,103,80,114,111,112,101,114,116,105,101,115,0]) [CLSID_TimedMetadataEncodingProperties]); DEFINE_IID!(IID_IVideoEncodingProperties, 1995336858, 14274, 20266, 136, 10, 18, 130, 187, 180, 55, 61); RT_INTERFACE!{interface IVideoEncodingProperties(IVideoEncodingPropertiesVtbl): IInspectable(IInspectableVtbl) [IID_IVideoEncodingProperties] { fn put_Bitrate(&self, value: u32) -> HRESULT, @@ -24672,6 +25493,17 @@ impl IVideoEncodingProperties4 { if hr == S_OK { Ok(out) } else { err(hr) } }} } +DEFINE_IID!(IID_IVideoEncodingProperties5, 1230571535, 10031, 20174, 164, 223, 192, 204, 219, 51, 216, 64); +RT_INTERFACE!{interface IVideoEncodingProperties5(IVideoEncodingProperties5Vtbl): IInspectable(IInspectableVtbl) [IID_IVideoEncodingProperties5] { + fn Copy(&self, out: *mut *mut VideoEncodingProperties) -> HRESULT +}} +impl IVideoEncodingProperties5 { + #[inline] pub fn copy(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).Copy)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IVideoEncodingPropertiesStatics, 1021398340, 7621, 17371, 159, 56, 235, 235, 249, 1, 82, 203); RT_INTERFACE!{static interface IVideoEncodingPropertiesStatics(IVideoEncodingPropertiesStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IVideoEncodingPropertiesStatics] { fn CreateH264(&self, out: *mut *mut VideoEncodingProperties) -> HRESULT, @@ -25246,6 +26078,23 @@ impl IAdaptiveMediaSourceDiagnosticAvailableEventArgs2 { if hr == S_OK { Ok(out) } else { err(hr) } }} } +DEFINE_IID!(IID_IAdaptiveMediaSourceDiagnosticAvailableEventArgs3, 3278179541, 56043, 16643, 132, 218, 104, 118, 154, 213, 19, 255); +RT_INTERFACE!{interface IAdaptiveMediaSourceDiagnosticAvailableEventArgs3(IAdaptiveMediaSourceDiagnosticAvailableEventArgs3Vtbl): IInspectable(IInspectableVtbl) [IID_IAdaptiveMediaSourceDiagnosticAvailableEventArgs3] { + fn get_ResourceDuration(&self, out: *mut *mut foundation::IReference) -> HRESULT, + fn get_ResourceContentType(&self, out: *mut HSTRING) -> HRESULT +}} +impl IAdaptiveMediaSourceDiagnosticAvailableEventArgs3 { + #[inline] pub fn get_resource_duration(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ResourceDuration)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_resource_content_type(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ResourceContentType)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IAdaptiveMediaSourceDiagnostics, 2602888808, 38446, 17548, 174, 191, 178, 155, 86, 9, 142, 35); RT_INTERFACE!{interface IAdaptiveMediaSourceDiagnostics(IAdaptiveMediaSourceDiagnosticsVtbl): IInspectable(IInspectableVtbl) [IID_IAdaptiveMediaSourceDiagnostics] { fn add_DiagnosticAvailable(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, @@ -25357,6 +26206,23 @@ impl IAdaptiveMediaSourceDownloadCompletedEventArgs2 { if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IAdaptiveMediaSourceDownloadCompletedEventArgs3, 260738001, 37810, 18374, 186, 220, 139, 226, 200, 247, 246, 232); +RT_INTERFACE!{interface IAdaptiveMediaSourceDownloadCompletedEventArgs3(IAdaptiveMediaSourceDownloadCompletedEventArgs3Vtbl): IInspectable(IInspectableVtbl) [IID_IAdaptiveMediaSourceDownloadCompletedEventArgs3] { + fn get_ResourceDuration(&self, out: *mut *mut foundation::IReference) -> HRESULT, + fn get_ResourceContentType(&self, out: *mut HSTRING) -> HRESULT +}} +impl IAdaptiveMediaSourceDownloadCompletedEventArgs3 { + #[inline] pub fn get_resource_duration(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ResourceDuration)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_resource_content_type(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ResourceContentType)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IAdaptiveMediaSourceDownloadFailedEventArgs, 930320456, 62635, 16548, 177, 53, 198, 223, 216, 189, 127, 241); RT_INTERFACE!{interface IAdaptiveMediaSourceDownloadFailedEventArgs(IAdaptiveMediaSourceDownloadFailedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IAdaptiveMediaSourceDownloadFailedEventArgs] { fn get_ResourceType(&self, out: *mut AdaptiveMediaSourceResourceType) -> HRESULT, @@ -25422,6 +26288,23 @@ impl IAdaptiveMediaSourceDownloadFailedEventArgs2 { if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IAdaptiveMediaSourceDownloadFailedEventArgs3, 3493152073, 4402, 18960, 145, 90, 194, 33, 27, 91, 148, 9); +RT_INTERFACE!{interface IAdaptiveMediaSourceDownloadFailedEventArgs3(IAdaptiveMediaSourceDownloadFailedEventArgs3Vtbl): IInspectable(IInspectableVtbl) [IID_IAdaptiveMediaSourceDownloadFailedEventArgs3] { + fn get_ResourceDuration(&self, out: *mut *mut foundation::IReference) -> HRESULT, + fn get_ResourceContentType(&self, out: *mut HSTRING) -> HRESULT +}} +impl IAdaptiveMediaSourceDownloadFailedEventArgs3 { + #[inline] pub fn get_resource_duration(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ResourceDuration)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_resource_content_type(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ResourceContentType)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IAdaptiveMediaSourceDownloadRequestedDeferral, 96898916, 64032, 19901, 152, 33, 75, 244, 201, 191, 119, 171); RT_INTERFACE!{interface IAdaptiveMediaSourceDownloadRequestedDeferral(IAdaptiveMediaSourceDownloadRequestedDeferralVtbl): IInspectable(IInspectableVtbl) [IID_IAdaptiveMediaSourceDownloadRequestedDeferral] { fn Complete(&self) -> HRESULT @@ -25492,6 +26375,23 @@ impl IAdaptiveMediaSourceDownloadRequestedEventArgs2 { if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IAdaptiveMediaSourceDownloadRequestedEventArgs3, 859590909, 20322, 17537, 171, 68, 30, 71, 176, 87, 66, 37); +RT_INTERFACE!{interface IAdaptiveMediaSourceDownloadRequestedEventArgs3(IAdaptiveMediaSourceDownloadRequestedEventArgs3Vtbl): IInspectable(IInspectableVtbl) [IID_IAdaptiveMediaSourceDownloadRequestedEventArgs3] { + fn get_ResourceDuration(&self, out: *mut *mut foundation::IReference) -> HRESULT, + fn get_ResourceContentType(&self, out: *mut HSTRING) -> HRESULT +}} +impl IAdaptiveMediaSourceDownloadRequestedEventArgs3 { + #[inline] pub fn get_resource_duration(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ResourceDuration)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_resource_content_type(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ResourceContentType)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IAdaptiveMediaSourceDownloadResult, 4105165939, 48366, 19050, 159, 10, 254, 196, 30, 35, 57, 176); RT_INTERFACE!{interface IAdaptiveMediaSourceDownloadResult(IAdaptiveMediaSourceDownloadResultVtbl): IInspectable(IInspectableVtbl) [IID_IAdaptiveMediaSourceDownloadResult] { fn get_ResourceUri(&self, out: *mut *mut foundation::Uri) -> HRESULT, diff --git a/src/rt/gen/windows/mod.rs b/src/rt/gen/windows/mod.rs index 698e809..db1f7f6 100644 --- a/src/rt/gen/windows/mod.rs +++ b/src/rt/gen/windows/mod.rs @@ -1,3 +1,4 @@ +#[cfg(feature="windows-ai")] pub mod ai; // Windows.AI #[cfg(feature="windows-applicationmodel")] pub mod applicationmodel; // Windows.ApplicationModel #[cfg(feature="windows-data")] pub mod data; // Windows.Data #[cfg(feature="windows-devices")] pub mod devices; // Windows.Devices diff --git a/src/rt/gen/windows/networking.rs b/src/rt/gen/windows/networking.rs index 42332a2..46aad13 100644 --- a/src/rt/gen/windows/networking.rs +++ b/src/rt/gen/windows/networking.rs @@ -156,6 +156,506 @@ use ::prelude::*; RT_ENUM! { enum DataClasses: u32 { None (DataClasses_None) = 0, Gprs (DataClasses_Gprs) = 1, Edge (DataClasses_Edge) = 2, Umts (DataClasses_Umts) = 4, Hsdpa (DataClasses_Hsdpa) = 8, Hsupa (DataClasses_Hsupa) = 16, LteAdvanced (DataClasses_LteAdvanced) = 32, Cdma1xRtt (DataClasses_Cdma1xRtt) = 65536, Cdma1xEvdo (DataClasses_Cdma1xEvdo) = 131072, Cdma1xEvdoRevA (DataClasses_Cdma1xEvdoRevA) = 262144, Cdma1xEvdv (DataClasses_Cdma1xEvdv) = 524288, Cdma3xRtt (DataClasses_Cdma3xRtt) = 1048576, Cdma1xEvdoRevB (DataClasses_Cdma1xEvdoRevB) = 2097152, CdmaUmb (DataClasses_CdmaUmb) = 4194304, Custom (DataClasses_Custom) = 2147483648, }} +DEFINE_IID!(IID_IESim, 1869508134, 61731, 17277, 140, 237, 220, 29, 43, 192, 195, 169); +RT_INTERFACE!{interface IESim(IESimVtbl): IInspectable(IInspectableVtbl) [IID_IESim] { + fn get_AvailableMemoryInBytes(&self, out: *mut *mut foundation::IReference) -> HRESULT, + fn get_Eid(&self, out: *mut HSTRING) -> HRESULT, + fn get_FirmwareVersion(&self, out: *mut HSTRING) -> HRESULT, + fn get_MobileBroadbandModemDeviceId(&self, out: *mut HSTRING) -> HRESULT, + fn get_Policy(&self, out: *mut *mut ESimPolicy) -> HRESULT, + fn get_State(&self, out: *mut ESimState) -> HRESULT, + fn GetProfiles(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT, + fn DeleteProfileAsync(&self, profileId: HSTRING, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn DownloadProfileMetadataAsync(&self, activationCode: HSTRING, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn ResetAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn add_ProfileChanged(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_ProfileChanged(&self, token: foundation::EventRegistrationToken) -> HRESULT +}} +impl IESim { + #[inline] pub fn get_available_memory_in_bytes(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_AvailableMemoryInBytes)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_eid(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Eid)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_firmware_version(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_FirmwareVersion)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_mobile_broadband_modem_device_id(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_MobileBroadbandModemDeviceId)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_policy(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Policy)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_state(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_State)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_profiles(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetProfiles)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn delete_profile_async(&self, profileId: &HStringArg) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).DeleteProfileAsync)(self as *const _ as *mut _, profileId.get(), &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn download_profile_metadata_async(&self, activationCode: &HStringArg) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).DownloadProfileMetadataAsync)(self as *const _ as *mut _, activationCode.get(), &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn reset_async(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).ResetAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn add_profile_changed(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_ProfileChanged)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_profile_changed(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_ProfileChanged)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class ESim: IESim} +DEFINE_IID!(IID_IESimAddedEventArgs, 951913048, 19802, 19720, 141, 167, 231, 62, 255, 54, 157, 221); +RT_INTERFACE!{interface IESimAddedEventArgs(IESimAddedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IESimAddedEventArgs] { + fn get_ESim(&self, out: *mut *mut ESim) -> HRESULT +}} +impl IESimAddedEventArgs { + #[inline] pub fn get_esim(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ESim)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +RT_CLASS!{class ESimAddedEventArgs: IESimAddedEventArgs} +RT_ENUM! { enum ESimAuthenticationPreference: i32 { + OnEntry (ESimAuthenticationPreference_OnEntry) = 0, OnAction (ESimAuthenticationPreference_OnAction) = 1, Never (ESimAuthenticationPreference_Never) = 2, +}} +DEFINE_IID!(IID_IESimDownloadProfileMetadataResult, 3290647966, 23254, 17005, 141, 0, 68, 52, 244, 73, 175, 236); +RT_INTERFACE!{interface IESimDownloadProfileMetadataResult(IESimDownloadProfileMetadataResultVtbl): IInspectable(IInspectableVtbl) [IID_IESimDownloadProfileMetadataResult] { + fn get_Result(&self, out: *mut *mut ESimOperationResult) -> HRESULT, + fn get_ProfileMetadata(&self, out: *mut *mut ESimProfileMetadata) -> HRESULT +}} +impl IESimDownloadProfileMetadataResult { + #[inline] pub fn get_result(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Result)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_profile_metadata(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ProfileMetadata)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +RT_CLASS!{class ESimDownloadProfileMetadataResult: IESimDownloadProfileMetadataResult} +RT_CLASS!{static class ESimManager} +impl RtActivatable for ESimManager {} +impl ESimManager { + #[inline] pub fn get_service_info() -> Result>> { + >::get_activation_factory().get_service_info() + } + #[inline] pub fn try_create_esim_watcher() -> Result>> { + >::get_activation_factory().try_create_esim_watcher() + } + #[inline] pub fn add_service_info_changed(handler: &foundation::EventHandler) -> Result { + >::get_activation_factory().add_service_info_changed(handler) + } + #[inline] pub fn remove_service_info_changed(token: foundation::EventRegistrationToken) -> Result<()> { + >::get_activation_factory().remove_service_info_changed(token) + } +} +DEFINE_CLSID!(ESimManager(&[87,105,110,100,111,119,115,46,78,101,116,119,111,114,107,105,110,103,46,78,101,116,119,111,114,107,79,112,101,114,97,116,111,114,115,46,69,83,105,109,77,97,110,97,103,101,114,0]) [CLSID_ESimManager]); +DEFINE_IID!(IID_IESimManagerStatics, 200944652, 57224, 17969, 191, 4, 193, 46, 40, 27, 57, 98); +RT_INTERFACE!{static interface IESimManagerStatics(IESimManagerStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IESimManagerStatics] { + fn get_ServiceInfo(&self, out: *mut *mut ESimServiceInfo) -> HRESULT, + fn TryCreateESimWatcher(&self, out: *mut *mut ESimWatcher) -> HRESULT, + fn add_ServiceInfoChanged(&self, handler: *mut foundation::EventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_ServiceInfoChanged(&self, token: foundation::EventRegistrationToken) -> HRESULT +}} +impl IESimManagerStatics { + #[inline] pub fn get_service_info(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ServiceInfo)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn try_create_esim_watcher(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).TryCreateESimWatcher)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn add_service_info_changed(&self, handler: &foundation::EventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_ServiceInfoChanged)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_service_info_changed(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_ServiceInfoChanged)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +DEFINE_IID!(IID_IESimOperationResult, 2793104305, 12443, 20087, 158, 126, 205, 147, 241, 221, 199, 185); +RT_INTERFACE!{interface IESimOperationResult(IESimOperationResultVtbl): IInspectable(IInspectableVtbl) [IID_IESimOperationResult] { + fn get_Status(&self, out: *mut ESimOperationStatus) -> HRESULT +}} +impl IESimOperationResult { + #[inline] pub fn get_status(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Status)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} +RT_CLASS!{class ESimOperationResult: IESimOperationResult} +RT_ENUM! { enum ESimOperationStatus: i32 { + Success (ESimOperationStatus_Success) = 0, NotAuthorized (ESimOperationStatus_NotAuthorized) = 1, NotFound (ESimOperationStatus_NotFound) = 2, PolicyViolation (ESimOperationStatus_PolicyViolation) = 3, InsufficientSpaceOnCard (ESimOperationStatus_InsufficientSpaceOnCard) = 4, ServerFailure (ESimOperationStatus_ServerFailure) = 5, ServerNotReachable (ESimOperationStatus_ServerNotReachable) = 6, TimeoutWaitingForUserConsent (ESimOperationStatus_TimeoutWaitingForUserConsent) = 7, IncorrectConfirmationCode (ESimOperationStatus_IncorrectConfirmationCode) = 8, ConfirmationCodeMaxRetriesExceeded (ESimOperationStatus_ConfirmationCodeMaxRetriesExceeded) = 9, CardRemoved (ESimOperationStatus_CardRemoved) = 10, CardBusy (ESimOperationStatus_CardBusy) = 11, Other (ESimOperationStatus_Other) = 12, +}} +DEFINE_IID!(IID_IESimPolicy, 1105312157, 53118, 17173, 136, 43, 111, 30, 116, 176, 211, 143); +RT_INTERFACE!{interface IESimPolicy(IESimPolicyVtbl): IInspectable(IInspectableVtbl) [IID_IESimPolicy] { + fn get_ShouldEnableManagingUi(&self, out: *mut bool) -> HRESULT +}} +impl IESimPolicy { + #[inline] pub fn get_should_enable_managing_ui(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_ShouldEnableManagingUi)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} +RT_CLASS!{class ESimPolicy: IESimPolicy} +DEFINE_IID!(IID_IESimProfile, 3994974336, 1705, 16423, 180, 248, 221, 178, 61, 120, 16, 224); +RT_INTERFACE!{interface IESimProfile(IESimProfileVtbl): IInspectable(IInspectableVtbl) [IID_IESimProfile] { + fn get_Class(&self, out: *mut ESimProfileClass) -> HRESULT, + fn get_Nickname(&self, out: *mut HSTRING) -> HRESULT, + fn get_Policy(&self, out: *mut *mut ESimProfilePolicy) -> HRESULT, + fn get_Id(&self, out: *mut HSTRING) -> HRESULT, + #[cfg(not(feature="windows-storage"))] fn __Dummy4(&self) -> (), + #[cfg(feature="windows-storage")] fn get_ProviderIcon(&self, out: *mut *mut super::super::storage::streams::IRandomAccessStreamReference) -> HRESULT, + fn get_ProviderId(&self, out: *mut HSTRING) -> HRESULT, + fn get_ProviderName(&self, out: *mut HSTRING) -> HRESULT, + fn get_State(&self, out: *mut ESimProfileState) -> HRESULT, + fn DisableAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn EnableAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn SetNicknameAsync(&self, newNickname: HSTRING, out: *mut *mut foundation::IAsyncOperation) -> HRESULT +}} +impl IESimProfile { + #[inline] pub fn get_class(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Class)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_nickname(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Nickname)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_policy(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Policy)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_id(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Id)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[cfg(feature="windows-storage")] #[inline] pub fn get_provider_icon(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ProviderIcon)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_provider_id(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ProviderId)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_provider_name(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ProviderName)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_state(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_State)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn disable_async(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).DisableAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn enable_async(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).EnableAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn set_nickname_async(&self, newNickname: &HStringArg) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).SetNicknameAsync)(self as *const _ as *mut _, newNickname.get(), &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} +} +RT_CLASS!{class ESimProfile: IESimProfile} +RT_ENUM! { enum ESimProfileClass: i32 { + Operational (ESimProfileClass_Operational) = 0, Test (ESimProfileClass_Test) = 1, Provisioning (ESimProfileClass_Provisioning) = 2, +}} +RT_STRUCT! { struct ESimProfileInstallProgress { + TotalSizeInBytes: i32, InstalledSizeInBytes: i32, +}} +DEFINE_IID!(IID_IESimProfileMetadata, 3978658591, 37083, 18829, 167, 180, 235, 206, 128, 125, 60, 35); +RT_INTERFACE!{interface IESimProfileMetadata(IESimProfileMetadataVtbl): IInspectable(IInspectableVtbl) [IID_IESimProfileMetadata] { + fn get_IsConfirmationCodeRequired(&self, out: *mut bool) -> HRESULT, + fn get_Policy(&self, out: *mut *mut ESimProfilePolicy) -> HRESULT, + fn get_Id(&self, out: *mut HSTRING) -> HRESULT, + #[cfg(not(feature="windows-storage"))] fn __Dummy3(&self) -> (), + #[cfg(feature="windows-storage")] fn get_ProviderIcon(&self, out: *mut *mut super::super::storage::streams::IRandomAccessStreamReference) -> HRESULT, + fn get_ProviderId(&self, out: *mut HSTRING) -> HRESULT, + fn get_ProviderName(&self, out: *mut HSTRING) -> HRESULT, + fn get_State(&self, out: *mut ESimProfileMetadataState) -> HRESULT, + fn DenyInstallAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn ConfirmInstallAsync(&self, out: *mut *mut foundation::IAsyncOperationWithProgress) -> HRESULT, + fn ConfirmInstallWithConfirmationCodeAsync(&self, confirmationCode: HSTRING, out: *mut *mut foundation::IAsyncOperationWithProgress) -> HRESULT, + fn PostponeInstallAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn add_StateChanged(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_StateChanged(&self, token: foundation::EventRegistrationToken) -> HRESULT +}} +impl IESimProfileMetadata { + #[inline] pub fn get_is_confirmation_code_required(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_IsConfirmationCodeRequired)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_policy(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Policy)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_id(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Id)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[cfg(feature="windows-storage")] #[inline] pub fn get_provider_icon(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ProviderIcon)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_provider_id(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ProviderId)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_provider_name(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ProviderName)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_state(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_State)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn deny_install_async(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).DenyInstallAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn confirm_install_async(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).ConfirmInstallAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn confirm_install_with_confirmation_code_async(&self, confirmationCode: &HStringArg) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).ConfirmInstallWithConfirmationCodeAsync)(self as *const _ as *mut _, confirmationCode.get(), &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn postpone_install_async(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).PostponeInstallAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn add_state_changed(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_StateChanged)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_state_changed(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_StateChanged)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class ESimProfileMetadata: IESimProfileMetadata} +RT_ENUM! { enum ESimProfileMetadataState: i32 { + Unknown (ESimProfileMetadataState_Unknown) = 0, WaitingForInstall (ESimProfileMetadataState_WaitingForInstall) = 1, Downloading (ESimProfileMetadataState_Downloading) = 2, Installing (ESimProfileMetadataState_Installing) = 3, Expired (ESimProfileMetadataState_Expired) = 4, RejectingDownload (ESimProfileMetadataState_RejectingDownload) = 5, NoLongerAvailable (ESimProfileMetadataState_NoLongerAvailable) = 6, DeniedByPolicy (ESimProfileMetadataState_DeniedByPolicy) = 7, +}} +DEFINE_IID!(IID_IESimProfilePolicy, 3873247005, 40028, 18117, 162, 137, 169, 72, 153, 155, 240, 98); +RT_INTERFACE!{interface IESimProfilePolicy(IESimProfilePolicyVtbl): IInspectable(IInspectableVtbl) [IID_IESimProfilePolicy] { + fn get_CanDelete(&self, out: *mut bool) -> HRESULT, + fn get_CanDisable(&self, out: *mut bool) -> HRESULT, + fn get_IsManagedByEnterprise(&self, out: *mut bool) -> HRESULT +}} +impl IESimProfilePolicy { + #[inline] pub fn get_can_delete(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_CanDelete)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_can_disable(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_CanDisable)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_is_managed_by_enterprise(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_IsManagedByEnterprise)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} +RT_CLASS!{class ESimProfilePolicy: IESimProfilePolicy} +RT_ENUM! { enum ESimProfileState: i32 { + Unknown (ESimProfileState_Unknown) = 0, Disabled (ESimProfileState_Disabled) = 1, Enabled (ESimProfileState_Enabled) = 2, Deleted (ESimProfileState_Deleted) = 3, +}} +DEFINE_IID!(IID_IESimRemovedEventArgs, 3737462651, 12249, 20185, 131, 118, 217, 181, 228, 18, 120, 163); +RT_INTERFACE!{interface IESimRemovedEventArgs(IESimRemovedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IESimRemovedEventArgs] { + fn get_ESim(&self, out: *mut *mut ESim) -> HRESULT +}} +impl IESimRemovedEventArgs { + #[inline] pub fn get_esim(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ESim)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +RT_CLASS!{class ESimRemovedEventArgs: IESimRemovedEventArgs} +DEFINE_IID!(IID_IESimServiceInfo, 4050299855, 32601, 19025, 132, 148, 189, 137, 213, 255, 80, 238); +RT_INTERFACE!{interface IESimServiceInfo(IESimServiceInfoVtbl): IInspectable(IInspectableVtbl) [IID_IESimServiceInfo] { + fn get_AuthenticationPreference(&self, out: *mut ESimAuthenticationPreference) -> HRESULT, + fn get_IsESimUiEnabled(&self, out: *mut bool) -> HRESULT +}} +impl IESimServiceInfo { + #[inline] pub fn get_authentication_preference(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_AuthenticationPreference)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_is_esim_ui_enabled(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_IsESimUiEnabled)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} +RT_CLASS!{class ESimServiceInfo: IESimServiceInfo} +RT_ENUM! { enum ESimState: i32 { + Unknown (ESimState_Unknown) = 0, Idle (ESimState_Idle) = 1, Removed (ESimState_Removed) = 2, Busy (ESimState_Busy) = 3, +}} +DEFINE_IID!(IID_IESimUpdatedEventArgs, 1276271852, 20621, 19336, 131, 203, 104, 190, 248, 22, 141, 18); +RT_INTERFACE!{interface IESimUpdatedEventArgs(IESimUpdatedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IESimUpdatedEventArgs] { + fn get_ESim(&self, out: *mut *mut ESim) -> HRESULT +}} +impl IESimUpdatedEventArgs { + #[inline] pub fn get_esim(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ESim)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +RT_CLASS!{class ESimUpdatedEventArgs: IESimUpdatedEventArgs} +DEFINE_IID!(IID_IESimWatcher, 3254275307, 41613, 20415, 151, 113, 110, 49, 184, 28, 207, 34); +RT_INTERFACE!{interface IESimWatcher(IESimWatcherVtbl): IInspectable(IInspectableVtbl) [IID_IESimWatcher] { + fn get_Status(&self, out: *mut ESimWatcherStatus) -> HRESULT, + fn Start(&self) -> HRESULT, + fn Stop(&self) -> HRESULT, + fn add_Added(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_Added(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn add_EnumerationCompleted(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_EnumerationCompleted(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn add_Removed(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_Removed(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn add_Stopped(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_Stopped(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn add_Updated(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_Updated(&self, token: foundation::EventRegistrationToken) -> HRESULT +}} +impl IESimWatcher { + #[inline] pub fn get_status(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Status)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn start(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).Start)(self as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn stop(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).Stop)(self as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_added(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_Added)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_added(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_Added)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_enumeration_completed(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_EnumerationCompleted)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_enumeration_completed(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_EnumerationCompleted)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_removed(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_Removed)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_removed(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_Removed)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_stopped(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_Stopped)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_stopped(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_Stopped)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_updated(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_Updated)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_updated(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_Updated)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class ESimWatcher: IESimWatcher} +RT_ENUM! { enum ESimWatcherStatus: i32 { + Created (ESimWatcherStatus_Created) = 0, Started (ESimWatcherStatus_Started) = 1, EnumerationCompleted (ESimWatcherStatus_EnumerationCompleted) = 2, Stopping (ESimWatcherStatus_Stopping) = 3, Stopped (ESimWatcherStatus_Stopped) = 4, +}} DEFINE_IID!(IID_IHotspotAuthenticationContext, 3881224081, 4099, 19941, 131, 199, 222, 97, 216, 136, 49, 208); RT_INTERFACE!{interface IHotspotAuthenticationContext(IHotspotAuthenticationContextVtbl): IInspectable(IInspectableVtbl) [IID_IHotspotAuthenticationContext] { fn get_WirelessNetworkId(&self, outSize: *mut u32, out: *mut *mut u8) -> HRESULT, @@ -682,7 +1182,25 @@ impl IMobileBroadbandAntennaSar { if hr == S_OK { Ok(out) } else { err(hr) } }} } -RT_CLASS!{class MobileBroadbandAntennaSar: IMobileBroadbandAntennaSar} +RT_CLASS!{class MobileBroadbandAntennaSar: IMobileBroadbandAntennaSar} +impl RtActivatable for MobileBroadbandAntennaSar {} +impl MobileBroadbandAntennaSar { + #[inline] pub fn create_with_index(antennaIndex: i32, sarBackoffIndex: i32) -> Result> { + >::get_activation_factory().create_with_index(antennaIndex, sarBackoffIndex) + } +} +DEFINE_CLSID!(MobileBroadbandAntennaSar(&[87,105,110,100,111,119,115,46,78,101,116,119,111,114,107,105,110,103,46,78,101,116,119,111,114,107,79,112,101,114,97,116,111,114,115,46,77,111,98,105,108,101,66,114,111,97,100,98,97,110,100,65,110,116,101,110,110,97,83,97,114,0]) [CLSID_MobileBroadbandAntennaSar]); +DEFINE_IID!(IID_IMobileBroadbandAntennaSarFactory, 2837321494, 49229, 18977, 134, 152, 20, 89, 220, 103, 44, 110); +RT_INTERFACE!{static interface IMobileBroadbandAntennaSarFactory(IMobileBroadbandAntennaSarFactoryVtbl): IInspectable(IInspectableVtbl) [IID_IMobileBroadbandAntennaSarFactory] { + fn CreateWithIndex(&self, antennaIndex: i32, sarBackoffIndex: i32, out: *mut *mut MobileBroadbandAntennaSar) -> HRESULT +}} +impl IMobileBroadbandAntennaSarFactory { + #[inline] pub fn create_with_index(&self, antennaIndex: i32, sarBackoffIndex: i32) -> Result> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreateWithIndex)(self as *const _ as *mut _, antennaIndex, sarBackoffIndex, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IMobileBroadbandCellCdma, 100774836, 16666, 20270, 130, 135, 118, 245, 101, 12, 96, 205); RT_INTERFACE!{interface IMobileBroadbandCellCdma(IMobileBroadbandCellCdmaVtbl): IInspectable(IInspectableVtbl) [IID_IMobileBroadbandCellCdma] { fn get_BaseStationId(&self, out: *mut *mut foundation::IReference) -> HRESULT, @@ -1411,6 +1929,34 @@ impl IMobileBroadbandModem2 { if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IMobileBroadbandModem3, 3925788394, 12084, 17794, 145, 2, 195, 20, 210, 168, 126, 236); +RT_INTERFACE!{interface IMobileBroadbandModem3(IMobileBroadbandModem3Vtbl): IInspectable(IInspectableVtbl) [IID_IMobileBroadbandModem3] { + fn TryGetPcoAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn get_IsInEmergencyCallMode(&self, out: *mut bool) -> HRESULT, + fn add_IsInEmergencyCallModeChanged(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_IsInEmergencyCallModeChanged(&self, token: foundation::EventRegistrationToken) -> HRESULT +}} +impl IMobileBroadbandModem3 { + #[inline] pub fn try_get_pco_async(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).TryGetPcoAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_is_in_emergency_call_mode(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_IsInEmergencyCallMode)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn add_is_in_emergency_call_mode_changed(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_IsInEmergencyCallModeChanged)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_is_in_emergency_call_mode_changed(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_IsInEmergencyCallModeChanged)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} DEFINE_IID!(IID_IMobileBroadbandModemConfiguration, 4242552227, 54989, 17184, 185, 130, 190, 157, 62, 199, 137, 15); RT_INTERFACE!{interface IMobileBroadbandModemConfiguration(IMobileBroadbandModemConfigurationVtbl): IInspectable(IInspectableVtbl) [IID_IMobileBroadbandModemConfiguration] { fn get_Uicc(&self, out: *mut *mut MobileBroadbandUicc) -> HRESULT, @@ -1446,6 +1992,52 @@ impl IMobileBroadbandModemConfiguration2 { if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IMobileBroadbandModemIsolation, 3043069932, 58977, 17200, 155, 180, 52, 128, 33, 46, 195, 84); +RT_INTERFACE!{interface IMobileBroadbandModemIsolation(IMobileBroadbandModemIsolationVtbl): IInspectable(IInspectableVtbl) [IID_IMobileBroadbandModemIsolation] { + fn AddAllowedHost(&self, host: *mut super::HostName) -> HRESULT, + fn AddAllowedHostRange(&self, first: *mut super::HostName, last: *mut super::HostName) -> HRESULT, + fn ApplyConfigurationAsync(&self, out: *mut *mut foundation::IAsyncAction) -> HRESULT, + fn ClearConfigurationAsync(&self, out: *mut *mut foundation::IAsyncAction) -> HRESULT +}} +impl IMobileBroadbandModemIsolation { + #[inline] pub fn add_allowed_host(&self, host: &super::HostName) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).AddAllowedHost)(self as *const _ as *mut _, host as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_allowed_host_range(&self, first: &super::HostName, last: &super::HostName) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).AddAllowedHostRange)(self as *const _ as *mut _, first as *const _ as *mut _, last as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn apply_configuration_async(&self) -> Result> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).ApplyConfigurationAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn clear_configuration_async(&self) -> Result> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).ClearConfigurationAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} +} +RT_CLASS!{class MobileBroadbandModemIsolation: IMobileBroadbandModemIsolation} +impl RtActivatable for MobileBroadbandModemIsolation {} +impl MobileBroadbandModemIsolation { + #[inline] pub fn create(modemDeviceId: &HStringArg, ruleGroupId: &HStringArg) -> Result> { + >::get_activation_factory().create(modemDeviceId, ruleGroupId) + } +} +DEFINE_CLSID!(MobileBroadbandModemIsolation(&[87,105,110,100,111,119,115,46,78,101,116,119,111,114,107,105,110,103,46,78,101,116,119,111,114,107,79,112,101,114,97,116,111,114,115,46,77,111,98,105,108,101,66,114,111,97,100,98,97,110,100,77,111,100,101,109,73,115,111,108,97,116,105,111,110,0]) [CLSID_MobileBroadbandModemIsolation]); +DEFINE_IID!(IID_IMobileBroadbandModemIsolationFactory, 567798872, 49841, 19503, 160, 48, 114, 130, 10, 36, 236, 217); +RT_INTERFACE!{static interface IMobileBroadbandModemIsolationFactory(IMobileBroadbandModemIsolationFactoryVtbl): IInspectable(IInspectableVtbl) [IID_IMobileBroadbandModemIsolationFactory] { + fn Create(&self, modemDeviceId: HSTRING, ruleGroupId: HSTRING, out: *mut *mut MobileBroadbandModemIsolation) -> HRESULT +}} +impl IMobileBroadbandModemIsolationFactory { + #[inline] pub fn create(&self, modemDeviceId: &HStringArg, ruleGroupId: &HStringArg) -> Result> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, modemDeviceId.get(), ruleGroupId.get(), &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IMobileBroadbandModemStatics, 4187936311, 55025, 19064, 140, 188, 100, 33, 166, 80, 99, 200); RT_INTERFACE!{static interface IMobileBroadbandModemStatics(IMobileBroadbandModemStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IMobileBroadbandModemStatics] { fn GetDeviceSelector(&self, out: *mut HSTRING) -> HRESULT, @@ -1595,6 +2187,43 @@ impl IMobileBroadbandNetworkRegistrationStateChangeTriggerDetails { }} } RT_CLASS!{class MobileBroadbandNetworkRegistrationStateChangeTriggerDetails: IMobileBroadbandNetworkRegistrationStateChangeTriggerDetails} +DEFINE_IID!(IID_IMobileBroadbandPco, 3571776702, 58275, 17349, 168, 123, 108, 134, 210, 41, 215, 250); +RT_INTERFACE!{interface IMobileBroadbandPco(IMobileBroadbandPcoVtbl): IInspectable(IInspectableVtbl) [IID_IMobileBroadbandPco] { + #[cfg(not(feature="windows-storage"))] fn __Dummy0(&self) -> (), + #[cfg(feature="windows-storage")] fn get_Data(&self, out: *mut *mut super::super::storage::streams::IBuffer) -> HRESULT, + fn get_IsComplete(&self, out: *mut bool) -> HRESULT, + fn get_DeviceId(&self, out: *mut HSTRING) -> HRESULT +}} +impl IMobileBroadbandPco { + #[cfg(feature="windows-storage")] #[inline] pub fn get_data(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Data)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_is_complete(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_IsComplete)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_device_id(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_DeviceId)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} +} +RT_CLASS!{class MobileBroadbandPco: IMobileBroadbandPco} +DEFINE_IID!(IID_IMobileBroadbandPcoDataChangeTriggerDetails, 641683732, 25824, 17555, 144, 155, 45, 20, 160, 25, 98, 177); +RT_INTERFACE!{interface IMobileBroadbandPcoDataChangeTriggerDetails(IMobileBroadbandPcoDataChangeTriggerDetailsVtbl): IInspectable(IInspectableVtbl) [IID_IMobileBroadbandPcoDataChangeTriggerDetails] { + fn get_UpdatedData(&self, out: *mut *mut MobileBroadbandPco) -> HRESULT +}} +impl IMobileBroadbandPcoDataChangeTriggerDetails { + #[inline] pub fn get_updated_data(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_UpdatedData)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +RT_CLASS!{class MobileBroadbandPcoDataChangeTriggerDetails: IMobileBroadbandPcoDataChangeTriggerDetails} DEFINE_IID!(IID_IMobileBroadbandPin, 3865171721, 59257, 17855, 130, 129, 117, 50, 61, 249, 227, 33); RT_INTERFACE!{interface IMobileBroadbandPin(IMobileBroadbandPinVtbl): IInspectable(IInspectableVtbl) [IID_IMobileBroadbandPin] { fn get_Type(&self, out: *mut MobileBroadbandPinType) -> HRESULT, @@ -2025,6 +2654,21 @@ RT_CLASS!{class MobileBroadbandUiccAppsResult: IMobileBroadbandUiccAppsResult} RT_ENUM! { enum NetworkDeviceStatus: i32 { DeviceNotReady (NetworkDeviceStatus_DeviceNotReady) = 0, DeviceReady (NetworkDeviceStatus_DeviceReady) = 1, SimNotInserted (NetworkDeviceStatus_SimNotInserted) = 2, BadSim (NetworkDeviceStatus_BadSim) = 3, DeviceHardwareFailure (NetworkDeviceStatus_DeviceHardwareFailure) = 4, AccountNotActivated (NetworkDeviceStatus_AccountNotActivated) = 5, DeviceLocked (NetworkDeviceStatus_DeviceLocked) = 6, DeviceBlocked (NetworkDeviceStatus_DeviceBlocked) = 7, }} +RT_ENUM! { enum NetworkOperatorDataUsageNotificationKind: i32 { + DataUsageProgress (NetworkOperatorDataUsageNotificationKind_DataUsageProgress) = 0, +}} +DEFINE_IID!(IID_INetworkOperatorDataUsageTriggerDetails, 1357058669, 42085, 20203, 147, 23, 40, 161, 103, 99, 12, 234); +RT_INTERFACE!{interface INetworkOperatorDataUsageTriggerDetails(INetworkOperatorDataUsageTriggerDetailsVtbl): IInspectable(IInspectableVtbl) [IID_INetworkOperatorDataUsageTriggerDetails] { + fn get_NotificationKind(&self, out: *mut NetworkOperatorDataUsageNotificationKind) -> HRESULT +}} +impl INetworkOperatorDataUsageTriggerDetails { + #[inline] pub fn get_notification_kind(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_NotificationKind)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} +RT_CLASS!{class NetworkOperatorDataUsageTriggerDetails: INetworkOperatorDataUsageTriggerDetails} RT_ENUM! { enum NetworkOperatorEventMessageType: i32 { Gsm (NetworkOperatorEventMessageType_Gsm) = 0, Cdma (NetworkOperatorEventMessageType_Cdma) = 1, Ussd (NetworkOperatorEventMessageType_Ussd) = 2, DataPlanThresholdReached (NetworkOperatorEventMessageType_DataPlanThresholdReached) = 3, DataPlanReset (NetworkOperatorEventMessageType_DataPlanReset) = 4, DataPlanDeleted (NetworkOperatorEventMessageType_DataPlanDeleted) = 5, ProfileConnected (NetworkOperatorEventMessageType_ProfileConnected) = 6, ProfileDisconnected (NetworkOperatorEventMessageType_ProfileDisconnected) = 7, RegisteredRoaming (NetworkOperatorEventMessageType_RegisteredRoaming) = 8, RegisteredHome (NetworkOperatorEventMessageType_RegisteredHome) = 9, TetheringEntitlementCheck (NetworkOperatorEventMessageType_TetheringEntitlementCheck) = 10, TetheringOperationalStateChanged (NetworkOperatorEventMessageType_TetheringOperationalStateChanged) = 11, TetheringNumberOfClientsChanged (NetworkOperatorEventMessageType_TetheringNumberOfClientsChanged) = 12, }} @@ -2354,6 +2998,28 @@ impl IProvisioningAgentStaticMethods { RT_ENUM! { enum TetheringCapability: i32 { Enabled (TetheringCapability_Enabled) = 0, DisabledByGroupPolicy (TetheringCapability_DisabledByGroupPolicy) = 1, DisabledByHardwareLimitation (TetheringCapability_DisabledByHardwareLimitation) = 2, DisabledByOperator (TetheringCapability_DisabledByOperator) = 3, DisabledBySku (TetheringCapability_DisabledBySku) = 4, DisabledByRequiredAppNotInstalled (TetheringCapability_DisabledByRequiredAppNotInstalled) = 5, DisabledDueToUnknownCause (TetheringCapability_DisabledDueToUnknownCause) = 6, DisabledBySystemCapability (TetheringCapability_DisabledBySystemCapability) = 7, }} +DEFINE_IID!(IID_ITetheringEntitlementCheckTriggerDetails, 63331997, 22822, 16883, 169, 78, 181, 9, 38, 252, 66, 27); +RT_INTERFACE!{interface ITetheringEntitlementCheckTriggerDetails(ITetheringEntitlementCheckTriggerDetailsVtbl): IInspectable(IInspectableVtbl) [IID_ITetheringEntitlementCheckTriggerDetails] { + fn get_NetworkAccountId(&self, out: *mut HSTRING) -> HRESULT, + fn AllowTethering(&self) -> HRESULT, + fn DenyTethering(&self, entitlementFailureReason: HSTRING) -> HRESULT +}} +impl ITetheringEntitlementCheckTriggerDetails { + #[inline] pub fn get_network_account_id(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_NetworkAccountId)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn allow_tethering(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).AllowTethering)(self as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn deny_tethering(&self, entitlementFailureReason: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).DenyTethering)(self as *const _ as *mut _, entitlementFailureReason.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class TetheringEntitlementCheckTriggerDetails: ITetheringEntitlementCheckTriggerDetails} RT_ENUM! { enum TetheringOperationalState: i32 { Unknown (TetheringOperationalState_Unknown) = 0, On (TetheringOperationalState_On) = 1, Off (TetheringOperationalState_Off) = 2, InTransition (TetheringOperationalState_InTransition) = 3, }} @@ -2607,6 +3273,22 @@ impl ICellularApnContext { RT_CLASS!{class CellularApnContext: ICellularApnContext} impl RtActivatable for CellularApnContext {} DEFINE_CLSID!(CellularApnContext(&[87,105,110,100,111,119,115,46,78,101,116,119,111,114,107,105,110,103,46,67,111,110,110,101,99,116,105,118,105,116,121,46,67,101,108,108,117,108,97,114,65,112,110,67,111,110,116,101,120,116,0]) [CLSID_CellularApnContext]); +DEFINE_IID!(IID_ICellularApnContext2, 1991306010, 44105, 17232, 177, 229, 220, 71, 99, 188, 105, 199); +RT_INTERFACE!{interface ICellularApnContext2(ICellularApnContext2Vtbl): IInspectable(IInspectableVtbl) [IID_ICellularApnContext2] { + fn get_ProfileName(&self, out: *mut HSTRING) -> HRESULT, + fn put_ProfileName(&self, value: HSTRING) -> HRESULT +}} +impl ICellularApnContext2 { + #[inline] pub fn get_profile_name(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ProfileName)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn set_profile_name(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_ProfileName)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} DEFINE_IID!(IID_IConnectionCost, 3134707753, 13334, 19216, 162, 2, 186, 192, 176, 117, 189, 174); RT_INTERFACE!{interface IConnectionCost(IConnectionCostVtbl): IInspectable(IInspectableVtbl) [IID_IConnectionCost] { fn get_NetworkCostType(&self, out: *mut NetworkCostType) -> HRESULT, @@ -2896,6 +3578,22 @@ impl IConnectionProfileFilter2 { if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IConnectionProfileFilter3, 178915776, 20500, 17532, 136, 9, 174, 228, 203, 10, 249, 74); +RT_INTERFACE!{interface IConnectionProfileFilter3(IConnectionProfileFilter3Vtbl): IInspectable(IInspectableVtbl) [IID_IConnectionProfileFilter3] { + fn put_PurposeGuid(&self, value: *mut foundation::IReference) -> HRESULT, + fn get_PurposeGuid(&self, out: *mut *mut foundation::IReference) -> HRESULT +}} +impl IConnectionProfileFilter3 { + #[inline] pub fn set_purpose_guid(&self, value: &foundation::IReference) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_PurposeGuid)(self as *const _ as *mut _, value as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_purpose_guid(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_PurposeGuid)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IConnectionSession, 4287651148, 63547, 16816, 138, 12, 20, 98, 217, 197, 107, 115); RT_INTERFACE!{interface IConnectionSession(IConnectionSessionVtbl): IInspectable(IInspectableVtbl) [IID_IConnectionSession] { fn get_ConnectionProfile(&self, out: *mut *mut ConnectionProfile) -> HRESULT @@ -3522,9 +4220,29 @@ impl IWwanConnectionProfileDetails { }} } RT_CLASS!{class WwanConnectionProfileDetails: IWwanConnectionProfileDetails} +DEFINE_IID!(IID_IWwanConnectionProfileDetails2, 2054508254, 41453, 18610, 142, 146, 180, 96, 3, 61, 82, 226); +RT_INTERFACE!{interface IWwanConnectionProfileDetails2(IWwanConnectionProfileDetails2Vtbl): IInspectable(IInspectableVtbl) [IID_IWwanConnectionProfileDetails2] { + fn get_IPKind(&self, out: *mut WwanNetworkIPKind) -> HRESULT, + fn get_PurposeGuids(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT +}} +impl IWwanConnectionProfileDetails2 { + #[inline] pub fn get_ipkind(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_IPKind)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_purpose_guids(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_PurposeGuids)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} RT_ENUM! { enum WwanDataClass: u32 { None (WwanDataClass_None) = 0, Gprs (WwanDataClass_Gprs) = 1, Edge (WwanDataClass_Edge) = 2, Umts (WwanDataClass_Umts) = 4, Hsdpa (WwanDataClass_Hsdpa) = 8, Hsupa (WwanDataClass_Hsupa) = 16, LteAdvanced (WwanDataClass_LteAdvanced) = 32, Cdma1xRtt (WwanDataClass_Cdma1xRtt) = 65536, Cdma1xEvdo (WwanDataClass_Cdma1xEvdo) = 131072, Cdma1xEvdoRevA (WwanDataClass_Cdma1xEvdoRevA) = 262144, Cdma1xEvdv (WwanDataClass_Cdma1xEvdv) = 524288, Cdma3xRtt (WwanDataClass_Cdma3xRtt) = 1048576, Cdma1xEvdoRevB (WwanDataClass_Cdma1xEvdoRevB) = 2097152, CdmaUmb (WwanDataClass_CdmaUmb) = 4194304, Custom (WwanDataClass_Custom) = 2147483648, }} +RT_ENUM! { enum WwanNetworkIPKind: i32 { + None (WwanNetworkIPKind_None) = 0, Ipv4 (WwanNetworkIPKind_Ipv4) = 1, Ipv6 (WwanNetworkIPKind_Ipv6) = 2, Ipv4v6 (WwanNetworkIPKind_Ipv4v6) = 3, Ipv4v6v4Xlat (WwanNetworkIPKind_Ipv4v6v4Xlat) = 4, +}} RT_ENUM! { enum WwanNetworkRegistrationState: i32 { None (WwanNetworkRegistrationState_None) = 0, Deregistered (WwanNetworkRegistrationState_Deregistered) = 1, Searching (WwanNetworkRegistrationState_Searching) = 2, Home (WwanNetworkRegistrationState_Home) = 3, Roaming (WwanNetworkRegistrationState_Roaming) = 4, Partner (WwanNetworkRegistrationState_Partner) = 5, Denied (WwanNetworkRegistrationState_Denied) = 6, }} @@ -4377,6 +5095,16 @@ impl IDownloadOperation3 { if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IDownloadOperation4, 215658228, 36079, 16458, 150, 109, 240, 88, 64, 11, 237, 128); +RT_INTERFACE!{interface IDownloadOperation4(IDownloadOperation4Vtbl): IInspectable(IInspectableVtbl) [IID_IDownloadOperation4] { + fn MakeCurrentInTransferGroup(&self) -> HRESULT +}} +impl IDownloadOperation4 { + #[inline] pub fn make_current_in_transfer_group(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).MakeCurrentInTransferGroup)(self as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} DEFINE_IID!(IID_IResponseInformation, 4173044242, 63251, 18322, 139, 104, 217, 210, 151, 249, 29, 46); RT_INTERFACE!{interface IResponseInformation(IResponseInformationVtbl): IInspectable(IInspectableVtbl) [IID_IResponseInformation] { fn get_IsResumable(&self, out: *mut bool) -> HRESULT, @@ -4461,6 +5189,16 @@ impl IUploadOperation2 { if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IUploadOperation3, 1120480419, 56889, 17734, 188, 98, 55, 116, 180, 41, 77, 227); +RT_INTERFACE!{interface IUploadOperation3(IUploadOperation3Vtbl): IInspectable(IInspectableVtbl) [IID_IUploadOperation3] { + fn MakeCurrentInTransferGroup(&self) -> HRESULT +}} +impl IUploadOperation3 { + #[inline] pub fn make_current_in_transfer_group(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).MakeCurrentInTransferGroup)(self as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} } // Windows.Networking.BackgroundTransfer pub mod proximity { // Windows.Networking.Proximity use ::prelude::*; @@ -5762,6 +6500,23 @@ impl IMessageWebSocket2 { if hr == S_OK { Ok(()) } else { err(hr) } }} } +DEFINE_IID!(IID_IMessageWebSocket3, 1507450619, 29103, 17225, 132, 135, 145, 31, 207, 104, 21, 151); +RT_INTERFACE!{interface IMessageWebSocket3(IMessageWebSocket3Vtbl): IInspectable(IInspectableVtbl) [IID_IMessageWebSocket3] { + #[cfg(feature="windows-storage")] fn SendNonfinalFrameAsync(&self, data: *mut super::super::storage::streams::IBuffer, out: *mut *mut foundation::IAsyncOperationWithProgress) -> HRESULT, + #[cfg(feature="windows-storage")] fn SendFinalFrameAsync(&self, data: *mut super::super::storage::streams::IBuffer, out: *mut *mut foundation::IAsyncOperationWithProgress) -> HRESULT +}} +impl IMessageWebSocket3 { + #[cfg(feature="windows-storage")] #[inline] pub fn send_nonfinal_frame_async(&self, data: &super::super::storage::streams::IBuffer) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).SendNonfinalFrameAsync)(self as *const _ as *mut _, data as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[cfg(feature="windows-storage")] #[inline] pub fn send_final_frame_async(&self, data: &super::super::storage::streams::IBuffer) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).SendFinalFrameAsync)(self as *const _ as *mut _, data as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IMessageWebSocketControl, 2165848202, 50729, 20234, 128, 251, 129, 252, 5, 83, 136, 98); RT_INTERFACE!{interface IMessageWebSocketControl(IMessageWebSocketControlVtbl): IInspectable(IInspectableVtbl) [IID_IMessageWebSocketControl] { fn get_MaxMessageSize(&self, out: *mut u32) -> HRESULT, @@ -5876,6 +6631,165 @@ RT_ENUM! { enum MessageWebSocketReceiveMode: i32 { RT_STRUCT! { struct RoundTripTimeStatistics { Variance: u32, Max: u32, Min: u32, Sum: u32, }} +DEFINE_IID!(IID_IServerMessageWebSocket, 3819737664, 33083, 24317, 126, 17, 174, 35, 5, 252, 119, 241); +RT_INTERFACE!{interface IServerMessageWebSocket(IServerMessageWebSocketVtbl): IInspectable(IInspectableVtbl) [IID_IServerMessageWebSocket] { + fn add_MessageReceived(&self, value: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_MessageReceived(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn get_Control(&self, out: *mut *mut ServerMessageWebSocketControl) -> HRESULT, + fn get_Information(&self, out: *mut *mut ServerMessageWebSocketInformation) -> HRESULT, + #[cfg(not(feature="windows-storage"))] fn __Dummy4(&self) -> (), + #[cfg(feature="windows-storage")] fn get_OutputStream(&self, out: *mut *mut super::super::storage::streams::IOutputStream) -> HRESULT, + fn add_Closed(&self, value: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_Closed(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn CloseWithStatus(&self, code: u16, reason: HSTRING) -> HRESULT +}} +impl IServerMessageWebSocket { + #[inline] pub fn add_message_received(&self, value: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_MessageReceived)(self as *const _ as *mut _, value as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_message_received(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_MessageReceived)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_control(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Control)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_information(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Information)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[cfg(feature="windows-storage")] #[inline] pub fn get_output_stream(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_OutputStream)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn add_closed(&self, value: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_Closed)(self as *const _ as *mut _, value as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_closed(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_Closed)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn close_with_status(&self, code: u16, reason: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).CloseWithStatus)(self as *const _ as *mut _, code, reason.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class ServerMessageWebSocket: IServerMessageWebSocket} +DEFINE_IID!(IID_IServerMessageWebSocketControl, 1774383185, 7199, 22650, 69, 25, 33, 129, 97, 1, 146, 183); +RT_INTERFACE!{interface IServerMessageWebSocketControl(IServerMessageWebSocketControlVtbl): IInspectable(IInspectableVtbl) [IID_IServerMessageWebSocketControl] { + fn get_MessageType(&self, out: *mut SocketMessageType) -> HRESULT, + fn put_MessageType(&self, value: SocketMessageType) -> HRESULT +}} +impl IServerMessageWebSocketControl { + #[inline] pub fn get_message_type(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_MessageType)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_message_type(&self, value: SocketMessageType) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_MessageType)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class ServerMessageWebSocketControl: IServerMessageWebSocketControl} +DEFINE_IID!(IID_IServerMessageWebSocketInformation, 4231181407, 17480, 21765, 108, 201, 9, 175, 168, 145, 95, 93); +RT_INTERFACE!{interface IServerMessageWebSocketInformation(IServerMessageWebSocketInformationVtbl): IInspectable(IInspectableVtbl) [IID_IServerMessageWebSocketInformation] { + fn get_BandwidthStatistics(&self, out: *mut BandwidthStatistics) -> HRESULT, + fn get_Protocol(&self, out: *mut HSTRING) -> HRESULT, + fn get_LocalAddress(&self, out: *mut *mut super::HostName) -> HRESULT +}} +impl IServerMessageWebSocketInformation { + #[inline] pub fn get_bandwidth_statistics(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_BandwidthStatistics)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_protocol(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Protocol)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_local_address(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_LocalAddress)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +RT_CLASS!{class ServerMessageWebSocketInformation: IServerMessageWebSocketInformation} +DEFINE_IID!(IID_IServerStreamWebSocket, 753753023, 29942, 21988, 121, 223, 145, 50, 104, 13, 254, 232); +RT_INTERFACE!{interface IServerStreamWebSocket(IServerStreamWebSocketVtbl): IInspectable(IInspectableVtbl) [IID_IServerStreamWebSocket] { + fn get_Information(&self, out: *mut *mut ServerStreamWebSocketInformation) -> HRESULT, + #[cfg(not(feature="windows-storage"))] fn __Dummy1(&self) -> (), + #[cfg(feature="windows-storage")] fn get_InputStream(&self, out: *mut *mut super::super::storage::streams::IInputStream) -> HRESULT, + #[cfg(not(feature="windows-storage"))] fn __Dummy2(&self) -> (), + #[cfg(feature="windows-storage")] fn get_OutputStream(&self, out: *mut *mut super::super::storage::streams::IOutputStream) -> HRESULT, + fn add_Closed(&self, value: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_Closed(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn CloseWithStatus(&self, code: u16, reason: HSTRING) -> HRESULT +}} +impl IServerStreamWebSocket { + #[inline] pub fn get_information(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Information)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[cfg(feature="windows-storage")] #[inline] pub fn get_input_stream(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_InputStream)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[cfg(feature="windows-storage")] #[inline] pub fn get_output_stream(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_OutputStream)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn add_closed(&self, value: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_Closed)(self as *const _ as *mut _, value as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_closed(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_Closed)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn close_with_status(&self, code: u16, reason: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).CloseWithStatus)(self as *const _ as *mut _, code, reason.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class ServerStreamWebSocket: IServerStreamWebSocket} +DEFINE_IID!(IID_IServerStreamWebSocketInformation, 4231181407, 17480, 21765, 108, 201, 9, 171, 168, 145, 95, 93); +RT_INTERFACE!{interface IServerStreamWebSocketInformation(IServerStreamWebSocketInformationVtbl): IInspectable(IInspectableVtbl) [IID_IServerStreamWebSocketInformation] { + fn get_BandwidthStatistics(&self, out: *mut BandwidthStatistics) -> HRESULT, + fn get_Protocol(&self, out: *mut HSTRING) -> HRESULT, + fn get_LocalAddress(&self, out: *mut *mut super::HostName) -> HRESULT +}} +impl IServerStreamWebSocketInformation { + #[inline] pub fn get_bandwidth_statistics(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_BandwidthStatistics)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_protocol(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Protocol)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_local_address(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_LocalAddress)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +RT_CLASS!{class ServerStreamWebSocketInformation: IServerStreamWebSocketInformation} RT_ENUM! { enum SocketActivityConnectedStandbyAction: i32 { DoNotWake (SocketActivityConnectedStandbyAction_DoNotWake) = 0, Wake (SocketActivityConnectedStandbyAction_Wake) = 1, }} @@ -7118,6 +8032,43 @@ impl IVpnChannel2 { if hr == S_OK { Ok(()) } else { err(hr) } }} } +DEFINE_IID!(IID_IVpnChannel4, 3609620190, 10551, 16797, 149, 112, 72, 106, 235, 184, 24, 3); +RT_INTERFACE!{interface IVpnChannel4(IVpnChannel4Vtbl): IInspectable(IInspectableVtbl) [IID_IVpnChannel4] { + fn AddAndAssociateTransport(&self, transport: *mut IInspectable, context: *mut IInspectable) -> HRESULT, + fn StartWithMultipleTransports(&self, assignedClientIpv4Addresses: *mut foundation::collections::IIterable, assignedClientIpv6Addresses: *mut foundation::collections::IIterable, vpninterfaceId: *mut VpnInterfaceId, assignedRoutes: *mut VpnRouteAssignment, assignedNamespace: *mut VpnDomainNameAssignment, mtuSize: u32, maxFrameSize: u32, reserved: bool, transports: *mut foundation::collections::IIterable, assignedTrafficFilters: *mut VpnTrafficFilterAssignment) -> HRESULT, + fn ReplaceAndAssociateTransport(&self, transport: *mut IInspectable, context: *mut IInspectable) -> HRESULT, + fn StartReconnectingTransport(&self, transport: *mut IInspectable, context: *mut IInspectable) -> HRESULT, + fn GetSlotTypeForTransportContext(&self, context: *mut IInspectable, out: *mut super::sockets::ControlChannelTriggerStatus) -> HRESULT, + fn get_CurrentRequestTransportContext(&self, out: *mut *mut IInspectable) -> HRESULT +}} +impl IVpnChannel4 { + #[inline] pub fn add_and_associate_transport(&self, transport: &IInspectable, context: &IInspectable) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).AddAndAssociateTransport)(self as *const _ as *mut _, transport as *const _ as *mut _, context as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn start_with_multiple_transports(&self, assignedClientIpv4Addresses: &foundation::collections::IIterable, assignedClientIpv6Addresses: &foundation::collections::IIterable, vpninterfaceId: &VpnInterfaceId, assignedRoutes: &VpnRouteAssignment, assignedNamespace: &VpnDomainNameAssignment, mtuSize: u32, maxFrameSize: u32, reserved: bool, transports: &foundation::collections::IIterable, assignedTrafficFilters: &VpnTrafficFilterAssignment) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).StartWithMultipleTransports)(self as *const _ as *mut _, assignedClientIpv4Addresses as *const _ as *mut _, assignedClientIpv6Addresses as *const _ as *mut _, vpninterfaceId as *const _ as *mut _, assignedRoutes as *const _ as *mut _, assignedNamespace as *const _ as *mut _, mtuSize, maxFrameSize, reserved, transports as *const _ as *mut _, assignedTrafficFilters as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn replace_and_associate_transport(&self, transport: &IInspectable, context: &IInspectable) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).ReplaceAndAssociateTransport)(self as *const _ as *mut _, transport as *const _ as *mut _, context as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn start_reconnecting_transport(&self, transport: &IInspectable, context: &IInspectable) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).StartReconnectingTransport)(self as *const _ as *mut _, transport as *const _ as *mut _, context as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_slot_type_for_transport_context(&self, context: &IInspectable) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).GetSlotTypeForTransportContext)(self as *const _ as *mut _, context as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_current_request_transport_context(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_CurrentRequestTransportContext)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IVpnChannelActivityEventArgs, 2741799154, 45020, 18293, 133, 93, 212, 172, 10, 53, 252, 85); RT_INTERFACE!{interface IVpnChannelActivityEventArgs(IVpnChannelActivityEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IVpnChannelActivityEventArgs] { fn get_Type(&self, out: *mut VpnChannelActivityEventType) -> HRESULT @@ -7950,6 +8901,22 @@ impl IVpnPacketBuffer2 { if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IVpnPacketBuffer3, 3797288751, 4219, 19520, 177, 39, 91, 197, 62, 10, 217, 96); +RT_INTERFACE!{interface IVpnPacketBuffer3(IVpnPacketBuffer3Vtbl): IInspectable(IInspectableVtbl) [IID_IVpnPacketBuffer3] { + fn put_TransportContext(&self, value: *mut IInspectable) -> HRESULT, + fn get_TransportContext(&self, out: *mut *mut IInspectable) -> HRESULT +}} +impl IVpnPacketBuffer3 { + #[inline] pub fn set_transport_context(&self, value: &IInspectable) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_TransportContext)(self as *const _ as *mut _, value as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_transport_context(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_TransportContext)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IVpnPacketBufferFactory, 2653805730, 5906, 19684, 177, 121, 140, 101, 44, 109, 153, 153); RT_INTERFACE!{static interface IVpnPacketBufferFactory(IVpnPacketBufferFactoryVtbl): IInspectable(IInspectableVtbl) [IID_IVpnPacketBufferFactory] { fn CreateVpnPacketBuffer(&self, parentBuffer: *mut VpnPacketBuffer, offset: u32, length: u32, out: *mut *mut VpnPacketBuffer) -> HRESULT diff --git a/src/rt/gen/windows/security.rs b/src/rt/gen/windows/security.rs index 4ea3645..ba447b8 100644 --- a/src/rt/gen/windows/security.rs +++ b/src/rt/gen/windows/security.rs @@ -420,6 +420,17 @@ impl IWebAccountProvider3 { if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IWebAccountProvider4, 1905252571, 59286, 16912, 183, 78, 132, 210, 152, 148, 176, 128); +RT_INTERFACE!{interface IWebAccountProvider4(IWebAccountProvider4Vtbl): IInspectable(IInspectableVtbl) [IID_IWebAccountProvider4] { + fn get_IsSystemProvider(&self, out: *mut bool) -> HRESULT +}} +impl IWebAccountProvider4 { + #[inline] pub fn get_is_system_provider(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_IsSystemProvider)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} DEFINE_IID!(IID_IWebAccountProviderFactory, 494304753, 57825, 19354, 167, 116, 92, 124, 126, 59, 243, 113); RT_INTERFACE!{static interface IWebAccountProviderFactory(IWebAccountProviderFactoryVtbl): IInspectable(IInspectableVtbl) [IID_IWebAccountProviderFactory] { fn CreateWebAccountProvider(&self, id: HSTRING, displayName: HSTRING, iconUri: *mut foundation::Uri, out: *mut *mut WebAccountProvider) -> HRESULT @@ -822,7 +833,7 @@ impl SecondaryAuthenticationFactorAuthentication { } DEFINE_CLSID!(SecondaryAuthenticationFactorAuthentication(&[87,105,110,100,111,119,115,46,83,101,99,117,114,105,116,121,46,65,117,116,104,101,110,116,105,99,97,116,105,111,110,46,73,100,101,110,116,105,116,121,46,80,114,111,118,105,100,101,114,46,83,101,99,111,110,100,97,114,121,65,117,116,104,101,110,116,105,99,97,116,105,111,110,70,97,99,116,111,114,65,117,116,104,101,110,116,105,99,97,116,105,111,110,0]) [CLSID_SecondaryAuthenticationFactorAuthentication]); RT_ENUM! { enum SecondaryAuthenticationFactorAuthenticationMessage: i32 { - Invalid (SecondaryAuthenticationFactorAuthenticationMessage_Invalid) = 0, SwipeUpWelcome (SecondaryAuthenticationFactorAuthenticationMessage_SwipeUpWelcome) = 1, TapWelcome (SecondaryAuthenticationFactorAuthenticationMessage_TapWelcome) = 2, DeviceNeedsAttention (SecondaryAuthenticationFactorAuthenticationMessage_DeviceNeedsAttention) = 3, LookingForDevice (SecondaryAuthenticationFactorAuthenticationMessage_LookingForDevice) = 4, LookingForDevicePluggedin (SecondaryAuthenticationFactorAuthenticationMessage_LookingForDevicePluggedin) = 5, BluetoothIsDisabled (SecondaryAuthenticationFactorAuthenticationMessage_BluetoothIsDisabled) = 6, NfcIsDisabled (SecondaryAuthenticationFactorAuthenticationMessage_NfcIsDisabled) = 7, WiFiIsDisabled (SecondaryAuthenticationFactorAuthenticationMessage_WiFiIsDisabled) = 8, ExtraTapIsRequired (SecondaryAuthenticationFactorAuthenticationMessage_ExtraTapIsRequired) = 9, DisabledByPolicy (SecondaryAuthenticationFactorAuthenticationMessage_DisabledByPolicy) = 10, TapOnDeviceRequired (SecondaryAuthenticationFactorAuthenticationMessage_TapOnDeviceRequired) = 11, HoldFinger (SecondaryAuthenticationFactorAuthenticationMessage_HoldFinger) = 12, ScanFinger (SecondaryAuthenticationFactorAuthenticationMessage_ScanFinger) = 13, UnauthorizedUser (SecondaryAuthenticationFactorAuthenticationMessage_UnauthorizedUser) = 14, ReregisterRequired (SecondaryAuthenticationFactorAuthenticationMessage_ReregisterRequired) = 15, TryAgain (SecondaryAuthenticationFactorAuthenticationMessage_TryAgain) = 16, SayPassphrase (SecondaryAuthenticationFactorAuthenticationMessage_SayPassphrase) = 17, ReadyToSignIn (SecondaryAuthenticationFactorAuthenticationMessage_ReadyToSignIn) = 18, UseAnotherSignInOption (SecondaryAuthenticationFactorAuthenticationMessage_UseAnotherSignInOption) = 19, + Invalid (SecondaryAuthenticationFactorAuthenticationMessage_Invalid) = 0, SwipeUpWelcome (SecondaryAuthenticationFactorAuthenticationMessage_SwipeUpWelcome) = 1, TapWelcome (SecondaryAuthenticationFactorAuthenticationMessage_TapWelcome) = 2, DeviceNeedsAttention (SecondaryAuthenticationFactorAuthenticationMessage_DeviceNeedsAttention) = 3, LookingForDevice (SecondaryAuthenticationFactorAuthenticationMessage_LookingForDevice) = 4, LookingForDevicePluggedin (SecondaryAuthenticationFactorAuthenticationMessage_LookingForDevicePluggedin) = 5, BluetoothIsDisabled (SecondaryAuthenticationFactorAuthenticationMessage_BluetoothIsDisabled) = 6, NfcIsDisabled (SecondaryAuthenticationFactorAuthenticationMessage_NfcIsDisabled) = 7, WiFiIsDisabled (SecondaryAuthenticationFactorAuthenticationMessage_WiFiIsDisabled) = 8, ExtraTapIsRequired (SecondaryAuthenticationFactorAuthenticationMessage_ExtraTapIsRequired) = 9, DisabledByPolicy (SecondaryAuthenticationFactorAuthenticationMessage_DisabledByPolicy) = 10, TapOnDeviceRequired (SecondaryAuthenticationFactorAuthenticationMessage_TapOnDeviceRequired) = 11, HoldFinger (SecondaryAuthenticationFactorAuthenticationMessage_HoldFinger) = 12, ScanFinger (SecondaryAuthenticationFactorAuthenticationMessage_ScanFinger) = 13, UnauthorizedUser (SecondaryAuthenticationFactorAuthenticationMessage_UnauthorizedUser) = 14, ReregisterRequired (SecondaryAuthenticationFactorAuthenticationMessage_ReregisterRequired) = 15, TryAgain (SecondaryAuthenticationFactorAuthenticationMessage_TryAgain) = 16, SayPassphrase (SecondaryAuthenticationFactorAuthenticationMessage_SayPassphrase) = 17, ReadyToSignIn (SecondaryAuthenticationFactorAuthenticationMessage_ReadyToSignIn) = 18, UseAnotherSignInOption (SecondaryAuthenticationFactorAuthenticationMessage_UseAnotherSignInOption) = 19, ConnectionRequired (SecondaryAuthenticationFactorAuthenticationMessage_ConnectionRequired) = 20, TimeLimitExceeded (SecondaryAuthenticationFactorAuthenticationMessage_TimeLimitExceeded) = 21, CanceledByUser (SecondaryAuthenticationFactorAuthenticationMessage_CanceledByUser) = 22, CenterHand (SecondaryAuthenticationFactorAuthenticationMessage_CenterHand) = 23, MoveHandCloser (SecondaryAuthenticationFactorAuthenticationMessage_MoveHandCloser) = 24, MoveHandFarther (SecondaryAuthenticationFactorAuthenticationMessage_MoveHandFarther) = 25, PlaceHandAbove (SecondaryAuthenticationFactorAuthenticationMessage_PlaceHandAbove) = 26, RecognitionFailed (SecondaryAuthenticationFactorAuthenticationMessage_RecognitionFailed) = 27, DeviceUnavailable (SecondaryAuthenticationFactorAuthenticationMessage_DeviceUnavailable) = 28, }} DEFINE_IID!(IID_ISecondaryAuthenticationFactorAuthenticationResult, 2629523847, 61293, 19394, 191, 73, 70, 23, 81, 90, 15, 154); RT_INTERFACE!{interface ISecondaryAuthenticationFactorAuthenticationResult(ISecondaryAuthenticationFactorAuthenticationResultVtbl): IInspectable(IInspectableVtbl) [IID_ISecondaryAuthenticationFactorAuthenticationResult] { @@ -2318,6 +2329,29 @@ impl IWebProviderTokenRequest2 { if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IWebProviderTokenRequest3, 455546538, 17033, 17518, 146, 86, 218, 251, 111, 102, 165, 30); +RT_INTERFACE!{interface IWebProviderTokenRequest3(IWebProviderTokenRequest3Vtbl): IInspectable(IInspectableVtbl) [IID_IWebProviderTokenRequest3] { + fn get_ApplicationPackageFamilyName(&self, out: *mut HSTRING) -> HRESULT, + fn get_ApplicationProcessName(&self, out: *mut HSTRING) -> HRESULT, + fn CheckApplicationForCapabilityAsync(&self, capabilityName: HSTRING, out: *mut *mut foundation::IAsyncOperation) -> HRESULT +}} +impl IWebProviderTokenRequest3 { + #[inline] pub fn get_application_package_family_name(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ApplicationPackageFamilyName)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_application_process_name(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ApplicationProcessName)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn check_application_for_capability_async(&self, capabilityName: &HStringArg) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).CheckApplicationForCapabilityAsync)(self as *const _ as *mut _, capabilityName.get(), &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IWebProviderTokenResponse, 4011931539, 61269, 16774, 183, 206, 140, 178, 231, 249, 132, 158); RT_INTERFACE!{interface IWebProviderTokenResponse(IWebProviderTokenResponseVtbl): IInspectable(IInspectableVtbl) [IID_IWebProviderTokenResponse] { fn get_ClientResponse(&self, out: *mut *mut super::core::WebTokenResponse) -> HRESULT @@ -2351,6 +2385,33 @@ impl IWebProviderTokenResponseFactory { } // Windows.Security.Authentication.Web.Provider pub mod core { // Windows.Security.Authentication.Web.Core use ::prelude::*; +DEFINE_IID!(IID_IFindAllAccountsResult, 2776705885, 46894, 16908, 134, 171, 170, 192, 215, 183, 38, 31); +RT_INTERFACE!{interface IFindAllAccountsResult(IFindAllAccountsResultVtbl): IInspectable(IInspectableVtbl) [IID_IFindAllAccountsResult] { + fn get_Accounts(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT, + fn get_Status(&self, out: *mut FindAllWebAccountsStatus) -> HRESULT, + fn get_ProviderError(&self, out: *mut *mut WebProviderError) -> HRESULT +}} +impl IFindAllAccountsResult { + #[inline] pub fn get_accounts(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Accounts)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_status(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Status)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_provider_error(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ProviderError)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +RT_CLASS!{class FindAllAccountsResult: IFindAllAccountsResult} +RT_ENUM! { enum FindAllWebAccountsStatus: i32 { + Success (FindAllWebAccountsStatus_Success) = 0, NotAllowedByProvider (FindAllWebAccountsStatus_NotAllowedByProvider) = 1, NotSupportedByProvider (FindAllWebAccountsStatus_NotSupportedByProvider) = 2, ProviderError (FindAllWebAccountsStatus_ProviderError) = 3, +}} DEFINE_IID!(IID_IWebAccountEventArgs, 1874264957, 16974, 17644, 151, 124, 239, 36, 21, 70, 42, 90); RT_INTERFACE!{interface IWebAccountEventArgs(IWebAccountEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IWebAccountEventArgs] { fn get_Account(&self, out: *mut *mut super::super::super::credentials::WebAccount) -> HRESULT @@ -2406,6 +2467,7 @@ RT_CLASS!{static class WebAuthenticationCoreManager} impl RtActivatable for WebAuthenticationCoreManager {} impl RtActivatable for WebAuthenticationCoreManager {} impl RtActivatable for WebAuthenticationCoreManager {} +impl RtActivatable for WebAuthenticationCoreManager {} impl WebAuthenticationCoreManager { #[inline] pub fn get_token_silently_async(request: &WebTokenRequest) -> Result>> { >::get_activation_factory().get_token_silently_async(request) @@ -2434,6 +2496,21 @@ impl WebAuthenticationCoreManager { #[inline] pub fn create_web_account_monitor(webAccounts: &foundation::collections::IIterable) -> Result>> { >::get_activation_factory().create_web_account_monitor(webAccounts) } + #[inline] pub fn find_all_accounts_async(provider: &super::super::super::credentials::WebAccountProvider) -> Result>> { + >::get_activation_factory().find_all_accounts_async(provider) + } + #[inline] pub fn find_all_accounts_with_client_id_async(provider: &super::super::super::credentials::WebAccountProvider, clientId: &HStringArg) -> Result>> { + >::get_activation_factory().find_all_accounts_with_client_id_async(provider, clientId) + } + #[inline] pub fn find_system_account_provider_async(webAccountProviderId: &HStringArg) -> Result>> { + >::get_activation_factory().find_system_account_provider_async(webAccountProviderId) + } + #[inline] pub fn find_system_account_provider_with_authority_async(webAccountProviderId: &HStringArg, authority: &HStringArg) -> Result>> { + >::get_activation_factory().find_system_account_provider_with_authority_async(webAccountProviderId, authority) + } + #[cfg(feature="windows-system")] #[inline] pub fn find_system_account_provider_with_authority_for_user_async(webAccountProviderId: &HStringArg, authority: &HStringArg, user: &::rt::gen::windows::system::User) -> Result>> { + >::get_activation_factory().find_system_account_provider_with_authority_for_user_async(webAccountProviderId, authority, user) + } } DEFINE_CLSID!(WebAuthenticationCoreManager(&[87,105,110,100,111,119,115,46,83,101,99,117,114,105,116,121,46,65,117,116,104,101,110,116,105,99,97,116,105,111,110,46,87,101,98,46,67,111,114,101,46,87,101,98,65,117,116,104,101,110,116,105,99,97,116,105,111,110,67,111,114,101,77,97,110,97,103,101,114,0]) [CLSID_WebAuthenticationCoreManager]); DEFINE_IID!(IID_IWebAuthenticationCoreManagerStatics, 1791655058, 42369, 17529, 156, 16, 117, 46, 255, 68, 253, 52); @@ -2505,6 +2582,41 @@ impl IWebAuthenticationCoreManagerStatics3 { if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IWebAuthenticationCoreManagerStatics4, 1424372734, 38624, 16872, 152, 50, 18, 152, 137, 124, 42, 175); +RT_INTERFACE!{static interface IWebAuthenticationCoreManagerStatics4(IWebAuthenticationCoreManagerStatics4Vtbl): IInspectable(IInspectableVtbl) [IID_IWebAuthenticationCoreManagerStatics4] { + fn FindAllAccountsAsync(&self, provider: *mut super::super::super::credentials::WebAccountProvider, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn FindAllAccountsWithClientIdAsync(&self, provider: *mut super::super::super::credentials::WebAccountProvider, clientId: HSTRING, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn FindSystemAccountProviderAsync(&self, webAccountProviderId: HSTRING, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn FindSystemAccountProviderWithAuthorityAsync(&self, webAccountProviderId: HSTRING, authority: HSTRING, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + #[cfg(feature="windows-system")] fn FindSystemAccountProviderWithAuthorityForUserAsync(&self, webAccountProviderId: HSTRING, authority: HSTRING, user: *mut ::rt::gen::windows::system::User, out: *mut *mut foundation::IAsyncOperation) -> HRESULT +}} +impl IWebAuthenticationCoreManagerStatics4 { + #[inline] pub fn find_all_accounts_async(&self, provider: &super::super::super::credentials::WebAccountProvider) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).FindAllAccountsAsync)(self as *const _ as *mut _, provider as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn find_all_accounts_with_client_id_async(&self, provider: &super::super::super::credentials::WebAccountProvider, clientId: &HStringArg) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).FindAllAccountsWithClientIdAsync)(self as *const _ as *mut _, provider as *const _ as *mut _, clientId.get(), &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn find_system_account_provider_async(&self, webAccountProviderId: &HStringArg) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).FindSystemAccountProviderAsync)(self as *const _ as *mut _, webAccountProviderId.get(), &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn find_system_account_provider_with_authority_async(&self, webAccountProviderId: &HStringArg, authority: &HStringArg) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).FindSystemAccountProviderWithAuthorityAsync)(self as *const _ as *mut _, webAccountProviderId.get(), authority.get(), &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[cfg(feature="windows-system")] #[inline] pub fn find_system_account_provider_with_authority_for_user_async(&self, webAccountProviderId: &HStringArg, authority: &HStringArg, user: &::rt::gen::windows::system::User) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).FindSystemAccountProviderWithAuthorityForUserAsync)(self as *const _ as *mut _, webAccountProviderId.get(), authority.get(), user as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IWebProviderError, 3675855793, 20677, 18441, 141, 202, 9, 201, 148, 16, 36, 92); RT_INTERFACE!{interface IWebProviderError(IWebProviderErrorVtbl): IInspectable(IInspectableVtbl) [IID_IWebProviderError] { fn get_ErrorCode(&self, out: *mut u32) -> HRESULT, diff --git a/src/rt/gen/windows/services.rs b/src/rt/gen/windows/services.rs index f28bde7..c16e37a 100644 --- a/src/rt/gen/windows/services.rs +++ b/src/rt/gen/windows/services.rs @@ -552,6 +552,22 @@ impl IMapRouteDrivingOptions { RT_CLASS!{class MapRouteDrivingOptions: IMapRouteDrivingOptions} impl RtActivatable for MapRouteDrivingOptions {} DEFINE_CLSID!(MapRouteDrivingOptions(&[87,105,110,100,111,119,115,46,83,101,114,118,105,99,101,115,46,77,97,112,115,46,77,97,112,82,111,117,116,101,68,114,105,118,105,110,103,79,112,116,105,111,110,115,0]) [CLSID_MapRouteDrivingOptions]); +DEFINE_IID!(IID_IMapRouteDrivingOptions2, 903644784, 49816, 18640, 181, 173, 130, 84, 96, 100, 86, 3); +RT_INTERFACE!{interface IMapRouteDrivingOptions2(IMapRouteDrivingOptions2Vtbl): IInspectable(IInspectableVtbl) [IID_IMapRouteDrivingOptions2] { + fn get_DepartureTime(&self, out: *mut *mut foundation::IReference) -> HRESULT, + fn put_DepartureTime(&self, value: *mut foundation::IReference) -> HRESULT +}} +impl IMapRouteDrivingOptions2 { + #[inline] pub fn get_departure_time(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_DepartureTime)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn set_departure_time(&self, value: &foundation::IReference) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_DepartureTime)(self as *const _ as *mut _, value as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} RT_CLASS!{static class MapRouteFinder} impl RtActivatable for MapRouteFinder {} impl RtActivatable for MapRouteFinder {} @@ -989,6 +1005,7 @@ impl IPlaceInfo { } RT_CLASS!{class PlaceInfo: IPlaceInfo} impl RtActivatable for PlaceInfo {} +impl RtActivatable for PlaceInfo {} impl PlaceInfo { #[cfg(feature="windows-devices")] #[inline] pub fn create(referencePoint: &super::super::devices::geolocation::Geopoint) -> Result>> { >::get_activation_factory().create(referencePoint) @@ -1008,6 +1025,12 @@ impl PlaceInfo { #[inline] pub fn get_is_show_supported() -> Result { >::get_activation_factory().get_is_show_supported() } + #[inline] pub fn create_from_address(displayAddress: &HStringArg) -> Result>> { + >::get_activation_factory().create_from_address(displayAddress) + } + #[inline] pub fn create_from_address_with_name(displayAddress: &HStringArg, displayName: &HStringArg) -> Result>> { + >::get_activation_factory().create_from_address_with_name(displayAddress, displayName) + } } DEFINE_CLSID!(PlaceInfo(&[87,105,110,100,111,119,115,46,83,101,114,118,105,99,101,115,46,77,97,112,115,46,80,108,97,99,101,73,110,102,111,0]) [CLSID_PlaceInfo]); DEFINE_IID!(IID_IPlaceInfoCreateOptions, 3442721061, 26609, 19379, 153, 7, 236, 206, 147, 155, 3, 153); @@ -1084,6 +1107,23 @@ impl IPlaceInfoStatics { if hr == S_OK { Ok(out) } else { err(hr) } }} } +DEFINE_IID!(IID_IPlaceInfoStatics2, 1930363465, 16455, 17571, 143, 129, 37, 80, 165, 33, 99, 112); +RT_INTERFACE!{static interface IPlaceInfoStatics2(IPlaceInfoStatics2Vtbl): IInspectable(IInspectableVtbl) [IID_IPlaceInfoStatics2] { + fn CreateFromAddress(&self, displayAddress: HSTRING, out: *mut *mut PlaceInfo) -> HRESULT, + fn CreateFromAddressWithName(&self, displayAddress: HSTRING, displayName: HSTRING, out: *mut *mut PlaceInfo) -> HRESULT +}} +impl IPlaceInfoStatics2 { + #[inline] pub fn create_from_address(&self, displayAddress: &HStringArg) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreateFromAddress)(self as *const _ as *mut _, displayAddress.get(), &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn create_from_address_with_name(&self, displayAddress: &HStringArg, displayName: &HStringArg) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreateFromAddressWithName)(self as *const _ as *mut _, displayAddress.get(), displayName.get(), &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} RT_ENUM! { enum TrafficCongestion: i32 { Unknown (TrafficCongestion_Unknown) = 0, Light (TrafficCongestion_Light) = 1, Mild (TrafficCongestion_Mild) = 2, Medium (TrafficCongestion_Medium) = 3, Heavy (TrafficCongestion_Heavy) = 4, }} @@ -2348,6 +2388,33 @@ impl IStoreAvailability { }} } RT_CLASS!{class StoreAvailability: IStoreAvailability} +DEFINE_IID!(IID_IStoreCanAcquireLicenseResult, 979975603, 136, 18479, 134, 213, 189, 70, 82, 38, 99, 173); +RT_INTERFACE!{interface IStoreCanAcquireLicenseResult(IStoreCanAcquireLicenseResultVtbl): IInspectable(IInspectableVtbl) [IID_IStoreCanAcquireLicenseResult] { + fn get_ExtendedError(&self, out: *mut foundation::HResult) -> HRESULT, + fn get_LicensableSku(&self, out: *mut HSTRING) -> HRESULT, + fn get_Status(&self, out: *mut StoreCanLicenseStatus) -> HRESULT +}} +impl IStoreCanAcquireLicenseResult { + #[inline] pub fn get_extended_error(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_ExtendedError)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_licensable_sku(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_LicensableSku)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_status(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Status)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} +RT_CLASS!{class StoreCanAcquireLicenseResult: IStoreCanAcquireLicenseResult} +RT_ENUM! { enum StoreCanLicenseStatus: i32 { + NotLicensableToUser (StoreCanLicenseStatus_NotLicensableToUser) = 0, Licensable (StoreCanLicenseStatus_Licensable) = 1, LicenseActionNotApplicableToProduct (StoreCanLicenseStatus_LicenseActionNotApplicableToProduct) = 2, NetworkError (StoreCanLicenseStatus_NetworkError) = 3, ServerError (StoreCanLicenseStatus_ServerError) = 4, +}} DEFINE_IID!(IID_IStoreCollectionData, 2326053811, 23475, 17434, 42, 180, 77, 171, 115, 213, 206, 103); RT_INTERFACE!{interface IStoreCollectionData(IStoreCollectionDataVtbl): IInspectable(IInspectableVtbl) [IID_IStoreCollectionData] { fn get_IsTrial(&self, out: *mut bool) -> HRESULT, @@ -2589,6 +2656,98 @@ impl IStoreContext2 { if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IStoreContext3, 3798083274, 6657, 18224, 133, 166, 236, 200, 150, 228, 174, 56); +RT_INTERFACE!{interface IStoreContext3(IStoreContext3Vtbl): IInspectable(IInspectableVtbl) [IID_IStoreContext3] { + fn get_CanSilentlyDownloadStorePackageUpdates(&self, out: *mut bool) -> HRESULT, + fn TrySilentDownloadStorePackageUpdatesAsync(&self, storePackageUpdates: *mut foundation::collections::IIterable, out: *mut *mut foundation::IAsyncOperationWithProgress) -> HRESULT, + fn TrySilentDownloadAndInstallStorePackageUpdatesAsync(&self, storePackageUpdates: *mut foundation::collections::IIterable, out: *mut *mut foundation::IAsyncOperationWithProgress) -> HRESULT, + #[cfg(not(feature="windows-applicationmodel"))] fn __Dummy3(&self) -> (), + #[cfg(feature="windows-applicationmodel")] fn CanAcquireStoreLicenseForOptionalPackageAsync(&self, optionalPackage: *mut super::super::applicationmodel::Package, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn CanAcquireStoreLicenseAsync(&self, productStoreId: HSTRING, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn GetStoreProductsWithOptionsAsync(&self, productKinds: *mut foundation::collections::IIterable, storeIds: *mut foundation::collections::IIterable, storeProductOptions: *mut StoreProductOptions, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn GetAssociatedStoreQueueItemsAsync(&self, out: *mut *mut foundation::IAsyncOperation>) -> HRESULT, + fn GetStoreQueueItemsAsync(&self, storeIds: *mut foundation::collections::IIterable, out: *mut *mut foundation::IAsyncOperation>) -> HRESULT, + fn RequestDownloadAndInstallStorePackagesWithInstallOptionsAsync(&self, storeIds: *mut foundation::collections::IIterable, storePackageInstallOptions: *mut StorePackageInstallOptions, out: *mut *mut foundation::IAsyncOperationWithProgress) -> HRESULT, + fn DownloadAndInstallStorePackagesAsync(&self, storeIds: *mut foundation::collections::IIterable, out: *mut *mut foundation::IAsyncOperationWithProgress) -> HRESULT, + #[cfg(not(feature="windows-applicationmodel"))] fn __Dummy10(&self) -> (), + #[cfg(feature="windows-applicationmodel")] fn RequestUninstallStorePackageAsync(&self, package: *mut super::super::applicationmodel::Package, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn RequestUninstallStorePackageByStoreIdAsync(&self, storeId: HSTRING, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + #[cfg(not(feature="windows-applicationmodel"))] fn __Dummy12(&self) -> (), + #[cfg(feature="windows-applicationmodel")] fn UninstallStorePackageAsync(&self, package: *mut super::super::applicationmodel::Package, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn UninstallStorePackageByStoreIdAsync(&self, storeId: HSTRING, out: *mut *mut foundation::IAsyncOperation) -> HRESULT +}} +impl IStoreContext3 { + #[inline] pub fn get_can_silently_download_store_package_updates(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_CanSilentlyDownloadStorePackageUpdates)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn try_silent_download_store_package_updates_async(&self, storePackageUpdates: &foundation::collections::IIterable) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).TrySilentDownloadStorePackageUpdatesAsync)(self as *const _ as *mut _, storePackageUpdates as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn try_silent_download_and_install_store_package_updates_async(&self, storePackageUpdates: &foundation::collections::IIterable) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).TrySilentDownloadAndInstallStorePackageUpdatesAsync)(self as *const _ as *mut _, storePackageUpdates as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[cfg(feature="windows-applicationmodel")] #[inline] pub fn can_acquire_store_license_for_optional_package_async(&self, optionalPackage: &super::super::applicationmodel::Package) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).CanAcquireStoreLicenseForOptionalPackageAsync)(self as *const _ as *mut _, optionalPackage as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn can_acquire_store_license_async(&self, productStoreId: &HStringArg) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).CanAcquireStoreLicenseAsync)(self as *const _ as *mut _, productStoreId.get(), &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_store_products_with_options_async(&self, productKinds: &foundation::collections::IIterable, storeIds: &foundation::collections::IIterable, storeProductOptions: &StoreProductOptions) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetStoreProductsWithOptionsAsync)(self as *const _ as *mut _, productKinds as *const _ as *mut _, storeIds as *const _ as *mut _, storeProductOptions as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_associated_store_queue_items_async(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetAssociatedStoreQueueItemsAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_store_queue_items_async(&self, storeIds: &foundation::collections::IIterable) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetStoreQueueItemsAsync)(self as *const _ as *mut _, storeIds as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn request_download_and_install_store_packages_with_install_options_async(&self, storeIds: &foundation::collections::IIterable, storePackageInstallOptions: &StorePackageInstallOptions) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).RequestDownloadAndInstallStorePackagesWithInstallOptionsAsync)(self as *const _ as *mut _, storeIds as *const _ as *mut _, storePackageInstallOptions as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn download_and_install_store_packages_async(&self, storeIds: &foundation::collections::IIterable) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).DownloadAndInstallStorePackagesAsync)(self as *const _ as *mut _, storeIds as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[cfg(feature="windows-applicationmodel")] #[inline] pub fn request_uninstall_store_package_async(&self, package: &super::super::applicationmodel::Package) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).RequestUninstallStorePackageAsync)(self as *const _ as *mut _, package as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn request_uninstall_store_package_by_store_id_async(&self, storeId: &HStringArg) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).RequestUninstallStorePackageByStoreIdAsync)(self as *const _ as *mut _, storeId.get(), &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[cfg(feature="windows-applicationmodel")] #[inline] pub fn uninstall_store_package_async(&self, package: &super::super::applicationmodel::Package) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).UninstallStorePackageAsync)(self as *const _ as *mut _, package as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn uninstall_store_package_by_store_id_async(&self, storeId: &HStringArg) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).UninstallStorePackageByStoreIdAsync)(self as *const _ as *mut _, storeId.get(), &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IStoreContextStatics, 2617699935, 5568, 20082, 147, 48, 214, 25, 28, 235, 209, 156); RT_INTERFACE!{static interface IStoreContextStatics(IStoreContextStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IStoreContextStatics] { fn GetDefault(&self, out: *mut *mut StoreContext) -> HRESULT, @@ -2681,6 +2840,25 @@ impl IStoreLicense { }} } RT_CLASS!{class StoreLicense: IStoreLicense} +DEFINE_IID!(IID_IStorePackageInstallOptions, 490562316, 3277, 17629, 140, 89, 128, 129, 10, 114, 153, 115); +RT_INTERFACE!{interface IStorePackageInstallOptions(IStorePackageInstallOptionsVtbl): IInspectable(IInspectableVtbl) [IID_IStorePackageInstallOptions] { + fn get_AllowForcedAppRestart(&self, out: *mut bool) -> HRESULT, + fn put_AllowForcedAppRestart(&self, value: bool) -> HRESULT +}} +impl IStorePackageInstallOptions { + #[inline] pub fn get_allow_forced_app_restart(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_AllowForcedAppRestart)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_allow_forced_app_restart(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_AllowForcedAppRestart)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class StorePackageInstallOptions: IStorePackageInstallOptions} +impl RtActivatable for StorePackageInstallOptions {} +DEFINE_CLSID!(StorePackageInstallOptions(&[87,105,110,100,111,119,115,46,83,101,114,118,105,99,101,115,46,83,116,111,114,101,46,83,116,111,114,101,80,97,99,107,97,103,101,73,110,115,116,97,108,108,79,112,116,105,111,110,115,0]) [CLSID_StorePackageInstallOptions]); DEFINE_IID!(IID_IStorePackageLicense, 205936404, 5345, 18803, 189, 20, 247, 119, 36, 39, 30, 153); RT_INTERFACE!{interface IStorePackageLicense(IStorePackageLicenseVtbl): IInspectable(IInspectableVtbl) [IID_IStorePackageLicense] { fn add_LicenseLost(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, @@ -2753,6 +2931,17 @@ impl IStorePackageUpdateResult { }} } RT_CLASS!{class StorePackageUpdateResult: IStorePackageUpdateResult} +DEFINE_IID!(IID_IStorePackageUpdateResult2, 119341358, 48226, 20270, 135, 234, 153, 216, 1, 174, 175, 152); +RT_INTERFACE!{interface IStorePackageUpdateResult2(IStorePackageUpdateResult2Vtbl): IInspectable(IInspectableVtbl) [IID_IStorePackageUpdateResult2] { + fn get_StoreQueueItems(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT +}} +impl IStorePackageUpdateResult2 { + #[inline] pub fn get_store_queue_items(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_StoreQueueItems)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} RT_ENUM! { enum StorePackageUpdateState: i32 { Pending (StorePackageUpdateState_Pending) = 0, Downloading (StorePackageUpdateState_Downloading) = 1, Deploying (StorePackageUpdateState_Deploying) = 2, Completed (StorePackageUpdateState_Completed) = 3, Canceled (StorePackageUpdateState_Canceled) = 4, OtherError (StorePackageUpdateState_OtherError) = 5, ErrorLowBattery (StorePackageUpdateState_ErrorLowBattery) = 6, ErrorWiFiRecommended (StorePackageUpdateState_ErrorWiFiRecommended) = 7, ErrorWiFiRequired (StorePackageUpdateState_ErrorWiFiRequired) = 8, }} @@ -2915,6 +3104,20 @@ impl IStoreProduct { }} } RT_CLASS!{class StoreProduct: IStoreProduct} +DEFINE_IID!(IID_IStoreProductOptions, 1530175737, 41235, 18449, 131, 38, 22, 25, 156, 146, 127, 49); +RT_INTERFACE!{interface IStoreProductOptions(IStoreProductOptionsVtbl): IInspectable(IInspectableVtbl) [IID_IStoreProductOptions] { + fn get_ActionFilters(&self, out: *mut *mut foundation::collections::IVector) -> HRESULT +}} +impl IStoreProductOptions { + #[inline] pub fn get_action_filters(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ActionFilters)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +RT_CLASS!{class StoreProductOptions: IStoreProductOptions} +impl RtActivatable for StoreProductOptions {} +DEFINE_CLSID!(StoreProductOptions(&[87,105,110,100,111,119,115,46,83,101,114,118,105,99,101,115,46,83,116,111,114,101,46,83,116,111,114,101,80,114,111,100,117,99,116,79,112,116,105,111,110,115,0]) [CLSID_StoreProductOptions]); DEFINE_IID!(IID_IStoreProductPagedQueryResult, 3374782661, 19925, 18537, 164, 98, 236, 198, 135, 46, 67, 197); RT_INTERFACE!{interface IStoreProductPagedQueryResult(IStoreProductPagedQueryResultVtbl): IInspectable(IInspectableVtbl) [IID_IStoreProductPagedQueryResult] { fn get_Products(&self, out: *mut *mut foundation::collections::IMapView) -> HRESULT, @@ -3049,6 +3252,109 @@ RT_CLASS!{class StorePurchaseResult: IStorePurchaseResult} RT_ENUM! { enum StorePurchaseStatus: i32 { Succeeded (StorePurchaseStatus_Succeeded) = 0, AlreadyPurchased (StorePurchaseStatus_AlreadyPurchased) = 1, NotPurchased (StorePurchaseStatus_NotPurchased) = 2, NetworkError (StorePurchaseStatus_NetworkError) = 3, ServerError (StorePurchaseStatus_ServerError) = 4, }} +DEFINE_IID!(IID_IStoreQueueItem, 1456849707, 63536, 17043, 145, 136, 202, 210, 220, 222, 115, 87); +RT_INTERFACE!{interface IStoreQueueItem(IStoreQueueItemVtbl): IInspectable(IInspectableVtbl) [IID_IStoreQueueItem] { + fn get_ProductId(&self, out: *mut HSTRING) -> HRESULT, + fn get_PackageFamilyName(&self, out: *mut HSTRING) -> HRESULT, + fn get_InstallKind(&self, out: *mut StoreQueueItemKind) -> HRESULT, + fn GetCurrentStatus(&self, out: *mut *mut StoreQueueItemStatus) -> HRESULT, + fn add_Completed(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_Completed(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn add_StatusChanged(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_StatusChanged(&self, token: foundation::EventRegistrationToken) -> HRESULT +}} +impl IStoreQueueItem { + #[inline] pub fn get_product_id(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ProductId)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_package_family_name(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_PackageFamilyName)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_install_kind(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_InstallKind)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_current_status(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetCurrentStatus)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn add_completed(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_Completed)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_completed(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_Completed)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_status_changed(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_StatusChanged)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_status_changed(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_StatusChanged)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class StoreQueueItem: IStoreQueueItem} +DEFINE_IID!(IID_IStoreQueueItemCompletedEventArgs, 306700140, 46154, 17307, 187, 7, 29, 48, 3, 208, 5, 194); +RT_INTERFACE!{interface IStoreQueueItemCompletedEventArgs(IStoreQueueItemCompletedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IStoreQueueItemCompletedEventArgs] { + fn get_Status(&self, out: *mut *mut StoreQueueItemStatus) -> HRESULT +}} +impl IStoreQueueItemCompletedEventArgs { + #[inline] pub fn get_status(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Status)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +RT_CLASS!{class StoreQueueItemCompletedEventArgs: IStoreQueueItemCompletedEventArgs} +RT_ENUM! { enum StoreQueueItemExtendedState: i32 { + ActivePending (StoreQueueItemExtendedState_ActivePending) = 0, ActiveStarting (StoreQueueItemExtendedState_ActiveStarting) = 1, ActiveAcquiringLicense (StoreQueueItemExtendedState_ActiveAcquiringLicense) = 2, ActiveDownloading (StoreQueueItemExtendedState_ActiveDownloading) = 3, ActiveRestoringData (StoreQueueItemExtendedState_ActiveRestoringData) = 4, ActiveInstalling (StoreQueueItemExtendedState_ActiveInstalling) = 5, Completed (StoreQueueItemExtendedState_Completed) = 6, Canceled (StoreQueueItemExtendedState_Canceled) = 7, Paused (StoreQueueItemExtendedState_Paused) = 8, Error (StoreQueueItemExtendedState_Error) = 9, PausedPackagesInUse (StoreQueueItemExtendedState_PausedPackagesInUse) = 10, PausedLowBattery (StoreQueueItemExtendedState_PausedLowBattery) = 11, PausedWiFiRecommended (StoreQueueItemExtendedState_PausedWiFiRecommended) = 12, PausedWiFiRequired (StoreQueueItemExtendedState_PausedWiFiRequired) = 13, PausedReadyToInstall (StoreQueueItemExtendedState_PausedReadyToInstall) = 14, +}} +RT_ENUM! { enum StoreQueueItemKind: i32 { + Install (StoreQueueItemKind_Install) = 0, Update (StoreQueueItemKind_Update) = 1, Repair (StoreQueueItemKind_Repair) = 2, +}} +RT_ENUM! { enum StoreQueueItemState: i32 { + Active (StoreQueueItemState_Active) = 0, Completed (StoreQueueItemState_Completed) = 1, Canceled (StoreQueueItemState_Canceled) = 2, Error (StoreQueueItemState_Error) = 3, Paused (StoreQueueItemState_Paused) = 4, +}} +DEFINE_IID!(IID_IStoreQueueItemStatus, 2614524271, 40131, 20163, 178, 239, 123, 228, 51, 179, 1, 116); +RT_INTERFACE!{interface IStoreQueueItemStatus(IStoreQueueItemStatusVtbl): IInspectable(IInspectableVtbl) [IID_IStoreQueueItemStatus] { + fn get_PackageInstallState(&self, out: *mut StoreQueueItemState) -> HRESULT, + fn get_PackageInstallExtendedState(&self, out: *mut StoreQueueItemExtendedState) -> HRESULT, + fn get_UpdateStatus(&self, out: *mut StorePackageUpdateStatus) -> HRESULT, + fn get_ExtendedError(&self, out: *mut foundation::HResult) -> HRESULT +}} +impl IStoreQueueItemStatus { + #[inline] pub fn get_package_install_state(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_PackageInstallState)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_package_install_extended_state(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_PackageInstallExtendedState)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_update_status(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_UpdateStatus)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_extended_error(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_ExtendedError)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} +RT_CLASS!{class StoreQueueItemStatus: IStoreQueueItemStatus} RT_CLASS!{static class StoreRequestHelper} impl RtActivatable for StoreRequestHelper {} impl StoreRequestHelper { @@ -3253,6 +3559,27 @@ impl IStoreSubscriptionInfo { }} } RT_CLASS!{class StoreSubscriptionInfo: IStoreSubscriptionInfo} +DEFINE_IID!(IID_IStoreUninstallStorePackageResult, 2680830461, 4719, 19674, 184, 1, 19, 70, 184, 208, 162, 96); +RT_INTERFACE!{interface IStoreUninstallStorePackageResult(IStoreUninstallStorePackageResultVtbl): IInspectable(IInspectableVtbl) [IID_IStoreUninstallStorePackageResult] { + fn get_ExtendedError(&self, out: *mut foundation::HResult) -> HRESULT, + fn get_Status(&self, out: *mut StoreUninstallStorePackageStatus) -> HRESULT +}} +impl IStoreUninstallStorePackageResult { + #[inline] pub fn get_extended_error(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_ExtendedError)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_status(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Status)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} +RT_CLASS!{class StoreUninstallStorePackageResult: IStoreUninstallStorePackageResult} +RT_ENUM! { enum StoreUninstallStorePackageStatus: i32 { + Succeeded (StoreUninstallStorePackageStatus_Succeeded) = 0, CanceledByUser (StoreUninstallStorePackageStatus_CanceledByUser) = 1, NetworkError (StoreUninstallStorePackageStatus_NetworkError) = 2, UninstallNotApplicable (StoreUninstallStorePackageStatus_UninstallNotApplicable) = 3, Error (StoreUninstallStorePackageStatus_Error) = 4, +}} DEFINE_IID!(IID_IStoreVideo, 4067209604, 28510, 19906, 136, 108, 60, 99, 8, 60, 47, 148); RT_INTERFACE!{interface IStoreVideo(IStoreVideoVtbl): IInspectable(IInspectableVtbl) [IID_IStoreVideo] { fn get_Uri(&self, out: *mut *mut foundation::Uri) -> HRESULT, diff --git a/src/rt/gen/windows/storage.rs b/src/rt/gen/windows/storage.rs index f70d2b6..12c00c2 100644 --- a/src/rt/gen/windows/storage.rs +++ b/src/rt/gen/windows/storage.rs @@ -1177,6 +1177,17 @@ impl IStorageFolder2 { if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IStorageFolder3, 2673965209, 48609, 16676, 174, 179, 176, 106, 217, 111, 152, 212); +RT_INTERFACE!{interface IStorageFolder3(IStorageFolder3Vtbl): IInspectable(IInspectableVtbl) [IID_IStorageFolder3] { + fn TryGetChangeTracker(&self, out: *mut *mut StorageLibraryChangeTracker) -> HRESULT +}} +impl IStorageFolder3 { + #[inline] pub fn try_get_change_tracker(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).TryGetChangeTracker)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IStorageFolderStatics, 150153215, 34261, 18617, 174, 233, 40, 81, 30, 51, 159, 159); RT_INTERFACE!{static interface IStorageFolderStatics(IStorageFolderStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IStorageFolderStatics] { fn GetFolderFromPathAsync(&self, path: HSTRING, out: *mut *mut foundation::IAsyncOperation) -> HRESULT @@ -3551,6 +3562,24 @@ impl IStorageItemQueryResult { }} } RT_CLASS!{class StorageItemQueryResult: IStorageItemQueryResult} +DEFINE_IID!(IID_IStorageLibraryChangeTrackerTriggerDetails, 499622761, 47011, 19954, 157, 97, 235, 168, 90, 3, 67, 210); +RT_INTERFACE!{interface IStorageLibraryChangeTrackerTriggerDetails(IStorageLibraryChangeTrackerTriggerDetailsVtbl): IInspectable(IInspectableVtbl) [IID_IStorageLibraryChangeTrackerTriggerDetails] { + fn get_Folder(&self, out: *mut *mut super::StorageFolder) -> HRESULT, + fn get_ChangeTracker(&self, out: *mut *mut super::StorageLibraryChangeTracker) -> HRESULT +}} +impl IStorageLibraryChangeTrackerTriggerDetails { + #[inline] pub fn get_folder(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Folder)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_change_tracker(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ChangeTracker)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +RT_CLASS!{class StorageLibraryChangeTrackerTriggerDetails: IStorageLibraryChangeTrackerTriggerDetails} DEFINE_IID!(IID_IStorageLibraryContentChangedTriggerDetails, 708254071, 43967, 19997, 138, 165, 99, 133, 216, 136, 71, 153); RT_INTERFACE!{interface IStorageLibraryContentChangedTriggerDetails(IStorageLibraryContentChangedTriggerDetailsVtbl): IInspectable(IInspectableVtbl) [IID_IStorageLibraryContentChangedTriggerDetails] { fn get_Folder(&self, out: *mut *mut super::StorageFolder) -> HRESULT, @@ -4424,6 +4453,77 @@ RT_ENUM! { enum FileUpdateStatus: i32 { RT_ENUM! { enum ReadActivationMode: i32 { NotNeeded (ReadActivationMode_NotNeeded) = 0, BeforeAccess (ReadActivationMode_BeforeAccess) = 1, }} +DEFINE_IID!(IID_IStorageProviderGetContentInfoForPathResult, 627339549, 43657, 19730, 130, 227, 247, 42, 146, 227, 57, 102); +RT_INTERFACE!{interface IStorageProviderGetContentInfoForPathResult(IStorageProviderGetContentInfoForPathResultVtbl): IInspectable(IInspectableVtbl) [IID_IStorageProviderGetContentInfoForPathResult] { + fn get_Status(&self, out: *mut StorageProviderUriSourceStatus) -> HRESULT, + fn put_Status(&self, value: StorageProviderUriSourceStatus) -> HRESULT, + fn get_ContentUri(&self, out: *mut HSTRING) -> HRESULT, + fn put_ContentUri(&self, value: HSTRING) -> HRESULT, + fn get_ContentId(&self, out: *mut HSTRING) -> HRESULT, + fn put_ContentId(&self, value: HSTRING) -> HRESULT +}} +impl IStorageProviderGetContentInfoForPathResult { + #[inline] pub fn get_status(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Status)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_status(&self, value: StorageProviderUriSourceStatus) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Status)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_content_uri(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ContentUri)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn set_content_uri(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_ContentUri)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_content_id(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ContentId)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn set_content_id(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_ContentId)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class StorageProviderGetContentInfoForPathResult: IStorageProviderGetContentInfoForPathResult} +impl RtActivatable for StorageProviderGetContentInfoForPathResult {} +DEFINE_CLSID!(StorageProviderGetContentInfoForPathResult(&[87,105,110,100,111,119,115,46,83,116,111,114,97,103,101,46,80,114,111,118,105,100,101,114,46,83,116,111,114,97,103,101,80,114,111,118,105,100,101,114,71,101,116,67,111,110,116,101,110,116,73,110,102,111,70,111,114,80,97,116,104,82,101,115,117,108,116,0]) [CLSID_StorageProviderGetContentInfoForPathResult]); +DEFINE_IID!(IID_IStorageProviderGetPathForContentUriResult, 1668356765, 16664, 17830, 172, 182, 34, 196, 157, 1, 159, 64); +RT_INTERFACE!{interface IStorageProviderGetPathForContentUriResult(IStorageProviderGetPathForContentUriResultVtbl): IInspectable(IInspectableVtbl) [IID_IStorageProviderGetPathForContentUriResult] { + fn get_Status(&self, out: *mut StorageProviderUriSourceStatus) -> HRESULT, + fn put_Status(&self, value: StorageProviderUriSourceStatus) -> HRESULT, + fn get_Path(&self, out: *mut HSTRING) -> HRESULT, + fn put_Path(&self, value: HSTRING) -> HRESULT +}} +impl IStorageProviderGetPathForContentUriResult { + #[inline] pub fn get_status(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Status)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_status(&self, value: StorageProviderUriSourceStatus) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Status)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_path(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Path)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn set_path(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Path)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class StorageProviderGetPathForContentUriResult: IStorageProviderGetPathForContentUriResult} +impl RtActivatable for StorageProviderGetPathForContentUriResult {} +DEFINE_CLSID!(StorageProviderGetPathForContentUriResult(&[87,105,110,100,111,119,115,46,83,116,111,114,97,103,101,46,80,114,111,118,105,100,101,114,46,83,116,111,114,97,103,101,80,114,111,118,105,100,101,114,71,101,116,80,97,116,104,70,111,114,67,111,110,116,101,110,116,85,114,105,82,101,115,117,108,116,0]) [CLSID_StorageProviderGetPathForContentUriResult]); RT_ENUM! { enum StorageProviderHardlinkPolicy: u32 { None (StorageProviderHardlinkPolicy_None) = 0, Allowed (StorageProviderHardlinkPolicy_Allowed) = 1, }} @@ -4786,6 +4886,24 @@ impl IStorageProviderSyncRootManagerStatics { if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IStorageProviderUriSource, 2996307665, 35808, 18786, 139, 182, 13, 76, 46, 20, 212, 122); +RT_INTERFACE!{interface IStorageProviderUriSource(IStorageProviderUriSourceVtbl): IInspectable(IInspectableVtbl) [IID_IStorageProviderUriSource] { + fn GetPathForContentUri(&self, contentUri: HSTRING, result: *mut StorageProviderGetPathForContentUriResult) -> HRESULT, + fn GetContentInfoForPath(&self, path: HSTRING, result: *mut StorageProviderGetContentInfoForPathResult) -> HRESULT +}} +impl IStorageProviderUriSource { + #[inline] pub fn get_path_for_content_uri(&self, contentUri: &HStringArg, result: &StorageProviderGetPathForContentUriResult) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).GetPathForContentUri)(self as *const _ as *mut _, contentUri.get(), result as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_content_info_for_path(&self, path: &HStringArg, result: &StorageProviderGetContentInfoForPathResult) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).GetContentInfoForPath)(self as *const _ as *mut _, path.get(), result as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_ENUM! { enum StorageProviderUriSourceStatus: i32 { + Success (StorageProviderUriSourceStatus_Success) = 0, NoSyncRoot (StorageProviderUriSourceStatus_NoSyncRoot) = 1, FileNotFound (StorageProviderUriSourceStatus_FileNotFound) = 2, +}} RT_ENUM! { enum UIStatus: i32 { Unavailable (UIStatus_Unavailable) = 0, Hidden (UIStatus_Hidden) = 1, Visible (UIStatus_Visible) = 2, Complete (UIStatus_Complete) = 3, }} diff --git a/src/rt/gen/windows/system.rs b/src/rt/gen/windows/system.rs index d231df9..8833394 100644 --- a/src/rt/gen/windows/system.rs +++ b/src/rt/gen/windows/system.rs @@ -1,4 +1,22 @@ use ::prelude::*; +DEFINE_IID!(IID_IAppActivationResult, 1800571136, 62574, 20144, 170, 108, 56, 175, 85, 124, 249, 237); +RT_INTERFACE!{interface IAppActivationResult(IAppActivationResultVtbl): IInspectable(IInspectableVtbl) [IID_IAppActivationResult] { + fn get_ExtendedError(&self, out: *mut foundation::HResult) -> HRESULT, + fn get_AppResourceGroupInfo(&self, out: *mut *mut AppResourceGroupInfo) -> HRESULT +}} +impl IAppActivationResult { + #[inline] pub fn get_extended_error(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_ExtendedError)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_app_resource_group_info(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_AppResourceGroupInfo)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +RT_CLASS!{class AppActivationResult: IAppActivationResult} DEFINE_IID!(IID_IAppDiagnosticInfo, 3813189274, 34953, 19619, 190, 7, 213, 255, 255, 95, 8, 4); RT_INTERFACE!{interface IAppDiagnosticInfo(IAppDiagnosticInfoVtbl): IInspectable(IInspectableVtbl) [IID_IAppDiagnosticInfo] { #[cfg(feature="windows-applicationmodel")] fn get_AppInfo(&self, out: *mut *mut super::applicationmodel::AppInfo) -> HRESULT @@ -51,6 +69,17 @@ impl IAppDiagnosticInfo2 { if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IAppDiagnosticInfo3, 3365258813, 56673, 19557, 186, 189, 129, 161, 11, 79, 152, 21); +RT_INTERFACE!{interface IAppDiagnosticInfo3(IAppDiagnosticInfo3Vtbl): IInspectable(IInspectableVtbl) [IID_IAppDiagnosticInfo3] { + fn LaunchAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT +}} +impl IAppDiagnosticInfo3 { + #[inline] pub fn launch_async(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).LaunchAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IAppDiagnosticInfoStatics, 3462997439, 4298, 16584, 169, 202, 197, 201, 101, 1, 134, 110); RT_INTERFACE!{static interface IAppDiagnosticInfoStatics(IAppDiagnosticInfoStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IAppDiagnosticInfoStatics] { fn RequestInfoAsync(&self, out: *mut *mut foundation::IAsyncOperation>) -> HRESULT @@ -178,6 +207,18 @@ RT_CLASS!{class AppDiagnosticInfoWatcherEventArgs: IAppDiagnosticInfoWatcherEven RT_ENUM! { enum AppDiagnosticInfoWatcherStatus: i32 { Created (AppDiagnosticInfoWatcherStatus_Created) = 0, Started (AppDiagnosticInfoWatcherStatus_Started) = 1, EnumerationCompleted (AppDiagnosticInfoWatcherStatus_EnumerationCompleted) = 2, Stopping (AppDiagnosticInfoWatcherStatus_Stopping) = 3, Stopped (AppDiagnosticInfoWatcherStatus_Stopped) = 4, Aborted (AppDiagnosticInfoWatcherStatus_Aborted) = 5, }} +DEFINE_IID!(IID_IAppExecutionStateChangeResult, 1862507504, 63771, 19960, 174, 119, 48, 51, 204, 182, 145, 20); +RT_INTERFACE!{interface IAppExecutionStateChangeResult(IAppExecutionStateChangeResultVtbl): IInspectable(IInspectableVtbl) [IID_IAppExecutionStateChangeResult] { + fn get_ExtendedError(&self, out: *mut foundation::HResult) -> HRESULT +}} +impl IAppExecutionStateChangeResult { + #[inline] pub fn get_extended_error(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_ExtendedError)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} +RT_CLASS!{class AppExecutionStateChangeResult: IAppExecutionStateChangeResult} DEFINE_IID!(IID_IAppMemoryReport, 1835348891, 19823, 17852, 156, 94, 228, 155, 63, 242, 117, 141); RT_INTERFACE!{interface IAppMemoryReport(IAppMemoryReportVtbl): IInspectable(IInspectableVtbl) [IID_IAppMemoryReport] { fn get_PrivateCommitUsage(&self, out: *mut u64) -> HRESULT, @@ -318,6 +359,29 @@ impl IAppResourceGroupInfo { }} } RT_CLASS!{class AppResourceGroupInfo: IAppResourceGroupInfo} +DEFINE_IID!(IID_IAppResourceGroupInfo2, 4003144557, 54021, 19819, 146, 247, 106, 253, 173, 114, 222, 220); +RT_INTERFACE!{interface IAppResourceGroupInfo2(IAppResourceGroupInfo2Vtbl): IInspectable(IInspectableVtbl) [IID_IAppResourceGroupInfo2] { + fn StartSuspendAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn StartResumeAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn StartTerminateAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT +}} +impl IAppResourceGroupInfo2 { + #[inline] pub fn start_suspend_async(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).StartSuspendAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn start_resume_async(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).StartResumeAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn start_terminate_async(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).StartTerminateAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IAppResourceGroupInfoWatcher, 3652231421, 28250, 19570, 139, 23, 9, 254, 196, 162, 18, 189); RT_INTERFACE!{interface IAppResourceGroupInfoWatcher(IAppResourceGroupInfoWatcherVtbl): IInspectable(IInspectableVtbl) [IID_IAppResourceGroupInfoWatcher] { fn add_Added(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, @@ -482,6 +546,9 @@ impl IAppResourceGroupStateReport { }} } RT_CLASS!{class AppResourceGroupStateReport: IAppResourceGroupStateReport} +RT_ENUM! { enum AutoUpdateTimeZoneStatus: i32 { + Attempted (AutoUpdateTimeZoneStatus_Attempted) = 0, TimedOut (AutoUpdateTimeZoneStatus_TimedOut) = 1, Failed (AutoUpdateTimeZoneStatus_Failed) = 2, +}} RT_CLASS!{static class DateTimeSettings} impl RtActivatable for DateTimeSettings {} impl DateTimeSettings { @@ -1663,6 +1730,7 @@ impl IShutdownManagerStatics2 { } RT_CLASS!{static class TimeZoneSettings} impl RtActivatable for TimeZoneSettings {} +impl RtActivatable for TimeZoneSettings {} impl TimeZoneSettings { #[inline] pub fn get_current_time_zone_display_name() -> Result { >::get_activation_factory().get_current_time_zone_display_name() @@ -1676,6 +1744,9 @@ impl TimeZoneSettings { #[inline] pub fn change_time_zone_by_display_name(timeZoneDisplayName: &HStringArg) -> Result<()> { >::get_activation_factory().change_time_zone_by_display_name(timeZoneDisplayName) } + #[inline] pub fn auto_update_time_zone_async(timeout: foundation::TimeSpan) -> Result>> { + >::get_activation_factory().auto_update_time_zone_async(timeout) + } } DEFINE_CLSID!(TimeZoneSettings(&[87,105,110,100,111,119,115,46,83,121,115,116,101,109,46,84,105,109,101,90,111,110,101,83,101,116,116,105,110,103,115,0]) [CLSID_TimeZoneSettings]); DEFINE_IID!(IID_ITimeZoneSettingsStatics, 2604346346, 41217, 16814, 159, 189, 2, 135, 40, 186, 183, 61); @@ -1706,6 +1777,17 @@ impl ITimeZoneSettingsStatics { if hr == S_OK { Ok(()) } else { err(hr) } }} } +DEFINE_IID!(IID_ITimeZoneSettingsStatics2, 1432096184, 14760, 18938, 180, 246, 162, 199, 252, 40, 66, 236); +RT_INTERFACE!{static interface ITimeZoneSettingsStatics2(ITimeZoneSettingsStatics2Vtbl): IInspectable(IInspectableVtbl) [IID_ITimeZoneSettingsStatics2] { + fn AutoUpdateTimeZoneAsync(&self, timeout: foundation::TimeSpan, out: *mut *mut foundation::IAsyncOperation) -> HRESULT +}} +impl ITimeZoneSettingsStatics2 { + #[inline] pub fn auto_update_time_zone_async(&self, timeout: foundation::TimeSpan) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).AutoUpdateTimeZoneAsync)(self as *const _ as *mut _, timeout, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IUser, 3751421638, 59206, 19405, 181, 212, 18, 1, 3, 196, 32, 155); RT_INTERFACE!{interface IUser(IUserVtbl): IInspectable(IInspectableVtbl) [IID_IUser] { fn get_NonRoamableId(&self, out: *mut HSTRING) -> HRESULT, @@ -2213,6 +2295,7 @@ impl IFirstSignInSettingsStatics { RT_CLASS!{static class GlobalizationPreferences} impl RtActivatable for GlobalizationPreferences {} impl RtActivatable for GlobalizationPreferences {} +impl RtActivatable for GlobalizationPreferences {} impl GlobalizationPreferences { #[inline] pub fn get_calendars() -> Result>>> { >::get_activation_factory().get_calendars() @@ -2238,8 +2321,59 @@ impl GlobalizationPreferences { #[inline] pub fn try_set_languages(languageTags: &foundation::collections::IIterable) -> Result { >::get_activation_factory().try_set_languages(languageTags) } + #[inline] pub fn get_for_user(user: &super::User) -> Result>> { + >::get_activation_factory().get_for_user(user) + } } DEFINE_CLSID!(GlobalizationPreferences(&[87,105,110,100,111,119,115,46,83,121,115,116,101,109,46,85,115,101,114,80,114,111,102,105,108,101,46,71,108,111,98,97,108,105,122,97,116,105,111,110,80,114,101,102,101,114,101,110,99,101,115,0]) [CLSID_GlobalizationPreferences]); +DEFINE_IID!(IID_IGlobalizationPreferencesForUser, 353306517, 20334, 16570, 160, 16, 226, 125, 129, 189, 167, 245); +RT_INTERFACE!{interface IGlobalizationPreferencesForUser(IGlobalizationPreferencesForUserVtbl): IInspectable(IInspectableVtbl) [IID_IGlobalizationPreferencesForUser] { + fn get_User(&self, out: *mut *mut super::User) -> HRESULT, + fn get_Calendars(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT, + fn get_Clocks(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT, + fn get_Currencies(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT, + fn get_Languages(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT, + fn get_HomeGeographicRegion(&self, out: *mut HSTRING) -> HRESULT, + #[cfg(feature="windows-globalization")] fn get_WeekStartsOn(&self, out: *mut super::super::globalization::DayOfWeek) -> HRESULT +}} +impl IGlobalizationPreferencesForUser { + #[inline] pub fn get_user(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_User)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_calendars(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Calendars)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_clocks(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Clocks)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_currencies(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Currencies)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_languages(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Languages)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_home_geographic_region(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_HomeGeographicRegion)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[cfg(feature="windows-globalization")] #[inline] pub fn get_week_starts_on(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_WeekStartsOn)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} +RT_CLASS!{class GlobalizationPreferencesForUser: IGlobalizationPreferencesForUser} DEFINE_IID!(IID_IGlobalizationPreferencesStatics, 29311782, 60727, 20118, 176, 233, 193, 52, 13, 30, 161, 88); RT_INTERFACE!{static interface IGlobalizationPreferencesStatics(IGlobalizationPreferencesStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IGlobalizationPreferencesStatics] { fn get_Calendars(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT, @@ -2298,6 +2432,17 @@ impl IGlobalizationPreferencesStatics2 { if hr == S_OK { Ok(out) } else { err(hr) } }} } +DEFINE_IID!(IID_IGlobalizationPreferencesStatics3, 503682867, 13813, 16600, 185, 232, 174, 243, 239, 133, 111, 206); +RT_INTERFACE!{static interface IGlobalizationPreferencesStatics3(IGlobalizationPreferencesStatics3Vtbl): IInspectable(IInspectableVtbl) [IID_IGlobalizationPreferencesStatics3] { + fn GetForUser(&self, user: *mut super::User, out: *mut *mut GlobalizationPreferencesForUser) -> HRESULT +}} +impl IGlobalizationPreferencesStatics3 { + #[inline] pub fn get_for_user(&self, user: &super::User) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetForUser)(self as *const _ as *mut _, user as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} RT_CLASS!{static class LockScreen} impl RtActivatable for LockScreen {} impl RtActivatable for LockScreen {} @@ -2573,6 +2718,7 @@ pub mod profile { // Windows.System.Profile use ::prelude::*; RT_CLASS!{static class AnalyticsInfo} impl RtActivatable for AnalyticsInfo {} +impl RtActivatable for AnalyticsInfo {} impl AnalyticsInfo { #[inline] pub fn get_version_info() -> Result>> { >::get_activation_factory().get_version_info() @@ -2580,6 +2726,9 @@ impl AnalyticsInfo { #[inline] pub fn get_device_form() -> Result { >::get_activation_factory().get_device_form() } + #[inline] pub fn get_system_properties_async(attributeNames: &foundation::collections::IIterable) -> Result>>> { + >::get_activation_factory().get_system_properties_async(attributeNames) + } } DEFINE_CLSID!(AnalyticsInfo(&[87,105,110,100,111,119,115,46,83,121,115,116,101,109,46,80,114,111,102,105,108,101,46,65,110,97,108,121,116,105,99,115,73,110,102,111,0]) [CLSID_AnalyticsInfo]); DEFINE_IID!(IID_IAnalyticsInfoStatics, 492757094, 6285, 23465, 67, 135, 172, 174, 176, 231, 227, 5); @@ -2599,6 +2748,17 @@ impl IAnalyticsInfoStatics { if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IAnalyticsInfoStatics2, 269944042, 43001, 18130, 171, 148, 1, 104, 101, 175, 219, 37); +RT_INTERFACE!{static interface IAnalyticsInfoStatics2(IAnalyticsInfoStatics2Vtbl): IInspectable(IInspectableVtbl) [IID_IAnalyticsInfoStatics2] { + fn GetSystemPropertiesAsync(&self, attributeNames: *mut foundation::collections::IIterable, out: *mut *mut foundation::IAsyncOperation>) -> HRESULT +}} +impl IAnalyticsInfoStatics2 { + #[inline] pub fn get_system_properties_async(&self, attributeNames: &foundation::collections::IIterable) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetSystemPropertiesAsync)(self as *const _ as *mut _, attributeNames as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IAnalyticsVersionInfo, 2455843000, 39253, 19572, 189, 193, 124, 208, 222, 207, 155, 3); RT_INTERFACE!{interface IAnalyticsVersionInfo(IAnalyticsVersionInfoVtbl): IInspectable(IInspectableVtbl) [IID_IAnalyticsVersionInfo] { fn get_DeviceFamily(&self, out: *mut HSTRING) -> HRESULT, @@ -3633,6 +3793,17 @@ impl DiagnosticInvoker { } } DEFINE_CLSID!(DiagnosticInvoker(&[87,105,110,100,111,119,115,46,83,121,115,116,101,109,46,68,105,97,103,110,111,115,116,105,99,115,46,68,105,97,103,110,111,115,116,105,99,73,110,118,111,107,101,114,0]) [CLSID_DiagnosticInvoker]); +DEFINE_IID!(IID_IDiagnosticInvoker2, 3820983388, 5466, 19282, 168, 236, 7, 12, 68, 249, 80, 0); +RT_INTERFACE!{interface IDiagnosticInvoker2(IDiagnosticInvoker2Vtbl): IInspectable(IInspectableVtbl) [IID_IDiagnosticInvoker2] { + fn RunDiagnosticActionFromStringAsync(&self, context: HSTRING, out: *mut *mut foundation::IAsyncOperationWithProgress) -> HRESULT +}} +impl IDiagnosticInvoker2 { + #[inline] pub fn run_diagnostic_action_from_string_async(&self, context: &HStringArg) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).RunDiagnosticActionFromStringAsync)(self as *const _ as *mut _, context.get(), &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IDiagnosticInvokerStatics, 1559943390, 61788, 17748, 168, 19, 193, 19, 195, 136, 27, 9); RT_INTERFACE!{static interface IDiagnosticInvokerStatics(IDiagnosticInvokerStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IDiagnosticInvokerStatics] { fn GetDefault(&self, out: *mut *mut DiagnosticInvoker) -> HRESULT, @@ -4365,6 +4536,64 @@ impl IDevicePortalConnectionStatics { if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IDevicePortalWebSocketConnection, 1734703392, 54874, 17136, 174, 244, 120, 120, 8, 9, 139, 123); +RT_INTERFACE!{interface IDevicePortalWebSocketConnection(IDevicePortalWebSocketConnectionVtbl): IInspectable(IInspectableVtbl) [IID_IDevicePortalWebSocketConnection] { + #[cfg(all(feature="windows-networking",feature="windows-web"))] fn GetServerMessageWebSocketForRequest(&self, request: *mut ::rt::gen::windows::web::http::HttpRequestMessage, out: *mut *mut ::rt::gen::windows::networking::sockets::ServerMessageWebSocket) -> HRESULT, + #[cfg(all(feature="windows-networking",feature="windows-web"))] fn GetServerMessageWebSocketForRequest2(&self, request: *mut ::rt::gen::windows::web::http::HttpRequestMessage, messageType: ::rt::gen::windows::networking::sockets::SocketMessageType, protocol: HSTRING, out: *mut *mut ::rt::gen::windows::networking::sockets::ServerMessageWebSocket) -> HRESULT, + #[cfg(all(feature="windows-networking",feature="windows-web"))] fn GetServerMessageWebSocketForRequest3(&self, request: *mut ::rt::gen::windows::web::http::HttpRequestMessage, messageType: ::rt::gen::windows::networking::sockets::SocketMessageType, protocol: HSTRING, outboundBufferSizeInBytes: u32, maxMessageSize: u32, receiveMode: ::rt::gen::windows::networking::sockets::MessageWebSocketReceiveMode, out: *mut *mut ::rt::gen::windows::networking::sockets::ServerMessageWebSocket) -> HRESULT, + #[cfg(all(feature="windows-networking",feature="windows-web"))] fn GetServerStreamWebSocketForRequest(&self, request: *mut ::rt::gen::windows::web::http::HttpRequestMessage, out: *mut *mut ::rt::gen::windows::networking::sockets::ServerStreamWebSocket) -> HRESULT, + #[cfg(all(feature="windows-networking",feature="windows-web"))] fn GetServerStreamWebSocketForRequest2(&self, request: *mut ::rt::gen::windows::web::http::HttpRequestMessage, protocol: HSTRING, outboundBufferSizeInBytes: u32, noDelay: bool, out: *mut *mut ::rt::gen::windows::networking::sockets::ServerStreamWebSocket) -> HRESULT +}} +impl IDevicePortalWebSocketConnection { + #[cfg(all(feature="windows-networking",feature="windows-web"))] #[inline] pub fn get_server_message_web_socket_for_request(&self, request: &::rt::gen::windows::web::http::HttpRequestMessage) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetServerMessageWebSocketForRequest)(self as *const _ as *mut _, request as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[cfg(all(feature="windows-networking",feature="windows-web"))] #[inline] pub fn get_server_message_web_socket_for_request2(&self, request: &::rt::gen::windows::web::http::HttpRequestMessage, messageType: ::rt::gen::windows::networking::sockets::SocketMessageType, protocol: &HStringArg) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetServerMessageWebSocketForRequest2)(self as *const _ as *mut _, request as *const _ as *mut _, messageType, protocol.get(), &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[cfg(all(feature="windows-networking",feature="windows-web"))] #[inline] pub fn get_server_message_web_socket_for_request3(&self, request: &::rt::gen::windows::web::http::HttpRequestMessage, messageType: ::rt::gen::windows::networking::sockets::SocketMessageType, protocol: &HStringArg, outboundBufferSizeInBytes: u32, maxMessageSize: u32, receiveMode: ::rt::gen::windows::networking::sockets::MessageWebSocketReceiveMode) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetServerMessageWebSocketForRequest3)(self as *const _ as *mut _, request as *const _ as *mut _, messageType, protocol.get(), outboundBufferSizeInBytes, maxMessageSize, receiveMode, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[cfg(all(feature="windows-networking",feature="windows-web"))] #[inline] pub fn get_server_stream_web_socket_for_request(&self, request: &::rt::gen::windows::web::http::HttpRequestMessage) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetServerStreamWebSocketForRequest)(self as *const _ as *mut _, request as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[cfg(all(feature="windows-networking",feature="windows-web"))] #[inline] pub fn get_server_stream_web_socket_for_request2(&self, request: &::rt::gen::windows::web::http::HttpRequestMessage, protocol: &HStringArg, outboundBufferSizeInBytes: u32, noDelay: bool) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetServerStreamWebSocketForRequest2)(self as *const _ as *mut _, request as *const _ as *mut _, protocol.get(), outboundBufferSizeInBytes, noDelay, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +DEFINE_IID!(IID_IDevicePortalWebSocketConnectionRequestReceivedEventArgs, 2046675642, 5980, 18233, 159, 116, 221, 167, 151, 195, 91, 63); +RT_INTERFACE!{interface IDevicePortalWebSocketConnectionRequestReceivedEventArgs(IDevicePortalWebSocketConnectionRequestReceivedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IDevicePortalWebSocketConnectionRequestReceivedEventArgs] { + fn get_IsWebSocketUpgradeRequest(&self, out: *mut bool) -> HRESULT, + fn get_WebSocketProtocolsRequested(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT, + fn GetDeferral(&self, out: *mut *mut foundation::Deferral) -> HRESULT +}} +impl IDevicePortalWebSocketConnectionRequestReceivedEventArgs { + #[inline] pub fn get_is_web_socket_upgrade_request(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_IsWebSocketUpgradeRequest)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_web_socket_protocols_requested(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_WebSocketProtocolsRequested)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_deferral(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetDeferral)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} } // Windows.System.Diagnostics.DevicePortal } // Windows.System.Diagnostics pub mod remotesystems { // Windows.System.RemoteSystems @@ -4505,6 +4734,17 @@ impl IRemoteSystem3 { if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IRemoteSystem4, 4049928165, 47495, 19621, 153, 38, 250, 4, 56, 190, 98, 115); +RT_INTERFACE!{interface IRemoteSystem4(IRemoteSystem4Vtbl): IInspectable(IInspectableVtbl) [IID_IRemoteSystem4] { + fn get_Platform(&self, out: *mut RemoteSystemPlatform) -> HRESULT +}} +impl IRemoteSystem4 { + #[inline] pub fn get_platform(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Platform)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} RT_ENUM! { enum RemoteSystemAccessStatus: i32 { Unspecified (RemoteSystemAccessStatus_Unspecified) = 0, Allowed (RemoteSystemAccessStatus_Allowed) = 1, DeniedByUser (RemoteSystemAccessStatus_DeniedByUser) = 2, DeniedBySystem (RemoteSystemAccessStatus_DeniedBySystem) = 3, }} @@ -4616,6 +4856,11 @@ impl IRemoteSystemDiscoveryTypeFilterFactory { if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IRemoteSystemEnumerationCompletedEventArgs, 3337108831, 16432, 17236, 160, 96, 20, 241, 178, 44, 84, 93); +RT_INTERFACE!{interface IRemoteSystemEnumerationCompletedEventArgs(IRemoteSystemEnumerationCompletedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IRemoteSystemEnumerationCompletedEventArgs] { + +}} +RT_CLASS!{class RemoteSystemEnumerationCompletedEventArgs: IRemoteSystemEnumerationCompletedEventArgs} DEFINE_IID!(IID_IRemoteSystemFilter, 1245424100, 39403, 17899, 186, 22, 3, 103, 114, 143, 243, 116); RT_INTERFACE!{interface IRemoteSystemFilter(IRemoteSystemFilterVtbl): IInspectable(IInspectableVtbl) [IID_IRemoteSystemFilter] { @@ -4738,6 +4983,9 @@ impl IRemoteSystemKindStatics2 { if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } }} } +RT_ENUM! { enum RemoteSystemPlatform: i32 { + Unknown (RemoteSystemPlatform_Unknown) = 0, Windows (RemoteSystemPlatform_Windows) = 1, Android (RemoteSystemPlatform_Android) = 2, Ios (RemoteSystemPlatform_Ios) = 3, Linux (RemoteSystemPlatform_Linux) = 4, +}} DEFINE_IID!(IID_IRemoteSystemRemovedEventArgs, 2336036539, 29446, 18922, 183, 223, 103, 213, 113, 76, 176, 19); RT_INTERFACE!{interface IRemoteSystemRemovedEventArgs(IRemoteSystemRemovedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IRemoteSystemRemovedEventArgs] { fn get_RemoteSystemId(&self, out: *mut HSTRING) -> HRESULT @@ -5476,6 +5724,48 @@ impl IRemoteSystemWatcher { }} } RT_CLASS!{class RemoteSystemWatcher: IRemoteSystemWatcher} +DEFINE_IID!(IID_IRemoteSystemWatcher2, 1933797120, 6602, 18681, 164, 205, 120, 15, 122, 213, 140, 113); +RT_INTERFACE!{interface IRemoteSystemWatcher2(IRemoteSystemWatcher2Vtbl): IInspectable(IInspectableVtbl) [IID_IRemoteSystemWatcher2] { + fn add_EnumerationCompleted(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_EnumerationCompleted(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn add_ErrorOccurred(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_ErrorOccurred(&self, token: foundation::EventRegistrationToken) -> HRESULT +}} +impl IRemoteSystemWatcher2 { + #[inline] pub fn add_enumeration_completed(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_EnumerationCompleted)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_enumeration_completed(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_EnumerationCompleted)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_error_occurred(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_ErrorOccurred)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_error_occurred(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_ErrorOccurred)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_ENUM! { enum RemoteSystemWatcherError: i32 { + Unknown (RemoteSystemWatcherError_Unknown) = 0, InternetNotAvailable (RemoteSystemWatcherError_InternetNotAvailable) = 1, AuthenticationError (RemoteSystemWatcherError_AuthenticationError) = 2, +}} +DEFINE_IID!(IID_IRemoteSystemWatcherErrorOccurredEventArgs, 1959118511, 20756, 17446, 146, 22, 32, 216, 31, 133, 25, 174); +RT_INTERFACE!{interface IRemoteSystemWatcherErrorOccurredEventArgs(IRemoteSystemWatcherErrorOccurredEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IRemoteSystemWatcherErrorOccurredEventArgs] { + fn get_Error(&self, out: *mut RemoteSystemWatcherError) -> HRESULT +}} +impl IRemoteSystemWatcherErrorOccurredEventArgs { + #[inline] pub fn get_error(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Error)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} +RT_CLASS!{class RemoteSystemWatcherErrorOccurredEventArgs: IRemoteSystemWatcherErrorOccurredEventArgs} } // Windows.System.RemoteSystems pub mod threading { // Windows.System.Threading use ::prelude::*; @@ -5764,3 +6054,54 @@ RT_CLASS!{class DisplayRequest: IDisplayRequest} impl RtActivatable for DisplayRequest {} DEFINE_CLSID!(DisplayRequest(&[87,105,110,100,111,119,115,46,83,121,115,116,101,109,46,68,105,115,112,108,97,121,46,68,105,115,112,108,97,121,82,101,113,117,101,115,116,0]) [CLSID_DisplayRequest]); } // Windows.System.Display +pub mod inventory { // Windows.System.Inventory +use ::prelude::*; +DEFINE_IID!(IID_IInstalledDesktopApp, 1978317037, 49340, 21348, 76, 40, 22, 110, 5, 69, 22, 122); +RT_INTERFACE!{interface IInstalledDesktopApp(IInstalledDesktopAppVtbl): IInspectable(IInspectableVtbl) [IID_IInstalledDesktopApp] { + fn get_Id(&self, out: *mut HSTRING) -> HRESULT, + fn get_DisplayName(&self, out: *mut HSTRING) -> HRESULT, + fn get_Publisher(&self, out: *mut HSTRING) -> HRESULT, + fn get_DisplayVersion(&self, out: *mut HSTRING) -> HRESULT +}} +impl IInstalledDesktopApp { + #[inline] pub fn get_id(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Id)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_display_name(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_DisplayName)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_publisher(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Publisher)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_display_version(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_DisplayVersion)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} +} +RT_CLASS!{class InstalledDesktopApp: IInstalledDesktopApp} +impl RtActivatable for InstalledDesktopApp {} +impl InstalledDesktopApp { + #[inline] pub fn get_inventory_async() -> Result>>> { + >::get_activation_factory().get_inventory_async() + } +} +DEFINE_CLSID!(InstalledDesktopApp(&[87,105,110,100,111,119,115,46,83,121,115,116,101,109,46,73,110,118,101,110,116,111,114,121,46,73,110,115,116,97,108,108,101,100,68,101,115,107,116,111,112,65,112,112,0]) [CLSID_InstalledDesktopApp]); +DEFINE_IID!(IID_IInstalledDesktopAppStatics, 642578254, 8653, 24475, 96, 86, 120, 102, 173, 114, 72, 154); +RT_INTERFACE!{static interface IInstalledDesktopAppStatics(IInstalledDesktopAppStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IInstalledDesktopAppStatics] { + fn GetInventoryAsync(&self, out: *mut *mut foundation::IAsyncOperation>) -> HRESULT +}} +impl IInstalledDesktopAppStatics { + #[inline] pub fn get_inventory_async(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetInventoryAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} +} +} // Windows.System.Inventory diff --git a/src/rt/gen/windows/ui/mod.rs b/src/rt/gen/windows/ui/mod.rs index 490450f..f1c41c2 100644 --- a/src/rt/gen/windows/ui/mod.rs +++ b/src/rt/gen/windows/ui/mod.rs @@ -1362,7 +1362,7 @@ impl IAcceleratorKeyEventArgs2 { }} } RT_ENUM! { enum AppViewBackButtonVisibility: i32 { - Visible (AppViewBackButtonVisibility_Visible) = 0, Collapsed (AppViewBackButtonVisibility_Collapsed) = 1, + Visible (AppViewBackButtonVisibility_Visible) = 0, Collapsed (AppViewBackButtonVisibility_Collapsed) = 1, Disabled (AppViewBackButtonVisibility_Disabled) = 2, }} DEFINE_IID!(IID_IAutomationProviderRequestedEventArgs, 2518676056, 8639, 19266, 162, 152, 250, 71, 157, 76, 82, 226); RT_INTERFACE!{interface IAutomationProviderRequestedEventArgs(IAutomationProviderRequestedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IAutomationProviderRequestedEventArgs] { @@ -1847,6 +1847,17 @@ impl ICorePointerInputSource { if hr == S_OK { Ok(()) } else { err(hr) } }} } +DEFINE_IID!(IID_ICorePointerInputSource2, 3607326858, 17686, 18310, 177, 229, 39, 81, 213, 99, 249, 151); +RT_INTERFACE!{interface ICorePointerInputSource2(ICorePointerInputSource2Vtbl): IInspectable(IInspectableVtbl) [IID_ICorePointerInputSource2] { + #[cfg(feature="windows-system")] fn get_DispatcherQueue(&self, out: *mut *mut super::super::system::DispatcherQueue) -> HRESULT +}} +impl ICorePointerInputSource2 { + #[cfg(feature="windows-system")] #[inline] pub fn get_dispatcher_queue(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_DispatcherQueue)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_ICorePointerRedirector, 2409434260, 22152, 19212, 169, 241, 249, 49, 247, 250, 61, 195); RT_INTERFACE!{interface ICorePointerRedirector(ICorePointerRedirectorVtbl): IInspectable(IInspectableVtbl) [IID_ICorePointerRedirector] { fn add_PointerRoutedAway(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, @@ -5643,6 +5654,17 @@ impl ISpatialInteractionController2 { if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_ISpatialInteractionController3, 1652844192, 40337, 18955, 136, 141, 22, 94, 103, 10, 140, 213); +RT_INTERFACE!{interface ISpatialInteractionController3(ISpatialInteractionController3Vtbl): IInspectable(IInspectableVtbl) [IID_ISpatialInteractionController3] { + #[cfg(feature="windows-devices")] fn TryGetBatteryReport(&self, out: *mut *mut ::rt::gen::windows::devices::power::BatteryReport) -> HRESULT +}} +impl ISpatialInteractionController3 { + #[cfg(feature="windows-devices")] #[inline] pub fn try_get_battery_report(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).TryGetBatteryReport)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_ISpatialInteractionControllerProperties, 1627746225, 31657, 20021, 185, 63, 146, 114, 203, 169, 178, 139); RT_INTERFACE!{interface ISpatialInteractionControllerProperties(ISpatialInteractionControllerPropertiesVtbl): IInspectable(IInspectableVtbl) [IID_ISpatialInteractionControllerProperties] { fn get_IsTouchpadTouched(&self, out: *mut bool) -> HRESULT, @@ -6410,6 +6432,17 @@ impl RadialControllerIndependentInputSource { } } DEFINE_CLSID!(RadialControllerIndependentInputSource(&[87,105,110,100,111,119,115,46,85,73,46,73,110,112,117,116,46,67,111,114,101,46,82,97,100,105,97,108,67,111,110,116,114,111,108,108,101,114,73,110,100,101,112,101,110,100,101,110,116,73,110,112,117,116,83,111,117,114,99,101,0]) [CLSID_RadialControllerIndependentInputSource]); +DEFINE_IID!(IID_IRadialControllerIndependentInputSource2, 1886628568, 13811, 20203, 135, 81, 190, 77, 10, 102, 250, 244); +RT_INTERFACE!{interface IRadialControllerIndependentInputSource2(IRadialControllerIndependentInputSource2Vtbl): IInspectable(IInspectableVtbl) [IID_IRadialControllerIndependentInputSource2] { + #[cfg(feature="windows-system")] fn get_DispatcherQueue(&self, out: *mut *mut ::rt::gen::windows::system::DispatcherQueue) -> HRESULT +}} +impl IRadialControllerIndependentInputSource2 { + #[cfg(feature="windows-system")] #[inline] pub fn get_dispatcher_queue(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_DispatcherQueue)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IRadialControllerIndependentInputSourceStatics, 1029144309, 19694, 4582, 181, 53, 0, 27, 220, 6, 171, 59); RT_INTERFACE!{static interface IRadialControllerIndependentInputSourceStatics(IRadialControllerIndependentInputSourceStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IRadialControllerIndependentInputSourceStatics] { #[cfg(feature="windows-applicationmodel")] fn CreateForView(&self, view: *mut ::rt::gen::windows::applicationmodel::core::CoreApplicationView, out: *mut *mut RadialControllerIndependentInputSource) -> HRESULT @@ -6553,6 +6586,17 @@ impl IInkDrawingAttributes4 { if hr == S_OK { Ok(()) } else { err(hr) } }} } +DEFINE_IID!(IID_IInkDrawingAttributes5, 3508183227, 1909, 18514, 174, 100, 65, 20, 58, 122, 230, 201); +RT_INTERFACE!{interface IInkDrawingAttributes5(IInkDrawingAttributes5Vtbl): IInspectable(IInspectableVtbl) [IID_IInkDrawingAttributes5] { + fn get_ModelerAttributes(&self, out: *mut *mut InkModelerAttributes) -> HRESULT +}} +impl IInkDrawingAttributes5 { + #[inline] pub fn get_modeler_attributes(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ModelerAttributes)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} RT_ENUM! { enum InkDrawingAttributesKind: i32 { Default (InkDrawingAttributesKind_Default) = 0, Pencil (InkDrawingAttributesKind_Pencil) = 1, }} @@ -6587,6 +6631,34 @@ impl IInkDrawingAttributesStatics { RT_ENUM! { enum InkHighContrastAdjustment: i32 { UseSystemColorsWhenNecessary (InkHighContrastAdjustment_UseSystemColorsWhenNecessary) = 0, UseSystemColors (InkHighContrastAdjustment_UseSystemColors) = 1, UseOriginalColors (InkHighContrastAdjustment_UseOriginalColors) = 2, }} +DEFINE_IID!(IID_IInkInputConfiguration, 2477166020, 2939, 18903, 179, 79, 153, 1, 229, 36, 220, 242); +RT_INTERFACE!{interface IInkInputConfiguration(IInkInputConfigurationVtbl): IInspectable(IInspectableVtbl) [IID_IInkInputConfiguration] { + fn get_IsPrimaryBarrelButtonInputEnabled(&self, out: *mut bool) -> HRESULT, + fn put_IsPrimaryBarrelButtonInputEnabled(&self, value: bool) -> HRESULT, + fn get_IsEraserInputEnabled(&self, out: *mut bool) -> HRESULT, + fn put_IsEraserInputEnabled(&self, value: bool) -> HRESULT +}} +impl IInkInputConfiguration { + #[inline] pub fn get_is_primary_barrel_button_input_enabled(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_IsPrimaryBarrelButtonInputEnabled)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_is_primary_barrel_button_input_enabled(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_IsPrimaryBarrelButtonInputEnabled)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_is_eraser_input_enabled(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_IsEraserInputEnabled)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_is_eraser_input_enabled(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_IsEraserInputEnabled)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class InkInputConfiguration: IInkInputConfiguration} DEFINE_IID!(IID_IInkInputProcessingConfiguration, 662231134, 13258, 19206, 166, 211, 172, 57, 69, 17, 109, 55); RT_INTERFACE!{interface IInkInputProcessingConfiguration(IInkInputProcessingConfigurationVtbl): IInspectable(IInspectableVtbl) [IID_IInkInputProcessingConfiguration] { fn get_Mode(&self, out: *mut InkInputProcessingMode) -> HRESULT, @@ -6671,6 +6743,34 @@ DEFINE_CLSID!(InkManager(&[87,105,110,100,111,119,115,46,85,73,46,73,110,112,117 RT_ENUM! { enum InkManipulationMode: i32 { Inking (InkManipulationMode_Inking) = 0, Erasing (InkManipulationMode_Erasing) = 1, Selecting (InkManipulationMode_Selecting) = 2, }} +DEFINE_IID!(IID_IInkModelerAttributes, 3134398247, 3289, 19453, 182, 243, 158, 3, 186, 141, 116, 84); +RT_INTERFACE!{interface IInkModelerAttributes(IInkModelerAttributesVtbl): IInspectable(IInspectableVtbl) [IID_IInkModelerAttributes] { + fn get_PredictionTime(&self, out: *mut foundation::TimeSpan) -> HRESULT, + fn put_PredictionTime(&self, value: foundation::TimeSpan) -> HRESULT, + fn get_ScalingFactor(&self, out: *mut f32) -> HRESULT, + fn put_ScalingFactor(&self, value: f32) -> HRESULT +}} +impl IInkModelerAttributes { + #[inline] pub fn get_prediction_time(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_PredictionTime)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_prediction_time(&self, value: foundation::TimeSpan) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_PredictionTime)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_scaling_factor(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_ScalingFactor)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_scaling_factor(&self, value: f32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_ScalingFactor)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class InkModelerAttributes: IInkModelerAttributes} RT_ENUM! { enum InkPersistenceFormat: i32 { GifWithEmbeddedIsf (InkPersistenceFormat_GifWithEmbeddedIsf) = 0, Isf (InkPersistenceFormat_Isf) = 1, }} @@ -6865,6 +6965,17 @@ impl IInkPresenter2 { if hr == S_OK { Ok(()) } else { err(hr) } }} } +DEFINE_IID!(IID_IInkPresenter3, 1373752969, 54141, 19088, 131, 252, 127, 94, 157, 251, 242, 23); +RT_INTERFACE!{interface IInkPresenter3(IInkPresenter3Vtbl): IInspectable(IInspectableVtbl) [IID_IInkPresenter3] { + fn get_InputConfiguration(&self, out: *mut *mut InkInputConfiguration) -> HRESULT +}} +impl IInkPresenter3 { + #[inline] pub fn get_input_configuration(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_InputConfiguration)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} RT_ENUM! { enum InkPresenterPredefinedConfiguration: i32 { SimpleSinglePointer (InkPresenterPredefinedConfiguration_SimpleSinglePointer) = 0, SimpleMultiplePointer (InkPresenterPredefinedConfiguration_SimpleMultiplePointer) = 1, }} @@ -8276,6 +8387,69 @@ use ::prelude::*; RT_ENUM! { enum CaretType: i32 { Normal (CaretType_Normal) = 0, Null (CaretType_Null) = 1, }} +DEFINE_IID!(IID_IContentLinkInfo, 517285157, 7263, 18635, 179, 53, 120, 181, 10, 46, 230, 66); +RT_INTERFACE!{interface IContentLinkInfo(IContentLinkInfoVtbl): IInspectable(IInspectableVtbl) [IID_IContentLinkInfo] { + fn get_Id(&self, out: *mut u32) -> HRESULT, + fn put_Id(&self, value: u32) -> HRESULT, + fn get_DisplayText(&self, out: *mut HSTRING) -> HRESULT, + fn put_DisplayText(&self, value: HSTRING) -> HRESULT, + fn get_SecondaryText(&self, out: *mut HSTRING) -> HRESULT, + fn put_SecondaryText(&self, value: HSTRING) -> HRESULT, + fn get_Uri(&self, out: *mut *mut foundation::Uri) -> HRESULT, + fn put_Uri(&self, value: *mut foundation::Uri) -> HRESULT, + fn get_LinkContentKind(&self, out: *mut HSTRING) -> HRESULT, + fn put_LinkContentKind(&self, value: HSTRING) -> HRESULT +}} +impl IContentLinkInfo { + #[inline] pub fn get_id(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Id)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_id(&self, value: u32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Id)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_display_text(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_DisplayText)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn set_display_text(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_DisplayText)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_secondary_text(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_SecondaryText)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn set_secondary_text(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_SecondaryText)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_uri(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Uri)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn set_uri(&self, value: &foundation::Uri) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Uri)(self as *const _ as *mut _, value as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_link_content_kind(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_LinkContentKind)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn set_link_content_kind(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_LinkContentKind)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class ContentLinkInfo: IContentLinkInfo} +impl RtActivatable for ContentLinkInfo {} +DEFINE_CLSID!(ContentLinkInfo(&[87,105,110,100,111,119,115,46,85,73,46,84,101,120,116,46,67,111,110,116,101,110,116,76,105,110,107,73,110,102,111,0]) [CLSID_ContentLinkInfo]); RT_ENUM! { enum FindOptions: u32 { None (FindOptions_None) = 0, Word (FindOptions_Word) = 2, Case (FindOptions_Case) = 4, }} @@ -8438,6 +8612,23 @@ RT_ENUM! { enum RangeGravity: i32 { UIBehavior (RangeGravity_UIBehavior) = 0, Backward (RangeGravity_Backward) = 1, Forward (RangeGravity_Forward) = 2, Inward (RangeGravity_Inward) = 3, Outward (RangeGravity_Outward) = 4, }} RT_CLASS!{class RichEditTextDocument: ITextDocument} +DEFINE_IID!(IID_IRichEditTextRange, 927872277, 47754, 19054, 140, 89, 13, 222, 61, 12, 245, 205); +RT_INTERFACE!{interface IRichEditTextRange(IRichEditTextRangeVtbl): IInspectable(IInspectableVtbl) [IID_IRichEditTextRange] { + fn get_ContentLinkInfo(&self, out: *mut *mut ContentLinkInfo) -> HRESULT, + fn put_ContentLinkInfo(&self, value: *mut ContentLinkInfo) -> HRESULT +}} +impl IRichEditTextRange { + #[inline] pub fn get_content_link_info(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ContentLinkInfo)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn set_content_link_info(&self, value: &ContentLinkInfo) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_ContentLinkInfo)(self as *const _ as *mut _, value as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class RichEditTextRange: ITextRange} RT_ENUM! { enum SelectionOptions: u32 { StartActive (SelectionOptions_StartActive) = 1, AtEndOfLine (SelectionOptions_AtEndOfLine) = 2, Overtype (SelectionOptions_Overtype) = 4, Active (SelectionOptions_Active) = 8, Replace (SelectionOptions_Replace) = 16, }} @@ -9571,7 +9762,7 @@ impl ITextRange { }} } RT_ENUM! { enum TextRangeUnit: i32 { - Character (TextRangeUnit_Character) = 0, Word (TextRangeUnit_Word) = 1, Sentence (TextRangeUnit_Sentence) = 2, Paragraph (TextRangeUnit_Paragraph) = 3, Line (TextRangeUnit_Line) = 4, Story (TextRangeUnit_Story) = 5, Screen (TextRangeUnit_Screen) = 6, Section (TextRangeUnit_Section) = 7, Window (TextRangeUnit_Window) = 8, CharacterFormat (TextRangeUnit_CharacterFormat) = 9, ParagraphFormat (TextRangeUnit_ParagraphFormat) = 10, Object (TextRangeUnit_Object) = 11, HardParagraph (TextRangeUnit_HardParagraph) = 12, Cluster (TextRangeUnit_Cluster) = 13, Bold (TextRangeUnit_Bold) = 14, Italic (TextRangeUnit_Italic) = 15, Underline (TextRangeUnit_Underline) = 16, Strikethrough (TextRangeUnit_Strikethrough) = 17, ProtectedText (TextRangeUnit_ProtectedText) = 18, Link (TextRangeUnit_Link) = 19, SmallCaps (TextRangeUnit_SmallCaps) = 20, AllCaps (TextRangeUnit_AllCaps) = 21, Hidden (TextRangeUnit_Hidden) = 22, Outline (TextRangeUnit_Outline) = 23, Shadow (TextRangeUnit_Shadow) = 24, Imprint (TextRangeUnit_Imprint) = 25, Disabled (TextRangeUnit_Disabled) = 26, Revised (TextRangeUnit_Revised) = 27, Subscript (TextRangeUnit_Subscript) = 28, Superscript (TextRangeUnit_Superscript) = 29, FontBound (TextRangeUnit_FontBound) = 30, LinkProtected (TextRangeUnit_LinkProtected) = 31, + Character (TextRangeUnit_Character) = 0, Word (TextRangeUnit_Word) = 1, Sentence (TextRangeUnit_Sentence) = 2, Paragraph (TextRangeUnit_Paragraph) = 3, Line (TextRangeUnit_Line) = 4, Story (TextRangeUnit_Story) = 5, Screen (TextRangeUnit_Screen) = 6, Section (TextRangeUnit_Section) = 7, Window (TextRangeUnit_Window) = 8, CharacterFormat (TextRangeUnit_CharacterFormat) = 9, ParagraphFormat (TextRangeUnit_ParagraphFormat) = 10, Object (TextRangeUnit_Object) = 11, HardParagraph (TextRangeUnit_HardParagraph) = 12, Cluster (TextRangeUnit_Cluster) = 13, Bold (TextRangeUnit_Bold) = 14, Italic (TextRangeUnit_Italic) = 15, Underline (TextRangeUnit_Underline) = 16, Strikethrough (TextRangeUnit_Strikethrough) = 17, ProtectedText (TextRangeUnit_ProtectedText) = 18, Link (TextRangeUnit_Link) = 19, SmallCaps (TextRangeUnit_SmallCaps) = 20, AllCaps (TextRangeUnit_AllCaps) = 21, Hidden (TextRangeUnit_Hidden) = 22, Outline (TextRangeUnit_Outline) = 23, Shadow (TextRangeUnit_Shadow) = 24, Imprint (TextRangeUnit_Imprint) = 25, Disabled (TextRangeUnit_Disabled) = 26, Revised (TextRangeUnit_Revised) = 27, Subscript (TextRangeUnit_Subscript) = 28, Superscript (TextRangeUnit_Superscript) = 29, FontBound (TextRangeUnit_FontBound) = 30, LinkProtected (TextRangeUnit_LinkProtected) = 31, ContentLink (TextRangeUnit_ContentLink) = 32, }} RT_ENUM! { enum TextScript: i32 { Undefined (TextScript_Undefined) = 0, Ansi (TextScript_Ansi) = 1, EastEurope (TextScript_EastEurope) = 2, Cyrillic (TextScript_Cyrillic) = 3, Greek (TextScript_Greek) = 4, Turkish (TextScript_Turkish) = 5, Hebrew (TextScript_Hebrew) = 6, Arabic (TextScript_Arabic) = 7, Baltic (TextScript_Baltic) = 8, Vietnamese (TextScript_Vietnamese) = 9, Default (TextScript_Default) = 10, Symbol (TextScript_Symbol) = 11, Thai (TextScript_Thai) = 12, ShiftJis (TextScript_ShiftJis) = 13, GB2312 (TextScript_GB2312) = 14, Hangul (TextScript_Hangul) = 15, Big5 (TextScript_Big5) = 16, PC437 (TextScript_PC437) = 17, Oem (TextScript_Oem) = 18, Mac (TextScript_Mac) = 19, Armenian (TextScript_Armenian) = 20, Syriac (TextScript_Syriac) = 21, Thaana (TextScript_Thaana) = 22, Devanagari (TextScript_Devanagari) = 23, Bengali (TextScript_Bengali) = 24, Gurmukhi (TextScript_Gurmukhi) = 25, Gujarati (TextScript_Gujarati) = 26, Oriya (TextScript_Oriya) = 27, Tamil (TextScript_Tamil) = 28, Telugu (TextScript_Telugu) = 29, Kannada (TextScript_Kannada) = 30, Malayalam (TextScript_Malayalam) = 31, Sinhala (TextScript_Sinhala) = 32, Lao (TextScript_Lao) = 33, Tibetan (TextScript_Tibetan) = 34, Myanmar (TextScript_Myanmar) = 35, Georgian (TextScript_Georgian) = 36, Jamo (TextScript_Jamo) = 37, Ethiopic (TextScript_Ethiopic) = 38, Cherokee (TextScript_Cherokee) = 39, Aboriginal (TextScript_Aboriginal) = 40, Ogham (TextScript_Ogham) = 41, Runic (TextScript_Runic) = 42, Khmer (TextScript_Khmer) = 43, Mongolian (TextScript_Mongolian) = 44, Braille (TextScript_Braille) = 45, Yi (TextScript_Yi) = 46, Limbu (TextScript_Limbu) = 47, TaiLe (TextScript_TaiLe) = 48, NewTaiLue (TextScript_NewTaiLue) = 49, SylotiNagri (TextScript_SylotiNagri) = 50, Kharoshthi (TextScript_Kharoshthi) = 51, Kayahli (TextScript_Kayahli) = 52, UnicodeSymbol (TextScript_UnicodeSymbol) = 53, Emoji (TextScript_Emoji) = 54, Glagolitic (TextScript_Glagolitic) = 55, Lisu (TextScript_Lisu) = 56, Vai (TextScript_Vai) = 57, NKo (TextScript_NKo) = 58, Osmanya (TextScript_Osmanya) = 59, PhagsPa (TextScript_PhagsPa) = 60, Gothic (TextScript_Gothic) = 61, Deseret (TextScript_Deseret) = 62, Tifinagh (TextScript_Tifinagh) = 63, @@ -11568,6 +11759,39 @@ impl CoreInputView { } } DEFINE_CLSID!(CoreInputView(&[87,105,110,100,111,119,115,46,85,73,46,86,105,101,119,77,97,110,97,103,101,109,101,110,116,46,67,111,114,101,46,67,111,114,101,73,110,112,117,116,86,105,101,119,0]) [CLSID_CoreInputView]); +DEFINE_IID!(IID_ICoreInputView2, 248981185, 57498, 19176, 174, 223, 223, 164, 133, 125, 26, 1); +RT_INTERFACE!{interface ICoreInputView2(ICoreInputView2Vtbl): IInspectable(IInspectableVtbl) [IID_ICoreInputView2] { + fn add_XYFocusTransferringFromPrimaryView(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_XYFocusTransferringFromPrimaryView(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn add_XYFocusTransferredToPrimaryView(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_XYFocusTransferredToPrimaryView(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn TryTransferXYFocusToPrimaryView(&self, origin: foundation::Rect, direction: CoreInputViewXYFocusTransferDirection, out: *mut bool) -> HRESULT +}} +impl ICoreInputView2 { + #[inline] pub fn add_xyfocus_transferring_from_primary_view(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_XYFocusTransferringFromPrimaryView)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_xyfocus_transferring_from_primary_view(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_XYFocusTransferringFromPrimaryView)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_xyfocus_transferred_to_primary_view(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_XYFocusTransferredToPrimaryView)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_xyfocus_transferred_to_primary_view(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_XYFocusTransferredToPrimaryView)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn try_transfer_xyfocus_to_primary_view(&self, origin: foundation::Rect, direction: CoreInputViewXYFocusTransferDirection) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).TryTransferXYFocusToPrimaryView)(self as *const _ as *mut _, origin, direction, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} DEFINE_IID!(IID_ICoreInputViewOcclusion, 3426143750, 14437, 16759, 181, 245, 139, 101, 224, 185, 206, 132); RT_INTERFACE!{interface ICoreInputViewOcclusion(ICoreInputViewOcclusionVtbl): IInspectable(IInspectableVtbl) [IID_ICoreInputViewOcclusion] { fn get_OccludingRect(&self, out: *mut foundation::Rect) -> HRESULT, @@ -11623,6 +11847,49 @@ impl ICoreInputViewStatics { if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_ICoreInputViewTransferringXYFocusEventArgs, 81663647, 47618, 18512, 139, 85, 216, 45, 3, 186, 109, 127); +RT_INTERFACE!{interface ICoreInputViewTransferringXYFocusEventArgs(ICoreInputViewTransferringXYFocusEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_ICoreInputViewTransferringXYFocusEventArgs] { + fn get_Origin(&self, out: *mut foundation::Rect) -> HRESULT, + fn get_Direction(&self, out: *mut CoreInputViewXYFocusTransferDirection) -> HRESULT, + fn put_TransferHandled(&self, value: bool) -> HRESULT, + fn get_TransferHandled(&self, out: *mut bool) -> HRESULT, + fn put_KeepPrimaryViewVisible(&self, value: bool) -> HRESULT, + fn get_KeepPrimaryViewVisible(&self, out: *mut bool) -> HRESULT +}} +impl ICoreInputViewTransferringXYFocusEventArgs { + #[inline] pub fn get_origin(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Origin)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_direction(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Direction)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_transfer_handled(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_TransferHandled)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_transfer_handled(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_TransferHandled)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_keep_primary_view_visible(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_KeepPrimaryViewVisible)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_keep_primary_view_visible(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_KeepPrimaryViewVisible)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} +RT_CLASS!{class CoreInputViewTransferringXYFocusEventArgs: ICoreInputViewTransferringXYFocusEventArgs} +RT_ENUM! { enum CoreInputViewXYFocusTransferDirection: i32 { + Up (CoreInputViewXYFocusTransferDirection_Up) = 0, Right (CoreInputViewXYFocusTransferDirection_Right) = 1, Down (CoreInputViewXYFocusTransferDirection_Down) = 2, Left (CoreInputViewXYFocusTransferDirection_Left) = 3, +}} } // Windows.UI.ViewManagement.Core } // Windows.UI.ViewManagement pub mod applicationsettings { // Windows.UI.ApplicationSettings @@ -11646,6 +11913,7 @@ impl IAccountsSettingsPane { RT_CLASS!{class AccountsSettingsPane: IAccountsSettingsPane} impl RtActivatable for AccountsSettingsPane {} impl RtActivatable for AccountsSettingsPane {} +impl RtActivatable for AccountsSettingsPane {} impl AccountsSettingsPane { #[inline] pub fn get_for_current_view() -> Result>> { >::get_activation_factory().get_for_current_view() @@ -11659,6 +11927,12 @@ impl AccountsSettingsPane { #[inline] pub fn show_add_account_async() -> Result> { >::get_activation_factory().show_add_account_async() } + #[cfg(feature="windows-system")] #[inline] pub fn show_manage_accounts_for_user_async(user: &super::super::system::User) -> Result> { + >::get_activation_factory().show_manage_accounts_for_user_async(user) + } + #[cfg(feature="windows-system")] #[inline] pub fn show_add_account_for_user_async(user: &super::super::system::User) -> Result> { + >::get_activation_factory().show_add_account_for_user_async(user) + } } DEFINE_CLSID!(AccountsSettingsPane(&[87,105,110,100,111,119,115,46,85,73,46,65,112,112,108,105,99,97,116,105,111,110,83,101,116,116,105,110,103,115,46,65,99,99,111,117,110,116,115,83,101,116,116,105,110,103,115,80,97,110,101,0]) [CLSID_AccountsSettingsPane]); DEFINE_IID!(IID_IAccountsSettingsPaneCommandsRequestedEventArgs, 996720793, 56089, 17872, 154, 191, 149, 211, 119, 60, 147, 48); @@ -11708,6 +11982,17 @@ impl IAccountsSettingsPaneCommandsRequestedEventArgs { }} } RT_CLASS!{class AccountsSettingsPaneCommandsRequestedEventArgs: IAccountsSettingsPaneCommandsRequestedEventArgs} +DEFINE_IID!(IID_IAccountsSettingsPaneCommandsRequestedEventArgs2, 909081517, 20023, 18791, 140, 64, 231, 142, 231, 161, 229, 187); +RT_INTERFACE!{interface IAccountsSettingsPaneCommandsRequestedEventArgs2(IAccountsSettingsPaneCommandsRequestedEventArgs2Vtbl): IInspectable(IInspectableVtbl) [IID_IAccountsSettingsPaneCommandsRequestedEventArgs2] { + #[cfg(feature="windows-system")] fn get_User(&self, out: *mut *mut super::super::system::User) -> HRESULT +}} +impl IAccountsSettingsPaneCommandsRequestedEventArgs2 { + #[cfg(feature="windows-system")] #[inline] pub fn get_user(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_User)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IAccountsSettingsPaneEventDeferral, 3421658431, 58810, 16623, 147, 218, 101, 224, 150, 229, 251, 4); RT_INTERFACE!{interface IAccountsSettingsPaneEventDeferral(IAccountsSettingsPaneEventDeferralVtbl): IInspectable(IInspectableVtbl) [IID_IAccountsSettingsPaneEventDeferral] { fn Complete(&self) -> HRESULT @@ -11752,6 +12037,23 @@ impl IAccountsSettingsPaneStatics2 { if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IAccountsSettingsPaneStatics3, 138478680, 41658, 19567, 180, 172, 72, 245, 20, 51, 18, 22); +RT_INTERFACE!{static interface IAccountsSettingsPaneStatics3(IAccountsSettingsPaneStatics3Vtbl): IInspectable(IInspectableVtbl) [IID_IAccountsSettingsPaneStatics3] { + #[cfg(feature="windows-system")] fn ShowManageAccountsForUserAsync(&self, user: *mut super::super::system::User, out: *mut *mut foundation::IAsyncAction) -> HRESULT, + #[cfg(feature="windows-system")] fn ShowAddAccountForUserAsync(&self, user: *mut super::super::system::User, out: *mut *mut foundation::IAsyncAction) -> HRESULT +}} +impl IAccountsSettingsPaneStatics3 { + #[cfg(feature="windows-system")] #[inline] pub fn show_manage_accounts_for_user_async(&self, user: &super::super::system::User) -> Result> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).ShowManageAccountsForUserAsync)(self as *const _ as *mut _, user as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[cfg(feature="windows-system")] #[inline] pub fn show_add_account_for_user_async(&self, user: &super::super::system::User) -> Result> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).ShowAddAccountForUserAsync)(self as *const _ as *mut _, user as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_ICredentialCommand, 2784388582, 24899, 19066, 169, 113, 176, 23, 186, 151, 140, 226); RT_INTERFACE!{interface ICredentialCommand(ICredentialCommandVtbl): IInspectable(IInspectableVtbl) [IID_ICredentialCommand] { #[cfg(not(feature="windows-security"))] fn __Dummy0(&self) -> (), @@ -12452,6 +12754,8 @@ impl IWebUIBackgroundTaskInstanceStatics { if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } +#[cfg(feature="windows-applicationmodel")] RT_CLASS!{class WebUIBarcodeScannerPreviewActivatedEventArgs: super::super::applicationmodel::activation::IBarcodeScannerPreviewActivatedEventArgs} +#[cfg(not(feature="windows-applicationmodel"))] RT_CLASS!{class WebUIBarcodeScannerPreviewActivatedEventArgs: IInspectable} #[cfg(feature="windows-applicationmodel")] RT_CLASS!{class WebUICachedFileUpdaterActivatedEventArgs: super::super::applicationmodel::activation::ICachedFileUpdaterActivatedEventArgs} #[cfg(not(feature="windows-applicationmodel"))] RT_CLASS!{class WebUICachedFileUpdaterActivatedEventArgs: IInspectable} #[cfg(feature="windows-applicationmodel")] RT_CLASS!{class WebUICameraSettingsActivatedEventArgs: super::super::applicationmodel::activation::ICameraSettingsActivatedEventArgs} @@ -13394,6 +13698,25 @@ impl ITileMixedRealityModel { }} } RT_CLASS!{class TileMixedRealityModel: ITileMixedRealityModel} +DEFINE_IID!(IID_ITileMixedRealityModel2, 1133801650, 55237, 16651, 131, 25, 148, 134, 162, 123, 108, 103); +RT_INTERFACE!{interface ITileMixedRealityModel2(ITileMixedRealityModel2Vtbl): IInspectable(IInspectableVtbl) [IID_ITileMixedRealityModel2] { + fn put_ActivationBehavior(&self, value: TileMixedRealityModelActivationBehavior) -> HRESULT, + fn get_ActivationBehavior(&self, out: *mut TileMixedRealityModelActivationBehavior) -> HRESULT +}} +impl ITileMixedRealityModel2 { + #[inline] pub fn set_activation_behavior(&self, value: TileMixedRealityModelActivationBehavior) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_ActivationBehavior)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_activation_behavior(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_ActivationBehavior)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} +RT_ENUM! { enum TileMixedRealityModelActivationBehavior: i32 { + Default (TileMixedRealityModelActivationBehavior_Default) = 0, None (TileMixedRealityModelActivationBehavior_None) = 1, +}} RT_ENUM! { enum TileOptions: u32 { None (TileOptions_None) = 0, ShowNameOnLogo (TileOptions_ShowNameOnLogo) = 1, ShowNameOnWideLogo (TileOptions_ShowNameOnWideLogo) = 2, CopyOnDeployment (TileOptions_CopyOnDeployment) = 4, }} @@ -14519,6 +14842,22 @@ impl IScheduledToastNotification3 { if hr == S_OK { Ok(()) } else { err(hr) } }} } +DEFINE_IID!(IID_IScheduledToastNotification4, 491217405, 48623, 20042, 150, 190, 1, 1, 54, 155, 88, 210); +RT_INTERFACE!{interface IScheduledToastNotification4(IScheduledToastNotification4Vtbl): IInspectable(IInspectableVtbl) [IID_IScheduledToastNotification4] { + fn get_ExpirationTime(&self, out: *mut *mut foundation::IReference) -> HRESULT, + fn put_ExpirationTime(&self, value: *mut foundation::IReference) -> HRESULT +}} +impl IScheduledToastNotification4 { + #[inline] pub fn get_expiration_time(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ExpirationTime)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn set_expiration_time(&self, value: &foundation::IReference) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_ExpirationTime)(self as *const _ as *mut _, value as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} DEFINE_IID!(IID_IScheduledToastNotificationFactory, 3888042385, 3001, 16777, 131, 148, 49, 118, 27, 71, 111, 215); RT_INTERFACE!{static interface IScheduledToastNotificationFactory(IScheduledToastNotificationFactoryVtbl): IInspectable(IInspectableVtbl) [IID_IScheduledToastNotificationFactory] { #[cfg(feature="windows-data")] fn CreateScheduledToastNotification(&self, content: *mut super::super::data::xml::dom::XmlDocument, deliveryTime: foundation::DateTime, out: *mut *mut ScheduledToastNotification) -> HRESULT, @@ -15705,6 +16044,85 @@ impl IAmbientLight2 { if hr == S_OK { Ok(()) } else { err(hr) } }} } +DEFINE_IID!(IID_IAnimationController, 3375689682, 1826, 20319, 164, 226, 149, 16, 243, 212, 59, 247); +RT_INTERFACE!{interface IAnimationController(IAnimationControllerVtbl): IInspectable(IInspectableVtbl) [IID_IAnimationController] { + fn get_PlaybackRate(&self, out: *mut f32) -> HRESULT, + fn put_PlaybackRate(&self, value: f32) -> HRESULT, + fn get_Progress(&self, out: *mut f32) -> HRESULT, + fn put_Progress(&self, value: f32) -> HRESULT, + fn get_ProgressBehavior(&self, out: *mut AnimationControllerProgressBehavior) -> HRESULT, + fn put_ProgressBehavior(&self, value: AnimationControllerProgressBehavior) -> HRESULT, + fn Pause(&self) -> HRESULT, + fn Resume(&self) -> HRESULT +}} +impl IAnimationController { + #[inline] pub fn get_playback_rate(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_PlaybackRate)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_playback_rate(&self, value: f32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_PlaybackRate)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_progress(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Progress)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_progress(&self, value: f32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Progress)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_progress_behavior(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_ProgressBehavior)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_progress_behavior(&self, value: AnimationControllerProgressBehavior) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_ProgressBehavior)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn pause(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).Pause)(self as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn resume(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).Resume)(self as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class AnimationController: IAnimationController} +impl RtActivatable for AnimationController {} +impl AnimationController { + #[inline] pub fn get_max_playback_rate() -> Result { + >::get_activation_factory().get_max_playback_rate() + } + #[inline] pub fn get_min_playback_rate() -> Result { + >::get_activation_factory().get_min_playback_rate() + } +} +DEFINE_CLSID!(AnimationController(&[87,105,110,100,111,119,115,46,85,73,46,67,111,109,112,111,115,105,116,105,111,110,46,65,110,105,109,97,116,105,111,110,67,111,110,116,114,111,108,108,101,114,0]) [CLSID_AnimationController]); +RT_ENUM! { enum AnimationControllerProgressBehavior: i32 { + Default (AnimationControllerProgressBehavior_Default) = 0, IncludesDelayTime (AnimationControllerProgressBehavior_IncludesDelayTime) = 1, +}} +DEFINE_IID!(IID_IAnimationControllerStatics, 3876676831, 25883, 18432, 185, 229, 106, 59, 207, 237, 51, 101); +RT_INTERFACE!{static interface IAnimationControllerStatics(IAnimationControllerStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IAnimationControllerStatics] { + fn get_MaxPlaybackRate(&self, out: *mut f32) -> HRESULT, + fn get_MinPlaybackRate(&self, out: *mut f32) -> HRESULT +}} +impl IAnimationControllerStatics { + #[inline] pub fn get_max_playback_rate(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_MaxPlaybackRate)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_min_playback_rate(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_MinPlaybackRate)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} RT_ENUM! { enum AnimationDelayBehavior: i32 { SetInitialValueAfterDelay (AnimationDelayBehavior_SetInitialValueAfterDelay) = 0, SetInitialValueBeforeDelay (AnimationDelayBehavior_SetInitialValueBeforeDelay) = 1, }} @@ -15717,6 +16135,90 @@ RT_ENUM! { enum AnimationIterationBehavior: i32 { RT_ENUM! { enum AnimationStopBehavior: i32 { LeaveCurrentValue (AnimationStopBehavior_LeaveCurrentValue) = 0, SetToInitialValue (AnimationStopBehavior_SetToInitialValue) = 1, SetToFinalValue (AnimationStopBehavior_SetToFinalValue) = 2, }} +DEFINE_IID!(IID_IBounceScalarNaturalMotionAnimation, 3131248076, 42547, 17944, 155, 6, 127, 124, 114, 200, 124, 255); +RT_INTERFACE!{interface IBounceScalarNaturalMotionAnimation(IBounceScalarNaturalMotionAnimationVtbl): IInspectable(IInspectableVtbl) [IID_IBounceScalarNaturalMotionAnimation] { + fn get_Acceleration(&self, out: *mut f32) -> HRESULT, + fn put_Acceleration(&self, value: f32) -> HRESULT, + fn get_Restitution(&self, out: *mut f32) -> HRESULT, + fn put_Restitution(&self, value: f32) -> HRESULT +}} +impl IBounceScalarNaturalMotionAnimation { + #[inline] pub fn get_acceleration(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Acceleration)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_acceleration(&self, value: f32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Acceleration)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_restitution(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Restitution)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_restitution(&self, value: f32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Restitution)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class BounceScalarNaturalMotionAnimation: IBounceScalarNaturalMotionAnimation} +DEFINE_IID!(IID_IBounceVector2NaturalMotionAnimation, 3660857750, 8532, 19260, 136, 170, 71, 54, 18, 4, 236, 205); +RT_INTERFACE!{interface IBounceVector2NaturalMotionAnimation(IBounceVector2NaturalMotionAnimationVtbl): IInspectable(IInspectableVtbl) [IID_IBounceVector2NaturalMotionAnimation] { + fn get_Acceleration(&self, out: *mut f32) -> HRESULT, + fn put_Acceleration(&self, value: f32) -> HRESULT, + fn get_Restitution(&self, out: *mut f32) -> HRESULT, + fn put_Restitution(&self, value: f32) -> HRESULT +}} +impl IBounceVector2NaturalMotionAnimation { + #[inline] pub fn get_acceleration(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Acceleration)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_acceleration(&self, value: f32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Acceleration)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_restitution(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Restitution)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_restitution(&self, value: f32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Restitution)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class BounceVector2NaturalMotionAnimation: IBounceVector2NaturalMotionAnimation} +DEFINE_IID!(IID_IBounceVector3NaturalMotionAnimation, 1205517361, 4307, 17688, 134, 241, 9, 202, 247, 66, 209, 19); +RT_INTERFACE!{interface IBounceVector3NaturalMotionAnimation(IBounceVector3NaturalMotionAnimationVtbl): IInspectable(IInspectableVtbl) [IID_IBounceVector3NaturalMotionAnimation] { + fn get_Acceleration(&self, out: *mut f32) -> HRESULT, + fn put_Acceleration(&self, value: f32) -> HRESULT, + fn get_Restitution(&self, out: *mut f32) -> HRESULT, + fn put_Restitution(&self, value: f32) -> HRESULT +}} +impl IBounceVector3NaturalMotionAnimation { + #[inline] pub fn get_acceleration(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Acceleration)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_acceleration(&self, value: f32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Acceleration)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_restitution(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Restitution)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_restitution(&self, value: f32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Restitution)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class BounceVector3NaturalMotionAnimation: IBounceVector3NaturalMotionAnimation} DEFINE_IID!(IID_IColorKeyFrameAnimation, 2477635049, 36357, 17811, 132, 163, 220, 161, 82, 120, 30, 86); RT_INTERFACE!{interface IColorKeyFrameAnimation(IColorKeyFrameAnimationVtbl): IInspectable(IInspectableVtbl) [IID_IColorKeyFrameAnimation] { fn get_InterpolationColorSpace(&self, out: *mut CompositionColorSpace) -> HRESULT, @@ -16126,6 +16628,18 @@ RT_CLASS!{class CompositionCommitBatch: ICompositionCommitBatch} RT_ENUM! { enum CompositionCompositeMode: i32 { Inherit (CompositionCompositeMode_Inherit) = 0, SourceOver (CompositionCompositeMode_SourceOver) = 1, DestinationInvert (CompositionCompositeMode_DestinationInvert) = 2, MinBlend (CompositionCompositeMode_MinBlend) = 3, }} +DEFINE_IID!(IID_ICompositionContainerShape, 1331594651, 11867, 17576, 152, 44, 170, 15, 105, 193, 96, 89); +RT_INTERFACE!{interface ICompositionContainerShape(ICompositionContainerShapeVtbl): IInspectable(IInspectableVtbl) [IID_ICompositionContainerShape] { + fn get_Shapes(&self, out: *mut *mut CompositionShapeCollection) -> HRESULT +}} +impl ICompositionContainerShape { + #[inline] pub fn get_shapes(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Shapes)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +RT_CLASS!{class CompositionContainerShape: ICompositionContainerShape} DEFINE_IID!(IID_ICompositionDrawingSurface, 2707866368, 64208, 19729, 158, 103, 228, 51, 22, 47, 244, 158); RT_INTERFACE!{interface ICompositionDrawingSurface(ICompositionDrawingSurfaceVtbl): IInspectable(IInspectableVtbl) [IID_ICompositionDrawingSurface] { #[cfg(not(feature="windows-graphics"))] fn __Dummy0(&self) -> (), @@ -16278,15 +16792,86 @@ impl ICompositionEffectSourceParameterFactory { if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } }} } -RT_ENUM! { enum CompositionGetValueStatus: i32 { - Succeeded (CompositionGetValueStatus_Succeeded) = 0, TypeMismatch (CompositionGetValueStatus_TypeMismatch) = 1, NotFound (CompositionGetValueStatus_NotFound) = 2, +DEFINE_IID!(IID_ICompositionEllipseGeometry, 1208088708, 63149, 19347, 175, 169, 137, 123, 100, 229, 123, 31); +RT_INTERFACE!{interface ICompositionEllipseGeometry(ICompositionEllipseGeometryVtbl): IInspectable(IInspectableVtbl) [IID_ICompositionEllipseGeometry] { + fn get_Center(&self, out: *mut foundation::numerics::Vector2) -> HRESULT, + fn put_Center(&self, value: foundation::numerics::Vector2) -> HRESULT, + fn get_Radius(&self, out: *mut foundation::numerics::Vector2) -> HRESULT, + fn put_Radius(&self, value: foundation::numerics::Vector2) -> HRESULT }} -DEFINE_IID!(IID_ICompositionGradientBrush, 496437728, 65478, 19470, 169, 171, 52, 20, 77, 76, 144, 152); -RT_INTERFACE!{interface ICompositionGradientBrush(ICompositionGradientBrushVtbl): IInspectable(IInspectableVtbl) [IID_ICompositionGradientBrush] { - fn get_AnchorPoint(&self, out: *mut foundation::numerics::Vector2) -> HRESULT, - fn put_AnchorPoint(&self, value: foundation::numerics::Vector2) -> HRESULT, - fn get_CenterPoint(&self, out: *mut foundation::numerics::Vector2) -> HRESULT, - fn put_CenterPoint(&self, value: foundation::numerics::Vector2) -> HRESULT, +impl ICompositionEllipseGeometry { + #[inline] pub fn get_center(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Center)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_center(&self, value: foundation::numerics::Vector2) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Center)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_radius(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Radius)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_radius(&self, value: foundation::numerics::Vector2) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Radius)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class CompositionEllipseGeometry: ICompositionEllipseGeometry} +DEFINE_IID!(IID_ICompositionGeometry, 3917816188, 27159, 16903, 171, 216, 95, 211, 221, 97, 42, 157); +RT_INTERFACE!{interface ICompositionGeometry(ICompositionGeometryVtbl): IInspectable(IInspectableVtbl) [IID_ICompositionGeometry] { + fn get_TrimEnd(&self, out: *mut f32) -> HRESULT, + fn put_TrimEnd(&self, value: f32) -> HRESULT, + fn get_TrimOffset(&self, out: *mut f32) -> HRESULT, + fn put_TrimOffset(&self, value: f32) -> HRESULT, + fn get_TrimStart(&self, out: *mut f32) -> HRESULT, + fn put_TrimStart(&self, value: f32) -> HRESULT +}} +impl ICompositionGeometry { + #[inline] pub fn get_trim_end(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_TrimEnd)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_trim_end(&self, value: f32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_TrimEnd)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_trim_offset(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_TrimOffset)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_trim_offset(&self, value: f32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_TrimOffset)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_trim_start(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_TrimStart)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_trim_start(&self, value: f32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_TrimStart)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class CompositionGeometry: ICompositionGeometry} +DEFINE_IID!(IID_ICompositionGeometryFactory, 3221143521, 35877, 18443, 159, 86, 254, 214, 178, 136, 5, 93); +RT_INTERFACE!{interface ICompositionGeometryFactory(ICompositionGeometryFactoryVtbl): IInspectable(IInspectableVtbl) [IID_ICompositionGeometryFactory] { + +}} +RT_ENUM! { enum CompositionGetValueStatus: i32 { + Succeeded (CompositionGetValueStatus_Succeeded) = 0, TypeMismatch (CompositionGetValueStatus_TypeMismatch) = 1, NotFound (CompositionGetValueStatus_NotFound) = 2, +}} +DEFINE_IID!(IID_ICompositionGradientBrush, 496437728, 65478, 19470, 169, 171, 52, 20, 77, 76, 144, 152); +RT_INTERFACE!{interface ICompositionGradientBrush(ICompositionGradientBrushVtbl): IInspectable(IInspectableVtbl) [IID_ICompositionGradientBrush] { + fn get_AnchorPoint(&self, out: *mut foundation::numerics::Vector2) -> HRESULT, + fn put_AnchorPoint(&self, value: foundation::numerics::Vector2) -> HRESULT, + fn get_CenterPoint(&self, out: *mut foundation::numerics::Vector2) -> HRESULT, + fn put_CenterPoint(&self, value: foundation::numerics::Vector2) -> HRESULT, fn get_ColorStops(&self, out: *mut *mut CompositionColorGradientStopCollection) -> HRESULT, fn get_ExtendMode(&self, out: *mut CompositionGradientExtendMode) -> HRESULT, fn put_ExtendMode(&self, value: CompositionGradientExtendMode) -> HRESULT, @@ -16463,6 +17048,22 @@ impl ICompositionLight2 { if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_ICompositionLight3, 1259012324, 57095, 18777, 183, 164, 79, 126, 66, 51, 248, 56); +RT_INTERFACE!{interface ICompositionLight3(ICompositionLight3Vtbl): IInspectable(IInspectableVtbl) [IID_ICompositionLight3] { + fn get_IsEnabled(&self, out: *mut bool) -> HRESULT, + fn put_IsEnabled(&self, value: bool) -> HRESULT +}} +impl ICompositionLight3 { + #[inline] pub fn get_is_enabled(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_IsEnabled)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_is_enabled(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_IsEnabled)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} DEFINE_IID!(IID_ICompositionLightFactory, 110949126, 55868, 19268, 131, 138, 94, 3, 213, 26, 206, 85); RT_INTERFACE!{interface ICompositionLightFactory(ICompositionLightFactoryVtbl): IInspectable(IInspectableVtbl) [IID_ICompositionLightFactory] { @@ -16495,6 +17096,34 @@ impl ICompositionLinearGradientBrush { }} } RT_CLASS!{class CompositionLinearGradientBrush: ICompositionLinearGradientBrush} +DEFINE_IID!(IID_ICompositionLineGeometry, 3715503524, 3226, 19303, 141, 206, 68, 10, 91, 249, 205, 236); +RT_INTERFACE!{interface ICompositionLineGeometry(ICompositionLineGeometryVtbl): IInspectable(IInspectableVtbl) [IID_ICompositionLineGeometry] { + fn get_Start(&self, out: *mut foundation::numerics::Vector2) -> HRESULT, + fn put_Start(&self, value: foundation::numerics::Vector2) -> HRESULT, + fn get_End(&self, out: *mut foundation::numerics::Vector2) -> HRESULT, + fn put_End(&self, value: foundation::numerics::Vector2) -> HRESULT +}} +impl ICompositionLineGeometry { + #[inline] pub fn get_start(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Start)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_start(&self, value: foundation::numerics::Vector2) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Start)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_end(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_End)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_end(&self, value: foundation::numerics::Vector2) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_End)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class CompositionLineGeometry: ICompositionLineGeometry} DEFINE_IID!(IID_ICompositionMaskBrush, 1378676894, 48747, 20289, 190, 73, 249, 34, 109, 71, 27, 74); RT_INTERFACE!{interface ICompositionMaskBrush(ICompositionMaskBrushVtbl): IInspectable(IInspectableVtbl) [IID_ICompositionMaskBrush] { fn get_Mask(&self, out: *mut *mut CompositionBrush) -> HRESULT, @@ -16741,10 +17370,61 @@ impl ICompositionObject3 { if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_ICompositionObject4, 196311116, 13419, 19068, 150, 107, 115, 16, 150, 101, 83, 213); +RT_INTERFACE!{interface ICompositionObject4(ICompositionObject4Vtbl): IInspectable(IInspectableVtbl) [IID_ICompositionObject4] { + fn TryGetAnimationController(&self, propertyName: HSTRING, out: *mut *mut AnimationController) -> HRESULT +}} +impl ICompositionObject4 { + #[inline] pub fn try_get_animation_controller(&self, propertyName: &HStringArg) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).TryGetAnimationController)(self as *const _ as *mut _, propertyName.get(), &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_ICompositionObjectFactory, 1361075294, 21898, 20266, 141, 57, 55, 191, 225, 226, 13, 221); RT_INTERFACE!{interface ICompositionObjectFactory(ICompositionObjectFactoryVtbl): IInspectable(IInspectableVtbl) [IID_ICompositionObjectFactory] { }} +DEFINE_IID!(IID_ICompositionPath, 1725570399, 11792, 20258, 138, 6, 10, 129, 81, 145, 158, 96); +RT_INTERFACE!{interface ICompositionPath(ICompositionPathVtbl): IInspectable(IInspectableVtbl) [IID_ICompositionPath] { + +}} +RT_CLASS!{class CompositionPath: ICompositionPath} +impl RtActivatable for CompositionPath {} +impl CompositionPath { + #[cfg(feature="windows-graphics")] #[inline] pub fn create(source: &super::super::graphics::IGeometrySource2D) -> Result> { + >::get_activation_factory().create(source) + } +} +DEFINE_CLSID!(CompositionPath(&[87,105,110,100,111,119,115,46,85,73,46,67,111,109,112,111,115,105,116,105,111,110,46,67,111,109,112,111,115,105,116,105,111,110,80,97,116,104,0]) [CLSID_CompositionPath]); +DEFINE_IID!(IID_ICompositionPathFactory, 2619247722, 3891, 18257, 148, 55, 235, 63, 185, 211, 171, 7); +RT_INTERFACE!{static interface ICompositionPathFactory(ICompositionPathFactoryVtbl): IInspectable(IInspectableVtbl) [IID_ICompositionPathFactory] { + #[cfg(feature="windows-graphics")] fn Create(&self, source: *mut super::super::graphics::IGeometrySource2D, out: *mut *mut CompositionPath) -> HRESULT +}} +impl ICompositionPathFactory { + #[cfg(feature="windows-graphics")] #[inline] pub fn create(&self, source: &super::super::graphics::IGeometrySource2D) -> Result> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).Create)(self as *const _ as *mut _, source as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} +} +DEFINE_IID!(IID_ICompositionPathGeometry, 191512958, 11383, 19491, 175, 94, 99, 4, 193, 71, 187, 97); +RT_INTERFACE!{interface ICompositionPathGeometry(ICompositionPathGeometryVtbl): IInspectable(IInspectableVtbl) [IID_ICompositionPathGeometry] { + fn get_Path(&self, out: *mut *mut CompositionPath) -> HRESULT, + fn put_Path(&self, value: *mut CompositionPath) -> HRESULT +}} +impl ICompositionPathGeometry { + #[inline] pub fn get_path(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Path)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn set_path(&self, value: &CompositionPath) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Path)(self as *const _ as *mut _, value as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class CompositionPathGeometry: ICompositionPathGeometry} DEFINE_IID!(IID_ICompositionPropertySet, 3386298882, 24423, 17491, 145, 23, 158, 173, 212, 48, 211, 194); RT_INTERFACE!{interface ICompositionPropertySet(ICompositionPropertySetVtbl): IInspectable(IInspectableVtbl) [IID_ICompositionPropertySet] { fn InsertColor(&self, propertyName: HSTRING, value: super::Color) -> HRESULT, @@ -16855,6 +17535,73 @@ impl ICompositionPropertySet2 { if hr == S_OK { Ok((value, out)) } else { err(hr) } }} } +DEFINE_IID!(IID_ICompositionRectangleGeometry, 215290920, 21334, 16966, 174, 207, 122, 11, 118, 151, 84, 0); +RT_INTERFACE!{interface ICompositionRectangleGeometry(ICompositionRectangleGeometryVtbl): IInspectable(IInspectableVtbl) [IID_ICompositionRectangleGeometry] { + fn get_Offset(&self, out: *mut foundation::numerics::Vector2) -> HRESULT, + fn put_Offset(&self, value: foundation::numerics::Vector2) -> HRESULT, + fn get_Size(&self, out: *mut foundation::numerics::Vector2) -> HRESULT, + fn put_Size(&self, value: foundation::numerics::Vector2) -> HRESULT +}} +impl ICompositionRectangleGeometry { + #[inline] pub fn get_offset(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Offset)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_offset(&self, value: foundation::numerics::Vector2) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Offset)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_size(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Size)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_size(&self, value: foundation::numerics::Vector2) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Size)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class CompositionRectangleGeometry: ICompositionRectangleGeometry} +DEFINE_IID!(IID_ICompositionRoundedRectangleGeometry, 2272315426, 7504, 19339, 176, 19, 124, 154, 14, 70, 147, 95); +RT_INTERFACE!{interface ICompositionRoundedRectangleGeometry(ICompositionRoundedRectangleGeometryVtbl): IInspectable(IInspectableVtbl) [IID_ICompositionRoundedRectangleGeometry] { + fn get_CornerRadius(&self, out: *mut foundation::numerics::Vector2) -> HRESULT, + fn put_CornerRadius(&self, value: foundation::numerics::Vector2) -> HRESULT, + fn get_Offset(&self, out: *mut foundation::numerics::Vector2) -> HRESULT, + fn put_Offset(&self, value: foundation::numerics::Vector2) -> HRESULT, + fn get_Size(&self, out: *mut foundation::numerics::Vector2) -> HRESULT, + fn put_Size(&self, value: foundation::numerics::Vector2) -> HRESULT +}} +impl ICompositionRoundedRectangleGeometry { + #[inline] pub fn get_corner_radius(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_CornerRadius)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_corner_radius(&self, value: foundation::numerics::Vector2) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_CornerRadius)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_offset(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Offset)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_offset(&self, value: foundation::numerics::Vector2) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Offset)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_size(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Size)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_size(&self, value: foundation::numerics::Vector2) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Size)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class CompositionRoundedRectangleGeometry: ICompositionRoundedRectangleGeometry} DEFINE_IID!(IID_ICompositionScopedBatch, 218159824, 64263, 18173, 140, 114, 98, 128, 209, 163, 209, 221); RT_INTERFACE!{interface ICompositionScopedBatch(ICompositionScopedBatchVtbl): IInspectable(IInspectableVtbl) [IID_ICompositionScopedBatch] { fn get_IsActive(&self, out: *mut bool) -> HRESULT, @@ -16908,9 +17655,226 @@ DEFINE_IID!(IID_ICompositionShadowFactory, 572475695, 56506, 19345, 153, 158, 29 RT_INTERFACE!{interface ICompositionShadowFactory(ICompositionShadowFactoryVtbl): IInspectable(IInspectableVtbl) [IID_ICompositionShadowFactory] { }} +DEFINE_IID!(IID_ICompositionShape, 3028083447, 39560, 17092, 158, 135, 46, 80, 12, 168, 104, 140); +RT_INTERFACE!{interface ICompositionShape(ICompositionShapeVtbl): IInspectable(IInspectableVtbl) [IID_ICompositionShape] { + fn get_CenterPoint(&self, out: *mut foundation::numerics::Vector2) -> HRESULT, + fn put_CenterPoint(&self, value: foundation::numerics::Vector2) -> HRESULT, + fn get_Offset(&self, out: *mut foundation::numerics::Vector2) -> HRESULT, + fn put_Offset(&self, value: foundation::numerics::Vector2) -> HRESULT, + fn get_RotationAngle(&self, out: *mut f32) -> HRESULT, + fn put_RotationAngle(&self, value: f32) -> HRESULT, + fn get_RotationAngleInDegrees(&self, out: *mut f32) -> HRESULT, + fn put_RotationAngleInDegrees(&self, value: f32) -> HRESULT, + fn get_Scale(&self, out: *mut foundation::numerics::Vector2) -> HRESULT, + fn put_Scale(&self, value: foundation::numerics::Vector2) -> HRESULT, + fn get_TransformMatrix(&self, out: *mut foundation::numerics::Matrix3x2) -> HRESULT, + fn put_TransformMatrix(&self, value: foundation::numerics::Matrix3x2) -> HRESULT +}} +impl ICompositionShape { + #[inline] pub fn get_center_point(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_CenterPoint)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_center_point(&self, value: foundation::numerics::Vector2) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_CenterPoint)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_offset(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Offset)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_offset(&self, value: foundation::numerics::Vector2) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Offset)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_rotation_angle(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_RotationAngle)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_rotation_angle(&self, value: f32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_RotationAngle)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_rotation_angle_in_degrees(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_RotationAngleInDegrees)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_rotation_angle_in_degrees(&self, value: f32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_RotationAngleInDegrees)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_scale(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Scale)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_scale(&self, value: foundation::numerics::Vector2) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Scale)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_transform_matrix(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_TransformMatrix)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_transform_matrix(&self, value: foundation::numerics::Matrix3x2) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_TransformMatrix)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class CompositionShape: ICompositionShape} +RT_CLASS!{class CompositionShapeCollection: foundation::collections::IVector} +DEFINE_IID!(IID_ICompositionShapeFactory, 503068368, 45146, 17647, 130, 176, 18, 17, 139, 205, 76, 208); +RT_INTERFACE!{interface ICompositionShapeFactory(ICompositionShapeFactoryVtbl): IInspectable(IInspectableVtbl) [IID_ICompositionShapeFactory] { + +}} +DEFINE_IID!(IID_ICompositionSpriteShape, 1075536315, 7, 17251, 177, 243, 107, 204, 0, 63, 184, 62); +RT_INTERFACE!{interface ICompositionSpriteShape(ICompositionSpriteShapeVtbl): IInspectable(IInspectableVtbl) [IID_ICompositionSpriteShape] { + fn get_FillBrush(&self, out: *mut *mut CompositionBrush) -> HRESULT, + fn put_FillBrush(&self, value: *mut CompositionBrush) -> HRESULT, + fn get_Geometry(&self, out: *mut *mut CompositionGeometry) -> HRESULT, + fn put_Geometry(&self, value: *mut CompositionGeometry) -> HRESULT, + fn get_IsStrokeNonScaling(&self, out: *mut bool) -> HRESULT, + fn put_IsStrokeNonScaling(&self, value: bool) -> HRESULT, + fn get_StrokeBrush(&self, out: *mut *mut CompositionBrush) -> HRESULT, + fn put_StrokeBrush(&self, value: *mut CompositionBrush) -> HRESULT, + fn get_StrokeDashArray(&self, out: *mut *mut CompositionStrokeDashArray) -> HRESULT, + fn get_StrokeDashCap(&self, out: *mut CompositionStrokeCap) -> HRESULT, + fn put_StrokeDashCap(&self, value: CompositionStrokeCap) -> HRESULT, + fn get_StrokeDashOffset(&self, out: *mut f32) -> HRESULT, + fn put_StrokeDashOffset(&self, value: f32) -> HRESULT, + fn get_StrokeEndCap(&self, out: *mut CompositionStrokeCap) -> HRESULT, + fn put_StrokeEndCap(&self, value: CompositionStrokeCap) -> HRESULT, + fn get_StrokeLineJoin(&self, out: *mut CompositionStrokeLineJoin) -> HRESULT, + fn put_StrokeLineJoin(&self, value: CompositionStrokeLineJoin) -> HRESULT, + fn get_StrokeMiterLimit(&self, out: *mut f32) -> HRESULT, + fn put_StrokeMiterLimit(&self, value: f32) -> HRESULT, + fn get_StrokeStartCap(&self, out: *mut CompositionStrokeCap) -> HRESULT, + fn put_StrokeStartCap(&self, value: CompositionStrokeCap) -> HRESULT, + fn get_StrokeThickness(&self, out: *mut f32) -> HRESULT, + fn put_StrokeThickness(&self, value: f32) -> HRESULT +}} +impl ICompositionSpriteShape { + #[inline] pub fn get_fill_brush(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_FillBrush)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn set_fill_brush(&self, value: &CompositionBrush) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_FillBrush)(self as *const _ as *mut _, value as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_geometry(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Geometry)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn set_geometry(&self, value: &CompositionGeometry) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Geometry)(self as *const _ as *mut _, value as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_is_stroke_non_scaling(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_IsStrokeNonScaling)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_is_stroke_non_scaling(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_IsStrokeNonScaling)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_stroke_brush(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_StrokeBrush)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn set_stroke_brush(&self, value: &CompositionBrush) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_StrokeBrush)(self as *const _ as *mut _, value as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_stroke_dash_array(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_StrokeDashArray)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_stroke_dash_cap(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_StrokeDashCap)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_stroke_dash_cap(&self, value: CompositionStrokeCap) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_StrokeDashCap)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_stroke_dash_offset(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_StrokeDashOffset)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_stroke_dash_offset(&self, value: f32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_StrokeDashOffset)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_stroke_end_cap(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_StrokeEndCap)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_stroke_end_cap(&self, value: CompositionStrokeCap) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_StrokeEndCap)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_stroke_line_join(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_StrokeLineJoin)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_stroke_line_join(&self, value: CompositionStrokeLineJoin) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_StrokeLineJoin)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_stroke_miter_limit(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_StrokeMiterLimit)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_stroke_miter_limit(&self, value: f32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_StrokeMiterLimit)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_stroke_start_cap(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_StrokeStartCap)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_stroke_start_cap(&self, value: CompositionStrokeCap) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_StrokeStartCap)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_stroke_thickness(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_StrokeThickness)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_stroke_thickness(&self, value: f32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_StrokeThickness)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class CompositionSpriteShape: ICompositionSpriteShape} RT_ENUM! { enum CompositionStretch: i32 { None (CompositionStretch_None) = 0, Fill (CompositionStretch_Fill) = 1, Uniform (CompositionStretch_Uniform) = 2, UniformToFill (CompositionStretch_UniformToFill) = 3, }} +RT_ENUM! { enum CompositionStrokeCap: i32 { + Flat (CompositionStrokeCap_Flat) = 0, Square (CompositionStrokeCap_Square) = 1, Round (CompositionStrokeCap_Round) = 2, Triangle (CompositionStrokeCap_Triangle) = 3, +}} +RT_CLASS!{class CompositionStrokeDashArray: foundation::collections::IVector} +RT_ENUM! { enum CompositionStrokeLineJoin: i32 { + Miter (CompositionStrokeLineJoin_Miter) = 0, Bevel (CompositionStrokeLineJoin_Bevel) = 1, Round (CompositionStrokeLineJoin_Round) = 2, MiterOrBevel (CompositionStrokeLineJoin_MiterOrBevel) = 3, +}} DEFINE_IID!(IID_ICompositionSurface, 354898957, 17095, 18342, 164, 8, 102, 143, 121, 169, 13, 251); RT_INTERFACE!{interface ICompositionSurface(ICompositionSurfaceVtbl): IInspectable(IInspectableVtbl) [IID_ICompositionSurface] { @@ -17079,6 +18043,67 @@ DEFINE_IID!(IID_ICompositionTargetFactory, 2479725867, 34070, 19220, 168, 206, 2 RT_INTERFACE!{interface ICompositionTargetFactory(ICompositionTargetFactoryVtbl): IInspectable(IInspectableVtbl) [IID_ICompositionTargetFactory] { }} +DEFINE_IID!(IID_ICompositionViewBox, 3024142087, 1679, 17719, 132, 198, 78, 203, 224, 25, 225, 244); +RT_INTERFACE!{interface ICompositionViewBox(ICompositionViewBoxVtbl): IInspectable(IInspectableVtbl) [IID_ICompositionViewBox] { + fn get_HorizontalAlignmentRatio(&self, out: *mut f32) -> HRESULT, + fn put_HorizontalAlignmentRatio(&self, value: f32) -> HRESULT, + fn get_Offset(&self, out: *mut foundation::numerics::Vector2) -> HRESULT, + fn put_Offset(&self, value: foundation::numerics::Vector2) -> HRESULT, + fn get_Size(&self, out: *mut foundation::numerics::Vector2) -> HRESULT, + fn put_Size(&self, value: foundation::numerics::Vector2) -> HRESULT, + fn get_Stretch(&self, out: *mut CompositionStretch) -> HRESULT, + fn put_Stretch(&self, value: CompositionStretch) -> HRESULT, + fn get_VerticalAlignmentRatio(&self, out: *mut f32) -> HRESULT, + fn put_VerticalAlignmentRatio(&self, value: f32) -> HRESULT +}} +impl ICompositionViewBox { + #[inline] pub fn get_horizontal_alignment_ratio(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_HorizontalAlignmentRatio)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_horizontal_alignment_ratio(&self, value: f32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_HorizontalAlignmentRatio)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_offset(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Offset)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_offset(&self, value: foundation::numerics::Vector2) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Offset)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_size(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Size)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_size(&self, value: foundation::numerics::Vector2) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Size)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_stretch(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Stretch)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_stretch(&self, value: CompositionStretch) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Stretch)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_vertical_alignment_ratio(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_VerticalAlignmentRatio)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_vertical_alignment_ratio(&self, value: f32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_VerticalAlignmentRatio)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class CompositionViewBox: ICompositionViewBox} DEFINE_IID!(IID_ICompositionVirtualDrawingSurface, 2848163035, 34624, 20372, 139, 157, 182, 133, 33, 231, 134, 61); RT_INTERFACE!{interface ICompositionVirtualDrawingSurface(ICompositionVirtualDrawingSurfaceVtbl): IInspectable(IInspectableVtbl) [IID_ICompositionVirtualDrawingSurface] { #[cfg(feature="windows-graphics")] fn Trim(&self, rectsSize: u32, rects: *mut super::super::graphics::RectInt32) -> HRESULT @@ -17246,7 +18271,16 @@ impl ICompositor { }} } RT_CLASS!{class Compositor: ICompositor} +impl RtActivatable for Compositor {} impl RtActivatable for Compositor {} +impl Compositor { + #[inline] pub fn get_max_global_playback_rate() -> Result { + >::get_activation_factory().get_max_global_playback_rate() + } + #[inline] pub fn get_min_global_playback_rate() -> Result { + >::get_activation_factory().get_min_global_playback_rate() + } +} DEFINE_CLSID!(Compositor(&[87,105,110,100,111,119,115,46,85,73,46,67,111,109,112,111,115,105,116,105,111,110,46,67,111,109,112,111,115,105,116,111,114,0]) [CLSID_Compositor]); DEFINE_IID!(IID_ICompositor2, 1934655964, 24100, 17882, 163, 143, 227, 44, 195, 73, 169, 160); RT_INTERFACE!{interface ICompositor2(ICompositor2Vtbl): IInspectable(IInspectableVtbl) [IID_ICompositor2] { @@ -17383,6 +18417,146 @@ impl ICompositor4 { if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_ICompositor5, 1223307693, 32717, 16502, 167, 156, 144, 204, 75, 133, 44, 155); +RT_INTERFACE!{interface ICompositor5(ICompositor5Vtbl): IInspectable(IInspectableVtbl) [IID_ICompositor5] { + fn get_Comment(&self, out: *mut HSTRING) -> HRESULT, + fn put_Comment(&self, value: HSTRING) -> HRESULT, + fn get_GlobalPlaybackRate(&self, out: *mut f32) -> HRESULT, + fn put_GlobalPlaybackRate(&self, value: f32) -> HRESULT, + fn CreateBounceScalarAnimation(&self, out: *mut *mut BounceScalarNaturalMotionAnimation) -> HRESULT, + fn CreateBounceVector2Animation(&self, out: *mut *mut BounceVector2NaturalMotionAnimation) -> HRESULT, + fn CreateBounceVector3Animation(&self, out: *mut *mut BounceVector3NaturalMotionAnimation) -> HRESULT, + fn CreateContainerShape(&self, out: *mut *mut CompositionContainerShape) -> HRESULT, + fn CreateEllipseGeometry(&self, out: *mut *mut CompositionEllipseGeometry) -> HRESULT, + fn CreateLineGeometry(&self, out: *mut *mut CompositionLineGeometry) -> HRESULT, + fn CreatePathGeometry(&self, out: *mut *mut CompositionPathGeometry) -> HRESULT, + fn CreatePathGeometryWithPath(&self, path: *mut CompositionPath, out: *mut *mut CompositionPathGeometry) -> HRESULT, + fn CreatePathKeyFrameAnimation(&self, out: *mut *mut PathKeyFrameAnimation) -> HRESULT, + fn CreateRectangleGeometry(&self, out: *mut *mut CompositionRectangleGeometry) -> HRESULT, + fn CreateRoundedRectangleGeometry(&self, out: *mut *mut CompositionRoundedRectangleGeometry) -> HRESULT, + fn CreateShapeVisual(&self, out: *mut *mut ShapeVisual) -> HRESULT, + fn CreateSpriteShape(&self, out: *mut *mut CompositionSpriteShape) -> HRESULT, + fn CreateSpriteShapeWithGeometry(&self, geometry: *mut CompositionGeometry, out: *mut *mut CompositionSpriteShape) -> HRESULT, + fn CreateViewBox(&self, out: *mut *mut CompositionViewBox) -> HRESULT, + fn RequestCommitAsync(&self, out: *mut *mut foundation::IAsyncAction) -> HRESULT +}} +impl ICompositor5 { + #[inline] pub fn get_comment(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Comment)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn set_comment(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Comment)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_global_playback_rate(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_GlobalPlaybackRate)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_global_playback_rate(&self, value: f32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_GlobalPlaybackRate)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn create_bounce_scalar_animation(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreateBounceScalarAnimation)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn create_bounce_vector2_animation(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreateBounceVector2Animation)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn create_bounce_vector3_animation(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreateBounceVector3Animation)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn create_container_shape(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreateContainerShape)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn create_ellipse_geometry(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreateEllipseGeometry)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn create_line_geometry(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreateLineGeometry)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn create_path_geometry(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreatePathGeometry)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn create_path_geometry_with_path(&self, path: &CompositionPath) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreatePathGeometryWithPath)(self as *const _ as *mut _, path as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn create_path_key_frame_animation(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreatePathKeyFrameAnimation)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn create_rectangle_geometry(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreateRectangleGeometry)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn create_rounded_rectangle_geometry(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreateRoundedRectangleGeometry)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn create_shape_visual(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreateShapeVisual)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn create_sprite_shape(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreateSpriteShape)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn create_sprite_shape_with_geometry(&self, geometry: &CompositionGeometry) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreateSpriteShapeWithGeometry)(self as *const _ as *mut _, geometry as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn create_view_box(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreateViewBox)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn request_commit_async(&self) -> Result> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).RequestCommitAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} +} +DEFINE_IID!(IID_ICompositorStatics, 135117118, 4638, 19863, 139, 116, 29, 252, 249, 25, 135, 234); +RT_INTERFACE!{static interface ICompositorStatics(ICompositorStaticsVtbl): IInspectable(IInspectableVtbl) [IID_ICompositorStatics] { + fn get_MaxGlobalPlaybackRate(&self, out: *mut f32) -> HRESULT, + fn get_MinGlobalPlaybackRate(&self, out: *mut f32) -> HRESULT +}} +impl ICompositorStatics { + #[inline] pub fn get_max_global_playback_rate(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_MaxGlobalPlaybackRate)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_min_global_playback_rate(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_MinGlobalPlaybackRate)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} DEFINE_IID!(IID_IContainerVisual, 49724532, 60704, 18291, 175, 230, 212, 155, 74, 147, 219, 50); RT_INTERFACE!{interface IContainerVisual(IContainerVisualVtbl): IInspectable(IInspectableVtbl) [IID_IContainerVisual] { fn get_Children(&self, out: *mut *mut VisualCollection) -> HRESULT @@ -17816,6 +18990,22 @@ DEFINE_IID!(IID_INaturalMotionAnimationFactory, 4114270982, 53098, 17287, 163, 2 RT_INTERFACE!{interface INaturalMotionAnimationFactory(INaturalMotionAnimationFactoryVtbl): IInspectable(IInspectableVtbl) [IID_INaturalMotionAnimationFactory] { }} +DEFINE_IID!(IID_IPathKeyFrameAnimation, 2634881225, 5494, 19263, 190, 96, 29, 80, 49, 245, 231, 27); +RT_INTERFACE!{interface IPathKeyFrameAnimation(IPathKeyFrameAnimationVtbl): IInspectable(IInspectableVtbl) [IID_IPathKeyFrameAnimation] { + fn InsertKeyFrame(&self, normalizedProgressKey: f32, path: *mut CompositionPath) -> HRESULT, + fn InsertKeyFrameWithEasingFunction(&self, normalizedProgressKey: f32, path: *mut CompositionPath, easingFunction: *mut CompositionEasingFunction) -> HRESULT +}} +impl IPathKeyFrameAnimation { + #[inline] pub fn insert_key_frame(&self, normalizedProgressKey: f32, path: &CompositionPath) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).InsertKeyFrame)(self as *const _ as *mut _, normalizedProgressKey, path as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn insert_key_frame_with_easing_function(&self, normalizedProgressKey: f32, path: &CompositionPath, easingFunction: &CompositionEasingFunction) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).InsertKeyFrameWithEasingFunction)(self as *const _ as *mut _, normalizedProgressKey, path as *const _ as *mut _, easingFunction as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class PathKeyFrameAnimation: IPathKeyFrameAnimation} DEFINE_IID!(IID_IPointLight, 2978301363, 3162, 19120, 190, 220, 79, 53, 70, 148, 130, 114); RT_INTERFACE!{interface IPointLight(IPointLightVtbl): IInspectable(IInspectableVtbl) [IID_IPointLight] { fn get_Color(&self, out: *mut super::Color) -> HRESULT, @@ -17904,6 +19094,33 @@ impl IPointLight2 { if hr == S_OK { Ok(()) } else { err(hr) } }} } +DEFINE_IID!(IID_IPointLight3, 1275757415, 54505, 18058, 135, 174, 123, 164, 58, 178, 148, 133); +RT_INTERFACE!{interface IPointLight3(IPointLight3Vtbl): IInspectable(IInspectableVtbl) [IID_IPointLight3] { + fn get_MinAttenuationCutoff(&self, out: *mut f32) -> HRESULT, + fn put_MinAttenuationCutoff(&self, value: f32) -> HRESULT, + fn get_MaxAttenuationCutoff(&self, out: *mut f32) -> HRESULT, + fn put_MaxAttenuationCutoff(&self, value: f32) -> HRESULT +}} +impl IPointLight3 { + #[inline] pub fn get_min_attenuation_cutoff(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_MinAttenuationCutoff)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_min_attenuation_cutoff(&self, value: f32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_MinAttenuationCutoff)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_max_attenuation_cutoff(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_MaxAttenuationCutoff)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_max_attenuation_cutoff(&self, value: f32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_MaxAttenuationCutoff)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} DEFINE_IID!(IID_IQuaternionKeyFrameAnimation, 1078876213, 60662, 16960, 133, 32, 103, 18, 121, 207, 54, 188); RT_INTERFACE!{interface IQuaternionKeyFrameAnimation(IQuaternionKeyFrameAnimationVtbl): IInspectable(IInspectableVtbl) [IID_IQuaternionKeyFrameAnimation] { fn InsertKeyFrame(&self, normalizedProgressKey: f32, value: foundation::numerics::Quaternion) -> HRESULT, @@ -17991,6 +19208,29 @@ DEFINE_IID!(IID_IScalarNaturalMotionAnimationFactory, 2203755772, 26396, 16861, RT_INTERFACE!{interface IScalarNaturalMotionAnimationFactory(IScalarNaturalMotionAnimationFactoryVtbl): IInspectable(IInspectableVtbl) [IID_IScalarNaturalMotionAnimationFactory] { }} +DEFINE_IID!(IID_IShapeVisual, 4072477635, 47742, 19215, 145, 38, 255, 183, 83, 107, 129, 118); +RT_INTERFACE!{interface IShapeVisual(IShapeVisualVtbl): IInspectable(IInspectableVtbl) [IID_IShapeVisual] { + fn get_Shapes(&self, out: *mut *mut CompositionShapeCollection) -> HRESULT, + fn get_ViewBox(&self, out: *mut *mut CompositionViewBox) -> HRESULT, + fn put_ViewBox(&self, value: *mut CompositionViewBox) -> HRESULT +}} +impl IShapeVisual { + #[inline] pub fn get_shapes(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Shapes)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_view_box(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ViewBox)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn set_view_box(&self, value: &CompositionViewBox) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_ViewBox)(self as *const _ as *mut _, value as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class ShapeVisual: IShapeVisual} DEFINE_IID!(IID_ISpotLight, 1520427635, 17569, 20373, 164, 34, 143, 165, 17, 107, 219, 68); RT_INTERFACE!{interface ISpotLight(ISpotLightVtbl): IInspectable(IInspectableVtbl) [IID_ISpotLight] { fn get_ConstantAttenuation(&self, out: *mut f32) -> HRESULT, @@ -18156,6 +19396,33 @@ impl ISpotLight2 { if hr == S_OK { Ok(()) } else { err(hr) } }} } +DEFINE_IID!(IID_ISpotLight3, 3838852842, 4895, 18446, 133, 158, 184, 39, 5, 183, 67, 96); +RT_INTERFACE!{interface ISpotLight3(ISpotLight3Vtbl): IInspectable(IInspectableVtbl) [IID_ISpotLight3] { + fn get_MinAttenuationCutoff(&self, out: *mut f32) -> HRESULT, + fn put_MinAttenuationCutoff(&self, value: f32) -> HRESULT, + fn get_MaxAttenuationCutoff(&self, out: *mut f32) -> HRESULT, + fn put_MaxAttenuationCutoff(&self, value: f32) -> HRESULT +}} +impl ISpotLight3 { + #[inline] pub fn get_min_attenuation_cutoff(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_MinAttenuationCutoff)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_min_attenuation_cutoff(&self, value: f32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_MinAttenuationCutoff)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_max_attenuation_cutoff(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_MaxAttenuationCutoff)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_max_attenuation_cutoff(&self, value: f32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_MaxAttenuationCutoff)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} DEFINE_IID!(IID_ISpringScalarNaturalMotionAnimation, 91400543, 14329, 20414, 184, 123, 92, 208, 58, 137, 80, 28); RT_INTERFACE!{interface ISpringScalarNaturalMotionAnimation(ISpringScalarNaturalMotionAnimationVtbl): IInspectable(IInspectableVtbl) [IID_ISpringScalarNaturalMotionAnimation] { fn get_DampingRatio(&self, out: *mut f32) -> HRESULT, @@ -18767,6 +20034,122 @@ impl IVisualUnorderedCollection { }} } RT_CLASS!{class VisualUnorderedCollection: IVisualUnorderedCollection} +pub mod core { // Windows.UI.Composition.Core +use ::prelude::*; +DEFINE_IID!(IID_ICompositorController, 762704730, 28839, 17301, 186, 45, 206, 240, 177, 131, 153, 249); +RT_INTERFACE!{interface ICompositorController(ICompositorControllerVtbl): IInspectable(IInspectableVtbl) [IID_ICompositorController] { + fn get_Compositor(&self, out: *mut *mut super::Compositor) -> HRESULT, + fn Commit(&self) -> HRESULT, + fn EnsurePreviousCommitCompletedAsync(&self, out: *mut *mut foundation::IAsyncAction) -> HRESULT, + fn add_CommitNeeded(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_CommitNeeded(&self, token: foundation::EventRegistrationToken) -> HRESULT +}} +impl ICompositorController { + #[inline] pub fn get_compositor(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Compositor)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn commit(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).Commit)(self as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn ensure_previous_commit_completed_async(&self) -> Result> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).EnsurePreviousCommitCompletedAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn add_commit_needed(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_CommitNeeded)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_commit_needed(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_CommitNeeded)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class CompositorController: ICompositorController} +impl RtActivatable for CompositorController {} +DEFINE_CLSID!(CompositorController(&[87,105,110,100,111,119,115,46,85,73,46,67,111,109,112,111,115,105,116,105,111,110,46,67,111,114,101,46,67,111,109,112,111,115,105,116,111,114,67,111,110,116,114,111,108,108,101,114,0]) [CLSID_CompositorController]); +} // Windows.UI.Composition.Core +pub mod desktop { // Windows.UI.Composition.Desktop +use ::prelude::*; +DEFINE_IID!(IID_IDesktopWindowTarget, 1663686346, 13158, 18702, 157, 179, 37, 49, 41, 41, 172, 81); +RT_INTERFACE!{interface IDesktopWindowTarget(IDesktopWindowTargetVtbl): IInspectable(IInspectableVtbl) [IID_IDesktopWindowTarget] { + fn get_IsTopmost(&self, out: *mut bool) -> HRESULT +}} +impl IDesktopWindowTarget { + #[inline] pub fn get_is_topmost(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_IsTopmost)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} +RT_CLASS!{class DesktopWindowTarget: IDesktopWindowTarget} +} // Windows.UI.Composition.Desktop +pub mod diagnostics { // Windows.UI.Composition.Diagnostics +use ::prelude::*; +DEFINE_IID!(IID_ICompositionDebugHeatMaps, 3835465900, 12275, 22533, 113, 140, 183, 37, 238, 7, 101, 15); +RT_INTERFACE!{interface ICompositionDebugHeatMaps(ICompositionDebugHeatMapsVtbl): IInspectable(IInspectableVtbl) [IID_ICompositionDebugHeatMaps] { + fn Hide(&self, subtree: *mut super::Visual) -> HRESULT, + fn ShowMemoryUsage(&self, subtree: *mut super::Visual) -> HRESULT, + fn ShowOverdraw(&self, subtree: *mut super::Visual, contentKinds: CompositionDebugOverdrawContentKinds) -> HRESULT, + fn ShowRedraw(&self, subtree: *mut super::Visual) -> HRESULT +}} +impl ICompositionDebugHeatMaps { + #[inline] pub fn hide(&self, subtree: &super::Visual) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).Hide)(self as *const _ as *mut _, subtree as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn show_memory_usage(&self, subtree: &super::Visual) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).ShowMemoryUsage)(self as *const _ as *mut _, subtree as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn show_overdraw(&self, subtree: &super::Visual, contentKinds: CompositionDebugOverdrawContentKinds) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).ShowOverdraw)(self as *const _ as *mut _, subtree as *const _ as *mut _, contentKinds); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn show_redraw(&self, subtree: &super::Visual) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).ShowRedraw)(self as *const _ as *mut _, subtree as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class CompositionDebugHeatMaps: ICompositionDebugHeatMaps} +RT_ENUM! { enum CompositionDebugOverdrawContentKinds: u32 { + None (CompositionDebugOverdrawContentKinds_None) = 0, OffscreenRendered (CompositionDebugOverdrawContentKinds_OffscreenRendered) = 1, Colors (CompositionDebugOverdrawContentKinds_Colors) = 2, Effects (CompositionDebugOverdrawContentKinds_Effects) = 4, Shadows (CompositionDebugOverdrawContentKinds_Shadows) = 8, Lights (CompositionDebugOverdrawContentKinds_Lights) = 16, Surfaces (CompositionDebugOverdrawContentKinds_Surfaces) = 32, SwapChains (CompositionDebugOverdrawContentKinds_SwapChains) = 64, All (CompositionDebugOverdrawContentKinds_All) = 4294967295, +}} +DEFINE_IID!(IID_ICompositionDebugSettings, 674338942, 7554, 19768, 183, 183, 239, 209, 28, 123, 195, 209); +RT_INTERFACE!{interface ICompositionDebugSettings(ICompositionDebugSettingsVtbl): IInspectable(IInspectableVtbl) [IID_ICompositionDebugSettings] { + fn get_HeatMaps(&self, out: *mut *mut CompositionDebugHeatMaps) -> HRESULT +}} +impl ICompositionDebugSettings { + #[inline] pub fn get_heat_maps(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_HeatMaps)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +RT_CLASS!{class CompositionDebugSettings: ICompositionDebugSettings} +impl RtActivatable for CompositionDebugSettings {} +impl CompositionDebugSettings { + #[inline] pub fn try_get_settings(compositor: &super::Compositor) -> Result>> { + >::get_activation_factory().try_get_settings(compositor) + } +} +DEFINE_CLSID!(CompositionDebugSettings(&[87,105,110,100,111,119,115,46,85,73,46,67,111,109,112,111,115,105,116,105,111,110,46,68,105,97,103,110,111,115,116,105,99,115,46,67,111,109,112,111,115,105,116,105,111,110,68,101,98,117,103,83,101,116,116,105,110,103,115,0]) [CLSID_CompositionDebugSettings]); +DEFINE_IID!(IID_ICompositionDebugSettingsStatics, 1693196062, 27384, 19192, 184, 20, 200, 112, 253, 90, 149, 5); +RT_INTERFACE!{static interface ICompositionDebugSettingsStatics(ICompositionDebugSettingsStaticsVtbl): IInspectable(IInspectableVtbl) [IID_ICompositionDebugSettingsStatics] { + fn TryGetSettings(&self, compositor: *mut super::Compositor, out: *mut *mut CompositionDebugSettings) -> HRESULT +}} +impl ICompositionDebugSettingsStatics { + #[inline] pub fn try_get_settings(&self, compositor: &super::Compositor) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).TryGetSettings)(self as *const _ as *mut _, compositor as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +} // Windows.UI.Composition.Diagnostics pub mod effects { // Windows.UI.Composition.Effects use ::prelude::*; DEFINE_IID!(IID_ISceneLightingEffect, 2444975698, 38353, 20363, 154, 90, 100, 8, 178, 75, 140, 106); @@ -19735,7 +21118,7 @@ RT_INTERFACE!{interface IVisualInteractionSourceObjectFactory(IVisualInteraction }} RT_ENUM! { enum VisualInteractionSourceRedirectionMode: i32 { - Off (VisualInteractionSourceRedirectionMode_Off) = 0, CapableTouchpadOnly (VisualInteractionSourceRedirectionMode_CapableTouchpadOnly) = 1, + Off (VisualInteractionSourceRedirectionMode_Off) = 0, CapableTouchpadOnly (VisualInteractionSourceRedirectionMode_CapableTouchpadOnly) = 1, PointerWheelOnly (VisualInteractionSourceRedirectionMode_PointerWheelOnly) = 2, CapableTouchpadAndPointerWheel (VisualInteractionSourceRedirectionMode_CapableTouchpadAndPointerWheel) = 3, }} DEFINE_IID!(IID_IVisualInteractionSourceStatics, 916022753, 34373, 20341, 186, 0, 100, 121, 205, 16, 200, 230); RT_INTERFACE!{static interface IVisualInteractionSourceStatics(IVisualInteractionSourceStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IVisualInteractionSourceStatics] { diff --git a/src/rt/gen/windows/ui/xaml.rs b/src/rt/gen/windows/ui/xaml.rs index 08a9f2b..26f6ef0 100644 --- a/src/rt/gen/windows/ui/xaml.rs +++ b/src/rt/gen/windows/ui/xaml.rs @@ -402,6 +402,139 @@ impl IBringIntoViewOptions { RT_CLASS!{class BringIntoViewOptions: IBringIntoViewOptions} impl RtActivatable for BringIntoViewOptions {} DEFINE_CLSID!(BringIntoViewOptions(&[87,105,110,100,111,119,115,46,85,73,46,88,97,109,108,46,66,114,105,110,103,73,110,116,111,86,105,101,119,79,112,116,105,111,110,115,0]) [CLSID_BringIntoViewOptions]); +DEFINE_IID!(IID_IBringIntoViewOptions2, 3897942158, 25782, 4625, 189, 219, 31, 221, 187, 110, 130, 49); +RT_INTERFACE!{interface IBringIntoViewOptions2(IBringIntoViewOptions2Vtbl): IInspectable(IInspectableVtbl) [IID_IBringIntoViewOptions2] { + fn get_HorizontalAlignmentRatio(&self, out: *mut f64) -> HRESULT, + fn put_HorizontalAlignmentRatio(&self, value: f64) -> HRESULT, + fn get_VerticalAlignmentRatio(&self, out: *mut f64) -> HRESULT, + fn put_VerticalAlignmentRatio(&self, value: f64) -> HRESULT, + fn get_HorizontalOffset(&self, out: *mut f64) -> HRESULT, + fn put_HorizontalOffset(&self, value: f64) -> HRESULT, + fn get_VerticalOffset(&self, out: *mut f64) -> HRESULT, + fn put_VerticalOffset(&self, value: f64) -> HRESULT +}} +impl IBringIntoViewOptions2 { + #[inline] pub fn get_horizontal_alignment_ratio(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_HorizontalAlignmentRatio)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_horizontal_alignment_ratio(&self, value: f64) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_HorizontalAlignmentRatio)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_vertical_alignment_ratio(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_VerticalAlignmentRatio)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_vertical_alignment_ratio(&self, value: f64) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_VerticalAlignmentRatio)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_horizontal_offset(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_HorizontalOffset)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_horizontal_offset(&self, value: f64) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_HorizontalOffset)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_vertical_offset(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_VerticalOffset)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_vertical_offset(&self, value: f64) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_VerticalOffset)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +DEFINE_IID!(IID_IBringIntoViewRequestedEventArgs, 241344196, 8710, 19595, 148, 174, 189, 182, 106, 78, 191, 209); +RT_INTERFACE!{interface IBringIntoViewRequestedEventArgs(IBringIntoViewRequestedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IBringIntoViewRequestedEventArgs] { + fn get_TargetElement(&self, out: *mut *mut UIElement) -> HRESULT, + fn put_TargetElement(&self, value: *mut UIElement) -> HRESULT, + fn get_AnimationDesired(&self, out: *mut bool) -> HRESULT, + fn put_AnimationDesired(&self, value: bool) -> HRESULT, + fn get_TargetRect(&self, out: *mut foundation::Rect) -> HRESULT, + fn put_TargetRect(&self, value: foundation::Rect) -> HRESULT, + fn get_HorizontalAlignmentRatio(&self, out: *mut f64) -> HRESULT, + fn get_VerticalAlignmentRatio(&self, out: *mut f64) -> HRESULT, + fn get_HorizontalOffset(&self, out: *mut f64) -> HRESULT, + fn put_HorizontalOffset(&self, value: f64) -> HRESULT, + fn get_VerticalOffset(&self, out: *mut f64) -> HRESULT, + fn put_VerticalOffset(&self, value: f64) -> HRESULT, + fn get_Handled(&self, out: *mut bool) -> HRESULT, + fn put_Handled(&self, value: bool) -> HRESULT +}} +impl IBringIntoViewRequestedEventArgs { + #[inline] pub fn get_target_element(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_TargetElement)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn set_target_element(&self, value: &UIElement) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_TargetElement)(self as *const _ as *mut _, value as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_animation_desired(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_AnimationDesired)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_animation_desired(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_AnimationDesired)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_target_rect(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_TargetRect)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_target_rect(&self, value: foundation::Rect) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_TargetRect)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_horizontal_alignment_ratio(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_HorizontalAlignmentRatio)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_vertical_alignment_ratio(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_VerticalAlignmentRatio)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_horizontal_offset(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_HorizontalOffset)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_horizontal_offset(&self, value: f64) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_HorizontalOffset)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_vertical_offset(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_VerticalOffset)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_vertical_offset(&self, value: f64) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_VerticalOffset)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_handled(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Handled)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_handled(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Handled)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class BringIntoViewRequestedEventArgs: IBringIntoViewRequestedEventArgs} RT_STRUCT! { struct CornerRadius { TopLeft: f64, TopRight: f64, BottomRight: f64, BottomLeft: f64, }} @@ -1290,6 +1423,7 @@ RT_INTERFACE!{interface IElementSoundPlayer(IElementSoundPlayerVtbl): IInspectab }} RT_CLASS!{class ElementSoundPlayer: IElementSoundPlayer} impl RtActivatable for ElementSoundPlayer {} +impl RtActivatable for ElementSoundPlayer {} impl ElementSoundPlayer { #[inline] pub fn get_volume() -> Result { >::get_activation_factory().get_volume() @@ -1306,6 +1440,12 @@ impl ElementSoundPlayer { #[inline] pub fn play(sound: ElementSoundKind) -> Result<()> { >::get_activation_factory().play(sound) } + #[inline] pub fn get_spatial_audio_mode() -> Result { + >::get_activation_factory().get_spatial_audio_mode() + } + #[inline] pub fn set_spatial_audio_mode(value: ElementSpatialAudioMode) -> Result<()> { + >::get_activation_factory().set_spatial_audio_mode(value) + } } DEFINE_CLSID!(ElementSoundPlayer(&[87,105,110,100,111,119,115,46,85,73,46,88,97,109,108,46,69,108,101,109,101,110,116,83,111,117,110,100,80,108,97,121,101,114,0]) [CLSID_ElementSoundPlayer]); RT_ENUM! { enum ElementSoundPlayerState: i32 { @@ -1343,6 +1483,25 @@ impl IElementSoundPlayerStatics { if hr == S_OK { Ok(()) } else { err(hr) } }} } +DEFINE_IID!(IID_IElementSoundPlayerStatics2, 4065352022, 60737, 18647, 170, 232, 242, 171, 203, 68, 73, 41); +RT_INTERFACE!{static interface IElementSoundPlayerStatics2(IElementSoundPlayerStatics2Vtbl): IInspectable(IInspectableVtbl) [IID_IElementSoundPlayerStatics2] { + fn get_SpatialAudioMode(&self, out: *mut ElementSpatialAudioMode) -> HRESULT, + fn put_SpatialAudioMode(&self, value: ElementSpatialAudioMode) -> HRESULT +}} +impl IElementSoundPlayerStatics2 { + #[inline] pub fn get_spatial_audio_mode(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_SpatialAudioMode)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_spatial_audio_mode(&self, value: ElementSpatialAudioMode) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_SpatialAudioMode)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_ENUM! { enum ElementSpatialAudioMode: i32 { + Auto (ElementSpatialAudioMode_Auto) = 0, Off (ElementSpatialAudioMode_Off) = 1, On (ElementSpatialAudioMode_On) = 2, +}} RT_ENUM! { enum ElementTheme: i32 { Default (ElementTheme_Default) = 0, Light (ElementTheme_Light) = 1, Dark (ElementTheme_Dark) = 2, }} @@ -1414,7 +1573,7 @@ RT_ENUM! { enum FocusState: i32 { Unfocused (FocusState_Unfocused) = 0, Pointer (FocusState_Pointer) = 1, Keyboard (FocusState_Keyboard) = 2, Programmatic (FocusState_Programmatic) = 3, }} RT_ENUM! { enum FocusVisualKind: i32 { - DottedLine (FocusVisualKind_DottedLine) = 0, HighVisibility (FocusVisualKind_HighVisibility) = 1, + DottedLine (FocusVisualKind_DottedLine) = 0, HighVisibility (FocusVisualKind_HighVisibility) = 1, Reveal (FocusVisualKind_Reveal) = 2, }} RT_ENUM! { enum FontCapitals: i32 { Normal (FontCapitals_Normal) = 0, AllSmallCaps (FontCapitals_AllSmallCaps) = 1, SmallCaps (FontCapitals_SmallCaps) = 2, AllPetiteCaps (FontCapitals_AllPetiteCaps) = 3, PetiteCaps (FontCapitals_PetiteCaps) = 4, Unicase (FontCapitals_Unicase) = 5, Titling (FontCapitals_Titling) = 6, @@ -3646,6 +3805,7 @@ impl RtActivatable for UIElement {} impl RtActivatable for UIElement {} impl RtActivatable for UIElement {} impl RtActivatable for UIElement {} +impl RtActivatable for UIElement {} impl UIElement { #[inline] pub fn get_key_down_event() -> Result>> { >::get_activation_factory().get_key_down_event() @@ -3845,6 +4005,24 @@ impl UIElement { #[inline] pub fn get_preview_key_up_event() -> Result>> { >::get_activation_factory().get_preview_key_up_event() } + #[inline] pub fn get_bring_into_view_requested_event() -> Result>> { + >::get_activation_factory().get_bring_into_view_requested_event() + } + #[inline] pub fn get_context_requested_event() -> Result>> { + >::get_activation_factory().get_context_requested_event() + } + #[inline] pub fn get_key_tip_target_property() -> Result>> { + >::get_activation_factory().get_key_tip_target_property() + } + #[inline] pub fn get_keyboard_accelerator_placement_target_property() -> Result>> { + >::get_activation_factory().get_keyboard_accelerator_placement_target_property() + } + #[inline] pub fn get_keyboard_accelerator_placement_mode_property() -> Result>> { + >::get_activation_factory().get_keyboard_accelerator_placement_mode_property() + } + #[inline] pub fn register_as_scroll_port(element: &UIElement) -> Result<()> { + >::get_activation_factory().register_as_scroll_port(element) + } } DEFINE_CLSID!(UIElement(&[87,105,110,100,111,119,115,46,85,73,46,88,97,109,108,46,85,73,69,108,101,109,101,110,116,0]) [CLSID_UIElement]); DEFINE_IID!(IID_IUIElement2, 1735199737, 46700, 16854, 186, 80, 88, 207, 135, 242, 1, 209); @@ -4263,6 +4441,55 @@ impl IUIElement7 { if hr == S_OK { Ok(()) } else { err(hr) } }} } +DEFINE_IID!(IID_IUIElement8, 985075333, 54536, 17527, 182, 248, 14, 67, 87, 1, 200, 54); +RT_INTERFACE!{interface IUIElement8(IUIElement8Vtbl): IInspectable(IInspectableVtbl) [IID_IUIElement8] { + fn get_KeyTipTarget(&self, out: *mut *mut DependencyObject) -> HRESULT, + fn put_KeyTipTarget(&self, value: *mut DependencyObject) -> HRESULT, + fn get_KeyboardAcceleratorPlacementTarget(&self, out: *mut *mut DependencyObject) -> HRESULT, + fn put_KeyboardAcceleratorPlacementTarget(&self, value: *mut DependencyObject) -> HRESULT, + fn get_KeyboardAcceleratorPlacementMode(&self, out: *mut input::KeyboardAcceleratorPlacementMode) -> HRESULT, + fn put_KeyboardAcceleratorPlacementMode(&self, value: input::KeyboardAcceleratorPlacementMode) -> HRESULT, + fn add_BringIntoViewRequested(&self, value: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_BringIntoViewRequested(&self, token: foundation::EventRegistrationToken) -> HRESULT +}} +impl IUIElement8 { + #[inline] pub fn get_key_tip_target(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_KeyTipTarget)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn set_key_tip_target(&self, value: &DependencyObject) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_KeyTipTarget)(self as *const _ as *mut _, value as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_keyboard_accelerator_placement_target(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_KeyboardAcceleratorPlacementTarget)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn set_keyboard_accelerator_placement_target(&self, value: &DependencyObject) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_KeyboardAcceleratorPlacementTarget)(self as *const _ as *mut _, value as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_keyboard_accelerator_placement_mode(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_KeyboardAcceleratorPlacementMode)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_keyboard_accelerator_placement_mode(&self, value: input::KeyboardAcceleratorPlacementMode) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_KeyboardAcceleratorPlacementMode)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_bring_into_view_requested(&self, value: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_BringIntoViewRequested)(self as *const _ as *mut _, value as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_bring_into_view_requested(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_BringIntoViewRequested)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} DEFINE_IID!(IID_IUIElementFactory, 3119420414, 41784, 16799, 172, 50, 145, 220, 170, 223, 93, 8); RT_INTERFACE!{interface IUIElementFactory(IUIElementFactoryVtbl): IInspectable(IInspectableVtbl) [IID_IUIElementFactory] { @@ -4305,6 +4532,21 @@ impl IUIElementOverrides7 { if hr == S_OK { Ok(()) } else { err(hr) } }} } +DEFINE_IID!(IID_IUIElementOverrides8, 1247437916, 21645, 18639, 185, 152, 120, 68, 214, 226, 53, 161); +RT_INTERFACE!{interface IUIElementOverrides8(IUIElementOverrides8Vtbl): IInspectable(IInspectableVtbl) [IID_IUIElementOverrides8] { + fn OnKeyboardAcceleratorInvoked(&self, args: *mut input::KeyboardAcceleratorInvokedEventArgs) -> HRESULT, + fn OnBringIntoViewRequested(&self, e: *mut BringIntoViewRequestedEventArgs) -> HRESULT +}} +impl IUIElementOverrides8 { + #[inline] pub fn on_keyboard_accelerator_invoked(&self, args: &input::KeyboardAcceleratorInvokedEventArgs) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).OnKeyboardAcceleratorInvoked)(self as *const _ as *mut _, args as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn on_bring_into_view_requested(&self, e: &BringIntoViewRequestedEventArgs) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).OnBringIntoViewRequested)(self as *const _ as *mut _, e as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} DEFINE_IID!(IID_IUIElementStatics, 1490245435, 62764, 17854, 152, 139, 165, 134, 149, 100, 135, 60); RT_INTERFACE!{static interface IUIElementStatics(IUIElementStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IUIElementStatics] { fn get_KeyDownEvent(&self, out: *mut *mut RoutedEvent) -> HRESULT, @@ -4736,6 +4978,46 @@ impl IUIElementStatics7 { if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IUIElementStatics8, 398341255, 18549, 18709, 176, 177, 164, 192, 248, 81, 223, 63); +RT_INTERFACE!{static interface IUIElementStatics8(IUIElementStatics8Vtbl): IInspectable(IInspectableVtbl) [IID_IUIElementStatics8] { + fn get_BringIntoViewRequestedEvent(&self, out: *mut *mut RoutedEvent) -> HRESULT, + fn get_ContextRequestedEvent(&self, out: *mut *mut RoutedEvent) -> HRESULT, + fn get_KeyTipTargetProperty(&self, out: *mut *mut DependencyProperty) -> HRESULT, + fn get_KeyboardAcceleratorPlacementTargetProperty(&self, out: *mut *mut DependencyProperty) -> HRESULT, + fn get_KeyboardAcceleratorPlacementModeProperty(&self, out: *mut *mut DependencyProperty) -> HRESULT, + fn RegisterAsScrollPort(&self, element: *mut UIElement) -> HRESULT +}} +impl IUIElementStatics8 { + #[inline] pub fn get_bring_into_view_requested_event(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_BringIntoViewRequestedEvent)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_context_requested_event(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ContextRequestedEvent)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_key_tip_target_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_KeyTipTargetProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_keyboard_accelerator_placement_target_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_KeyboardAcceleratorPlacementTargetProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_keyboard_accelerator_placement_mode_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_KeyboardAcceleratorPlacementModeProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn register_as_scroll_port(&self, element: &UIElement) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).RegisterAsScrollPort)(self as *const _ as *mut _, element as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} DEFINE_IID!(IID_IUnhandledExceptionEventArgs, 1915758236, 1358, 19699, 134, 197, 190, 144, 235, 104, 99, 213); RT_INTERFACE!{interface IUnhandledExceptionEventArgs(IUnhandledExceptionEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IUnhandledExceptionEventArgs] { fn get_Exception(&self, out: *mut foundation::HResult) -> HRESULT, @@ -5448,6 +5730,7 @@ impl IAppBarButton { RT_CLASS!{class AppBarButton: IAppBarButton} impl RtActivatable for AppBarButton {} impl RtActivatable for AppBarButton {} +impl RtActivatable for AppBarButton {} impl AppBarButton { #[inline] pub fn get_label_property() -> Result>> { >::get_activation_factory().get_label_property() @@ -5467,6 +5750,9 @@ impl AppBarButton { #[inline] pub fn get_dynamic_overflow_order_property() -> Result>> { >::get_activation_factory().get_dynamic_overflow_order_property() } + #[inline] pub fn get_keyboard_accelerator_text_override_property() -> Result>> { + >::get_activation_factory().get_keyboard_accelerator_text_override_property() + } } DEFINE_CLSID!(AppBarButton(&[87,105,110,100,111,119,115,46,85,73,46,88,97,109,108,46,67,111,110,116,114,111,108,115,46,65,112,112,66,97,114,66,117,116,116,111,110,0]) [CLSID_AppBarButton]); DEFINE_IID!(IID_IAppBarButton3, 187179344, 6539, 20100, 143, 28, 159, 106, 139, 162, 103, 167); @@ -5485,6 +5771,33 @@ impl IAppBarButton3 { if hr == S_OK { Ok(()) } else { err(hr) } }} } +DEFINE_IID!(IID_IAppBarButton4, 2509229675, 64776, 17428, 132, 88, 157, 64, 134, 109, 200, 78); +RT_INTERFACE!{interface IAppBarButton4(IAppBarButton4Vtbl): IInspectable(IInspectableVtbl) [IID_IAppBarButton4] { + fn get_KeyboardAcceleratorTextOverride(&self, out: *mut HSTRING) -> HRESULT, + fn put_KeyboardAcceleratorTextOverride(&self, value: HSTRING) -> HRESULT +}} +impl IAppBarButton4 { + #[inline] pub fn get_keyboard_accelerator_text_override(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_KeyboardAcceleratorTextOverride)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn set_keyboard_accelerator_text_override(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_KeyboardAcceleratorTextOverride)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +DEFINE_IID!(IID_IAppBarButton5, 1083636863, 6892, 19215, 160, 49, 202, 140, 78, 6, 210, 237); +RT_INTERFACE!{interface IAppBarButton5(IAppBarButton5Vtbl): IInspectable(IInspectableVtbl) [IID_IAppBarButton5] { + fn get_TemplateSettings(&self, out: *mut *mut primitives::AppBarButtonTemplateSettings) -> HRESULT +}} +impl IAppBarButton5 { + #[inline] pub fn get_template_settings(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_TemplateSettings)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IAppBarButtonFactory, 3183156150, 52014, 17014, 171, 214, 121, 53, 19, 5, 16, 224); RT_INTERFACE!{interface IAppBarButtonFactory(IAppBarButtonFactoryVtbl): IInspectable(IInspectableVtbl) [IID_IAppBarButtonFactory] { fn CreateInstance(&self, outer: *mut IInspectable, inner: *mut *mut IInspectable, out: *mut *mut AppBarButton) -> HRESULT @@ -5542,6 +5855,17 @@ impl IAppBarButtonStatics3 { if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IAppBarButtonStatics4, 470475370, 51029, 20454, 163, 182, 14, 51, 148, 233, 82, 192); +RT_INTERFACE!{static interface IAppBarButtonStatics4(IAppBarButtonStatics4Vtbl): IInspectable(IInspectableVtbl) [IID_IAppBarButtonStatics4] { + fn get_KeyboardAcceleratorTextOverrideProperty(&self, out: *mut *mut super::DependencyProperty) -> HRESULT +}} +impl IAppBarButtonStatics4 { + #[inline] pub fn get_keyboard_accelerator_text_override_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_KeyboardAcceleratorTextOverrideProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} RT_ENUM! { enum AppBarClosedDisplayMode: i32 { Compact (AppBarClosedDisplayMode_Compact) = 0, Minimal (AppBarClosedDisplayMode_Minimal) = 1, Hidden (AppBarClosedDisplayMode_Hidden) = 2, }} @@ -5713,6 +6037,7 @@ impl IAppBarToggleButton { RT_CLASS!{class AppBarToggleButton: IAppBarToggleButton} impl RtActivatable for AppBarToggleButton {} impl RtActivatable for AppBarToggleButton {} +impl RtActivatable for AppBarToggleButton {} impl AppBarToggleButton { #[inline] pub fn get_label_property() -> Result>> { >::get_activation_factory().get_label_property() @@ -5732,6 +6057,9 @@ impl AppBarToggleButton { #[inline] pub fn get_dynamic_overflow_order_property() -> Result>> { >::get_activation_factory().get_dynamic_overflow_order_property() } + #[inline] pub fn get_keyboard_accelerator_text_override_property() -> Result>> { + >::get_activation_factory().get_keyboard_accelerator_text_override_property() + } } DEFINE_CLSID!(AppBarToggleButton(&[87,105,110,100,111,119,115,46,85,73,46,88,97,109,108,46,67,111,110,116,114,111,108,115,46,65,112,112,66,97,114,84,111,103,103,108,101,66,117,116,116,111,110,0]) [CLSID_AppBarToggleButton]); DEFINE_IID!(IID_IAppBarToggleButton3, 4019881445, 5887, 19826, 185, 232, 155, 134, 30, 175, 132, 168); @@ -5750,6 +6078,33 @@ impl IAppBarToggleButton3 { if hr == S_OK { Ok(()) } else { err(hr) } }} } +DEFINE_IID!(IID_IAppBarToggleButton4, 3094049646, 16047, 18257, 168, 151, 0, 2, 159, 31, 106, 202); +RT_INTERFACE!{interface IAppBarToggleButton4(IAppBarToggleButton4Vtbl): IInspectable(IInspectableVtbl) [IID_IAppBarToggleButton4] { + fn get_KeyboardAcceleratorTextOverride(&self, out: *mut HSTRING) -> HRESULT, + fn put_KeyboardAcceleratorTextOverride(&self, value: HSTRING) -> HRESULT +}} +impl IAppBarToggleButton4 { + #[inline] pub fn get_keyboard_accelerator_text_override(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_KeyboardAcceleratorTextOverride)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn set_keyboard_accelerator_text_override(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_KeyboardAcceleratorTextOverride)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +DEFINE_IID!(IID_IAppBarToggleButton5, 2647274327, 49456, 20406, 161, 226, 210, 179, 72, 254, 67, 190); +RT_INTERFACE!{interface IAppBarToggleButton5(IAppBarToggleButton5Vtbl): IInspectable(IInspectableVtbl) [IID_IAppBarToggleButton5] { + fn get_TemplateSettings(&self, out: *mut *mut primitives::AppBarToggleButtonTemplateSettings) -> HRESULT +}} +impl IAppBarToggleButton5 { + #[inline] pub fn get_template_settings(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_TemplateSettings)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IAppBarToggleButtonFactory, 42641364, 36692, 17830, 159, 144, 19, 96, 86, 86, 215, 147); RT_INTERFACE!{interface IAppBarToggleButtonFactory(IAppBarToggleButtonFactoryVtbl): IInspectable(IInspectableVtbl) [IID_IAppBarToggleButtonFactory] { fn CreateInstance(&self, outer: *mut IInspectable, inner: *mut *mut IInspectable, out: *mut *mut AppBarToggleButton) -> HRESULT @@ -5807,6 +6162,17 @@ impl IAppBarToggleButtonStatics3 { if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IAppBarToggleButtonStatics4, 2759375236, 59670, 16695, 189, 189, 149, 189, 70, 255, 60, 230); +RT_INTERFACE!{static interface IAppBarToggleButtonStatics4(IAppBarToggleButtonStatics4Vtbl): IInspectable(IInspectableVtbl) [IID_IAppBarToggleButtonStatics4] { + fn get_KeyboardAcceleratorTextOverrideProperty(&self, out: *mut *mut super::DependencyProperty) -> HRESULT +}} +impl IAppBarToggleButtonStatics4 { + #[inline] pub fn get_keyboard_accelerator_text_override_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_KeyboardAcceleratorTextOverrideProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IAutoSuggestBox, 272538387, 13312, 18966, 144, 185, 105, 18, 191, 6, 151, 79); RT_INTERFACE!{interface IAutoSuggestBox(IAutoSuggestBoxVtbl): IInspectable(IInspectableVtbl) [IID_IAutoSuggestBox] { fn get_MaxSuggestionListHeight(&self, out: *mut f64) -> HRESULT, @@ -10418,6 +10784,34 @@ impl IContentDialogStatics2 { if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IContentLinkChangedEventArgs, 1693708766, 35323, 19319, 139, 155, 25, 27, 109, 25, 41, 10); +RT_INTERFACE!{interface IContentLinkChangedEventArgs(IContentLinkChangedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IContentLinkChangedEventArgs] { + fn get_ChangeKind(&self, out: *mut ContentLinkChangeKind) -> HRESULT, + #[cfg(not(feature="windows-ui"))] fn __Dummy1(&self) -> (), + #[cfg(feature="windows-ui")] fn get_ContentLinkInfo(&self, out: *mut *mut super::super::text::ContentLinkInfo) -> HRESULT, + fn get_TextRange(&self, out: *mut super::documents::TextRange) -> HRESULT +}} +impl IContentLinkChangedEventArgs { + #[inline] pub fn get_change_kind(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_ChangeKind)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[cfg(feature="windows-ui")] #[inline] pub fn get_content_link_info(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ContentLinkInfo)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_text_range(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_TextRange)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} +RT_CLASS!{class ContentLinkChangedEventArgs: IContentLinkChangedEventArgs} +RT_ENUM! { enum ContentLinkChangeKind: i32 { + Inserted (ContentLinkChangeKind_Inserted) = 0, Removed (ContentLinkChangeKind_Removed) = 1, Edited (ContentLinkChangeKind_Edited) = 2, +}} DEFINE_IID!(IID_IContentPresenter, 2046682548, 52535, 18716, 136, 69, 218, 244, 114, 222, 255, 246); RT_INTERFACE!{interface IContentPresenter(IContentPresenterVtbl): IInspectable(IInspectableVtbl) [IID_IContentPresenter] { fn get_Content(&self, out: *mut *mut IInspectable) -> HRESULT, @@ -14096,6 +14490,154 @@ impl IGroupStyleSelectorOverrides { if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IHandwritingPanelClosedEventArgs, 1337531507, 6445, 19922, 161, 162, 128, 237, 1, 18, 88, 118); +RT_INTERFACE!{interface IHandwritingPanelClosedEventArgs(IHandwritingPanelClosedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IHandwritingPanelClosedEventArgs] { + +}} +RT_CLASS!{class HandwritingPanelClosedEventArgs: IHandwritingPanelClosedEventArgs} +DEFINE_IID!(IID_IHandwritingPanelOpenedEventArgs, 4229280109, 40725, 18352, 185, 122, 148, 166, 140, 198, 19, 69); +RT_INTERFACE!{interface IHandwritingPanelOpenedEventArgs(IHandwritingPanelOpenedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IHandwritingPanelOpenedEventArgs] { + +}} +RT_CLASS!{class HandwritingPanelOpenedEventArgs: IHandwritingPanelOpenedEventArgs} +RT_ENUM! { enum HandwritingPanelPlacementAlignment: i32 { + Auto (HandwritingPanelPlacementAlignment_Auto) = 0, TopLeft (HandwritingPanelPlacementAlignment_TopLeft) = 1, TopRight (HandwritingPanelPlacementAlignment_TopRight) = 2, BottomLeft (HandwritingPanelPlacementAlignment_BottomLeft) = 3, BottomRight (HandwritingPanelPlacementAlignment_BottomRight) = 4, +}} +DEFINE_IID!(IID_IHandwritingView, 3292660903, 12768, 17596, 163, 139, 75, 238, 100, 236, 217, 159); +RT_INTERFACE!{interface IHandwritingView(IHandwritingViewVtbl): IInspectable(IInspectableVtbl) [IID_IHandwritingView] { + fn get_PlacementTarget(&self, out: *mut *mut super::UIElement) -> HRESULT, + fn put_PlacementTarget(&self, value: *mut super::UIElement) -> HRESULT, + fn get_PlacementAlignment(&self, out: *mut HandwritingPanelPlacementAlignment) -> HRESULT, + fn put_PlacementAlignment(&self, value: HandwritingPanelPlacementAlignment) -> HRESULT, + fn get_IsOpen(&self, out: *mut bool) -> HRESULT, + fn get_AreCandidatesEnabled(&self, out: *mut bool) -> HRESULT, + fn put_AreCandidatesEnabled(&self, value: bool) -> HRESULT, + fn add_Opened(&self, value: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_Opened(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn add_Closed(&self, value: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_Closed(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn TryClose(&self, out: *mut bool) -> HRESULT, + fn TryOpen(&self, out: *mut bool) -> HRESULT +}} +impl IHandwritingView { + #[inline] pub fn get_placement_target(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_PlacementTarget)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn set_placement_target(&self, value: &super::UIElement) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_PlacementTarget)(self as *const _ as *mut _, value as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_placement_alignment(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_PlacementAlignment)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_placement_alignment(&self, value: HandwritingPanelPlacementAlignment) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_PlacementAlignment)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_is_open(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_IsOpen)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_are_candidates_enabled(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_AreCandidatesEnabled)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_are_candidates_enabled(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_AreCandidatesEnabled)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_opened(&self, value: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_Opened)(self as *const _ as *mut _, value as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_opened(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_Opened)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_closed(&self, value: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_Closed)(self as *const _ as *mut _, value as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_closed(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_Closed)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn try_close(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).TryClose)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn try_open(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).TryOpen)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} +RT_CLASS!{class HandwritingView: IHandwritingView} +impl RtActivatable for HandwritingView {} +impl HandwritingView { + #[inline] pub fn get_placement_target_property() -> Result>> { + >::get_activation_factory().get_placement_target_property() + } + #[inline] pub fn get_placement_alignment_property() -> Result>> { + >::get_activation_factory().get_placement_alignment_property() + } + #[inline] pub fn get_is_open_property() -> Result>> { + >::get_activation_factory().get_is_open_property() + } + #[inline] pub fn get_are_candidates_enabled_property() -> Result>> { + >::get_activation_factory().get_are_candidates_enabled_property() + } +} +DEFINE_CLSID!(HandwritingView(&[87,105,110,100,111,119,115,46,85,73,46,88,97,109,108,46,67,111,110,116,114,111,108,115,46,72,97,110,100,119,114,105,116,105,110,103,86,105,101,119,0]) [CLSID_HandwritingView]); +DEFINE_IID!(IID_IHandwritingViewFactory, 3758917439, 18, 18268, 137, 12, 151, 174, 48, 134, 66, 222); +RT_INTERFACE!{interface IHandwritingViewFactory(IHandwritingViewFactoryVtbl): IInspectable(IInspectableVtbl) [IID_IHandwritingViewFactory] { + fn CreateInstance(&self, outer: *mut IInspectable, inner: *mut *mut IInspectable, out: *mut *mut HandwritingView) -> HRESULT +}} +impl IHandwritingViewFactory { + #[inline] pub fn create_instance(&self, outer: &IInspectable) -> Result<(Option>, Option>)> { unsafe { + let mut inner = null_mut(); let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreateInstance)(self as *const _ as *mut _, outer as *const _ as *mut _, &mut inner, &mut out); + if hr == S_OK { Ok((ComPtr::wrap_optional(inner), ComPtr::wrap_optional(out))) } else { err(hr) } + }} +} +DEFINE_IID!(IID_IHandwritingViewStatics, 3145526992, 52319, 16388, 184, 200, 20, 46, 25, 95, 6, 24); +RT_INTERFACE!{static interface IHandwritingViewStatics(IHandwritingViewStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IHandwritingViewStatics] { + fn get_PlacementTargetProperty(&self, out: *mut *mut super::DependencyProperty) -> HRESULT, + fn get_PlacementAlignmentProperty(&self, out: *mut *mut super::DependencyProperty) -> HRESULT, + fn get_IsOpenProperty(&self, out: *mut *mut super::DependencyProperty) -> HRESULT, + fn get_AreCandidatesEnabledProperty(&self, out: *mut *mut super::DependencyProperty) -> HRESULT +}} +impl IHandwritingViewStatics { + #[inline] pub fn get_placement_target_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_PlacementTargetProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_placement_alignment_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_PlacementAlignmentProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_is_open_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_IsOpenProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_are_candidates_enabled_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_AreCandidatesEnabledProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IHub, 2926128770, 29460, 20305, 171, 17, 42, 241, 237, 74, 25, 248); RT_INTERFACE!{interface IHub(IHubVtbl): IInspectable(IInspectableVtbl) [IID_IHub] { fn get_Header(&self, out: *mut *mut IInspectable) -> HRESULT, @@ -19280,6 +19822,7 @@ RT_CLASS!{class MediaTransportControls: IMediaTransportControls} impl RtActivatable for MediaTransportControls {} impl RtActivatable for MediaTransportControls {} impl RtActivatable for MediaTransportControls {} +impl RtActivatable for MediaTransportControls {} impl MediaTransportControls { #[inline] pub fn get_is_full_window_button_visible_property() -> Result>> { >::get_activation_factory().get_is_full_window_button_visible_property() @@ -19362,6 +19905,12 @@ impl MediaTransportControls { #[inline] pub fn get_is_repeat_button_visible_property() -> Result>> { >::get_activation_factory().get_is_repeat_button_visible_property() } + #[inline] pub fn get_is_compact_overlay_button_visible_property() -> Result>> { + >::get_activation_factory().get_is_compact_overlay_button_visible_property() + } + #[inline] pub fn get_is_compact_overlay_enabled_property() -> Result>> { + >::get_activation_factory().get_is_compact_overlay_enabled_property() + } } DEFINE_CLSID!(MediaTransportControls(&[87,105,110,100,111,119,115,46,85,73,46,88,97,109,108,46,67,111,110,116,114,111,108,115,46,77,101,100,105,97,84,114,97,110,115,112,111,114,116,67,111,110,116,114,111,108,115,0]) [CLSID_MediaTransportControls]); DEFINE_IID!(IID_IMediaTransportControls2, 730460140, 7146, 17694, 139, 205, 207, 226, 217, 66, 50, 98); @@ -19505,6 +20054,33 @@ impl IMediaTransportControls3 { if hr == S_OK { Ok(()) } else { err(hr) } }} } +DEFINE_IID!(IID_IMediaTransportControls4, 263289944, 40739, 4583, 171, 196, 206, 194, 120, 182, 181, 10); +RT_INTERFACE!{interface IMediaTransportControls4(IMediaTransportControls4Vtbl): IInspectable(IInspectableVtbl) [IID_IMediaTransportControls4] { + fn get_IsCompactOverlayButtonVisible(&self, out: *mut bool) -> HRESULT, + fn put_IsCompactOverlayButtonVisible(&self, value: bool) -> HRESULT, + fn get_IsCompactOverlayEnabled(&self, out: *mut bool) -> HRESULT, + fn put_IsCompactOverlayEnabled(&self, value: bool) -> HRESULT +}} +impl IMediaTransportControls4 { + #[inline] pub fn get_is_compact_overlay_button_visible(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_IsCompactOverlayButtonVisible)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_is_compact_overlay_button_visible(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_IsCompactOverlayButtonVisible)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_is_compact_overlay_enabled(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_IsCompactOverlayEnabled)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_is_compact_overlay_enabled(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_IsCompactOverlayEnabled)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} DEFINE_IID!(IID_IMediaTransportControlsFactory, 497156442, 43236, 19483, 136, 201, 11, 24, 62, 204, 98, 227); RT_INTERFACE!{interface IMediaTransportControlsFactory(IMediaTransportControlsFactoryVtbl): IInspectable(IInspectableVtbl) [IID_IMediaTransportControlsFactory] { fn CreateInstance(&self, outer: *mut IInspectable, inner: *mut *mut IInspectable, out: *mut *mut MediaTransportControls) -> HRESULT @@ -19733,6 +20309,23 @@ impl IMediaTransportControlsStatics3 { if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IMediaTransportControlsStatics4, 263291204, 40739, 4583, 171, 196, 206, 194, 120, 182, 181, 10); +RT_INTERFACE!{static interface IMediaTransportControlsStatics4(IMediaTransportControlsStatics4Vtbl): IInspectable(IInspectableVtbl) [IID_IMediaTransportControlsStatics4] { + fn get_IsCompactOverlayButtonVisibleProperty(&self, out: *mut *mut super::DependencyProperty) -> HRESULT, + fn get_IsCompactOverlayEnabledProperty(&self, out: *mut *mut super::DependencyProperty) -> HRESULT +}} +impl IMediaTransportControlsStatics4 { + #[inline] pub fn get_is_compact_overlay_button_visible_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_IsCompactOverlayButtonVisibleProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_is_compact_overlay_enabled_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_IsCompactOverlayEnabledProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IMenuFlyout, 2905739505, 39003, 16753, 187, 186, 103, 188, 199, 41, 100, 155); RT_INTERFACE!{interface IMenuFlyout(IMenuFlyoutVtbl): IInspectable(IInspectableVtbl) [IID_IMenuFlyout] { fn get_Items(&self, out: *mut *mut foundation::collections::IVector) -> HRESULT, @@ -19836,6 +20429,7 @@ impl IMenuFlyoutItem { RT_CLASS!{class MenuFlyoutItem: IMenuFlyoutItem} impl RtActivatable for MenuFlyoutItem {} impl RtActivatable for MenuFlyoutItem {} +impl RtActivatable for MenuFlyoutItem {} impl MenuFlyoutItem { #[inline] pub fn get_text_property() -> Result>> { >::get_activation_factory().get_text_property() @@ -19849,6 +20443,9 @@ impl MenuFlyoutItem { #[inline] pub fn get_icon_property() -> Result>> { >::get_activation_factory().get_icon_property() } + #[inline] pub fn get_keyboard_accelerator_text_override_property() -> Result>> { + >::get_activation_factory().get_keyboard_accelerator_text_override_property() + } } DEFINE_CLSID!(MenuFlyoutItem(&[87,105,110,100,111,119,115,46,85,73,46,88,97,109,108,46,67,111,110,116,114,111,108,115,46,77,101,110,117,70,108,121,111,117,116,73,116,101,109,0]) [CLSID_MenuFlyoutItem]); DEFINE_IID!(IID_IMenuFlyoutItem2, 182609643, 652, 17443, 168, 227, 152, 159, 217, 221, 113, 38); @@ -19867,6 +20464,28 @@ impl IMenuFlyoutItem2 { if hr == S_OK { Ok(()) } else { err(hr) } }} } +DEFINE_IID!(IID_IMenuFlyoutItem3, 2535961315, 45750, 18908, 140, 34, 224, 19, 139, 148, 21, 89); +RT_INTERFACE!{interface IMenuFlyoutItem3(IMenuFlyoutItem3Vtbl): IInspectable(IInspectableVtbl) [IID_IMenuFlyoutItem3] { + fn get_KeyboardAcceleratorTextOverride(&self, out: *mut HSTRING) -> HRESULT, + fn put_KeyboardAcceleratorTextOverride(&self, value: HSTRING) -> HRESULT, + fn get_TemplateSettings(&self, out: *mut *mut primitives::MenuFlyoutItemTemplateSettings) -> HRESULT +}} +impl IMenuFlyoutItem3 { + #[inline] pub fn get_keyboard_accelerator_text_override(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_KeyboardAcceleratorTextOverride)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn set_keyboard_accelerator_text_override(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_KeyboardAcceleratorTextOverride)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_template_settings(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_TemplateSettings)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IMenuFlyoutItemBase, 4189413447, 36262, 18224, 146, 8, 20, 65, 37, 198, 179, 150); RT_INTERFACE!{interface IMenuFlyoutItemBase(IMenuFlyoutItemBaseVtbl): IInspectable(IInspectableVtbl) [IID_IMenuFlyoutItemBase] { @@ -19921,6 +20540,17 @@ impl IMenuFlyoutItemStatics2 { if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IMenuFlyoutItemStatics3, 3628062659, 2795, 20211, 130, 112, 139, 155, 149, 242, 178, 152); +RT_INTERFACE!{static interface IMenuFlyoutItemStatics3(IMenuFlyoutItemStatics3Vtbl): IInspectable(IInspectableVtbl) [IID_IMenuFlyoutItemStatics3] { + fn get_KeyboardAcceleratorTextOverrideProperty(&self, out: *mut *mut super::DependencyProperty) -> HRESULT +}} +impl IMenuFlyoutItemStatics3 { + #[inline] pub fn get_keyboard_accelerator_text_override_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_KeyboardAcceleratorTextOverrideProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IMenuFlyoutPresenter, 2423128836, 9550, 16703, 178, 25, 199, 185, 127, 0, 55, 82); RT_INTERFACE!{interface IMenuFlyoutPresenter(IMenuFlyoutPresenterVtbl): IInspectable(IInspectableVtbl) [IID_IMenuFlyoutPresenter] { @@ -20338,6 +20968,7 @@ impl INavigationView { } RT_CLASS!{class NavigationView: INavigationView} impl RtActivatable for NavigationView {} +impl RtActivatable for NavigationView {} impl NavigationView { #[inline] pub fn get_is_pane_open_property() -> Result>> { >::get_activation_factory().get_is_pane_open_property() @@ -20405,8 +21036,118 @@ impl NavigationView { #[inline] pub fn get_menu_item_container_style_selector_property() -> Result>> { >::get_activation_factory().get_menu_item_container_style_selector_property() } + #[inline] pub fn get_is_back_button_visible_property() -> Result>> { + >::get_activation_factory().get_is_back_button_visible_property() + } + #[inline] pub fn get_is_back_enabled_property() -> Result>> { + >::get_activation_factory().get_is_back_enabled_property() + } + #[inline] pub fn get_pane_title_property() -> Result>> { + >::get_activation_factory().get_pane_title_property() + } } DEFINE_CLSID!(NavigationView(&[87,105,110,100,111,119,115,46,85,73,46,88,97,109,108,46,67,111,110,116,114,111,108,115,46,78,97,118,105,103,97,116,105,111,110,86,105,101,119,0]) [CLSID_NavigationView]); +DEFINE_IID!(IID_INavigationView2, 736401207, 31763, 19524, 134, 195, 139, 37, 230, 151, 168, 14); +RT_INTERFACE!{interface INavigationView2(INavigationView2Vtbl): IInspectable(IInspectableVtbl) [IID_INavigationView2] { + fn get_IsBackButtonVisible(&self, out: *mut NavigationViewBackButtonVisible) -> HRESULT, + fn put_IsBackButtonVisible(&self, value: NavigationViewBackButtonVisible) -> HRESULT, + fn get_IsBackEnabled(&self, out: *mut bool) -> HRESULT, + fn put_IsBackEnabled(&self, value: bool) -> HRESULT, + fn get_PaneTitle(&self, out: *mut HSTRING) -> HRESULT, + fn put_PaneTitle(&self, value: HSTRING) -> HRESULT, + fn add_BackRequested(&self, value: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_BackRequested(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn add_PaneClosed(&self, value: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_PaneClosed(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn add_PaneClosing(&self, value: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_PaneClosing(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn add_PaneOpened(&self, value: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_PaneOpened(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn add_PaneOpening(&self, value: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_PaneOpening(&self, token: foundation::EventRegistrationToken) -> HRESULT +}} +impl INavigationView2 { + #[inline] pub fn get_is_back_button_visible(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_IsBackButtonVisible)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_is_back_button_visible(&self, value: NavigationViewBackButtonVisible) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_IsBackButtonVisible)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_is_back_enabled(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_IsBackEnabled)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_is_back_enabled(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_IsBackEnabled)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_pane_title(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_PaneTitle)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn set_pane_title(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_PaneTitle)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_back_requested(&self, value: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_BackRequested)(self as *const _ as *mut _, value as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_back_requested(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_BackRequested)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_pane_closed(&self, value: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_PaneClosed)(self as *const _ as *mut _, value as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_pane_closed(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_PaneClosed)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_pane_closing(&self, value: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_PaneClosing)(self as *const _ as *mut _, value as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_pane_closing(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_PaneClosing)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_pane_opened(&self, value: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_PaneOpened)(self as *const _ as *mut _, value as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_pane_opened(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_PaneOpened)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_pane_opening(&self, value: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_PaneOpening)(self as *const _ as *mut _, value as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_pane_opening(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_PaneOpening)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_ENUM! { enum NavigationViewBackButtonVisible: i32 { + Collapsed (NavigationViewBackButtonVisible_Collapsed) = 0, Visible (NavigationViewBackButtonVisible_Visible) = 1, Auto (NavigationViewBackButtonVisible_Auto) = 2, +}} +DEFINE_IID!(IID_INavigationViewBackRequestedEventArgs, 1147601121, 39581, 17664, 167, 29, 37, 193, 88, 9, 184, 121); +RT_INTERFACE!{interface INavigationViewBackRequestedEventArgs(INavigationViewBackRequestedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_INavigationViewBackRequestedEventArgs] { + +}} +RT_CLASS!{class NavigationViewBackRequestedEventArgs: INavigationViewBackRequestedEventArgs} RT_ENUM! { enum NavigationViewDisplayMode: i32 { Minimal (NavigationViewDisplayMode_Minimal) = 0, Compact (NavigationViewDisplayMode_Compact) = 1, Expanded (NavigationViewDisplayMode_Expanded) = 2, }} @@ -20571,6 +21312,23 @@ impl INavigationViewListFactory { if hr == S_OK { Ok((ComPtr::wrap_optional(inner), ComPtr::wrap_optional(out))) } else { err(hr) } }} } +DEFINE_IID!(IID_INavigationViewPaneClosingEventArgs, 2505405882, 30197, 17197, 180, 155, 96, 228, 117, 82, 213, 238); +RT_INTERFACE!{interface INavigationViewPaneClosingEventArgs(INavigationViewPaneClosingEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_INavigationViewPaneClosingEventArgs] { + fn get_Cancel(&self, out: *mut bool) -> HRESULT, + fn put_Cancel(&self, value: bool) -> HRESULT +}} +impl INavigationViewPaneClosingEventArgs { + #[inline] pub fn get_cancel(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Cancel)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_cancel(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Cancel)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class NavigationViewPaneClosingEventArgs: INavigationViewPaneClosingEventArgs} DEFINE_IID!(IID_INavigationViewSelectionChangedEventArgs, 1520765344, 14942, 20308, 137, 108, 152, 184, 95, 129, 149, 8); RT_INTERFACE!{interface INavigationViewSelectionChangedEventArgs(INavigationViewSelectionChangedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_INavigationViewSelectionChangedEventArgs] { fn get_SelectedItem(&self, out: *mut *mut IInspectable) -> HRESULT, @@ -20726,6 +21484,29 @@ impl INavigationViewStatics { if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_INavigationViewStatics2, 2361724276, 6722, 18514, 171, 90, 109, 200, 47, 40, 164, 186); +RT_INTERFACE!{static interface INavigationViewStatics2(INavigationViewStatics2Vtbl): IInspectable(IInspectableVtbl) [IID_INavigationViewStatics2] { + fn get_IsBackButtonVisibleProperty(&self, out: *mut *mut super::DependencyProperty) -> HRESULT, + fn get_IsBackEnabledProperty(&self, out: *mut *mut super::DependencyProperty) -> HRESULT, + fn get_PaneTitleProperty(&self, out: *mut *mut super::DependencyProperty) -> HRESULT +}} +impl INavigationViewStatics2 { + #[inline] pub fn get_is_back_button_visible_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_IsBackButtonVisibleProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_is_back_enabled_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_IsBackEnabledProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_pane_title_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_PaneTitleProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_INotifyEventArgs, 2936931831, 50359, 17605, 176, 157, 92, 183, 5, 43, 58, 151); RT_INTERFACE!{interface INotifyEventArgs(INotifyEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_INotifyEventArgs] { fn get_Value(&self, out: *mut HSTRING) -> HRESULT @@ -23160,6 +23941,256 @@ impl IRatingItemInfoFactory { if hr == S_OK { Ok((ComPtr::wrap_optional(inner), ComPtr::wrap_optional(out))) } else { err(hr) } }} } +DEFINE_IID!(IID_IRefreshContainer, 1398653971, 45525, 17345, 176, 87, 134, 88, 206, 30, 11, 162); +RT_INTERFACE!{interface IRefreshContainer(IRefreshContainerVtbl): IInspectable(IInspectableVtbl) [IID_IRefreshContainer] { + fn get_Visualizer(&self, out: *mut *mut RefreshVisualizer) -> HRESULT, + fn put_Visualizer(&self, value: *mut RefreshVisualizer) -> HRESULT, + fn get_PullDirection(&self, out: *mut RefreshPullDirection) -> HRESULT, + fn put_PullDirection(&self, value: RefreshPullDirection) -> HRESULT, + fn add_RefreshRequested(&self, value: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_RefreshRequested(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn RequestRefresh(&self) -> HRESULT +}} +impl IRefreshContainer { + #[inline] pub fn get_visualizer(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Visualizer)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn set_visualizer(&self, value: &RefreshVisualizer) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Visualizer)(self as *const _ as *mut _, value as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_pull_direction(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_PullDirection)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_pull_direction(&self, value: RefreshPullDirection) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_PullDirection)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_refresh_requested(&self, value: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_RefreshRequested)(self as *const _ as *mut _, value as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_refresh_requested(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_RefreshRequested)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn request_refresh(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).RequestRefresh)(self as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class RefreshContainer: IRefreshContainer} +impl RtActivatable for RefreshContainer {} +impl RefreshContainer { + #[inline] pub fn get_visualizer_property() -> Result>> { + >::get_activation_factory().get_visualizer_property() + } + #[inline] pub fn get_pull_direction_property() -> Result>> { + >::get_activation_factory().get_pull_direction_property() + } +} +DEFINE_CLSID!(RefreshContainer(&[87,105,110,100,111,119,115,46,85,73,46,88,97,109,108,46,67,111,110,116,114,111,108,115,46,82,101,102,114,101,115,104,67,111,110,116,97,105,110,101,114,0]) [CLSID_RefreshContainer]); +DEFINE_IID!(IID_IRefreshContainerFactory, 168064895, 2206, 16953, 186, 235, 196, 100, 20, 132, 195, 126); +RT_INTERFACE!{interface IRefreshContainerFactory(IRefreshContainerFactoryVtbl): IInspectable(IInspectableVtbl) [IID_IRefreshContainerFactory] { + fn CreateInstance(&self, outer: *mut IInspectable, inner: *mut *mut IInspectable, out: *mut *mut RefreshContainer) -> HRESULT +}} +impl IRefreshContainerFactory { + #[inline] pub fn create_instance(&self, outer: &IInspectable) -> Result<(Option>, Option>)> { unsafe { + let mut inner = null_mut(); let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreateInstance)(self as *const _ as *mut _, outer as *const _ as *mut _, &mut inner, &mut out); + if hr == S_OK { Ok((ComPtr::wrap_optional(inner), ComPtr::wrap_optional(out))) } else { err(hr) } + }} +} +DEFINE_IID!(IID_IRefreshContainerStatics, 2718627237, 28693, 18269, 157, 227, 129, 160, 71, 157, 218, 56); +RT_INTERFACE!{static interface IRefreshContainerStatics(IRefreshContainerStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IRefreshContainerStatics] { + fn get_VisualizerProperty(&self, out: *mut *mut super::DependencyProperty) -> HRESULT, + fn get_PullDirectionProperty(&self, out: *mut *mut super::DependencyProperty) -> HRESULT +}} +impl IRefreshContainerStatics { + #[inline] pub fn get_visualizer_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_VisualizerProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_pull_direction_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_PullDirectionProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +DEFINE_IID!(IID_IRefreshInteractionRatioChangedEventArgs, 3622074400, 56391, 19342, 187, 39, 127, 10, 131, 242, 154, 7); +RT_INTERFACE!{interface IRefreshInteractionRatioChangedEventArgs(IRefreshInteractionRatioChangedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IRefreshInteractionRatioChangedEventArgs] { + fn get_InteractionRatio(&self, out: *mut f64) -> HRESULT +}} +impl IRefreshInteractionRatioChangedEventArgs { + #[inline] pub fn get_interaction_ratio(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_InteractionRatio)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} +RT_CLASS!{class RefreshInteractionRatioChangedEventArgs: IRefreshInteractionRatioChangedEventArgs} +RT_ENUM! { enum RefreshPullDirection: i32 { + LeftToRight (RefreshPullDirection_LeftToRight) = 0, TopToBottom (RefreshPullDirection_TopToBottom) = 1, RightToLeft (RefreshPullDirection_RightToLeft) = 2, BottomToTop (RefreshPullDirection_BottomToTop) = 3, +}} +DEFINE_IID!(IID_IRefreshRequestedEventArgs, 453549891, 53199, 19142, 179, 31, 141, 171, 110, 239, 221, 147); +RT_INTERFACE!{interface IRefreshRequestedEventArgs(IRefreshRequestedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IRefreshRequestedEventArgs] { + fn GetDeferral(&self, out: *mut *mut foundation::Deferral) -> HRESULT +}} +impl IRefreshRequestedEventArgs { + #[inline] pub fn get_deferral(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetDeferral)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +RT_CLASS!{class RefreshRequestedEventArgs: IRefreshRequestedEventArgs} +DEFINE_IID!(IID_IRefreshStateChangedEventArgs, 3144454174, 8702, 16649, 175, 128, 115, 236, 102, 27, 103, 138); +RT_INTERFACE!{interface IRefreshStateChangedEventArgs(IRefreshStateChangedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IRefreshStateChangedEventArgs] { + fn get_OldState(&self, out: *mut RefreshVisualizerState) -> HRESULT, + fn get_NewState(&self, out: *mut RefreshVisualizerState) -> HRESULT +}} +impl IRefreshStateChangedEventArgs { + #[inline] pub fn get_old_state(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_OldState)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_new_state(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_NewState)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} +RT_CLASS!{class RefreshStateChangedEventArgs: IRefreshStateChangedEventArgs} +DEFINE_IID!(IID_IRefreshVisualizer, 3236102434, 62443, 19370, 161, 31, 195, 248, 115, 66, 203, 244); +RT_INTERFACE!{interface IRefreshVisualizer(IRefreshVisualizerVtbl): IInspectable(IInspectableVtbl) [IID_IRefreshVisualizer] { + fn RequestRefresh(&self) -> HRESULT, + fn get_Orientation(&self, out: *mut RefreshVisualizerOrientation) -> HRESULT, + fn put_Orientation(&self, value: RefreshVisualizerOrientation) -> HRESULT, + fn get_Content(&self, out: *mut *mut super::UIElement) -> HRESULT, + fn put_Content(&self, value: *mut super::UIElement) -> HRESULT, + fn get_State(&self, out: *mut RefreshVisualizerState) -> HRESULT, + fn add_RefreshRequested(&self, value: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_RefreshRequested(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn add_RefreshStateChanged(&self, value: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_RefreshStateChanged(&self, token: foundation::EventRegistrationToken) -> HRESULT +}} +impl IRefreshVisualizer { + #[inline] pub fn request_refresh(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).RequestRefresh)(self as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_orientation(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Orientation)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_orientation(&self, value: RefreshVisualizerOrientation) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Orientation)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_content(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Content)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn set_content(&self, value: &super::UIElement) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Content)(self as *const _ as *mut _, value as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_state(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_State)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn add_refresh_requested(&self, value: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_RefreshRequested)(self as *const _ as *mut _, value as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_refresh_requested(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_RefreshRequested)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_refresh_state_changed(&self, value: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_RefreshStateChanged)(self as *const _ as *mut _, value as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_refresh_state_changed(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_RefreshStateChanged)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class RefreshVisualizer: IRefreshVisualizer} +impl RtActivatable for RefreshVisualizer {} +impl RefreshVisualizer { + #[inline] pub fn get_info_provider_property() -> Result>> { + >::get_activation_factory().get_info_provider_property() + } + #[inline] pub fn get_orientation_property() -> Result>> { + >::get_activation_factory().get_orientation_property() + } + #[inline] pub fn get_content_property() -> Result>> { + >::get_activation_factory().get_content_property() + } + #[inline] pub fn get_state_property() -> Result>> { + >::get_activation_factory().get_state_property() + } +} +DEFINE_CLSID!(RefreshVisualizer(&[87,105,110,100,111,119,115,46,85,73,46,88,97,109,108,46,67,111,110,116,114,111,108,115,46,82,101,102,114,101,115,104,86,105,115,117,97,108,105,122,101,114,0]) [CLSID_RefreshVisualizer]); +DEFINE_IID!(IID_IRefreshVisualizerFactory, 1868325170, 28169, 19472, 130, 74, 18, 125, 54, 103, 39, 21); +RT_INTERFACE!{interface IRefreshVisualizerFactory(IRefreshVisualizerFactoryVtbl): IInspectable(IInspectableVtbl) [IID_IRefreshVisualizerFactory] { + fn CreateInstance(&self, outer: *mut IInspectable, inner: *mut *mut IInspectable, out: *mut *mut RefreshVisualizer) -> HRESULT +}} +impl IRefreshVisualizerFactory { + #[inline] pub fn create_instance(&self, outer: &IInspectable) -> Result<(Option>, Option>)> { unsafe { + let mut inner = null_mut(); let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreateInstance)(self as *const _ as *mut _, outer as *const _ as *mut _, &mut inner, &mut out); + if hr == S_OK { Ok((ComPtr::wrap_optional(inner), ComPtr::wrap_optional(out))) } else { err(hr) } + }} +} +RT_ENUM! { enum RefreshVisualizerOrientation: i32 { + Auto (RefreshVisualizerOrientation_Auto) = 0, Normal (RefreshVisualizerOrientation_Normal) = 1, Rotate90DegreesCounterclockwise (RefreshVisualizerOrientation_Rotate90DegreesCounterclockwise) = 2, Rotate270DegreesCounterclockwise (RefreshVisualizerOrientation_Rotate270DegreesCounterclockwise) = 3, +}} +RT_ENUM! { enum RefreshVisualizerState: i32 { + Idle (RefreshVisualizerState_Idle) = 0, Peeking (RefreshVisualizerState_Peeking) = 1, Interacting (RefreshVisualizerState_Interacting) = 2, Pending (RefreshVisualizerState_Pending) = 3, Refreshing (RefreshVisualizerState_Refreshing) = 4, +}} +DEFINE_IID!(IID_IRefreshVisualizerStatics, 2951370415, 13866, 16405, 177, 85, 115, 58, 31, 134, 152, 49); +RT_INTERFACE!{static interface IRefreshVisualizerStatics(IRefreshVisualizerStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IRefreshVisualizerStatics] { + fn get_InfoProviderProperty(&self, out: *mut *mut super::DependencyProperty) -> HRESULT, + fn get_OrientationProperty(&self, out: *mut *mut super::DependencyProperty) -> HRESULT, + fn get_ContentProperty(&self, out: *mut *mut super::DependencyProperty) -> HRESULT, + fn get_StateProperty(&self, out: *mut *mut super::DependencyProperty) -> HRESULT +}} +impl IRefreshVisualizerStatics { + #[inline] pub fn get_info_provider_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_InfoProviderProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_orientation_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_OrientationProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_content_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ContentProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_state_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_StateProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IRelativePanel, 783022827, 45914, 16437, 172, 234, 60, 74, 55, 48, 104, 63); RT_INTERFACE!{interface IRelativePanel(IRelativePanelVtbl): IInspectable(IInspectableVtbl) [IID_IRelativePanel] { fn get_BorderBrush(&self, out: *mut *mut super::media::Brush) -> HRESULT, @@ -23814,6 +24845,7 @@ impl RtActivatable for RichEditBox {} impl RtActivatable for RichEditBox {} impl RtActivatable for RichEditBox {} impl RtActivatable for RichEditBox {} +impl RtActivatable for RichEditBox {} impl RichEditBox { #[inline] pub fn get_is_read_only_property() -> Result>> { >::get_activation_factory().get_is_read_only_property() @@ -23878,6 +24910,21 @@ impl RichEditBox { #[inline] pub fn get_disabled_formatting_accelerators_property() -> Result>> { >::get_activation_factory().get_disabled_formatting_accelerators_property() } + #[inline] pub fn get_content_link_foreground_color_property() -> Result>> { + >::get_activation_factory().get_content_link_foreground_color_property() + } + #[inline] pub fn get_content_link_background_color_property() -> Result>> { + >::get_activation_factory().get_content_link_background_color_property() + } + #[inline] pub fn get_content_link_providers_property() -> Result>> { + >::get_activation_factory().get_content_link_providers_property() + } + #[inline] pub fn get_handwriting_view_property() -> Result>> { + >::get_activation_factory().get_handwriting_view_property() + } + #[inline] pub fn get_is_handwriting_view_enabled_property() -> Result>> { + >::get_activation_factory().get_is_handwriting_view_enabled_property() + } } DEFINE_CLSID!(RichEditBox(&[87,105,110,100,111,119,115,46,85,73,46,88,97,109,108,46,67,111,110,116,114,111,108,115,46,82,105,99,104,69,100,105,116,66,111,120,0]) [CLSID_RichEditBox]); DEFINE_IID!(IID_IRichEditBox2, 3152703149, 59397, 18340, 187, 231, 71, 229, 155, 143, 116, 167); @@ -24153,6 +25200,88 @@ impl IRichEditBox6 { if hr == S_OK { Ok(()) } else { err(hr) } }} } +DEFINE_IID!(IID_IRichEditBox7, 2550961130, 9247, 20330, 165, 57, 157, 24, 92, 140, 241, 138); +RT_INTERFACE!{interface IRichEditBox7(IRichEditBox7Vtbl): IInspectable(IInspectableVtbl) [IID_IRichEditBox7] { + fn get_ContentLinkForegroundColor(&self, out: *mut *mut super::media::SolidColorBrush) -> HRESULT, + fn put_ContentLinkForegroundColor(&self, value: *mut super::media::SolidColorBrush) -> HRESULT, + fn get_ContentLinkBackgroundColor(&self, out: *mut *mut super::media::SolidColorBrush) -> HRESULT, + fn put_ContentLinkBackgroundColor(&self, value: *mut super::media::SolidColorBrush) -> HRESULT, + fn get_ContentLinkProviders(&self, out: *mut *mut super::documents::ContentLinkProviderCollection) -> HRESULT, + fn put_ContentLinkProviders(&self, value: *mut super::documents::ContentLinkProviderCollection) -> HRESULT, + fn get_HandwritingView(&self, out: *mut *mut HandwritingView) -> HRESULT, + fn put_HandwritingView(&self, value: *mut HandwritingView) -> HRESULT, + fn get_IsHandwritingViewEnabled(&self, out: *mut bool) -> HRESULT, + fn put_IsHandwritingViewEnabled(&self, value: bool) -> HRESULT, + fn add_ContentLinkChanged(&self, value: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_ContentLinkChanged(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn add_ContentLinkInvoked(&self, value: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_ContentLinkInvoked(&self, token: foundation::EventRegistrationToken) -> HRESULT +}} +impl IRichEditBox7 { + #[inline] pub fn get_content_link_foreground_color(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ContentLinkForegroundColor)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn set_content_link_foreground_color(&self, value: &super::media::SolidColorBrush) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_ContentLinkForegroundColor)(self as *const _ as *mut _, value as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_content_link_background_color(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ContentLinkBackgroundColor)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn set_content_link_background_color(&self, value: &super::media::SolidColorBrush) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_ContentLinkBackgroundColor)(self as *const _ as *mut _, value as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_content_link_providers(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ContentLinkProviders)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn set_content_link_providers(&self, value: &super::documents::ContentLinkProviderCollection) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_ContentLinkProviders)(self as *const _ as *mut _, value as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_handwriting_view(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_HandwritingView)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn set_handwriting_view(&self, value: &HandwritingView) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_HandwritingView)(self as *const _ as *mut _, value as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_is_handwriting_view_enabled(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_IsHandwritingViewEnabled)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_is_handwriting_view_enabled(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_IsHandwritingViewEnabled)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_content_link_changed(&self, value: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_ContentLinkChanged)(self as *const _ as *mut _, value as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_content_link_changed(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_ContentLinkChanged)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_content_link_invoked(&self, value: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_ContentLinkInvoked)(self as *const _ as *mut _, value as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_content_link_invoked(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_ContentLinkInvoked)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} DEFINE_IID!(IID_IRichEditBoxFactory, 1637998434, 10246, 16877, 136, 237, 174, 33, 244, 122, 180, 34); RT_INTERFACE!{interface IRichEditBoxFactory(IRichEditBoxFactoryVtbl): IInspectable(IInspectableVtbl) [IID_IRichEditBoxFactory] { fn CreateInstance(&self, outer: *mut IInspectable, inner: *mut *mut IInspectable, out: *mut *mut RichEditBox) -> HRESULT @@ -24320,6 +25449,41 @@ impl IRichEditBoxStatics6 { if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IRichEditBoxStatics7, 1509591439, 63585, 17370, 167, 206, 75, 156, 33, 216, 53, 249); +RT_INTERFACE!{static interface IRichEditBoxStatics7(IRichEditBoxStatics7Vtbl): IInspectable(IInspectableVtbl) [IID_IRichEditBoxStatics7] { + fn get_ContentLinkForegroundColorProperty(&self, out: *mut *mut super::DependencyProperty) -> HRESULT, + fn get_ContentLinkBackgroundColorProperty(&self, out: *mut *mut super::DependencyProperty) -> HRESULT, + fn get_ContentLinkProvidersProperty(&self, out: *mut *mut super::DependencyProperty) -> HRESULT, + fn get_HandwritingViewProperty(&self, out: *mut *mut super::DependencyProperty) -> HRESULT, + fn get_IsHandwritingViewEnabledProperty(&self, out: *mut *mut super::DependencyProperty) -> HRESULT +}} +impl IRichEditBoxStatics7 { + #[inline] pub fn get_content_link_foreground_color_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ContentLinkForegroundColorProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_content_link_background_color_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ContentLinkBackgroundColorProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_content_link_providers_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ContentLinkProvidersProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_handwriting_view_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_HandwritingViewProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_is_handwriting_view_enabled_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_IsHandwritingViewEnabledProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IRichEditBoxTextChangingEventArgs, 1409699864, 10259, 18722, 159, 142, 182, 187, 175, 217, 149, 216); RT_INTERFACE!{interface IRichEditBoxTextChangingEventArgs(IRichEditBoxTextChangingEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IRichEditBoxTextChangingEventArgs] { @@ -29566,6 +30730,7 @@ impl RtActivatable for TextBox {} impl RtActivatable for TextBox {} impl RtActivatable for TextBox {} impl RtActivatable for TextBox {} +impl RtActivatable for TextBox {} impl TextBox { #[inline] pub fn get_text_property() -> Result>> { >::get_activation_factory().get_text_property() @@ -29630,6 +30795,12 @@ impl TextBox { #[inline] pub fn get_placeholder_foreground_property() -> Result>> { >::get_activation_factory().get_placeholder_foreground_property() } + #[inline] pub fn get_handwriting_view_property() -> Result>> { + >::get_activation_factory().get_handwriting_view_property() + } + #[inline] pub fn get_is_handwriting_view_enabled_property() -> Result>> { + >::get_activation_factory().get_is_handwriting_view_enabled_property() + } } DEFINE_CLSID!(TextBox(&[87,105,110,100,111,119,115,46,85,73,46,88,97,109,108,46,67,111,110,116,114,111,108,115,46,84,101,120,116,66,111,120,0]) [CLSID_TextBox]); DEFINE_IID!(IID_ITextBox2, 4145449984, 5170, 17962, 148, 5, 56, 243, 133, 191, 195, 124); @@ -29894,6 +31065,33 @@ impl ITextBox6 { if hr == S_OK { Ok(()) } else { err(hr) } }} } +DEFINE_IID!(IID_ITextBox7, 3662221817, 65505, 19562, 172, 109, 27, 74, 23, 76, 207, 128); +RT_INTERFACE!{interface ITextBox7(ITextBox7Vtbl): IInspectable(IInspectableVtbl) [IID_ITextBox7] { + fn get_HandwritingView(&self, out: *mut *mut HandwritingView) -> HRESULT, + fn put_HandwritingView(&self, value: *mut HandwritingView) -> HRESULT, + fn get_IsHandwritingViewEnabled(&self, out: *mut bool) -> HRESULT, + fn put_IsHandwritingViewEnabled(&self, value: bool) -> HRESULT +}} +impl ITextBox7 { + #[inline] pub fn get_handwriting_view(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_HandwritingView)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn set_handwriting_view(&self, value: &HandwritingView) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_HandwritingView)(self as *const _ as *mut _, value as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_is_handwriting_view_enabled(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_IsHandwritingViewEnabled)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_is_handwriting_view_enabled(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_IsHandwritingViewEnabled)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} DEFINE_IID!(IID_ITextBoxBeforeTextChangingEventArgs, 2773753267, 30596, 16984, 170, 131, 228, 190, 221, 114, 116, 103); RT_INTERFACE!{interface ITextBoxBeforeTextChangingEventArgs(ITextBoxBeforeTextChangingEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_ITextBoxBeforeTextChangingEventArgs] { fn get_NewText(&self, out: *mut HSTRING) -> HRESULT, @@ -30079,6 +31277,23 @@ impl ITextBoxStatics6 { if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_ITextBoxStatics7, 3446435655, 5246, 18168, 164, 232, 116, 156, 73, 132, 122, 62); +RT_INTERFACE!{static interface ITextBoxStatics7(ITextBoxStatics7Vtbl): IInspectable(IInspectableVtbl) [IID_ITextBoxStatics7] { + fn get_HandwritingViewProperty(&self, out: *mut *mut super::DependencyProperty) -> HRESULT, + fn get_IsHandwritingViewEnabledProperty(&self, out: *mut *mut super::DependencyProperty) -> HRESULT +}} +impl ITextBoxStatics7 { + #[inline] pub fn get_handwriting_view_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_HandwritingViewProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_is_handwriting_view_enabled_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_IsHandwritingViewEnabledProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_ITextBoxTextChangingEventArgs, 1315588981, 17373, 20019, 172, 190, 45, 135, 150, 161, 121, 39); RT_INTERFACE!{interface ITextBoxTextChangingEventArgs(ITextBoxTextChangingEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_ITextBoxTextChangingEventArgs] { @@ -31019,6 +32234,544 @@ impl IToolTipStatics { if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_ITreeView, 2471742556, 56686, 17724, 174, 221, 12, 58, 201, 147, 151, 139); +RT_INTERFACE!{interface ITreeView(ITreeViewVtbl): IInspectable(IInspectableVtbl) [IID_ITreeView] { + fn get_RootNodes(&self, out: *mut *mut foundation::collections::IVector) -> HRESULT, + fn get_SelectionMode(&self, out: *mut TreeViewSelectionMode) -> HRESULT, + fn put_SelectionMode(&self, value: TreeViewSelectionMode) -> HRESULT, + fn get_SelectedNodes(&self, out: *mut *mut foundation::collections::IVector) -> HRESULT, + fn Expand(&self, value: *mut TreeViewNode) -> HRESULT, + fn Collapse(&self, value: *mut TreeViewNode) -> HRESULT, + fn SelectAll(&self) -> HRESULT, + fn add_ItemInvoked(&self, value: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_ItemInvoked(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn add_Expanding(&self, value: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_Expanding(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn add_Collapsed(&self, value: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_Collapsed(&self, token: foundation::EventRegistrationToken) -> HRESULT +}} +impl ITreeView { + #[inline] pub fn get_root_nodes(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_RootNodes)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_selection_mode(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_SelectionMode)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_selection_mode(&self, value: TreeViewSelectionMode) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_SelectionMode)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_selected_nodes(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_SelectedNodes)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn expand(&self, value: &TreeViewNode) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).Expand)(self as *const _ as *mut _, value as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn collapse(&self, value: &TreeViewNode) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).Collapse)(self as *const _ as *mut _, value as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn select_all(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).SelectAll)(self as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_item_invoked(&self, value: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_ItemInvoked)(self as *const _ as *mut _, value as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_item_invoked(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_ItemInvoked)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_expanding(&self, value: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_Expanding)(self as *const _ as *mut _, value as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_expanding(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_Expanding)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_collapsed(&self, value: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_Collapsed)(self as *const _ as *mut _, value as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_collapsed(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_Collapsed)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class TreeView: ITreeView} +impl RtActivatable for TreeView {} +impl TreeView { + #[inline] pub fn get_selection_mode_property() -> Result>> { + >::get_activation_factory().get_selection_mode_property() + } +} +DEFINE_CLSID!(TreeView(&[87,105,110,100,111,119,115,46,85,73,46,88,97,109,108,46,67,111,110,116,114,111,108,115,46,84,114,101,101,86,105,101,119,0]) [CLSID_TreeView]); +DEFINE_IID!(IID_ITreeViewCollapsedEventArgs, 958247856, 7768, 17721, 158, 147, 56, 121, 120, 244, 108, 206); +RT_INTERFACE!{interface ITreeViewCollapsedEventArgs(ITreeViewCollapsedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_ITreeViewCollapsedEventArgs] { + fn get_Node(&self, out: *mut *mut TreeViewNode) -> HRESULT +}} +impl ITreeViewCollapsedEventArgs { + #[inline] pub fn get_node(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Node)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +RT_CLASS!{class TreeViewCollapsedEventArgs: ITreeViewCollapsedEventArgs} +DEFINE_IID!(IID_ITreeViewExpandingEventArgs, 3319921251, 16724, 18898, 162, 31, 195, 65, 118, 96, 94, 58); +RT_INTERFACE!{interface ITreeViewExpandingEventArgs(ITreeViewExpandingEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_ITreeViewExpandingEventArgs] { + fn get_Node(&self, out: *mut *mut TreeViewNode) -> HRESULT +}} +impl ITreeViewExpandingEventArgs { + #[inline] pub fn get_node(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Node)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +RT_CLASS!{class TreeViewExpandingEventArgs: ITreeViewExpandingEventArgs} +DEFINE_IID!(IID_ITreeViewFactory, 3427952579, 27753, 18894, 180, 69, 117, 58, 206, 231, 148, 139); +RT_INTERFACE!{interface ITreeViewFactory(ITreeViewFactoryVtbl): IInspectable(IInspectableVtbl) [IID_ITreeViewFactory] { + fn CreateInstance(&self, outer: *mut IInspectable, inner: *mut *mut IInspectable, out: *mut *mut TreeView) -> HRESULT +}} +impl ITreeViewFactory { + #[inline] pub fn create_instance(&self, outer: &IInspectable) -> Result<(Option>, Option>)> { unsafe { + let mut inner = null_mut(); let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreateInstance)(self as *const _ as *mut _, outer as *const _ as *mut _, &mut inner, &mut out); + if hr == S_OK { Ok((ComPtr::wrap_optional(inner), ComPtr::wrap_optional(out))) } else { err(hr) } + }} +} +DEFINE_IID!(IID_ITreeViewItem, 1309004774, 24935, 17639, 156, 116, 41, 29, 221, 109, 246, 235); +RT_INTERFACE!{interface ITreeViewItem(ITreeViewItemVtbl): IInspectable(IInspectableVtbl) [IID_ITreeViewItem] { + fn get_GlyphOpacity(&self, out: *mut f64) -> HRESULT, + fn put_GlyphOpacity(&self, value: f64) -> HRESULT, + fn get_GlyphBrush(&self, out: *mut *mut super::media::Brush) -> HRESULT, + fn put_GlyphBrush(&self, value: *mut super::media::Brush) -> HRESULT, + fn get_ExpandedGlyph(&self, out: *mut HSTRING) -> HRESULT, + fn put_ExpandedGlyph(&self, value: HSTRING) -> HRESULT, + fn get_CollapsedGlyph(&self, out: *mut HSTRING) -> HRESULT, + fn put_CollapsedGlyph(&self, value: HSTRING) -> HRESULT, + fn get_GlyphSize(&self, out: *mut f64) -> HRESULT, + fn put_GlyphSize(&self, value: f64) -> HRESULT, + fn get_IsExpanded(&self, out: *mut bool) -> HRESULT, + fn put_IsExpanded(&self, value: bool) -> HRESULT, + fn get_TreeViewItemTemplateSettings(&self, out: *mut *mut TreeViewItemTemplateSettings) -> HRESULT +}} +impl ITreeViewItem { + #[inline] pub fn get_glyph_opacity(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_GlyphOpacity)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_glyph_opacity(&self, value: f64) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_GlyphOpacity)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_glyph_brush(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_GlyphBrush)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn set_glyph_brush(&self, value: &super::media::Brush) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_GlyphBrush)(self as *const _ as *mut _, value as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_expanded_glyph(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ExpandedGlyph)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn set_expanded_glyph(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_ExpandedGlyph)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_collapsed_glyph(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_CollapsedGlyph)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn set_collapsed_glyph(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_CollapsedGlyph)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_glyph_size(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_GlyphSize)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_glyph_size(&self, value: f64) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_GlyphSize)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_is_expanded(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_IsExpanded)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_is_expanded(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_IsExpanded)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_tree_view_item_template_settings(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_TreeViewItemTemplateSettings)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +RT_CLASS!{class TreeViewItem: ITreeViewItem} +impl RtActivatable for TreeViewItem {} +impl TreeViewItem { + #[inline] pub fn get_glyph_opacity_property() -> Result>> { + >::get_activation_factory().get_glyph_opacity_property() + } + #[inline] pub fn get_glyph_brush_property() -> Result>> { + >::get_activation_factory().get_glyph_brush_property() + } + #[inline] pub fn get_expanded_glyph_property() -> Result>> { + >::get_activation_factory().get_expanded_glyph_property() + } + #[inline] pub fn get_collapsed_glyph_property() -> Result>> { + >::get_activation_factory().get_collapsed_glyph_property() + } + #[inline] pub fn get_glyph_size_property() -> Result>> { + >::get_activation_factory().get_glyph_size_property() + } + #[inline] pub fn get_is_expanded_property() -> Result>> { + >::get_activation_factory().get_is_expanded_property() + } + #[inline] pub fn get_tree_view_item_template_settings_property() -> Result>> { + >::get_activation_factory().get_tree_view_item_template_settings_property() + } +} +DEFINE_CLSID!(TreeViewItem(&[87,105,110,100,111,119,115,46,85,73,46,88,97,109,108,46,67,111,110,116,114,111,108,115,46,84,114,101,101,86,105,101,119,73,116,101,109,0]) [CLSID_TreeViewItem]); +DEFINE_IID!(IID_ITreeViewItemFactory, 1319315249, 22157, 19725, 173, 253, 61, 141, 197, 170, 93, 136); +RT_INTERFACE!{interface ITreeViewItemFactory(ITreeViewItemFactoryVtbl): IInspectable(IInspectableVtbl) [IID_ITreeViewItemFactory] { + fn CreateInstance(&self, outer: *mut IInspectable, inner: *mut *mut IInspectable, out: *mut *mut TreeViewItem) -> HRESULT +}} +impl ITreeViewItemFactory { + #[inline] pub fn create_instance(&self, outer: &IInspectable) -> Result<(Option>, Option>)> { unsafe { + let mut inner = null_mut(); let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreateInstance)(self as *const _ as *mut _, outer as *const _ as *mut _, &mut inner, &mut out); + if hr == S_OK { Ok((ComPtr::wrap_optional(inner), ComPtr::wrap_optional(out))) } else { err(hr) } + }} +} +DEFINE_IID!(IID_ITreeViewItemInvokedEventArgs, 1193981217, 578, 17040, 147, 99, 171, 79, 231, 4, 82, 127); +RT_INTERFACE!{interface ITreeViewItemInvokedEventArgs(ITreeViewItemInvokedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_ITreeViewItemInvokedEventArgs] { + fn get_InvokedItem(&self, out: *mut *mut IInspectable) -> HRESULT, + fn put_Handled(&self, value: bool) -> HRESULT, + fn get_Handled(&self, out: *mut bool) -> HRESULT +}} +impl ITreeViewItemInvokedEventArgs { + #[inline] pub fn get_invoked_item(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_InvokedItem)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn set_handled(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Handled)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_handled(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Handled)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} +RT_CLASS!{class TreeViewItemInvokedEventArgs: ITreeViewItemInvokedEventArgs} +DEFINE_IID!(IID_ITreeViewItemStatics, 1130862014, 29590, 18140, 162, 100, 33, 197, 101, 129, 197, 229); +RT_INTERFACE!{static interface ITreeViewItemStatics(ITreeViewItemStaticsVtbl): IInspectable(IInspectableVtbl) [IID_ITreeViewItemStatics] { + fn get_GlyphOpacityProperty(&self, out: *mut *mut super::DependencyProperty) -> HRESULT, + fn get_GlyphBrushProperty(&self, out: *mut *mut super::DependencyProperty) -> HRESULT, + fn get_ExpandedGlyphProperty(&self, out: *mut *mut super::DependencyProperty) -> HRESULT, + fn get_CollapsedGlyphProperty(&self, out: *mut *mut super::DependencyProperty) -> HRESULT, + fn get_GlyphSizeProperty(&self, out: *mut *mut super::DependencyProperty) -> HRESULT, + fn get_IsExpandedProperty(&self, out: *mut *mut super::DependencyProperty) -> HRESULT, + fn get_TreeViewItemTemplateSettingsProperty(&self, out: *mut *mut super::DependencyProperty) -> HRESULT +}} +impl ITreeViewItemStatics { + #[inline] pub fn get_glyph_opacity_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_GlyphOpacityProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_glyph_brush_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_GlyphBrushProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_expanded_glyph_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ExpandedGlyphProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_collapsed_glyph_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_CollapsedGlyphProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_glyph_size_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_GlyphSizeProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_is_expanded_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_IsExpandedProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_tree_view_item_template_settings_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_TreeViewItemTemplateSettingsProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +DEFINE_IID!(IID_ITreeViewItemTemplateSettings, 3962713924, 56881, 18742, 191, 194, 28, 179, 123, 161, 220, 8); +RT_INTERFACE!{interface ITreeViewItemTemplateSettings(ITreeViewItemTemplateSettingsVtbl): IInspectable(IInspectableVtbl) [IID_ITreeViewItemTemplateSettings] { + fn get_ExpandedGlyphVisibility(&self, out: *mut super::Visibility) -> HRESULT, + fn get_CollapsedGlyphVisibility(&self, out: *mut super::Visibility) -> HRESULT, + fn get_Indentation(&self, out: *mut super::Thickness) -> HRESULT, + fn get_DragItemsCount(&self, out: *mut i32) -> HRESULT +}} +impl ITreeViewItemTemplateSettings { + #[inline] pub fn get_expanded_glyph_visibility(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_ExpandedGlyphVisibility)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_collapsed_glyph_visibility(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_CollapsedGlyphVisibility)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_indentation(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Indentation)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_drag_items_count(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_DragItemsCount)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} +RT_CLASS!{class TreeViewItemTemplateSettings: ITreeViewItemTemplateSettings} +impl RtActivatable for TreeViewItemTemplateSettings {} +impl TreeViewItemTemplateSettings { + #[inline] pub fn get_expanded_glyph_visibility_property() -> Result>> { + >::get_activation_factory().get_expanded_glyph_visibility_property() + } + #[inline] pub fn get_collapsed_glyph_visibility_property() -> Result>> { + >::get_activation_factory().get_collapsed_glyph_visibility_property() + } + #[inline] pub fn get_indentation_property() -> Result>> { + >::get_activation_factory().get_indentation_property() + } + #[inline] pub fn get_drag_items_count_property() -> Result>> { + >::get_activation_factory().get_drag_items_count_property() + } +} +DEFINE_CLSID!(TreeViewItemTemplateSettings(&[87,105,110,100,111,119,115,46,85,73,46,88,97,109,108,46,67,111,110,116,114,111,108,115,46,84,114,101,101,86,105,101,119,73,116,101,109,84,101,109,112,108,97,116,101,83,101,116,116,105,110,103,115,0]) [CLSID_TreeViewItemTemplateSettings]); +DEFINE_IID!(IID_ITreeViewItemTemplateSettingsFactory, 295802171, 12727, 20288, 134, 51, 2, 252, 97, 75, 81, 140); +RT_INTERFACE!{interface ITreeViewItemTemplateSettingsFactory(ITreeViewItemTemplateSettingsFactoryVtbl): IInspectable(IInspectableVtbl) [IID_ITreeViewItemTemplateSettingsFactory] { + fn CreateInstance(&self, outer: *mut IInspectable, inner: *mut *mut IInspectable, out: *mut *mut TreeViewItemTemplateSettings) -> HRESULT +}} +impl ITreeViewItemTemplateSettingsFactory { + #[inline] pub fn create_instance(&self, outer: &IInspectable) -> Result<(Option>, Option>)> { unsafe { + let mut inner = null_mut(); let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreateInstance)(self as *const _ as *mut _, outer as *const _ as *mut _, &mut inner, &mut out); + if hr == S_OK { Ok((ComPtr::wrap_optional(inner), ComPtr::wrap_optional(out))) } else { err(hr) } + }} +} +DEFINE_IID!(IID_ITreeViewItemTemplateSettingsStatics, 1439113384, 28909, 19489, 147, 244, 45, 121, 193, 164, 165, 247); +RT_INTERFACE!{static interface ITreeViewItemTemplateSettingsStatics(ITreeViewItemTemplateSettingsStaticsVtbl): IInspectable(IInspectableVtbl) [IID_ITreeViewItemTemplateSettingsStatics] { + fn get_ExpandedGlyphVisibilityProperty(&self, out: *mut *mut super::DependencyProperty) -> HRESULT, + fn get_CollapsedGlyphVisibilityProperty(&self, out: *mut *mut super::DependencyProperty) -> HRESULT, + fn get_IndentationProperty(&self, out: *mut *mut super::DependencyProperty) -> HRESULT, + fn get_DragItemsCountProperty(&self, out: *mut *mut super::DependencyProperty) -> HRESULT +}} +impl ITreeViewItemTemplateSettingsStatics { + #[inline] pub fn get_expanded_glyph_visibility_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ExpandedGlyphVisibilityProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_collapsed_glyph_visibility_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_CollapsedGlyphVisibilityProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_indentation_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_IndentationProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_drag_items_count_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_DragItemsCountProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +DEFINE_IID!(IID_ITreeViewList, 251700558, 2458, 18341, 169, 66, 148, 105, 43, 1, 244, 82); +RT_INTERFACE!{interface ITreeViewList(ITreeViewListVtbl): IInspectable(IInspectableVtbl) [IID_ITreeViewList] { + +}} +RT_CLASS!{class TreeViewList: ITreeViewList} +DEFINE_IID!(IID_ITreeViewListFactory, 680485426, 16850, 18167, 177, 245, 105, 28, 98, 82, 100, 183); +RT_INTERFACE!{interface ITreeViewListFactory(ITreeViewListFactoryVtbl): IInspectable(IInspectableVtbl) [IID_ITreeViewListFactory] { + fn CreateInstance(&self, outer: *mut IInspectable, inner: *mut *mut IInspectable, out: *mut *mut TreeViewList) -> HRESULT +}} +impl ITreeViewListFactory { + #[inline] pub fn create_instance(&self, outer: &IInspectable) -> Result<(Option>, Option>)> { unsafe { + let mut inner = null_mut(); let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreateInstance)(self as *const _ as *mut _, outer as *const _ as *mut _, &mut inner, &mut out); + if hr == S_OK { Ok((ComPtr::wrap_optional(inner), ComPtr::wrap_optional(out))) } else { err(hr) } + }} +} +DEFINE_IID!(IID_ITreeViewNode, 3226242771, 39666, 20085, 163, 41, 116, 151, 161, 16, 231, 168); +RT_INTERFACE!{interface ITreeViewNode(ITreeViewNodeVtbl): IInspectable(IInspectableVtbl) [IID_ITreeViewNode] { + fn get_Content(&self, out: *mut *mut IInspectable) -> HRESULT, + fn put_Content(&self, value: *mut IInspectable) -> HRESULT, + fn get_Parent(&self, out: *mut *mut TreeViewNode) -> HRESULT, + fn get_IsExpanded(&self, out: *mut bool) -> HRESULT, + fn put_IsExpanded(&self, value: bool) -> HRESULT, + fn get_HasChildren(&self, out: *mut bool) -> HRESULT, + fn get_Depth(&self, out: *mut i32) -> HRESULT, + fn get_HasUnrealizedChildren(&self, out: *mut bool) -> HRESULT, + fn put_HasUnrealizedChildren(&self, value: bool) -> HRESULT, + fn get_Children(&self, out: *mut *mut foundation::collections::IVector) -> HRESULT +}} +impl ITreeViewNode { + #[inline] pub fn get_content(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Content)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn set_content(&self, value: &IInspectable) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Content)(self as *const _ as *mut _, value as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_parent(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Parent)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_is_expanded(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_IsExpanded)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_is_expanded(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_IsExpanded)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_has_children(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_HasChildren)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_depth(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Depth)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_has_unrealized_children(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_HasUnrealizedChildren)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_has_unrealized_children(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_HasUnrealizedChildren)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_children(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Children)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +RT_CLASS!{class TreeViewNode: ITreeViewNode} +impl RtActivatable for TreeViewNode {} +impl TreeViewNode { + #[inline] pub fn get_content_property() -> Result>> { + >::get_activation_factory().get_content_property() + } + #[inline] pub fn get_depth_property() -> Result>> { + >::get_activation_factory().get_depth_property() + } + #[inline] pub fn get_is_expanded_property() -> Result>> { + >::get_activation_factory().get_is_expanded_property() + } + #[inline] pub fn get_has_children_property() -> Result>> { + >::get_activation_factory().get_has_children_property() + } +} +DEFINE_CLSID!(TreeViewNode(&[87,105,110,100,111,119,115,46,85,73,46,88,97,109,108,46,67,111,110,116,114,111,108,115,46,84,114,101,101,86,105,101,119,78,111,100,101,0]) [CLSID_TreeViewNode]); +DEFINE_IID!(IID_ITreeViewNodeFactory, 1858481552, 43545, 16714, 138, 69, 10, 85, 137, 168, 54, 247); +RT_INTERFACE!{interface ITreeViewNodeFactory(ITreeViewNodeFactoryVtbl): IInspectable(IInspectableVtbl) [IID_ITreeViewNodeFactory] { + fn CreateInstance(&self, outer: *mut IInspectable, inner: *mut *mut IInspectable, out: *mut *mut TreeViewNode) -> HRESULT +}} +impl ITreeViewNodeFactory { + #[inline] pub fn create_instance(&self, outer: &IInspectable) -> Result<(Option>, Option>)> { unsafe { + let mut inner = null_mut(); let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreateInstance)(self as *const _ as *mut _, outer as *const _ as *mut _, &mut inner, &mut out); + if hr == S_OK { Ok((ComPtr::wrap_optional(inner), ComPtr::wrap_optional(out))) } else { err(hr) } + }} +} +DEFINE_IID!(IID_ITreeViewNodeStatics, 1568831230, 57809, 19297, 158, 129, 199, 251, 24, 154, 41, 128); +RT_INTERFACE!{static interface ITreeViewNodeStatics(ITreeViewNodeStaticsVtbl): IInspectable(IInspectableVtbl) [IID_ITreeViewNodeStatics] { + fn get_ContentProperty(&self, out: *mut *mut super::DependencyProperty) -> HRESULT, + fn get_DepthProperty(&self, out: *mut *mut super::DependencyProperty) -> HRESULT, + fn get_IsExpandedProperty(&self, out: *mut *mut super::DependencyProperty) -> HRESULT, + fn get_HasChildrenProperty(&self, out: *mut *mut super::DependencyProperty) -> HRESULT +}} +impl ITreeViewNodeStatics { + #[inline] pub fn get_content_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ContentProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_depth_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_DepthProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_is_expanded_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_IsExpandedProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_has_children_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_HasChildrenProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +RT_ENUM! { enum TreeViewSelectionMode: i32 { + None (TreeViewSelectionMode_None) = 0, Single (TreeViewSelectionMode_Single) = 1, Multiple (TreeViewSelectionMode_Multiple) = 2, +}} +DEFINE_IID!(IID_ITreeViewStatics, 4019273224, 33778, 19990, 191, 177, 21, 119, 185, 131, 85, 245); +RT_INTERFACE!{static interface ITreeViewStatics(ITreeViewStaticsVtbl): IInspectable(IInspectableVtbl) [IID_ITreeViewStatics] { + fn get_SelectionModeProperty(&self, out: *mut *mut super::DependencyProperty) -> HRESULT +}} +impl ITreeViewStatics { + #[inline] pub fn get_selection_mode_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_SelectionModeProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IUIElementCollection, 3596627284, 35062, 17398, 133, 216, 169, 217, 20, 166, 221, 59); RT_INTERFACE!{interface IUIElementCollection(IUIElementCollectionVtbl): IInspectable(IInspectableVtbl) [IID_IUIElementCollection] { fn Move(&self, oldIndex: u32, newIndex: u32) -> HRESULT @@ -32012,6 +33765,22 @@ impl IWebView5 { if hr == S_OK { Ok(()) } else { err(hr) } }} } +DEFINE_IID!(IID_IWebView6, 952949058, 9526, 18044, 162, 17, 175, 53, 156, 59, 79, 218); +RT_INTERFACE!{interface IWebView6(IWebView6Vtbl): IInspectable(IInspectableVtbl) [IID_IWebView6] { + fn add_SeparateProcessLost(&self, value: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_SeparateProcessLost(&self, token: foundation::EventRegistrationToken) -> HRESULT +}} +impl IWebView6 { + #[inline] pub fn add_separate_process_lost(&self, value: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_SeparateProcessLost)(self as *const _ as *mut _, value as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_separate_process_lost(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_SeparateProcessLost)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} DEFINE_IID!(IID_IWebViewBrush, 1088974709, 3316, 19314, 164, 214, 207, 93, 21, 120, 1, 22); RT_INTERFACE!{interface IWebViewBrush(IWebViewBrushVtbl): IInspectable(IInspectableVtbl) [IID_IWebViewBrush] { fn get_SourceName(&self, out: *mut HSTRING) -> HRESULT, @@ -32117,7 +33886,7 @@ impl IWebViewDOMContentLoadedEventArgs { } RT_CLASS!{class WebViewDOMContentLoadedEventArgs: IWebViewDOMContentLoadedEventArgs} RT_ENUM! { enum WebViewExecutionMode: i32 { - SameThread (WebViewExecutionMode_SameThread) = 0, SeparateThread (WebViewExecutionMode_SeparateThread) = 1, + SameThread (WebViewExecutionMode_SameThread) = 0, SeparateThread (WebViewExecutionMode_SeparateThread) = 1, SeparateProcess (WebViewExecutionMode_SeparateProcess) = 2, }} DEFINE_IID!(IID_IWebViewFactory4, 2196614232, 61034, 19611, 163, 160, 147, 71, 167, 208, 239, 76); RT_INTERFACE!{static interface IWebViewFactory4(IWebViewFactory4Vtbl): IInspectable(IInspectableVtbl) [IID_IWebViewFactory4] { @@ -32318,8 +34087,13 @@ RT_ENUM! { enum WebViewPermissionState: i32 { Unknown (WebViewPermissionState_Unknown) = 0, Defer (WebViewPermissionState_Defer) = 1, Allow (WebViewPermissionState_Allow) = 2, Deny (WebViewPermissionState_Deny) = 3, }} RT_ENUM! { enum WebViewPermissionType: i32 { - Geolocation (WebViewPermissionType_Geolocation) = 0, UnlimitedIndexedDBQuota (WebViewPermissionType_UnlimitedIndexedDBQuota) = 1, Media (WebViewPermissionType_Media) = 2, PointerLock (WebViewPermissionType_PointerLock) = 3, WebNotifications (WebViewPermissionType_WebNotifications) = 4, + Geolocation (WebViewPermissionType_Geolocation) = 0, UnlimitedIndexedDBQuota (WebViewPermissionType_UnlimitedIndexedDBQuota) = 1, Media (WebViewPermissionType_Media) = 2, PointerLock (WebViewPermissionType_PointerLock) = 3, WebNotifications (WebViewPermissionType_WebNotifications) = 4, Screen (WebViewPermissionType_Screen) = 5, ImmersiveView (WebViewPermissionType_ImmersiveView) = 6, +}} +DEFINE_IID!(IID_IWebViewSeparateProcessLostEventArgs, 2751819786, 50306, 16565, 170, 234, 225, 12, 250, 159, 90, 190); +RT_INTERFACE!{interface IWebViewSeparateProcessLostEventArgs(IWebViewSeparateProcessLostEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IWebViewSeparateProcessLostEventArgs] { + }} +RT_CLASS!{class WebViewSeparateProcessLostEventArgs: IWebViewSeparateProcessLostEventArgs} DEFINE_IID!(IID_IWebViewSettings, 491826509, 44022, 18309, 141, 243, 253, 235, 193, 39, 3, 1); RT_INTERFACE!{interface IWebViewSettings(IWebViewSettingsVtbl): IInspectable(IInspectableVtbl) [IID_IWebViewSettings] { fn get_IsJavaScriptEnabled(&self, out: *mut bool) -> HRESULT, @@ -32659,6 +34433,18 @@ use ::prelude::*; RT_ENUM! { enum AnimationDirection: i32 { Left (AnimationDirection_Left) = 0, Top (AnimationDirection_Top) = 1, Right (AnimationDirection_Right) = 2, Bottom (AnimationDirection_Bottom) = 3, }} +DEFINE_IID!(IID_IAppBarButtonTemplateSettings, 3418993565, 3221, 18769, 191, 242, 19, 150, 54, 145, 195, 102); +RT_INTERFACE!{interface IAppBarButtonTemplateSettings(IAppBarButtonTemplateSettingsVtbl): IInspectable(IInspectableVtbl) [IID_IAppBarButtonTemplateSettings] { + fn get_KeyboardAcceleratorTextMinWidth(&self, out: *mut f64) -> HRESULT +}} +impl IAppBarButtonTemplateSettings { + #[inline] pub fn get_keyboard_accelerator_text_min_width(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_KeyboardAcceleratorTextMinWidth)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} +RT_CLASS!{class AppBarButtonTemplateSettings: IAppBarButtonTemplateSettings} DEFINE_IID!(IID_IAppBarTemplateSettings, 3166873699, 60213, 16956, 131, 137, 215, 130, 123, 227, 191, 103); RT_INTERFACE!{interface IAppBarTemplateSettings(IAppBarTemplateSettingsVtbl): IInspectable(IInspectableVtbl) [IID_IAppBarTemplateSettings] { fn get_ClipRect(&self, out: *mut foundation::Rect) -> HRESULT, @@ -32707,6 +34493,18 @@ impl IAppBarTemplateSettings { }} } RT_CLASS!{class AppBarTemplateSettings: IAppBarTemplateSettings} +DEFINE_IID!(IID_IAppBarToggleButtonTemplateSettings, 2868485192, 55540, 16601, 159, 163, 58, 100, 240, 254, 197, 216); +RT_INTERFACE!{interface IAppBarToggleButtonTemplateSettings(IAppBarToggleButtonTemplateSettingsVtbl): IInspectable(IInspectableVtbl) [IID_IAppBarToggleButtonTemplateSettings] { + fn get_KeyboardAcceleratorTextMinWidth(&self, out: *mut f64) -> HRESULT +}} +impl IAppBarToggleButtonTemplateSettings { + #[inline] pub fn get_keyboard_accelerator_text_min_width(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_KeyboardAcceleratorTextMinWidth)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} +RT_CLASS!{class AppBarToggleButtonTemplateSettings: IAppBarToggleButtonTemplateSettings} DEFINE_IID!(IID_IButtonBase, 4194315290, 18766, 18127, 145, 212, 225, 74, 141, 121, 134, 116); RT_INTERFACE!{interface IButtonBase(IButtonBaseVtbl): IInspectable(IInspectableVtbl) [IID_IButtonBase] { fn get_ClickMode(&self, out: *mut super::ClickMode) -> HRESULT, @@ -35531,6 +37329,18 @@ impl ILoopingSelectorStatics { if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IMenuFlyoutItemTemplateSettings, 1454184457, 14870, 16711, 129, 203, 208, 179, 92, 131, 78, 15); +RT_INTERFACE!{interface IMenuFlyoutItemTemplateSettings(IMenuFlyoutItemTemplateSettingsVtbl): IInspectable(IInspectableVtbl) [IID_IMenuFlyoutItemTemplateSettings] { + fn get_KeyboardAcceleratorTextMinWidth(&self, out: *mut f64) -> HRESULT +}} +impl IMenuFlyoutItemTemplateSettings { + #[inline] pub fn get_keyboard_accelerator_text_min_width(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_KeyboardAcceleratorTextMinWidth)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} +RT_CLASS!{class MenuFlyoutItemTemplateSettings: IMenuFlyoutItemTemplateSettings} DEFINE_IID!(IID_IMenuFlyoutPresenterTemplateSettings, 3599749133, 25245, 17225, 172, 81, 184, 119, 200, 9, 131, 184); RT_INTERFACE!{interface IMenuFlyoutPresenterTemplateSettings(IMenuFlyoutPresenterTemplateSettingsVtbl): IInspectable(IInspectableVtbl) [IID_IMenuFlyoutPresenterTemplateSettings] { fn get_FlyoutContentMinWidth(&self, out: *mut f64) -> HRESULT @@ -37825,6 +39635,7 @@ impl RtActivatable for MapControl {} impl RtActivatable for MapControl {} impl RtActivatable for MapControl {} impl RtActivatable for MapControl {} +impl RtActivatable for MapControl {} impl RtActivatable for MapControl {} impl MapControl { #[inline] pub fn get_center_property() -> Result>> { @@ -37944,6 +39755,9 @@ impl MapControl { #[inline] pub fn get_layers_property() -> Result>> { >::get_activation_factory().get_layers_property() } + #[inline] pub fn get_region_property() -> Result>> { + >::get_activation_factory().get_region_property() + } } DEFINE_CLSID!(MapControl(&[87,105,110,100,111,119,115,46,85,73,46,88,97,109,108,46,67,111,110,116,114,111,108,115,46,77,97,112,115,46,77,97,112,67,111,110,116,114,111,108,0]) [CLSID_MapControl]); DEFINE_IID!(IID_IMapControl2, 3791479885, 38636, 16485, 176, 240, 117, 40, 29, 163, 101, 77); @@ -38384,6 +40198,22 @@ impl IMapControl6 { if hr == S_OK { Ok((ComPtr::wrap_optional(location), out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IMapControl7, 226944083, 3103, 20350, 174, 102, 74, 208, 180, 152, 120, 87); +RT_INTERFACE!{interface IMapControl7(IMapControl7Vtbl): IInspectable(IInspectableVtbl) [IID_IMapControl7] { + fn get_Region(&self, out: *mut HSTRING) -> HRESULT, + fn put_Region(&self, value: HSTRING) -> HRESULT +}} +impl IMapControl7 { + #[inline] pub fn get_region(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Region)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn set_region(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Region)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} DEFINE_IID!(IID_IMapControlBusinessLandmarkClickEventArgs, 1581664546, 18970, 18327, 190, 183, 92, 247, 117, 76, 184, 103); RT_INTERFACE!{interface IMapControlBusinessLandmarkClickEventArgs(IMapControlBusinessLandmarkClickEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IMapControlBusinessLandmarkClickEventArgs] { #[cfg(feature="windows-services")] fn get_LocalLocations(&self, out: *mut *mut foundation::collections::IVectorView<::rt::gen::windows::services::maps::localsearch::LocalLocation>) -> HRESULT @@ -38831,6 +40661,17 @@ impl IMapControlStatics6 { if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IMapControlStatics7, 1441901645, 29378, 18098, 183, 174, 121, 2, 96, 190, 100, 27); +RT_INTERFACE!{static interface IMapControlStatics7(IMapControlStatics7Vtbl): IInspectable(IInspectableVtbl) [IID_IMapControlStatics7] { + fn get_RegionProperty(&self, out: *mut *mut super::super::DependencyProperty) -> HRESULT +}} +impl IMapControlStatics7 { + #[inline] pub fn get_region_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_RegionProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IMapControlTransitFeatureClickEventArgs, 1981258089, 46949, 17954, 176, 138, 48, 114, 116, 90, 69, 65); RT_INTERFACE!{interface IMapControlTransitFeatureClickEventArgs(IMapControlTransitFeatureClickEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IMapControlTransitFeatureClickEventArgs] { fn get_DisplayName(&self, out: *mut HSTRING) -> HRESULT, @@ -38993,6 +40834,7 @@ RT_CLASS!{class MapElement: IMapElement} impl RtActivatable for MapElement {} impl RtActivatable for MapElement {} impl RtActivatable for MapElement {} +impl RtActivatable for MapElement {} impl MapElement { #[inline] pub fn get_zindex_property() -> Result>> { >::get_activation_factory().get_zindex_property() @@ -39012,6 +40854,9 @@ impl MapElement { #[inline] pub fn get_tag_property() -> Result>> { >::get_activation_factory().get_tag_property() } + #[inline] pub fn get_is_enabled_property() -> Result>> { + >::get_activation_factory().get_is_enabled_property() + } } DEFINE_CLSID!(MapElement(&[87,105,110,100,111,119,115,46,85,73,46,88,97,109,108,46,67,111,110,116,114,111,108,115,46,77,97,112,115,46,77,97,112,69,108,101,109,101,110,116,0]) [CLSID_MapElement]); DEFINE_IID!(IID_IMapElement2, 1712976481, 64422, 18788, 167, 255, 241, 175, 99, 171, 156, 176); @@ -39197,6 +41042,22 @@ impl IMapElement3DStatics { if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IMapElement4, 1683522486, 8129, 19691, 147, 189, 220, 44, 150, 0, 114, 233); +RT_INTERFACE!{interface IMapElement4(IMapElement4Vtbl): IInspectable(IInspectableVtbl) [IID_IMapElement4] { + fn get_IsEnabled(&self, out: *mut bool) -> HRESULT, + fn put_IsEnabled(&self, value: bool) -> HRESULT +}} +impl IMapElement4 { + #[inline] pub fn get_is_enabled(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_IsEnabled)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_is_enabled(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_IsEnabled)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} DEFINE_IID!(IID_IMapElementClickEventArgs, 1075218961, 53376, 17689, 153, 161, 49, 73, 251, 137, 153, 208); RT_INTERFACE!{interface IMapElementClickEventArgs(IMapElementClickEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IMapElementClickEventArgs] { fn get_Position(&self, out: *mut foundation::Point) -> HRESULT, @@ -39531,6 +41392,17 @@ impl IMapElementStatics3 { if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IMapElementStatics4, 2754178827, 57336, 18044, 147, 21, 111, 109, 185, 62, 226, 186); +RT_INTERFACE!{static interface IMapElementStatics4(IMapElementStatics4Vtbl): IInspectable(IInspectableVtbl) [IID_IMapElementStatics4] { + fn get_IsEnabledProperty(&self, out: *mut *mut super::super::DependencyProperty) -> HRESULT +}} +impl IMapElementStatics4 { + #[inline] pub fn get_is_enabled_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_IsEnabledProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IMapIcon, 3523831922, 9177, 18987, 139, 224, 105, 243, 168, 84, 130, 171); RT_INTERFACE!{interface IMapIcon(IMapIconVtbl): IInspectable(IInspectableVtbl) [IID_IMapIcon] { #[cfg(not(feature="windows-devices"))] fn __Dummy0(&self) -> (), @@ -42246,6 +44118,7 @@ RT_INTERFACE!{interface ICompositionTarget(ICompositionTargetVtbl): IInspectable }} RT_CLASS!{class CompositionTarget: ICompositionTarget} impl RtActivatable for CompositionTarget {} +impl RtActivatable for CompositionTarget {} impl CompositionTarget { #[inline] pub fn add_rendering(value: &foundation::EventHandler) -> Result { >::get_activation_factory().add_rendering(value) @@ -42259,6 +44132,12 @@ impl CompositionTarget { #[inline] pub fn remove_surface_contents_lost(token: foundation::EventRegistrationToken) -> Result<()> { >::get_activation_factory().remove_surface_contents_lost(token) } + #[inline] pub fn add_rendered(value: &foundation::EventHandler) -> Result { + >::get_activation_factory().add_rendered(value) + } + #[inline] pub fn remove_rendered(token: foundation::EventRegistrationToken) -> Result<()> { + >::get_activation_factory().remove_rendered(token) + } } DEFINE_CLSID!(CompositionTarget(&[87,105,110,100,111,119,115,46,85,73,46,88,97,109,108,46,77,101,100,105,97,46,67,111,109,112,111,115,105,116,105,111,110,84,97,114,103,101,116,0]) [CLSID_CompositionTarget]); DEFINE_IID!(IID_ICompositionTargetStatics, 723185725, 7890, 19289, 189, 0, 117, 148, 238, 146, 131, 43); @@ -42288,6 +44167,22 @@ impl ICompositionTargetStatics { if hr == S_OK { Ok(()) } else { err(hr) } }} } +DEFINE_IID!(IID_ICompositionTargetStatics3, 3154803929, 26448, 18184, 153, 76, 32, 40, 224, 49, 42, 200); +RT_INTERFACE!{static interface ICompositionTargetStatics3(ICompositionTargetStatics3Vtbl): IInspectable(IInspectableVtbl) [IID_ICompositionTargetStatics3] { + fn add_Rendered(&self, value: *mut foundation::EventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_Rendered(&self, token: foundation::EventRegistrationToken) -> HRESULT +}} +impl ICompositionTargetStatics3 { + #[inline] pub fn add_rendered(&self, value: &foundation::EventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_Rendered)(self as *const _ as *mut _, value as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_rendered(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_Rendered)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} RT_CLASS!{class DoubleCollection: foundation::collections::IVector} impl RtActivatable for DoubleCollection {} DEFINE_CLSID!(DoubleCollection(&[87,105,110,100,111,119,115,46,85,73,46,88,97,109,108,46,77,101,100,105,97,46,68,111,117,98,108,101,67,111,108,108,101,99,116,105,111,110,0]) [CLSID_DoubleCollection]); @@ -43952,6 +45847,18 @@ impl IRectangleGeometryStatics { if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IRenderedEventArgs, 3813245309, 33223, 18744, 130, 140, 167, 226, 121, 123, 53, 166); +RT_INTERFACE!{interface IRenderedEventArgs(IRenderedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IRenderedEventArgs] { + fn get_FrameDuration(&self, out: *mut foundation::TimeSpan) -> HRESULT +}} +impl IRenderedEventArgs { + #[inline] pub fn get_frame_duration(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_FrameDuration)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} +RT_CLASS!{class RenderedEventArgs: IRenderedEventArgs} DEFINE_IID!(IID_IRenderingEventArgs, 1542968077, 38728, 19181, 131, 128, 215, 137, 14, 183, 118, 160); RT_INTERFACE!{interface IRenderingEventArgs(IRenderingEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IRenderingEventArgs] { fn get_RenderingTime(&self, out: *mut foundation::TimeSpan) -> HRESULT @@ -50200,6 +52107,7 @@ impl RtActivatable for AutomationElementI impl RtActivatable for AutomationElementIdentifiers {} impl RtActivatable for AutomationElementIdentifiers {} impl RtActivatable for AutomationElementIdentifiers {} +impl RtActivatable for AutomationElementIdentifiers {} impl AutomationElementIdentifiers { #[inline] pub fn get_accelerator_key_property() -> Result>> { >::get_activation_factory().get_accelerator_key_property() @@ -50312,6 +52220,9 @@ impl AutomationElementIdentifiers { #[inline] pub fn get_culture_property() -> Result>> { >::get_activation_factory().get_culture_property() } + #[inline] pub fn get_heading_level_property() -> Result>> { + >::get_activation_factory().get_heading_level_property() + } } DEFINE_CLSID!(AutomationElementIdentifiers(&[87,105,110,100,111,119,115,46,85,73,46,88,97,109,108,46,65,117,116,111,109,97,116,105,111,110,46,65,117,116,111,109,97,116,105,111,110,69,108,101,109,101,110,116,73,100,101,110,116,105,102,105,101,114,115,0]) [CLSID_AutomationElementIdentifiers]); DEFINE_IID!(IID_IAutomationElementIdentifiersStatics, 1162426783, 33600, 19815, 185, 191, 140, 42, 198, 160, 119, 58); @@ -50566,6 +52477,17 @@ impl IAutomationElementIdentifiersStatics6 { if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IAutomationElementIdentifiersStatics7, 15838130, 29740, 17514, 168, 246, 22, 114, 177, 13, 40, 116); +RT_INTERFACE!{static interface IAutomationElementIdentifiersStatics7(IAutomationElementIdentifiersStatics7Vtbl): IInspectable(IInspectableVtbl) [IID_IAutomationElementIdentifiersStatics7] { + fn get_HeadingLevelProperty(&self, out: *mut *mut AutomationProperty) -> HRESULT +}} +impl IAutomationElementIdentifiersStatics7 { + #[inline] pub fn get_heading_level_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_HeadingLevelProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} RT_ENUM! { enum AutomationFlowDirections: i32 { Default (AutomationFlowDirections_Default) = 0, RightToLeft (AutomationFlowDirections_RightToLeft) = 1, BottomToTop (AutomationFlowDirections_BottomToTop) = 2, Vertical (AutomationFlowDirections_Vertical) = 3, }} @@ -50583,6 +52505,7 @@ impl RtActivatable for AutomationProperties {} impl RtActivatable for AutomationProperties {} impl RtActivatable for AutomationProperties {} impl RtActivatable for AutomationProperties {} +impl RtActivatable for AutomationProperties {} impl AutomationProperties { #[inline] pub fn get_accelerator_key_property() -> Result>> { >::get_activation_factory().get_accelerator_key_property() @@ -50803,6 +52726,15 @@ impl AutomationProperties { #[inline] pub fn set_culture(element: &super::DependencyObject, value: i32) -> Result<()> { >::get_activation_factory().set_culture(element, value) } + #[inline] pub fn get_heading_level_property() -> Result>> { + >::get_activation_factory().get_heading_level_property() + } + #[inline] pub fn get_heading_level(element: &super::DependencyObject) -> Result { + >::get_activation_factory().get_heading_level(element) + } + #[inline] pub fn set_heading_level(element: &super::DependencyObject, value: peers::AutomationHeadingLevel) -> Result<()> { + >::get_activation_factory().set_heading_level(element, value) + } } DEFINE_CLSID!(AutomationProperties(&[87,105,110,100,111,119,115,46,85,73,46,88,97,109,108,46,65,117,116,111,109,97,116,105,111,110,46,65,117,116,111,109,97,116,105,111,110,80,114,111,112,101,114,116,105,101,115,0]) [CLSID_AutomationProperties]); DEFINE_IID!(IID_IAutomationPropertiesStatics, 3055091067, 13008, 18800, 156, 66, 124, 3, 154, 199, 190, 120); @@ -51252,6 +53184,28 @@ impl IAutomationPropertiesStatics6 { if hr == S_OK { Ok(()) } else { err(hr) } }} } +DEFINE_IID!(IID_IAutomationPropertiesStatics7, 4159278067, 36753, 16488, 164, 173, 183, 180, 2, 209, 10, 44); +RT_INTERFACE!{static interface IAutomationPropertiesStatics7(IAutomationPropertiesStatics7Vtbl): IInspectable(IInspectableVtbl) [IID_IAutomationPropertiesStatics7] { + fn get_HeadingLevelProperty(&self, out: *mut *mut super::DependencyProperty) -> HRESULT, + fn GetHeadingLevel(&self, element: *mut super::DependencyObject, out: *mut peers::AutomationHeadingLevel) -> HRESULT, + fn SetHeadingLevel(&self, element: *mut super::DependencyObject, value: peers::AutomationHeadingLevel) -> HRESULT +}} +impl IAutomationPropertiesStatics7 { + #[inline] pub fn get_heading_level_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_HeadingLevelProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_heading_level(&self, element: &super::DependencyObject) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).GetHeadingLevel)(self as *const _ as *mut _, element as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_heading_level(&self, element: &super::DependencyObject, value: peers::AutomationHeadingLevel) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).SetHeadingLevel)(self as *const _ as *mut _, element as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} DEFINE_IID!(IID_IAutomationProperty, 3056015707, 12839, 19990, 149, 52, 221, 236, 227, 13, 219, 70); RT_INTERFACE!{interface IAutomationProperty(IAutomationPropertyVtbl): IInspectable(IInspectableVtbl) [IID_IAutomationProperty] { @@ -52211,6 +54165,9 @@ RT_ENUM! { enum AutomationControlType: i32 { RT_ENUM! { enum AutomationEvents: i32 { ToolTipOpened (AutomationEvents_ToolTipOpened) = 0, ToolTipClosed (AutomationEvents_ToolTipClosed) = 1, MenuOpened (AutomationEvents_MenuOpened) = 2, MenuClosed (AutomationEvents_MenuClosed) = 3, AutomationFocusChanged (AutomationEvents_AutomationFocusChanged) = 4, InvokePatternOnInvoked (AutomationEvents_InvokePatternOnInvoked) = 5, SelectionItemPatternOnElementAddedToSelection (AutomationEvents_SelectionItemPatternOnElementAddedToSelection) = 6, SelectionItemPatternOnElementRemovedFromSelection (AutomationEvents_SelectionItemPatternOnElementRemovedFromSelection) = 7, SelectionItemPatternOnElementSelected (AutomationEvents_SelectionItemPatternOnElementSelected) = 8, SelectionPatternOnInvalidated (AutomationEvents_SelectionPatternOnInvalidated) = 9, TextPatternOnTextSelectionChanged (AutomationEvents_TextPatternOnTextSelectionChanged) = 10, TextPatternOnTextChanged (AutomationEvents_TextPatternOnTextChanged) = 11, AsyncContentLoaded (AutomationEvents_AsyncContentLoaded) = 12, PropertyChanged (AutomationEvents_PropertyChanged) = 13, StructureChanged (AutomationEvents_StructureChanged) = 14, DragStart (AutomationEvents_DragStart) = 15, DragCancel (AutomationEvents_DragCancel) = 16, DragComplete (AutomationEvents_DragComplete) = 17, DragEnter (AutomationEvents_DragEnter) = 18, DragLeave (AutomationEvents_DragLeave) = 19, Dropped (AutomationEvents_Dropped) = 20, LiveRegionChanged (AutomationEvents_LiveRegionChanged) = 21, InputReachedTarget (AutomationEvents_InputReachedTarget) = 22, InputReachedOtherElement (AutomationEvents_InputReachedOtherElement) = 23, InputDiscarded (AutomationEvents_InputDiscarded) = 24, WindowClosed (AutomationEvents_WindowClosed) = 25, WindowOpened (AutomationEvents_WindowOpened) = 26, ConversionTargetChanged (AutomationEvents_ConversionTargetChanged) = 27, TextEditTextChanged (AutomationEvents_TextEditTextChanged) = 28, LayoutInvalidated (AutomationEvents_LayoutInvalidated) = 29, }} +RT_ENUM! { enum AutomationHeadingLevel: i32 { + None (AutomationHeadingLevel_None) = 0, Level1 (AutomationHeadingLevel_Level1) = 1, Level2 (AutomationHeadingLevel_Level2) = 2, Level3 (AutomationHeadingLevel_Level3) = 3, Level4 (AutomationHeadingLevel_Level4) = 4, Level5 (AutomationHeadingLevel_Level5) = 5, Level6 (AutomationHeadingLevel_Level6) = 6, Level7 (AutomationHeadingLevel_Level7) = 7, Level8 (AutomationHeadingLevel_Level8) = 8, Level9 (AutomationHeadingLevel_Level9) = 9, +}} RT_ENUM! { enum AutomationLandmarkType: i32 { None (AutomationLandmarkType_None) = 0, Custom (AutomationLandmarkType_Custom) = 1, Form (AutomationLandmarkType_Form) = 2, Main (AutomationLandmarkType_Main) = 3, Navigation (AutomationLandmarkType_Navigation) = 4, Search (AutomationLandmarkType_Search) = 5, }} @@ -52577,6 +54534,17 @@ impl IAutomationPeer7 { if hr == S_OK { Ok(()) } else { err(hr) } }} } +DEFINE_IID!(IID_IAutomationPeer8, 1550458854, 39509, 19839, 148, 152, 207, 228, 41, 233, 45, 168); +RT_INTERFACE!{interface IAutomationPeer8(IAutomationPeer8Vtbl): IInspectable(IInspectableVtbl) [IID_IAutomationPeer8] { + fn GetHeadingLevel(&self, out: *mut AutomationHeadingLevel) -> HRESULT +}} +impl IAutomationPeer8 { + #[inline] pub fn get_heading_level(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).GetHeadingLevel)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} DEFINE_IID!(IID_IAutomationPeerAnnotation, 205873249, 21199, 17402, 130, 248, 7, 241, 55, 53, 30, 90); RT_INTERFACE!{interface IAutomationPeerAnnotation(IAutomationPeerAnnotationVtbl): IInspectable(IInspectableVtbl) [IID_IAutomationPeerAnnotation] { fn get_Type(&self, out: *mut super::AnnotationType) -> HRESULT, @@ -52966,6 +54934,17 @@ impl IAutomationPeerOverrides6 { if hr == S_OK { Ok(out) } else { err(hr) } }} } +DEFINE_IID!(IID_IAutomationPeerOverrides8, 236895188, 40963, 18742, 129, 117, 245, 69, 124, 7, 240, 198); +RT_INTERFACE!{interface IAutomationPeerOverrides8(IAutomationPeerOverrides8Vtbl): IInspectable(IInspectableVtbl) [IID_IAutomationPeerOverrides8] { + fn GetHeadingLevelCore(&self, out: *mut AutomationHeadingLevel) -> HRESULT +}} +impl IAutomationPeerOverrides8 { + #[inline] pub fn get_heading_level_core(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).GetHeadingLevelCore)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} DEFINE_IID!(IID_IAutomationPeerProtected, 4105440850, 25647, 17961, 165, 74, 234, 93, 35, 73, 196, 72); RT_INTERFACE!{interface IAutomationPeerProtected(IAutomationPeerProtectedVtbl): IInspectable(IInspectableVtbl) [IID_IAutomationPeerProtected] { fn PeerFromProvider(&self, provider: *mut super::provider::IRawElementProviderSimple, out: *mut *mut AutomationPeer) -> HRESULT, @@ -53063,6 +55042,22 @@ impl IButtonBaseAutomationPeerFactory { if hr == S_OK { Ok((ComPtr::wrap_optional(inner), ComPtr::wrap_optional(out))) } else { err(hr) } }} } +DEFINE_IID!(IID_ICalendarDatePickerAutomationPeer, 1087935374, 56158, 19203, 190, 186, 209, 15, 98, 65, 151, 135); +RT_INTERFACE!{interface ICalendarDatePickerAutomationPeer(ICalendarDatePickerAutomationPeerVtbl): IInspectable(IInspectableVtbl) [IID_ICalendarDatePickerAutomationPeer] { + +}} +RT_CLASS!{class CalendarDatePickerAutomationPeer: ICalendarDatePickerAutomationPeer} +DEFINE_IID!(IID_ICalendarDatePickerAutomationPeerFactory, 2876267986, 53907, 17855, 159, 25, 38, 247, 96, 58, 94, 155); +RT_INTERFACE!{interface ICalendarDatePickerAutomationPeerFactory(ICalendarDatePickerAutomationPeerFactoryVtbl): IInspectable(IInspectableVtbl) [IID_ICalendarDatePickerAutomationPeerFactory] { + fn CreateInstanceWithOwner(&self, owner: *mut super::super::controls::CalendarDatePicker, outer: *mut IInspectable, inner: *mut *mut IInspectable, out: *mut *mut CalendarDatePickerAutomationPeer) -> HRESULT +}} +impl ICalendarDatePickerAutomationPeerFactory { + #[inline] pub fn create_instance_with_owner(&self, owner: &super::super::controls::CalendarDatePicker, outer: &IInspectable) -> Result<(Option>, Option>)> { unsafe { + let mut inner = null_mut(); let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreateInstanceWithOwner)(self as *const _ as *mut _, owner as *const _ as *mut _, outer as *const _ as *mut _, &mut inner, &mut out); + if hr == S_OK { Ok((ComPtr::wrap_optional(inner), ComPtr::wrap_optional(out))) } else { err(hr) } + }} +} DEFINE_IID!(IID_ICaptureElementAutomationPeer, 3703852768, 64069, 17862, 139, 183, 50, 13, 128, 143, 89, 88); RT_INTERFACE!{interface ICaptureElementAutomationPeer(ICaptureElementAutomationPeerVtbl): IInspectable(IInspectableVtbl) [IID_ICaptureElementAutomationPeer] { @@ -54292,6 +56287,38 @@ impl IToggleSwitchAutomationPeerFactory { if hr == S_OK { Ok((ComPtr::wrap_optional(inner), ComPtr::wrap_optional(out))) } else { err(hr) } }} } +DEFINE_IID!(IID_ITreeViewItemAutomationPeer, 590468680, 46615, 17279, 146, 12, 113, 212, 80, 80, 62, 101); +RT_INTERFACE!{interface ITreeViewItemAutomationPeer(ITreeViewItemAutomationPeerVtbl): IInspectable(IInspectableVtbl) [IID_ITreeViewItemAutomationPeer] { + +}} +RT_CLASS!{class TreeViewItemAutomationPeer: ITreeViewItemAutomationPeer} +DEFINE_IID!(IID_ITreeViewItemAutomationPeerFactory, 1943242943, 7425, 16729, 130, 192, 43, 41, 150, 219, 253, 206); +RT_INTERFACE!{interface ITreeViewItemAutomationPeerFactory(ITreeViewItemAutomationPeerFactoryVtbl): IInspectable(IInspectableVtbl) [IID_ITreeViewItemAutomationPeerFactory] { + fn CreateInstanceWithOwner(&self, owner: *mut super::super::controls::TreeViewItem, outer: *mut IInspectable, inner: *mut *mut IInspectable, out: *mut *mut TreeViewItemAutomationPeer) -> HRESULT +}} +impl ITreeViewItemAutomationPeerFactory { + #[inline] pub fn create_instance_with_owner(&self, owner: &super::super::controls::TreeViewItem, outer: &IInspectable) -> Result<(Option>, Option>)> { unsafe { + let mut inner = null_mut(); let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreateInstanceWithOwner)(self as *const _ as *mut _, owner as *const _ as *mut _, outer as *const _ as *mut _, &mut inner, &mut out); + if hr == S_OK { Ok((ComPtr::wrap_optional(inner), ComPtr::wrap_optional(out))) } else { err(hr) } + }} +} +DEFINE_IID!(IID_ITreeViewListAutomationPeer, 1908520380, 47913, 17529, 168, 168, 96, 107, 230, 184, 35, 174); +RT_INTERFACE!{interface ITreeViewListAutomationPeer(ITreeViewListAutomationPeerVtbl): IInspectable(IInspectableVtbl) [IID_ITreeViewListAutomationPeer] { + +}} +RT_CLASS!{class TreeViewListAutomationPeer: ITreeViewListAutomationPeer} +DEFINE_IID!(IID_ITreeViewListAutomationPeerFactory, 16095202, 63505, 18266, 191, 230, 41, 15, 231, 7, 250, 136); +RT_INTERFACE!{interface ITreeViewListAutomationPeerFactory(ITreeViewListAutomationPeerFactoryVtbl): IInspectable(IInspectableVtbl) [IID_ITreeViewListAutomationPeerFactory] { + fn CreateInstanceWithOwner(&self, owner: *mut super::super::controls::TreeViewList, outer: *mut IInspectable, inner: *mut *mut IInspectable, out: *mut *mut TreeViewListAutomationPeer) -> HRESULT +}} +impl ITreeViewListAutomationPeerFactory { + #[inline] pub fn create_instance_with_owner(&self, owner: &super::super::controls::TreeViewList, outer: &IInspectable) -> Result<(Option>, Option>)> { unsafe { + let mut inner = null_mut(); let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreateInstanceWithOwner)(self as *const _ as *mut _, owner as *const _ as *mut _, outer as *const _ as *mut _, &mut inner, &mut out); + if hr == S_OK { Ok((ComPtr::wrap_optional(inner), ComPtr::wrap_optional(out))) } else { err(hr) } + }} +} } // Windows.UI.Xaml.Automation.Peers pub mod text { // Windows.UI.Xaml.Automation.Text use ::prelude::*; @@ -55396,6 +57423,405 @@ RT_INTERFACE!{interface IBold(IBoldVtbl): IInspectable(IInspectableVtbl) [IID_IB RT_CLASS!{class Bold: IBold} impl RtActivatable for Bold {} DEFINE_CLSID!(Bold(&[87,105,110,100,111,119,115,46,85,73,46,88,97,109,108,46,68,111,99,117,109,101,110,116,115,46,66,111,108,100,0]) [CLSID_Bold]); +DEFINE_IID!(IID_IContactContentLinkProvider, 4180660891, 22683, 19133, 157, 55, 53, 161, 70, 143, 2, 30); +RT_INTERFACE!{interface IContactContentLinkProvider(IContactContentLinkProviderVtbl): IInspectable(IInspectableVtbl) [IID_IContactContentLinkProvider] { + +}} +RT_CLASS!{class ContactContentLinkProvider: IContactContentLinkProvider} +impl RtActivatable for ContactContentLinkProvider {} +DEFINE_CLSID!(ContactContentLinkProvider(&[87,105,110,100,111,119,115,46,85,73,46,88,97,109,108,46,68,111,99,117,109,101,110,116,115,46,67,111,110,116,97,99,116,67,111,110,116,101,110,116,76,105,110,107,80,114,111,118,105,100,101,114,0]) [CLSID_ContactContentLinkProvider]); +DEFINE_IID!(IID_IContentLink, 1818280929, 21132, 17144, 146, 190, 52, 184, 198, 139, 227, 4); +RT_INTERFACE!{interface IContentLink(IContentLinkVtbl): IInspectable(IInspectableVtbl) [IID_IContentLink] { + #[cfg(not(feature="windows-ui"))] fn __Dummy0(&self) -> (), + #[cfg(feature="windows-ui")] fn get_Info(&self, out: *mut *mut super::super::text::ContentLinkInfo) -> HRESULT, + #[cfg(not(feature="windows-ui"))] fn __Dummy1(&self) -> (), + #[cfg(feature="windows-ui")] fn put_Info(&self, value: *mut super::super::text::ContentLinkInfo) -> HRESULT, + fn get_Background(&self, out: *mut *mut super::media::Brush) -> HRESULT, + fn put_Background(&self, value: *mut super::media::Brush) -> HRESULT, + #[cfg(not(feature="windows-ui"))] fn __Dummy4(&self) -> (), + #[cfg(feature="windows-ui")] fn get_Cursor(&self, out: *mut super::super::core::CoreCursorType) -> HRESULT, + #[cfg(not(feature="windows-ui"))] fn __Dummy5(&self) -> (), + #[cfg(feature="windows-ui")] fn put_Cursor(&self, value: super::super::core::CoreCursorType) -> HRESULT, + fn get_XYFocusLeft(&self, out: *mut *mut super::DependencyObject) -> HRESULT, + fn put_XYFocusLeft(&self, value: *mut super::DependencyObject) -> HRESULT, + fn get_XYFocusRight(&self, out: *mut *mut super::DependencyObject) -> HRESULT, + fn put_XYFocusRight(&self, value: *mut super::DependencyObject) -> HRESULT, + fn get_XYFocusUp(&self, out: *mut *mut super::DependencyObject) -> HRESULT, + fn put_XYFocusUp(&self, value: *mut super::DependencyObject) -> HRESULT, + fn get_XYFocusDown(&self, out: *mut *mut super::DependencyObject) -> HRESULT, + fn put_XYFocusDown(&self, value: *mut super::DependencyObject) -> HRESULT, + fn get_ElementSoundMode(&self, out: *mut super::ElementSoundMode) -> HRESULT, + fn put_ElementSoundMode(&self, value: super::ElementSoundMode) -> HRESULT, + fn get_FocusState(&self, out: *mut super::FocusState) -> HRESULT, + fn get_XYFocusUpNavigationStrategy(&self, out: *mut super::input::XYFocusNavigationStrategy) -> HRESULT, + fn put_XYFocusUpNavigationStrategy(&self, value: super::input::XYFocusNavigationStrategy) -> HRESULT, + fn get_XYFocusDownNavigationStrategy(&self, out: *mut super::input::XYFocusNavigationStrategy) -> HRESULT, + fn put_XYFocusDownNavigationStrategy(&self, value: super::input::XYFocusNavigationStrategy) -> HRESULT, + fn get_XYFocusLeftNavigationStrategy(&self, out: *mut super::input::XYFocusNavigationStrategy) -> HRESULT, + fn put_XYFocusLeftNavigationStrategy(&self, value: super::input::XYFocusNavigationStrategy) -> HRESULT, + fn get_XYFocusRightNavigationStrategy(&self, out: *mut super::input::XYFocusNavigationStrategy) -> HRESULT, + fn put_XYFocusRightNavigationStrategy(&self, value: super::input::XYFocusNavigationStrategy) -> HRESULT, + fn get_IsTabStop(&self, out: *mut bool) -> HRESULT, + fn put_IsTabStop(&self, value: bool) -> HRESULT, + fn get_TabIndex(&self, out: *mut i32) -> HRESULT, + fn put_TabIndex(&self, value: i32) -> HRESULT, + fn add_Invoked(&self, value: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_Invoked(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn add_GotFocus(&self, value: *mut super::RoutedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_GotFocus(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn add_LostFocus(&self, value: *mut super::RoutedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_LostFocus(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn Focus(&self, value: super::FocusState, out: *mut bool) -> HRESULT +}} +impl IContentLink { + #[cfg(feature="windows-ui")] #[inline] pub fn get_info(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Info)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[cfg(feature="windows-ui")] #[inline] pub fn set_info(&self, value: &super::super::text::ContentLinkInfo) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Info)(self as *const _ as *mut _, value as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_background(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Background)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn set_background(&self, value: &super::media::Brush) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Background)(self as *const _ as *mut _, value as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[cfg(feature="windows-ui")] #[inline] pub fn get_cursor(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Cursor)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[cfg(feature="windows-ui")] #[inline] pub fn set_cursor(&self, value: super::super::core::CoreCursorType) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Cursor)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_xyfocus_left(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_XYFocusLeft)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn set_xyfocus_left(&self, value: &super::DependencyObject) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_XYFocusLeft)(self as *const _ as *mut _, value as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_xyfocus_right(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_XYFocusRight)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn set_xyfocus_right(&self, value: &super::DependencyObject) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_XYFocusRight)(self as *const _ as *mut _, value as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_xyfocus_up(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_XYFocusUp)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn set_xyfocus_up(&self, value: &super::DependencyObject) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_XYFocusUp)(self as *const _ as *mut _, value as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_xyfocus_down(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_XYFocusDown)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn set_xyfocus_down(&self, value: &super::DependencyObject) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_XYFocusDown)(self as *const _ as *mut _, value as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_element_sound_mode(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_ElementSoundMode)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_element_sound_mode(&self, value: super::ElementSoundMode) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_ElementSoundMode)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_focus_state(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_FocusState)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_xyfocus_up_navigation_strategy(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_XYFocusUpNavigationStrategy)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_xyfocus_up_navigation_strategy(&self, value: super::input::XYFocusNavigationStrategy) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_XYFocusUpNavigationStrategy)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_xyfocus_down_navigation_strategy(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_XYFocusDownNavigationStrategy)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_xyfocus_down_navigation_strategy(&self, value: super::input::XYFocusNavigationStrategy) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_XYFocusDownNavigationStrategy)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_xyfocus_left_navigation_strategy(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_XYFocusLeftNavigationStrategy)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_xyfocus_left_navigation_strategy(&self, value: super::input::XYFocusNavigationStrategy) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_XYFocusLeftNavigationStrategy)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_xyfocus_right_navigation_strategy(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_XYFocusRightNavigationStrategy)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_xyfocus_right_navigation_strategy(&self, value: super::input::XYFocusNavigationStrategy) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_XYFocusRightNavigationStrategy)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_is_tab_stop(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_IsTabStop)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_is_tab_stop(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_IsTabStop)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_tab_index(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_TabIndex)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_tab_index(&self, value: i32) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_TabIndex)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_invoked(&self, value: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_Invoked)(self as *const _ as *mut _, value as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_invoked(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_Invoked)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_got_focus(&self, value: &super::RoutedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_GotFocus)(self as *const _ as *mut _, value as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_got_focus(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_GotFocus)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_lost_focus(&self, value: &super::RoutedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_LostFocus)(self as *const _ as *mut _, value as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_lost_focus(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_LostFocus)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn focus(&self, value: super::FocusState) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).Focus)(self as *const _ as *mut _, value, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} +RT_CLASS!{class ContentLink: IContentLink} +impl RtActivatable for ContentLink {} +impl RtActivatable for ContentLink {} +impl ContentLink { + #[inline] pub fn get_background_property() -> Result>> { + >::get_activation_factory().get_background_property() + } + #[inline] pub fn get_cursor_property() -> Result>> { + >::get_activation_factory().get_cursor_property() + } + #[inline] pub fn get_xyfocus_left_property() -> Result>> { + >::get_activation_factory().get_xyfocus_left_property() + } + #[inline] pub fn get_xyfocus_right_property() -> Result>> { + >::get_activation_factory().get_xyfocus_right_property() + } + #[inline] pub fn get_xyfocus_up_property() -> Result>> { + >::get_activation_factory().get_xyfocus_up_property() + } + #[inline] pub fn get_xyfocus_down_property() -> Result>> { + >::get_activation_factory().get_xyfocus_down_property() + } + #[inline] pub fn get_element_sound_mode_property() -> Result>> { + >::get_activation_factory().get_element_sound_mode_property() + } + #[inline] pub fn get_focus_state_property() -> Result>> { + >::get_activation_factory().get_focus_state_property() + } + #[inline] pub fn get_xyfocus_up_navigation_strategy_property() -> Result>> { + >::get_activation_factory().get_xyfocus_up_navigation_strategy_property() + } + #[inline] pub fn get_xyfocus_down_navigation_strategy_property() -> Result>> { + >::get_activation_factory().get_xyfocus_down_navigation_strategy_property() + } + #[inline] pub fn get_xyfocus_left_navigation_strategy_property() -> Result>> { + >::get_activation_factory().get_xyfocus_left_navigation_strategy_property() + } + #[inline] pub fn get_xyfocus_right_navigation_strategy_property() -> Result>> { + >::get_activation_factory().get_xyfocus_right_navigation_strategy_property() + } + #[inline] pub fn get_is_tab_stop_property() -> Result>> { + >::get_activation_factory().get_is_tab_stop_property() + } + #[inline] pub fn get_tab_index_property() -> Result>> { + >::get_activation_factory().get_tab_index_property() + } +} +DEFINE_CLSID!(ContentLink(&[87,105,110,100,111,119,115,46,85,73,46,88,97,109,108,46,68,111,99,117,109,101,110,116,115,46,67,111,110,116,101,110,116,76,105,110,107,0]) [CLSID_ContentLink]); +DEFINE_IID!(IID_IContentLinkInvokedEventArgs, 1416042433, 59615, 17811, 150, 57, 151, 89, 95, 223, 131, 16); +RT_INTERFACE!{interface IContentLinkInvokedEventArgs(IContentLinkInvokedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IContentLinkInvokedEventArgs] { + #[cfg(not(feature="windows-ui"))] fn __Dummy0(&self) -> (), + #[cfg(feature="windows-ui")] fn get_ContentLinkInfo(&self, out: *mut *mut super::super::text::ContentLinkInfo) -> HRESULT, + fn get_Handled(&self, out: *mut bool) -> HRESULT, + fn put_Handled(&self, value: bool) -> HRESULT +}} +impl IContentLinkInvokedEventArgs { + #[cfg(feature="windows-ui")] #[inline] pub fn get_content_link_info(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ContentLinkInfo)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_handled(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Handled)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_handled(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Handled)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class ContentLinkInvokedEventArgs: IContentLinkInvokedEventArgs} +DEFINE_IID!(IID_IContentLinkProvider, 1929742333, 49116, 19635, 144, 77, 182, 90, 179, 57, 187, 245); +RT_INTERFACE!{interface IContentLinkProvider(IContentLinkProviderVtbl): IInspectable(IInspectableVtbl) [IID_IContentLinkProvider] { + +}} +RT_CLASS!{class ContentLinkProvider: IContentLinkProvider} +DEFINE_IID!(IID_IContentLinkProviderCollection, 4122496268, 43508, 19738, 161, 60, 16, 222, 241, 132, 55, 52); +RT_INTERFACE!{interface IContentLinkProviderCollection(IContentLinkProviderCollectionVtbl): IInspectable(IInspectableVtbl) [IID_IContentLinkProviderCollection] { + +}} +RT_CLASS!{class ContentLinkProviderCollection: IContentLinkProviderCollection} +impl RtActivatable for ContentLinkProviderCollection {} +DEFINE_CLSID!(ContentLinkProviderCollection(&[87,105,110,100,111,119,115,46,85,73,46,88,97,109,108,46,68,111,99,117,109,101,110,116,115,46,67,111,110,116,101,110,116,76,105,110,107,80,114,111,118,105,100,101,114,67,111,108,108,101,99,116,105,111,110,0]) [CLSID_ContentLinkProviderCollection]); +DEFINE_IID!(IID_IContentLinkProviderFactory, 1473645883, 61210, 20110, 131, 155, 211, 110, 243, 165, 3, 224); +RT_INTERFACE!{interface IContentLinkProviderFactory(IContentLinkProviderFactoryVtbl): IInspectable(IInspectableVtbl) [IID_IContentLinkProviderFactory] { + fn CreateInstance(&self, outer: *mut IInspectable, inner: *mut *mut IInspectable, out: *mut *mut ContentLinkProvider) -> HRESULT +}} +impl IContentLinkProviderFactory { + #[inline] pub fn create_instance(&self, outer: &IInspectable) -> Result<(Option>, Option>)> { unsafe { + let mut inner = null_mut(); let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreateInstance)(self as *const _ as *mut _, outer as *const _ as *mut _, &mut inner, &mut out); + if hr == S_OK { Ok((ComPtr::wrap_optional(inner), ComPtr::wrap_optional(out))) } else { err(hr) } + }} +} +DEFINE_IID!(IID_IContentLinkStatics, 2739810403, 60182, 18510, 163, 223, 82, 43, 154, 131, 46, 110); +RT_INTERFACE!{static interface IContentLinkStatics(IContentLinkStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IContentLinkStatics] { + fn get_BackgroundProperty(&self, out: *mut *mut super::DependencyProperty) -> HRESULT, + fn get_CursorProperty(&self, out: *mut *mut super::DependencyProperty) -> HRESULT, + fn get_XYFocusLeftProperty(&self, out: *mut *mut super::DependencyProperty) -> HRESULT, + fn get_XYFocusRightProperty(&self, out: *mut *mut super::DependencyProperty) -> HRESULT, + fn get_XYFocusUpProperty(&self, out: *mut *mut super::DependencyProperty) -> HRESULT, + fn get_XYFocusDownProperty(&self, out: *mut *mut super::DependencyProperty) -> HRESULT, + fn get_ElementSoundModeProperty(&self, out: *mut *mut super::DependencyProperty) -> HRESULT, + fn get_FocusStateProperty(&self, out: *mut *mut super::DependencyProperty) -> HRESULT, + fn get_XYFocusUpNavigationStrategyProperty(&self, out: *mut *mut super::DependencyProperty) -> HRESULT, + fn get_XYFocusDownNavigationStrategyProperty(&self, out: *mut *mut super::DependencyProperty) -> HRESULT, + fn get_XYFocusLeftNavigationStrategyProperty(&self, out: *mut *mut super::DependencyProperty) -> HRESULT, + fn get_XYFocusRightNavigationStrategyProperty(&self, out: *mut *mut super::DependencyProperty) -> HRESULT, + fn get_IsTabStopProperty(&self, out: *mut *mut super::DependencyProperty) -> HRESULT, + fn get_TabIndexProperty(&self, out: *mut *mut super::DependencyProperty) -> HRESULT +}} +impl IContentLinkStatics { + #[inline] pub fn get_background_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_BackgroundProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_cursor_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_CursorProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_xyfocus_left_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_XYFocusLeftProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_xyfocus_right_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_XYFocusRightProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_xyfocus_up_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_XYFocusUpProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_xyfocus_down_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_XYFocusDownProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_element_sound_mode_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_ElementSoundModeProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_focus_state_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_FocusStateProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_xyfocus_up_navigation_strategy_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_XYFocusUpNavigationStrategyProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_xyfocus_down_navigation_strategy_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_XYFocusDownNavigationStrategyProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_xyfocus_left_navigation_strategy_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_XYFocusLeftNavigationStrategyProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_xyfocus_right_navigation_strategy_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_XYFocusRightNavigationStrategyProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_is_tab_stop_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_IsTabStopProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_tab_index_property(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_TabIndexProperty)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} DEFINE_IID!(IID_IGlyphs, 3497609611, 62129, 17025, 153, 162, 228, 208, 89, 50, 178, 181); RT_INTERFACE!{interface IGlyphs(IGlyphsVtbl): IInspectable(IInspectableVtbl) [IID_IGlyphs] { fn get_UnicodeString(&self, out: *mut HSTRING) -> HRESULT, @@ -56097,6 +58523,13 @@ impl IParagraphStatics { if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IPlaceContentLinkProvider, 271878732, 9062, 16830, 144, 200, 50, 88, 181, 59, 84, 131); +RT_INTERFACE!{interface IPlaceContentLinkProvider(IPlaceContentLinkProviderVtbl): IInspectable(IInspectableVtbl) [IID_IPlaceContentLinkProvider] { + +}} +RT_CLASS!{class PlaceContentLinkProvider: IPlaceContentLinkProvider} +impl RtActivatable for PlaceContentLinkProvider {} +DEFINE_CLSID!(PlaceContentLinkProvider(&[87,105,110,100,111,119,115,46,85,73,46,88,97,109,108,46,68,111,99,117,109,101,110,116,115,46,80,108,97,99,101,67,111,110,116,101,110,116,76,105,110,107,80,114,111,118,105,100,101,114,0]) [CLSID_PlaceContentLinkProvider]); DEFINE_IID!(IID_IRun, 1498758275, 3604, 18877, 184, 75, 197, 38, 243, 3, 67, 73); RT_INTERFACE!{interface IRun(IRunVtbl): IInspectable(IInspectableVtbl) [IID_IRun] { fn get_Text(&self, out: *mut HSTRING) -> HRESULT, @@ -60013,6 +62446,7 @@ impl RtActivatable for FocusManager {} impl RtActivatable for FocusManager {} impl RtActivatable for FocusManager {} impl RtActivatable for FocusManager {} +impl RtActivatable for FocusManager {} impl FocusManager { #[inline] pub fn get_focused_element() -> Result>> { >::get_activation_factory().get_focused_element() @@ -60041,6 +62475,15 @@ impl FocusManager { #[inline] pub fn find_next_element_with_options(focusNavigationDirection: FocusNavigationDirection, focusNavigationOptions: &FindNextElementOptions) -> Result>> { >::get_activation_factory().find_next_element_with_options(focusNavigationDirection, focusNavigationOptions) } + #[inline] pub fn try_focus_async(element: &super::DependencyObject, value: super::FocusState) -> Result>> { + >::get_activation_factory().try_focus_async(element, value) + } + #[inline] pub fn try_move_focus_async(focusNavigationDirection: FocusNavigationDirection) -> Result>> { + >::get_activation_factory().try_move_focus_async(focusNavigationDirection) + } + #[inline] pub fn try_move_focus_with_options_async(focusNavigationDirection: FocusNavigationDirection, focusNavigationOptions: &FindNextElementOptions) -> Result>> { + >::get_activation_factory().try_move_focus_with_options_async(focusNavigationDirection, focusNavigationOptions) + } } DEFINE_CLSID!(FocusManager(&[87,105,110,100,111,119,115,46,85,73,46,88,97,109,108,46,73,110,112,117,116,46,70,111,99,117,115,77,97,110,97,103,101,114,0]) [CLSID_FocusManager]); DEFINE_IID!(IID_IFocusManagerStatics, 516739878, 33154, 17538, 130, 106, 9, 24, 233, 237, 154, 247); @@ -60117,6 +62560,41 @@ impl IFocusManagerStatics4 { if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } }} } +DEFINE_IID!(IID_IFocusManagerStatics5, 672062561, 8314, 19835, 185, 143, 206, 22, 94, 27, 32, 21); +RT_INTERFACE!{static interface IFocusManagerStatics5(IFocusManagerStatics5Vtbl): IInspectable(IInspectableVtbl) [IID_IFocusManagerStatics5] { + fn TryFocusAsync(&self, element: *mut super::DependencyObject, value: super::FocusState, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn TryMoveFocusAsync(&self, focusNavigationDirection: FocusNavigationDirection, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn TryMoveFocusWithOptionsAsync(&self, focusNavigationDirection: FocusNavigationDirection, focusNavigationOptions: *mut FindNextElementOptions, out: *mut *mut foundation::IAsyncOperation) -> HRESULT +}} +impl IFocusManagerStatics5 { + #[inline] pub fn try_focus_async(&self, element: &super::DependencyObject, value: super::FocusState) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).TryFocusAsync)(self as *const _ as *mut _, element as *const _ as *mut _, value, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn try_move_focus_async(&self, focusNavigationDirection: FocusNavigationDirection) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).TryMoveFocusAsync)(self as *const _ as *mut _, focusNavigationDirection, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn try_move_focus_with_options_async(&self, focusNavigationDirection: FocusNavigationDirection, focusNavigationOptions: &FindNextElementOptions) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).TryMoveFocusWithOptionsAsync)(self as *const _ as *mut _, focusNavigationDirection, focusNavigationOptions as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} +} +DEFINE_IID!(IID_IFocusMovementResult, 115337939, 49838, 17595, 191, 171, 156, 115, 222, 132, 7, 164); +RT_INTERFACE!{interface IFocusMovementResult(IFocusMovementResultVtbl): IInspectable(IInspectableVtbl) [IID_IFocusMovementResult] { + fn get_Succeeded(&self, out: *mut bool) -> HRESULT +}} +impl IFocusMovementResult { + #[inline] pub fn get_succeeded(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Succeeded)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} +RT_CLASS!{class FocusMovementResult: IFocusMovementResult} RT_ENUM! { enum FocusNavigationDirection: i32 { Next (FocusNavigationDirection_Next) = 0, Previous (FocusNavigationDirection_Previous) = 1, Up (FocusNavigationDirection_Up) = 2, Down (FocusNavigationDirection_Down) = 3, Left (FocusNavigationDirection_Left) = 4, Right (FocusNavigationDirection_Right) = 5, None (FocusNavigationDirection_None) = 6, }} @@ -60183,6 +62661,23 @@ impl IGettingFocusEventArgs { }} } RT_CLASS!{class GettingFocusEventArgs: IGettingFocusEventArgs} +DEFINE_IID!(IID_IGettingFocusEventArgs2, 2289388923, 46265, 18777, 139, 206, 137, 191, 33, 46, 212, 235); +RT_INTERFACE!{interface IGettingFocusEventArgs2(IGettingFocusEventArgs2Vtbl): IInspectable(IInspectableVtbl) [IID_IGettingFocusEventArgs2] { + fn TryCancel(&self, out: *mut bool) -> HRESULT, + fn TrySetNewFocusedElement(&self, element: *mut super::DependencyObject, out: *mut bool) -> HRESULT +}} +impl IGettingFocusEventArgs2 { + #[inline] pub fn try_cancel(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).TryCancel)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn try_set_new_focused_element(&self, element: &super::DependencyObject) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).TrySetNewFocusedElement)(self as *const _ as *mut _, element as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} DEFINE_IID!(IID_HoldingEventHandler, 3970862285, 36446, 20414, 152, 70, 48, 166, 55, 10, 252, 223); RT_DELEGATE!{delegate HoldingEventHandler(HoldingEventHandlerVtbl, HoldingEventHandlerImpl) [IID_HoldingEventHandler] { fn Invoke(&self, sender: *mut IInspectable, e: *mut HoldingRoutedEventArgs) -> HRESULT @@ -60484,6 +62979,20 @@ impl IKeyboardAcceleratorInvokedEventArgs { }} } RT_CLASS!{class KeyboardAcceleratorInvokedEventArgs: IKeyboardAcceleratorInvokedEventArgs} +DEFINE_IID!(IID_IKeyboardAcceleratorInvokedEventArgs2, 3204228280, 22791, 18670, 142, 33, 156, 150, 144, 120, 250, 17); +RT_INTERFACE!{interface IKeyboardAcceleratorInvokedEventArgs2(IKeyboardAcceleratorInvokedEventArgs2Vtbl): IInspectable(IInspectableVtbl) [IID_IKeyboardAcceleratorInvokedEventArgs2] { + fn get_KeyboardAccelerator(&self, out: *mut *mut KeyboardAccelerator) -> HRESULT +}} +impl IKeyboardAcceleratorInvokedEventArgs2 { + #[inline] pub fn get_keyboard_accelerator(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_KeyboardAccelerator)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +RT_ENUM! { enum KeyboardAcceleratorPlacementMode: i32 { + Auto (KeyboardAcceleratorPlacementMode_Auto) = 0, Hidden (KeyboardAcceleratorPlacementMode_Hidden) = 1, +}} DEFINE_IID!(IID_IKeyboardAcceleratorStatics, 1003765073, 39859, 17773, 191, 21, 128, 74, 223, 184, 98, 97); RT_INTERFACE!{static interface IKeyboardAcceleratorStatics(IKeyboardAcceleratorStaticsVtbl): IInspectable(IInspectableVtbl) [IID_IKeyboardAcceleratorStatics] { fn get_KeyProperty(&self, out: *mut *mut super::DependencyProperty) -> HRESULT, @@ -60645,6 +63154,23 @@ impl ILosingFocusEventArgs { }} } RT_CLASS!{class LosingFocusEventArgs: ILosingFocusEventArgs} +DEFINE_IID!(IID_ILosingFocusEventArgs2, 76806873, 49791, 18079, 142, 98, 82, 179, 164, 247, 205, 84); +RT_INTERFACE!{interface ILosingFocusEventArgs2(ILosingFocusEventArgs2Vtbl): IInspectable(IInspectableVtbl) [IID_ILosingFocusEventArgs2] { + fn TryCancel(&self, out: *mut bool) -> HRESULT, + fn TrySetNewFocusedElement(&self, element: *mut super::DependencyObject, out: *mut bool) -> HRESULT +}} +impl ILosingFocusEventArgs2 { + #[inline] pub fn try_cancel(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).TryCancel)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn try_set_new_focused_element(&self, element: &super::DependencyObject) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).TrySetNewFocusedElement)(self as *const _ as *mut _, element as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} DEFINE_IID!(IID_ManipulationCompletedEventHandler, 955206415, 5368, 17119, 154, 30, 164, 188, 196, 175, 119, 244); RT_DELEGATE!{delegate ManipulationCompletedEventHandler(ManipulationCompletedEventHandlerVtbl, ManipulationCompletedEventHandlerImpl) [IID_ManipulationCompletedEventHandler] { fn Invoke(&self, sender: *mut IInspectable, e: *mut ManipulationCompletedRoutedEventArgs) -> HRESULT diff --git a/src/rt/gen/windows/web.rs b/src/rt/gen/windows/web.rs index 6a46ea8..619eb37 100644 --- a/src/rt/gen/windows/web.rs +++ b/src/rt/gen/windows/web.rs @@ -3260,6 +3260,932 @@ impl IHttpDiagnosticSourceLocation { RT_CLASS!{class HttpDiagnosticSourceLocation: IHttpDiagnosticSourceLocation} } // Windows.Web.Http.Diagnostics } // Windows.Web.Http +pub mod ui { // Windows.Web.UI +use ::prelude::*; +DEFINE_IID!(IID_IWebViewControl, 1066537750, 48240, 19418, 145, 54, 201, 67, 112, 137, 159, 171); +RT_INTERFACE!{interface IWebViewControl(IWebViewControlVtbl): IInspectable(IInspectableVtbl) [IID_IWebViewControl] { + fn get_Source(&self, out: *mut *mut foundation::Uri) -> HRESULT, + fn put_Source(&self, source: *mut foundation::Uri) -> HRESULT, + fn get_DocumentTitle(&self, out: *mut HSTRING) -> HRESULT, + fn get_CanGoBack(&self, out: *mut bool) -> HRESULT, + fn get_CanGoForward(&self, out: *mut bool) -> HRESULT, + #[cfg(not(feature="windows-ui"))] fn __Dummy5(&self) -> (), + #[cfg(feature="windows-ui")] fn put_DefaultBackgroundColor(&self, value: super::super::ui::Color) -> HRESULT, + #[cfg(not(feature="windows-ui"))] fn __Dummy6(&self) -> (), + #[cfg(feature="windows-ui")] fn get_DefaultBackgroundColor(&self, out: *mut super::super::ui::Color) -> HRESULT, + fn get_ContainsFullScreenElement(&self, out: *mut bool) -> HRESULT, + fn get_Settings(&self, out: *mut *mut WebViewControlSettings) -> HRESULT, + fn get_DeferredPermissionRequests(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT, + fn GoForward(&self) -> HRESULT, + fn GoBack(&self) -> HRESULT, + fn Refresh(&self) -> HRESULT, + fn Stop(&self) -> HRESULT, + fn Navigate(&self, source: *mut foundation::Uri) -> HRESULT, + fn NavigateToString(&self, text: HSTRING) -> HRESULT, + fn NavigateToLocalStreamUri(&self, source: *mut foundation::Uri, streamResolver: *mut super::IUriToStreamResolver) -> HRESULT, + fn NavigateWithHttpRequestMessage(&self, requestMessage: *mut super::http::HttpRequestMessage) -> HRESULT, + fn InvokeScriptAsync(&self, scriptName: HSTRING, arguments: *mut foundation::collections::IIterable, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + #[cfg(not(feature="windows-storage"))] fn __Dummy19(&self) -> (), + #[cfg(feature="windows-storage")] fn CapturePreviewToStreamAsync(&self, stream: *mut super::super::storage::streams::IRandomAccessStream, out: *mut *mut foundation::IAsyncAction) -> HRESULT, + #[cfg(not(feature="windows-applicationmodel"))] fn __Dummy20(&self) -> (), + #[cfg(feature="windows-applicationmodel")] fn CaptureSelectedContentToDataPackageAsync(&self, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn BuildLocalStreamUri(&self, contentIdentifier: HSTRING, relativePath: HSTRING, out: *mut *mut foundation::Uri) -> HRESULT, + fn GetDeferredPermissionRequestById(&self, id: u32, result: *mut *mut WebViewControlDeferredPermissionRequest) -> HRESULT, + fn add_NavigationStarting(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_NavigationStarting(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn add_ContentLoading(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_ContentLoading(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn add_DOMContentLoaded(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_DOMContentLoaded(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn add_NavigationCompleted(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_NavigationCompleted(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn add_FrameNavigationStarting(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_FrameNavigationStarting(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn add_FrameContentLoading(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_FrameContentLoading(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn add_FrameDOMContentLoaded(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_FrameDOMContentLoaded(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn add_FrameNavigationCompleted(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_FrameNavigationCompleted(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn add_ScriptNotify(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_ScriptNotify(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn add_LongRunningScriptDetected(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_LongRunningScriptDetected(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn add_UnsafeContentWarningDisplaying(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_UnsafeContentWarningDisplaying(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn add_UnviewableContentIdentified(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_UnviewableContentIdentified(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn add_PermissionRequested(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_PermissionRequested(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn add_UnsupportedUriSchemeIdentified(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_UnsupportedUriSchemeIdentified(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn add_NewWindowRequested(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_NewWindowRequested(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn add_ContainsFullScreenElementChanged(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_ContainsFullScreenElementChanged(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn add_WebResourceRequested(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_WebResourceRequested(&self, token: foundation::EventRegistrationToken) -> HRESULT +}} +impl IWebViewControl { + #[inline] pub fn get_source(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Source)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn set_source(&self, source: &foundation::Uri) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Source)(self as *const _ as *mut _, source as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_document_title(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_DocumentTitle)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_can_go_back(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_CanGoBack)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_can_go_forward(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_CanGoForward)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[cfg(feature="windows-ui")] #[inline] pub fn set_default_background_color(&self, value: super::super::ui::Color) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_DefaultBackgroundColor)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[cfg(feature="windows-ui")] #[inline] pub fn get_default_background_color(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_DefaultBackgroundColor)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_contains_full_screen_element(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_ContainsFullScreenElement)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_settings(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Settings)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_deferred_permission_requests(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_DeferredPermissionRequests)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn go_forward(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).GoForward)(self as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn go_back(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).GoBack)(self as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn refresh(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).Refresh)(self as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn stop(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).Stop)(self as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn navigate(&self, source: &foundation::Uri) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).Navigate)(self as *const _ as *mut _, source as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn navigate_to_string(&self, text: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).NavigateToString)(self as *const _ as *mut _, text.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn navigate_to_local_stream_uri(&self, source: &foundation::Uri, streamResolver: &super::IUriToStreamResolver) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).NavigateToLocalStreamUri)(self as *const _ as *mut _, source as *const _ as *mut _, streamResolver as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn navigate_with_http_request_message(&self, requestMessage: &super::http::HttpRequestMessage) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).NavigateWithHttpRequestMessage)(self as *const _ as *mut _, requestMessage as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn invoke_script_async(&self, scriptName: &HStringArg, arguments: &foundation::collections::IIterable) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).InvokeScriptAsync)(self as *const _ as *mut _, scriptName.get(), arguments as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[cfg(feature="windows-storage")] #[inline] pub fn capture_preview_to_stream_async(&self, stream: &super::super::storage::streams::IRandomAccessStream) -> Result> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).CapturePreviewToStreamAsync)(self as *const _ as *mut _, stream as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[cfg(feature="windows-applicationmodel")] #[inline] pub fn capture_selected_content_to_data_package_async(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).CaptureSelectedContentToDataPackageAsync)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn build_local_stream_uri(&self, contentIdentifier: &HStringArg, relativePath: &HStringArg) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).BuildLocalStreamUri)(self as *const _ as *mut _, contentIdentifier.get(), relativePath.get(), &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_deferred_permission_request_by_id(&self, id: u32) -> Result>> { unsafe { + let mut result = null_mut(); + let hr = ((*self.lpVtbl).GetDeferredPermissionRequestById)(self as *const _ as *mut _, id, &mut result); + if hr == S_OK { Ok(ComPtr::wrap_optional(result)) } else { err(hr) } + }} + #[inline] pub fn add_navigation_starting(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_NavigationStarting)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_navigation_starting(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_NavigationStarting)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_content_loading(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_ContentLoading)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_content_loading(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_ContentLoading)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_domcontent_loaded(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_DOMContentLoaded)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_domcontent_loaded(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_DOMContentLoaded)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_navigation_completed(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_NavigationCompleted)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_navigation_completed(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_NavigationCompleted)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_frame_navigation_starting(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_FrameNavigationStarting)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_frame_navigation_starting(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_FrameNavigationStarting)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_frame_content_loading(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_FrameContentLoading)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_frame_content_loading(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_FrameContentLoading)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_frame_domcontent_loaded(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_FrameDOMContentLoaded)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_frame_domcontent_loaded(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_FrameDOMContentLoaded)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_frame_navigation_completed(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_FrameNavigationCompleted)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_frame_navigation_completed(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_FrameNavigationCompleted)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_script_notify(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_ScriptNotify)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_script_notify(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_ScriptNotify)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_long_running_script_detected(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_LongRunningScriptDetected)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_long_running_script_detected(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_LongRunningScriptDetected)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_unsafe_content_warning_displaying(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_UnsafeContentWarningDisplaying)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_unsafe_content_warning_displaying(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_UnsafeContentWarningDisplaying)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_unviewable_content_identified(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_UnviewableContentIdentified)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_unviewable_content_identified(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_UnviewableContentIdentified)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_permission_requested(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_PermissionRequested)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_permission_requested(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_PermissionRequested)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_unsupported_uri_scheme_identified(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_UnsupportedUriSchemeIdentified)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_unsupported_uri_scheme_identified(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_UnsupportedUriSchemeIdentified)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_new_window_requested(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_NewWindowRequested)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_new_window_requested(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_NewWindowRequested)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_contains_full_screen_element_changed(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_ContainsFullScreenElementChanged)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_contains_full_screen_element_changed(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_ContainsFullScreenElementChanged)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_web_resource_requested(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_WebResourceRequested)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_web_resource_requested(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_WebResourceRequested)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +DEFINE_IID!(IID_IWebViewControlContentLoadingEventArgs, 2587872434, 47547, 16459, 162, 43, 102, 220, 205, 18, 80, 198); +RT_INTERFACE!{interface IWebViewControlContentLoadingEventArgs(IWebViewControlContentLoadingEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IWebViewControlContentLoadingEventArgs] { + fn get_Uri(&self, out: *mut *mut foundation::Uri) -> HRESULT +}} +impl IWebViewControlContentLoadingEventArgs { + #[inline] pub fn get_uri(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Uri)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +RT_CLASS!{class WebViewControlContentLoadingEventArgs: IWebViewControlContentLoadingEventArgs} +DEFINE_IID!(IID_IWebViewControlDeferredPermissionRequest, 753093088, 55129, 17500, 153, 38, 137, 149, 41, 143, 21, 43); +RT_INTERFACE!{interface IWebViewControlDeferredPermissionRequest(IWebViewControlDeferredPermissionRequestVtbl): IInspectable(IInspectableVtbl) [IID_IWebViewControlDeferredPermissionRequest] { + fn get_Id(&self, out: *mut u32) -> HRESULT, + fn get_Uri(&self, out: *mut *mut foundation::Uri) -> HRESULT, + fn get_PermissionType(&self, out: *mut WebViewControlPermissionType) -> HRESULT, + fn Allow(&self) -> HRESULT, + fn Deny(&self) -> HRESULT +}} +impl IWebViewControlDeferredPermissionRequest { + #[inline] pub fn get_id(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Id)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_uri(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Uri)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_permission_type(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_PermissionType)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn allow(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).Allow)(self as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn deny(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).Deny)(self as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class WebViewControlDeferredPermissionRequest: IWebViewControlDeferredPermissionRequest} +DEFINE_IID!(IID_IWebViewControlDOMContentLoadedEventArgs, 3196829704, 38209, 17733, 159, 242, 45, 245, 133, 178, 159, 125); +RT_INTERFACE!{interface IWebViewControlDOMContentLoadedEventArgs(IWebViewControlDOMContentLoadedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IWebViewControlDOMContentLoadedEventArgs] { + fn get_Uri(&self, out: *mut *mut foundation::Uri) -> HRESULT +}} +impl IWebViewControlDOMContentLoadedEventArgs { + #[inline] pub fn get_uri(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Uri)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +RT_CLASS!{class WebViewControlDOMContentLoadedEventArgs: IWebViewControlDOMContentLoadedEventArgs} +DEFINE_IID!(IID_IWebViewControlLongRunningScriptDetectedEventArgs, 711875514, 39092, 17852, 187, 235, 15, 105, 206, 73, 197, 153); +RT_INTERFACE!{interface IWebViewControlLongRunningScriptDetectedEventArgs(IWebViewControlLongRunningScriptDetectedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IWebViewControlLongRunningScriptDetectedEventArgs] { + fn get_ExecutionTime(&self, out: *mut foundation::TimeSpan) -> HRESULT, + fn get_StopPageScriptExecution(&self, out: *mut bool) -> HRESULT, + fn put_StopPageScriptExecution(&self, value: bool) -> HRESULT +}} +impl IWebViewControlLongRunningScriptDetectedEventArgs { + #[inline] pub fn get_execution_time(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_ExecutionTime)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_stop_page_script_execution(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_StopPageScriptExecution)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_stop_page_script_execution(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_StopPageScriptExecution)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class WebViewControlLongRunningScriptDetectedEventArgs: IWebViewControlLongRunningScriptDetectedEventArgs} +DEFINE_IID!(IID_IWebViewControlNavigationCompletedEventArgs, 541104408, 18965, 19526, 165, 93, 247, 158, 219, 11, 222, 139); +RT_INTERFACE!{interface IWebViewControlNavigationCompletedEventArgs(IWebViewControlNavigationCompletedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IWebViewControlNavigationCompletedEventArgs] { + fn get_Uri(&self, out: *mut *mut foundation::Uri) -> HRESULT, + fn get_IsSuccess(&self, out: *mut bool) -> HRESULT, + fn get_WebErrorStatus(&self, out: *mut super::WebErrorStatus) -> HRESULT +}} +impl IWebViewControlNavigationCompletedEventArgs { + #[inline] pub fn get_uri(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Uri)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_is_success(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_IsSuccess)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_web_error_status(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_WebErrorStatus)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} +RT_CLASS!{class WebViewControlNavigationCompletedEventArgs: IWebViewControlNavigationCompletedEventArgs} +DEFINE_IID!(IID_IWebViewControlNavigationStartingEventArgs, 210786245, 2568, 16839, 134, 59, 113, 227, 169, 84, 145, 55); +RT_INTERFACE!{interface IWebViewControlNavigationStartingEventArgs(IWebViewControlNavigationStartingEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IWebViewControlNavigationStartingEventArgs] { + fn get_Uri(&self, out: *mut *mut foundation::Uri) -> HRESULT, + fn get_Cancel(&self, out: *mut bool) -> HRESULT, + fn put_Cancel(&self, value: bool) -> HRESULT +}} +impl IWebViewControlNavigationStartingEventArgs { + #[inline] pub fn get_uri(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Uri)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_cancel(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Cancel)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_cancel(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Cancel)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class WebViewControlNavigationStartingEventArgs: IWebViewControlNavigationStartingEventArgs} +DEFINE_IID!(IID_IWebViewControlNewWindowRequestedEventArgs, 1039420347, 41252, 18133, 160, 131, 208, 44, 172, 223, 245, 173); +RT_INTERFACE!{interface IWebViewControlNewWindowRequestedEventArgs(IWebViewControlNewWindowRequestedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IWebViewControlNewWindowRequestedEventArgs] { + fn get_Uri(&self, out: *mut *mut foundation::Uri) -> HRESULT, + fn get_Referrer(&self, out: *mut *mut foundation::Uri) -> HRESULT, + fn get_Handled(&self, out: *mut bool) -> HRESULT, + fn put_Handled(&self, value: bool) -> HRESULT +}} +impl IWebViewControlNewWindowRequestedEventArgs { + #[inline] pub fn get_uri(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Uri)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_referrer(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Referrer)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_handled(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Handled)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_handled(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Handled)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class WebViewControlNewWindowRequestedEventArgs: IWebViewControlNewWindowRequestedEventArgs} +DEFINE_IID!(IID_IWebViewControlPermissionRequest, 3854336876, 61999, 16610, 149, 178, 119, 41, 248, 64, 235, 127); +RT_INTERFACE!{interface IWebViewControlPermissionRequest(IWebViewControlPermissionRequestVtbl): IInspectable(IInspectableVtbl) [IID_IWebViewControlPermissionRequest] { + fn get_Id(&self, out: *mut u32) -> HRESULT, + fn get_Uri(&self, out: *mut *mut foundation::Uri) -> HRESULT, + fn get_PermissionType(&self, out: *mut WebViewControlPermissionType) -> HRESULT, + fn get_State(&self, out: *mut WebViewControlPermissionState) -> HRESULT, + fn Defer(&self) -> HRESULT, + fn Allow(&self) -> HRESULT, + fn Deny(&self) -> HRESULT +}} +impl IWebViewControlPermissionRequest { + #[inline] pub fn get_id(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Id)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_uri(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Uri)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_permission_type(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_PermissionType)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_state(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_State)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn defer(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).Defer)(self as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn allow(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).Allow)(self as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn deny(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).Deny)(self as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class WebViewControlPermissionRequest: IWebViewControlPermissionRequest} +DEFINE_IID!(IID_IWebViewControlPermissionRequestedEventArgs, 656428369, 9352, 19653, 150, 142, 10, 119, 30, 89, 193, 71); +RT_INTERFACE!{interface IWebViewControlPermissionRequestedEventArgs(IWebViewControlPermissionRequestedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IWebViewControlPermissionRequestedEventArgs] { + fn get_PermissionRequest(&self, out: *mut *mut WebViewControlPermissionRequest) -> HRESULT +}} +impl IWebViewControlPermissionRequestedEventArgs { + #[inline] pub fn get_permission_request(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_PermissionRequest)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +RT_CLASS!{class WebViewControlPermissionRequestedEventArgs: IWebViewControlPermissionRequestedEventArgs} +RT_ENUM! { enum WebViewControlPermissionState: i32 { + Unknown (WebViewControlPermissionState_Unknown) = 0, Defer (WebViewControlPermissionState_Defer) = 1, Allow (WebViewControlPermissionState_Allow) = 2, Deny (WebViewControlPermissionState_Deny) = 3, +}} +RT_ENUM! { enum WebViewControlPermissionType: i32 { + Geolocation (WebViewControlPermissionType_Geolocation) = 0, UnlimitedIndexedDBQuota (WebViewControlPermissionType_UnlimitedIndexedDBQuota) = 1, Media (WebViewControlPermissionType_Media) = 2, PointerLock (WebViewControlPermissionType_PointerLock) = 3, WebNotifications (WebViewControlPermissionType_WebNotifications) = 4, Screen (WebViewControlPermissionType_Screen) = 5, +}} +DEFINE_IID!(IID_IWebViewControlScriptNotifyEventArgs, 1226696059, 28489, 16827, 181, 145, 81, 184, 91, 129, 112, 55); +RT_INTERFACE!{interface IWebViewControlScriptNotifyEventArgs(IWebViewControlScriptNotifyEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IWebViewControlScriptNotifyEventArgs] { + fn get_Uri(&self, out: *mut *mut foundation::Uri) -> HRESULT, + fn get_Value(&self, out: *mut HSTRING) -> HRESULT +}} +impl IWebViewControlScriptNotifyEventArgs { + #[inline] pub fn get_uri(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Uri)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_value(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Value)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} +} +RT_CLASS!{class WebViewControlScriptNotifyEventArgs: IWebViewControlScriptNotifyEventArgs} +DEFINE_IID!(IID_IWebViewControlSettings, 3382083519, 24216, 19709, 140, 206, 39, 176, 145, 30, 61, 232); +RT_INTERFACE!{interface IWebViewControlSettings(IWebViewControlSettingsVtbl): IInspectable(IInspectableVtbl) [IID_IWebViewControlSettings] { + fn put_IsJavaScriptEnabled(&self, value: bool) -> HRESULT, + fn get_IsJavaScriptEnabled(&self, out: *mut bool) -> HRESULT, + fn put_IsIndexedDBEnabled(&self, value: bool) -> HRESULT, + fn get_IsIndexedDBEnabled(&self, out: *mut bool) -> HRESULT, + fn put_IsScriptNotifyAllowed(&self, value: bool) -> HRESULT, + fn get_IsScriptNotifyAllowed(&self, out: *mut bool) -> HRESULT +}} +impl IWebViewControlSettings { + #[inline] pub fn set_is_java_script_enabled(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_IsJavaScriptEnabled)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_is_java_script_enabled(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_IsJavaScriptEnabled)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_is_indexed_dbenabled(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_IsIndexedDBEnabled)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_is_indexed_dbenabled(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_IsIndexedDBEnabled)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_is_script_notify_allowed(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_IsScriptNotifyAllowed)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_is_script_notify_allowed(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_IsScriptNotifyAllowed)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} +RT_CLASS!{class WebViewControlSettings: IWebViewControlSettings} +DEFINE_IID!(IID_IWebViewControlUnsupportedUriSchemeIdentifiedEventArgs, 3820493124, 58620, 17372, 148, 202, 249, 128, 243, 11, 197, 29); +RT_INTERFACE!{interface IWebViewControlUnsupportedUriSchemeIdentifiedEventArgs(IWebViewControlUnsupportedUriSchemeIdentifiedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IWebViewControlUnsupportedUriSchemeIdentifiedEventArgs] { + fn get_Uri(&self, out: *mut *mut foundation::Uri) -> HRESULT, + fn get_Handled(&self, out: *mut bool) -> HRESULT, + fn put_Handled(&self, value: bool) -> HRESULT +}} +impl IWebViewControlUnsupportedUriSchemeIdentifiedEventArgs { + #[inline] pub fn get_uri(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Uri)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_handled(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Handled)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_handled(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Handled)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class WebViewControlUnsupportedUriSchemeIdentifiedEventArgs: IWebViewControlUnsupportedUriSchemeIdentifiedEventArgs} +DEFINE_IID!(IID_IWebViewControlUnviewableContentIdentifiedEventArgs, 1251377371, 35058, 20000, 182, 147, 180, 226, 223, 74, 165, 129); +RT_INTERFACE!{interface IWebViewControlUnviewableContentIdentifiedEventArgs(IWebViewControlUnviewableContentIdentifiedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IWebViewControlUnviewableContentIdentifiedEventArgs] { + fn get_Uri(&self, out: *mut *mut foundation::Uri) -> HRESULT, + fn get_Referrer(&self, out: *mut *mut foundation::Uri) -> HRESULT, + fn get_MediaType(&self, out: *mut HSTRING) -> HRESULT +}} +impl IWebViewControlUnviewableContentIdentifiedEventArgs { + #[inline] pub fn get_uri(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Uri)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_referrer(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Referrer)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_media_type(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_MediaType)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} +} +RT_CLASS!{class WebViewControlUnviewableContentIdentifiedEventArgs: IWebViewControlUnviewableContentIdentifiedEventArgs} +DEFINE_IID!(IID_IWebViewControlWebResourceRequestedEventArgs, 1154896461, 21924, 19851, 137, 28, 147, 29, 142, 37, 212, 46); +RT_INTERFACE!{interface IWebViewControlWebResourceRequestedEventArgs(IWebViewControlWebResourceRequestedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IWebViewControlWebResourceRequestedEventArgs] { + fn GetDeferral(&self, out: *mut *mut foundation::Deferral) -> HRESULT, + fn get_Request(&self, out: *mut *mut super::http::HttpRequestMessage) -> HRESULT, + fn put_Response(&self, value: *mut super::http::HttpResponseMessage) -> HRESULT, + fn get_Response(&self, out: *mut *mut super::http::HttpResponseMessage) -> HRESULT +}} +impl IWebViewControlWebResourceRequestedEventArgs { + #[inline] pub fn get_deferral(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetDeferral)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn get_request(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Request)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn set_response(&self, value: &super::http::HttpResponseMessage) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Response)(self as *const _ as *mut _, value as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_response(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Response)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} +} +RT_CLASS!{class WebViewControlWebResourceRequestedEventArgs: IWebViewControlWebResourceRequestedEventArgs} +pub mod interop { // Windows.Web.UI.Interop +use ::prelude::*; +RT_CLASS!{class WebViewControl: super::IWebViewControl} +DEFINE_IID!(IID_IWebViewControlAcceleratorKeyPressedEventArgs, 2007147838, 31860, 17277, 162, 144, 58, 192, 216, 205, 86, 85); +RT_INTERFACE!{interface IWebViewControlAcceleratorKeyPressedEventArgs(IWebViewControlAcceleratorKeyPressedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IWebViewControlAcceleratorKeyPressedEventArgs] { + #[cfg(not(feature="windows-ui"))] fn __Dummy0(&self) -> (), + #[cfg(feature="windows-ui")] fn get_EventType(&self, out: *mut ::rt::gen::windows::ui::core::CoreAcceleratorKeyEventType) -> HRESULT, + #[cfg(not(feature="windows-system"))] fn __Dummy1(&self) -> (), + #[cfg(feature="windows-system")] fn get_VirtualKey(&self, out: *mut ::rt::gen::windows::system::VirtualKey) -> HRESULT, + #[cfg(not(feature="windows-ui"))] fn __Dummy2(&self) -> (), + #[cfg(feature="windows-ui")] fn get_KeyStatus(&self, out: *mut ::rt::gen::windows::ui::core::CorePhysicalKeyStatus) -> HRESULT, + fn get_RoutingStage(&self, out: *mut WebViewControlAcceleratorKeyRoutingStage) -> HRESULT, + fn get_Handled(&self, out: *mut bool) -> HRESULT, + fn put_Handled(&self, value: bool) -> HRESULT +}} +impl IWebViewControlAcceleratorKeyPressedEventArgs { + #[cfg(feature="windows-ui")] #[inline] pub fn get_event_type(&self) -> Result<::rt::gen::windows::ui::core::CoreAcceleratorKeyEventType> { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_EventType)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[cfg(feature="windows-system")] #[inline] pub fn get_virtual_key(&self) -> Result<::rt::gen::windows::system::VirtualKey> { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_VirtualKey)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[cfg(feature="windows-ui")] #[inline] pub fn get_key_status(&self) -> Result<::rt::gen::windows::ui::core::CorePhysicalKeyStatus> { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_KeyStatus)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_routing_stage(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_RoutingStage)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_handled(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Handled)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_handled(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Handled)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class WebViewControlAcceleratorKeyPressedEventArgs: IWebViewControlAcceleratorKeyPressedEventArgs} +RT_ENUM! { enum WebViewControlAcceleratorKeyRoutingStage: i32 { + Tunneling (WebViewControlAcceleratorKeyRoutingStage_Tunneling) = 0, Bubbling (WebViewControlAcceleratorKeyRoutingStage_Bubbling) = 1, +}} +RT_ENUM! { enum WebViewControlMoveFocusReason: i32 { + Programmatic (WebViewControlMoveFocusReason_Programmatic) = 0, Next (WebViewControlMoveFocusReason_Next) = 1, Previous (WebViewControlMoveFocusReason_Previous) = 2, +}} +DEFINE_IID!(IID_IWebViewControlMoveFocusRequestedEventArgs, 1797927949, 19408, 16478, 183, 193, 30, 114, 164, 146, 244, 70); +RT_INTERFACE!{interface IWebViewControlMoveFocusRequestedEventArgs(IWebViewControlMoveFocusRequestedEventArgsVtbl): IInspectable(IInspectableVtbl) [IID_IWebViewControlMoveFocusRequestedEventArgs] { + fn get_Reason(&self, out: *mut WebViewControlMoveFocusReason) -> HRESULT +}} +impl IWebViewControlMoveFocusRequestedEventArgs { + #[inline] pub fn get_reason(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Reason)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} +RT_CLASS!{class WebViewControlMoveFocusRequestedEventArgs: IWebViewControlMoveFocusRequestedEventArgs} +DEFINE_IID!(IID_IWebViewControlProcess, 46605292, 39126, 16970, 182, 62, 198, 19, 108, 54, 160, 242); +RT_INTERFACE!{interface IWebViewControlProcess(IWebViewControlProcessVtbl): IInspectable(IInspectableVtbl) [IID_IWebViewControlProcess] { + fn get_ProcessId(&self, out: *mut u32) -> HRESULT, + fn get_EnterpriseId(&self, out: *mut HSTRING) -> HRESULT, + fn get_IsPrivateNetworkClientServerCapabilityEnabled(&self, out: *mut bool) -> HRESULT, + fn CreateWebViewControlAsync(&self, hostWindowHandle: i64, bounds: foundation::Rect, out: *mut *mut foundation::IAsyncOperation) -> HRESULT, + fn GetWebViewControls(&self, out: *mut *mut foundation::collections::IVectorView) -> HRESULT, + fn Terminate(&self) -> HRESULT, + fn add_ProcessExited(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_ProcessExited(&self, token: foundation::EventRegistrationToken) -> HRESULT +}} +impl IWebViewControlProcess { + #[inline] pub fn get_process_id(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_ProcessId)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn get_enterprise_id(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_EnterpriseId)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_is_private_network_client_server_capability_enabled(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_IsPrivateNetworkClientServerCapabilityEnabled)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn create_web_view_control_async(&self, hostWindowHandle: i64, bounds: foundation::Rect) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreateWebViewControlAsync)(self as *const _ as *mut _, hostWindowHandle, bounds, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn get_web_view_controls(&self) -> Result>>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).GetWebViewControls)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn terminate(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).Terminate)(self as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_process_exited(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_ProcessExited)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_process_exited(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_ProcessExited)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +RT_CLASS!{class WebViewControlProcess: IWebViewControlProcess} +impl RtActivatable for WebViewControlProcess {} +impl RtActivatable for WebViewControlProcess {} +impl WebViewControlProcess { + #[inline] pub fn create_with_options(processOptions: &WebViewControlProcessOptions) -> Result> { + >::get_activation_factory().create_with_options(processOptions) + } +} +DEFINE_CLSID!(WebViewControlProcess(&[87,105,110,100,111,119,115,46,87,101,98,46,85,73,46,73,110,116,101,114,111,112,46,87,101,98,86,105,101,119,67,111,110,116,114,111,108,80,114,111,99,101,115,115,0]) [CLSID_WebViewControlProcess]); +RT_ENUM! { enum WebViewControlProcessCapabilityState: i32 { + Default (WebViewControlProcessCapabilityState_Default) = 0, Disabled (WebViewControlProcessCapabilityState_Disabled) = 1, Enabled (WebViewControlProcessCapabilityState_Enabled) = 2, +}} +DEFINE_IID!(IID_IWebViewControlProcessFactory, 1203133689, 41682, 17724, 176, 151, 246, 119, 157, 75, 142, 2); +RT_INTERFACE!{static interface IWebViewControlProcessFactory(IWebViewControlProcessFactoryVtbl): IInspectable(IInspectableVtbl) [IID_IWebViewControlProcessFactory] { + fn CreateWithOptions(&self, processOptions: *mut WebViewControlProcessOptions, out: *mut *mut WebViewControlProcess) -> HRESULT +}} +impl IWebViewControlProcessFactory { + #[inline] pub fn create_with_options(&self, processOptions: &WebViewControlProcessOptions) -> Result> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).CreateWithOptions)(self as *const _ as *mut _, processOptions as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap(out)) } else { err(hr) } + }} +} +DEFINE_IID!(IID_IWebViewControlProcessOptions, 483029671, 15318, 18470, 130, 97, 108, 129, 137, 80, 93, 137); +RT_INTERFACE!{interface IWebViewControlProcessOptions(IWebViewControlProcessOptionsVtbl): IInspectable(IInspectableVtbl) [IID_IWebViewControlProcessOptions] { + fn put_EnterpriseId(&self, value: HSTRING) -> HRESULT, + fn get_EnterpriseId(&self, out: *mut HSTRING) -> HRESULT, + fn put_PrivateNetworkClientServerCapability(&self, value: WebViewControlProcessCapabilityState) -> HRESULT, + fn get_PrivateNetworkClientServerCapability(&self, out: *mut WebViewControlProcessCapabilityState) -> HRESULT +}} +impl IWebViewControlProcessOptions { + #[inline] pub fn set_enterprise_id(&self, value: &HStringArg) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_EnterpriseId)(self as *const _ as *mut _, value.get()); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_enterprise_id(&self) -> Result { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_EnterpriseId)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(HString::wrap(out)) } else { err(hr) } + }} + #[inline] pub fn set_private_network_client_server_capability(&self, value: WebViewControlProcessCapabilityState) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_PrivateNetworkClientServerCapability)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_private_network_client_server_capability(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_PrivateNetworkClientServerCapability)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} +} +RT_CLASS!{class WebViewControlProcessOptions: IWebViewControlProcessOptions} +impl RtActivatable for WebViewControlProcessOptions {} +DEFINE_CLSID!(WebViewControlProcessOptions(&[87,105,110,100,111,119,115,46,87,101,98,46,85,73,46,73,110,116,101,114,111,112,46,87,101,98,86,105,101,119,67,111,110,116,114,111,108,80,114,111,99,101,115,115,79,112,116,105,111,110,115,0]) [CLSID_WebViewControlProcessOptions]); +DEFINE_IID!(IID_IWebViewControlSite, 322914246, 4828, 18584, 189, 71, 4, 150, 125, 230, 72, 186); +RT_INTERFACE!{interface IWebViewControlSite(IWebViewControlSiteVtbl): IInspectable(IInspectableVtbl) [IID_IWebViewControlSite] { + fn get_Process(&self, out: *mut *mut WebViewControlProcess) -> HRESULT, + fn put_Scale(&self, value: f64) -> HRESULT, + fn get_Scale(&self, out: *mut f64) -> HRESULT, + fn put_Bounds(&self, value: foundation::Rect) -> HRESULT, + fn get_Bounds(&self, out: *mut foundation::Rect) -> HRESULT, + fn put_IsVisible(&self, value: bool) -> HRESULT, + fn get_IsVisible(&self, out: *mut bool) -> HRESULT, + fn Close(&self) -> HRESULT, + fn MoveFocus(&self, reason: WebViewControlMoveFocusReason) -> HRESULT, + fn add_MoveFocusRequested(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_MoveFocusRequested(&self, token: foundation::EventRegistrationToken) -> HRESULT, + fn add_AcceleratorKeyPressed(&self, handler: *mut foundation::TypedEventHandler, out: *mut foundation::EventRegistrationToken) -> HRESULT, + fn remove_AcceleratorKeyPressed(&self, token: foundation::EventRegistrationToken) -> HRESULT +}} +impl IWebViewControlSite { + #[inline] pub fn get_process(&self) -> Result>> { unsafe { + let mut out = null_mut(); + let hr = ((*self.lpVtbl).get_Process)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(ComPtr::wrap_optional(out)) } else { err(hr) } + }} + #[inline] pub fn set_scale(&self, value: f64) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Scale)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_scale(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Scale)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_bounds(&self, value: foundation::Rect) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_Bounds)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_bounds(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_Bounds)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn set_is_visible(&self, value: bool) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).put_IsVisible)(self as *const _ as *mut _, value); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn get_is_visible(&self) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).get_IsVisible)(self as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn close(&self) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).Close)(self as *const _ as *mut _); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn move_focus(&self, reason: WebViewControlMoveFocusReason) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).MoveFocus)(self as *const _ as *mut _, reason); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_move_focus_requested(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_MoveFocusRequested)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_move_focus_requested(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_MoveFocusRequested)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} + #[inline] pub fn add_accelerator_key_pressed(&self, handler: &foundation::TypedEventHandler) -> Result { unsafe { + let mut out = zeroed(); + let hr = ((*self.lpVtbl).add_AcceleratorKeyPressed)(self as *const _ as *mut _, handler as *const _ as *mut _, &mut out); + if hr == S_OK { Ok(out) } else { err(hr) } + }} + #[inline] pub fn remove_accelerator_key_pressed(&self, token: foundation::EventRegistrationToken) -> Result<()> { unsafe { + let hr = ((*self.lpVtbl).remove_AcceleratorKeyPressed)(self as *const _ as *mut _, token); + if hr == S_OK { Ok(()) } else { err(hr) } + }} +} +} // Windows.Web.UI.Interop +} // Windows.Web.UI pub mod syndication { // Windows.Web.Syndication use ::prelude::*; RT_STRUCT! { struct RetrievalProgress {