From df77f14be6329c4aebae337df95e7f32d2cda10e Mon Sep 17 00:00:00 2001 From: Kenny Kerr Date: Fri, 14 Feb 2025 08:45:45 -0600 Subject: [PATCH 1/9] windows-async --- crates/libs/async/Cargo.toml | 29 + crates/libs/async/license-apache-2.0 | 201 +++ crates/libs/async/license-mit | 21 + crates/libs/async/readme.md | 7 + crates/libs/async/src/async.rs | 312 ++++ crates/libs/async/src/async_ready.rs | 232 +++ crates/libs/async/src/async_spawn.rs | 352 ++++ crates/libs/async/src/bindings.rs | 2220 ++++++++++++++++++++++++++ crates/libs/async/src/lib.rs | 22 + 9 files changed, 3396 insertions(+) create mode 100644 crates/libs/async/Cargo.toml create mode 100644 crates/libs/async/license-apache-2.0 create mode 100644 crates/libs/async/license-mit create mode 100644 crates/libs/async/readme.md create mode 100644 crates/libs/async/src/async.rs create mode 100644 crates/libs/async/src/async_ready.rs create mode 100644 crates/libs/async/src/async_spawn.rs create mode 100644 crates/libs/async/src/bindings.rs create mode 100644 crates/libs/async/src/lib.rs diff --git a/crates/libs/async/Cargo.toml b/crates/libs/async/Cargo.toml new file mode 100644 index 0000000000..138e51e1cf --- /dev/null +++ b/crates/libs/async/Cargo.toml @@ -0,0 +1,29 @@ +[package] +name = "windows-async" +version = "0.1.0" +edition = "2021" +rust-version = "1.74" +license = "MIT OR Apache-2.0" +description = "Windows async types" +repository = "https://github.com/microsoft/windows-rs" +readme = "readme.md" + +[lints] +workspace = true + +[package.metadata.docs.rs] +default-target = "x86_64-pc-windows-msvc" +targets = [] + +[features] +default = ["std"] +std = [] + +[dependencies.windows-core] +version = "0.59.0" +path = "../core" +default-features = false + +[dependencies.windows-link] +version = "0.1.0" +path = "../link" diff --git a/crates/libs/async/license-apache-2.0 b/crates/libs/async/license-apache-2.0 new file mode 100644 index 0000000000..b5ed4ecec2 --- /dev/null +++ b/crates/libs/async/license-apache-2.0 @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright (c) Microsoft Corporation. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/crates/libs/async/license-mit b/crates/libs/async/license-mit new file mode 100644 index 0000000000..9e841e7a26 --- /dev/null +++ b/crates/libs/async/license-mit @@ -0,0 +1,21 @@ + MIT License + + Copyright (c) Microsoft Corporation. + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in all + copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE diff --git a/crates/libs/async/readme.md b/crates/libs/async/readme.md new file mode 100644 index 0000000000..148e193e15 --- /dev/null +++ b/crates/libs/async/readme.md @@ -0,0 +1,7 @@ +## Windows async types + +The [windows-async](https://crates.io/crates/windows-async) crate provides stock async support for Windows APIs. + +* [Getting started](https://kennykerr.ca/rust-getting-started/) +* [Samples](https://github.com/microsoft/windows-rs/tree/master/crates/samples) +* [Releases](https://github.com/microsoft/windows-rs/releases) diff --git a/crates/libs/async/src/async.rs b/crates/libs/async/src/async.rs new file mode 100644 index 0000000000..4b4edd4fb9 --- /dev/null +++ b/crates/libs/async/src/async.rs @@ -0,0 +1,312 @@ +use super::*; +use std::future::{Future, IntoFuture}; +use std::pin::Pin; +use std::sync::{Arc, Mutex}; +use std::task::{Context, Poll, Waker}; +use windows_core::{imp::Waiter, *}; + +// An `Async` represents a WinRT async execution object or type. There are precisely four such types: +// - IAsyncAction +// - IAsyncActionWithProgress +// - IAsyncOperation +// - IAsyncOperationWithProgress +// +// All four implementations are provided here and there is thus no need to implement this trait. +// This trait provides an abstraction over the relevant differences so that the `AsyncFuture` +// implementation below can be reused for all of them. +pub trait Async: Interface { + // The type of value produced on completion. + type Output: Clone; + + // The type of the delegate use for completion notification. + type CompletedHandler: Interface; + + // Sets the handler or callback to invoke when execution completes. This handler can only be set once. + fn set_completed(&self, handler: F) -> Result<()>; + + // Calls the given handler with the current object and status. + fn invoke_completed(&self, hander: &Self::CompletedHandler, status: AsyncStatus); + + // Returns the value produced on completion. This should only be called when execution completes. + fn get_results(&self) -> Result; +} + +// The `AsyncFuture` is needed to store some extra state needed to keep async execution up to date with possible changes +// to Rust execution context. Each async type implements `IntoFuture` rather than implementing `Future` directly so that +// this adapter may be used. +pub struct AsyncFuture { + // Represents the async execution and provides the virtual methods for setting up a `Completed` handler and + // calling `GetResults` when execution is completed. + inner: A, + + // Provides the `Status` virtual method and saves repeated calls to `QueryInterface` during polling. + status: IAsyncInfo, + + // A shared waker is needed to keep the `Completed` handler updated. + // - `Option` is used to avoid allocations for async objects that have already completed. + // - `Arc` is used to share the `Waker` with the `Completed` handler and potentially replace the `Waker` + // since we don't have the ability to replace the `Completed` handler itself. + // - `Mutex` is used to synchronize replacing the `Waker` across threads. + waker: Option>>, +} + +impl AsyncFuture { + fn new(inner: A) -> Self { + Self { + // All four async interfaces implement `IAsyncInfo` so this `cast` will always succeed. + status: inner.cast().unwrap(), + inner, + waker: None, + } + } +} + +unsafe impl Send for AsyncFuture {} +unsafe impl Sync for AsyncFuture {} +impl Unpin for AsyncFuture {} + +impl Future for AsyncFuture { + type Output = Result; + + fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { + // A status of `Started` just means async execution is still in flight. Since WinRT async is always + // "hot start", if its not `Started` then its ready for us to call `GetResults` so we can skip all of + // the remaining set up. + if self.status.Status()? != AsyncStatus::Started { + return Poll::Ready(self.inner.get_results()); + } + + if let Some(shared_waker) = &self.waker { + // We have a shared waker which means we're either getting polled again or been transfered to + // another execution context. As we can't tell the difference, we need to update the shared waker + // to make sure we've got the "current" waker. + let mut guard = shared_waker.lock().unwrap(); + guard.clone_from(cx.waker()); + + // It may be possible that the `Completed` handler acquired the lock and signaled the old waker + // before we managed to acquire the lock to update it with the current waker. We check the status + // again here just in case this happens. + if self.status.Status()? != AsyncStatus::Started { + return Poll::Ready(self.inner.get_results()); + } + } else { + // If we don't have a saved waker it means this is the first time we're getting polled and should + // create the shared waker and set up a `Completed` handler. + let shared_waker = Arc::new(Mutex::new(cx.waker().clone())); + self.waker = Some(shared_waker.clone()); + + // Note that the handler can only be set once, which is why we need a shared waker in the first + // place. On the other hand, the handler will get called even if async execution has already + // completed, so we can just return `Pending` after setting the Completed handler. + self.inner.set_completed(move || { + shared_waker.lock().unwrap().wake_by_ref(); + })?; + }; + + Poll::Pending + } +} + +// +// The four `Async` trait implementations. +// + +impl Async for IAsyncAction { + type Output = (); + type CompletedHandler = AsyncActionCompletedHandler; + + fn set_completed(&self, handler: F) -> Result<()> { + self.SetCompleted(&AsyncActionCompletedHandler::new(move |_, _| { + handler(); + Ok(()) + })) + } + + fn invoke_completed(&self, handler: &Self::CompletedHandler, status: AsyncStatus) { + _ = handler.Invoke(self, status); + } + + fn get_results(&self) -> Result { + self.GetResults() + } +} + +impl Async for IAsyncOperation { + type Output = T; + type CompletedHandler = AsyncOperationCompletedHandler; + + fn set_completed(&self, handler: F) -> Result<()> { + self.SetCompleted(&AsyncOperationCompletedHandler::new(move |_, _| { + handler(); + Ok(()) + })) + } + + fn invoke_completed(&self, handler: &Self::CompletedHandler, status: AsyncStatus) { + _ = handler.Invoke(self, status); + } + + fn get_results(&self) -> Result { + self.GetResults() + } +} + +impl Async for IAsyncActionWithProgress

{ + type Output = (); + type CompletedHandler = AsyncActionWithProgressCompletedHandler

; + + fn set_completed(&self, handler: F) -> Result<()> { + self.SetCompleted(&AsyncActionWithProgressCompletedHandler::new( + move |_, _| { + handler(); + Ok(()) + }, + )) + } + + fn invoke_completed(&self, handler: &Self::CompletedHandler, status: AsyncStatus) { + _ = handler.Invoke(self, status); + } + + fn get_results(&self) -> Result { + self.GetResults() + } +} + +impl Async for IAsyncOperationWithProgress { + type Output = T; + type CompletedHandler = AsyncOperationWithProgressCompletedHandler; + + fn set_completed(&self, handler: F) -> Result<()> { + self.SetCompleted(&AsyncOperationWithProgressCompletedHandler::new( + move |_, _| { + handler(); + Ok(()) + }, + )) + } + + fn invoke_completed(&self, handler: &Self::CompletedHandler, status: AsyncStatus) { + _ = handler.Invoke(self, status); + } + + fn get_results(&self) -> Result { + self.GetResults() + } +} + +// +// The four `IntoFuture` trait implementations. +// + +impl IntoFuture for IAsyncAction { + type Output = Result<()>; + type IntoFuture = AsyncFuture; + + fn into_future(self) -> Self::IntoFuture { + AsyncFuture::new(self) + } +} + +impl IntoFuture for IAsyncOperation { + type Output = Result; + type IntoFuture = AsyncFuture; + + fn into_future(self) -> Self::IntoFuture { + AsyncFuture::new(self) + } +} + +impl IntoFuture for IAsyncActionWithProgress

{ + type Output = Result<()>; + type IntoFuture = AsyncFuture; + + fn into_future(self) -> Self::IntoFuture { + AsyncFuture::new(self) + } +} + +impl IntoFuture for IAsyncOperationWithProgress { + type Output = Result; + type IntoFuture = AsyncFuture; + + fn into_future(self) -> Self::IntoFuture { + AsyncFuture::new(self) + } +} + +// +// The four `get` implementations for synchronous completion. +// + +impl IAsyncAction { + /// Waits for the `IAsyncAction` to finish. + pub fn get(&self) -> Result<()> { + if self.Status()? == AsyncStatus::Started { + let (_waiter, signaler) = Waiter::new()?; + self.SetCompleted(&AsyncActionCompletedHandler::new(move |_, _| { + // This is safe because the waiter will only be dropped after being signaled. + unsafe { + signaler.signal(); + } + Ok(()) + }))?; + } + self.GetResults() + } +} + +impl IAsyncOperation { + /// Waits for the `IAsyncOperation` to finish. + pub fn get(&self) -> Result { + if self.Status()? == AsyncStatus::Started { + let (_waiter, signaler) = Waiter::new()?; + self.SetCompleted(&AsyncOperationCompletedHandler::new(move |_, _| { + // This is safe because the waiter will only be dropped after being signaled. + unsafe { + signaler.signal(); + } + Ok(()) + }))?; + } + self.GetResults() + } +} + +impl IAsyncActionWithProgress

{ + /// Waits for the `IAsyncActionWithProgress

` to finish. + pub fn get(&self) -> Result<()> { + if self.Status()? == AsyncStatus::Started { + let (_waiter, signaler) = Waiter::new()?; + self.SetCompleted(&AsyncActionWithProgressCompletedHandler::new( + move |_, _| { + // This is safe because the waiter will only be dropped after being signaled. + unsafe { + signaler.signal(); + } + Ok(()) + }, + ))?; + } + self.GetResults() + } +} + +impl IAsyncOperationWithProgress { + /// Waits for the `IAsyncOperationWithProgress` to finish. + pub fn get(&self) -> Result { + if self.Status()? == AsyncStatus::Started { + let (_waiter, signaler) = Waiter::new()?; + self.SetCompleted(&AsyncOperationWithProgressCompletedHandler::new( + move |_, _| { + // This is safe because the waiter will only be dropped after being signaled. + unsafe { + signaler.signal(); + } + Ok(()) + }, + ))?; + } + self.GetResults() + } +} diff --git a/crates/libs/async/src/async_ready.rs b/crates/libs/async/src/async_ready.rs new file mode 100644 index 0000000000..b02836c1bd --- /dev/null +++ b/crates/libs/async/src/async_ready.rs @@ -0,0 +1,232 @@ +use super::*; +use std::sync::atomic::{AtomicBool, Ordering}; +use windows_core::*; + +struct ReadyState { + set_completed: AtomicBool, + result: Result, +} + +impl ReadyState { + fn new(result: Result) -> Self { + Self { + set_completed: AtomicBool::new(false), + result, + } + } + + fn status(&self) -> AsyncStatus { + if self.result.is_ok() { + AsyncStatus::Completed + } else { + AsyncStatus::Error + } + } + + // The "Ready" implementations don't need to store the handler since the handler is invoked immediately + // but still need to confirm that `SetCompleted` is called at most once. + fn invoke_completed(&self, sender: &T, handler: Ref<'_, T::CompletedHandler>) -> Result<()> { + if !self.set_completed.swap(true, Ordering::SeqCst) { + sender.invoke_completed(handler.ok()?, self.status()); + Ok(()) + } else { + Err(Error::from_hresult(HRESULT(0x80000018u32 as i32))) // E_ILLEGAL_DELEGATE_ASSIGNMENT + } + } + + // The `From` implementation is not used here since we don't want to transfer any error object to the calling thread. + // That happens when `GetResults` is called. + fn error_code(&self) -> Result { + Ok(match &self.result { + Ok(_) => HRESULT(0), + Err(error) => error.code(), + }) + } +} + +#[implement(IAsyncAction, IAsyncInfo)] +struct ReadyAction(ReadyState); + +#[implement(IAsyncOperation, IAsyncInfo)] +struct ReadyOperation(ReadyState>) +where + T: RuntimeType + 'static; + +#[implement(IAsyncActionWithProgress

, IAsyncInfo)] +struct ReadyActionWithProgress

(ReadyState>) +where + P: RuntimeType + 'static; + +#[implement(IAsyncOperationWithProgress, IAsyncInfo)] +struct ReadyOperationWithProgress(ReadyState>) +where + T: RuntimeType + 'static, + P: RuntimeType + 'static; + +impl IAsyncInfo_Impl for ReadyAction_Impl { + fn Id(&self) -> Result { + Ok(1) + } + fn Status(&self) -> Result { + Ok(self.0.status()) + } + fn ErrorCode(&self) -> Result { + self.0.error_code() + } + fn Cancel(&self) -> Result<()> { + Ok(()) + } + fn Close(&self) -> Result<()> { + Ok(()) + } +} + +impl IAsyncInfo_Impl for ReadyOperation_Impl { + fn Id(&self) -> Result { + Ok(1) + } + fn Status(&self) -> Result { + Ok(self.0.status()) + } + fn ErrorCode(&self) -> Result { + self.0.error_code() + } + fn Cancel(&self) -> Result<()> { + Ok(()) + } + fn Close(&self) -> Result<()> { + Ok(()) + } +} + +impl IAsyncInfo_Impl for ReadyActionWithProgress_Impl

{ + fn Id(&self) -> Result { + Ok(1) + } + fn Status(&self) -> Result { + Ok(self.0.status()) + } + fn ErrorCode(&self) -> Result { + self.0.error_code() + } + fn Cancel(&self) -> Result<()> { + Ok(()) + } + fn Close(&self) -> Result<()> { + Ok(()) + } +} + +impl IAsyncInfo_Impl for ReadyOperationWithProgress_Impl { + fn Id(&self) -> Result { + Ok(1) + } + fn Status(&self) -> Result { + Ok(self.0.status()) + } + fn ErrorCode(&self) -> Result { + self.0.error_code() + } + fn Cancel(&self) -> Result<()> { + Ok(()) + } + fn Close(&self) -> Result<()> { + Ok(()) + } +} + +impl IAsyncAction_Impl for ReadyAction_Impl { + fn SetCompleted(&self, handler: Ref<'_, AsyncActionCompletedHandler>) -> Result<()> { + self.0.invoke_completed(&self.as_interface(), handler) + } + fn Completed(&self) -> Result { + Err(Error::empty()) + } + fn GetResults(&self) -> Result<()> { + self.0.result.clone() + } +} + +impl IAsyncOperation_Impl for ReadyOperation_Impl { + fn SetCompleted(&self, handler: Ref<'_, AsyncOperationCompletedHandler>) -> Result<()> { + self.0.invoke_completed(&self.as_interface(), handler) + } + fn Completed(&self) -> Result> { + Err(Error::empty()) + } + fn GetResults(&self) -> Result { + self.0.result.clone() + } +} + +impl IAsyncActionWithProgress_Impl

for ReadyActionWithProgress_Impl

{ + fn SetCompleted( + &self, + handler: Ref<'_, AsyncActionWithProgressCompletedHandler

>, + ) -> Result<()> { + self.0.invoke_completed(&self.as_interface(), handler) + } + fn Completed(&self) -> Result> { + Err(Error::empty()) + } + fn GetResults(&self) -> Result<()> { + self.0.result.clone() + } + fn SetProgress(&self, _: Ref<'_, AsyncActionProgressHandler

>) -> Result<()> { + Ok(()) + } + fn Progress(&self) -> Result> { + Err(Error::empty()) + } +} + +impl IAsyncOperationWithProgress_Impl + for ReadyOperationWithProgress_Impl +{ + fn SetCompleted( + &self, + handler: Ref<'_, AsyncOperationWithProgressCompletedHandler>, + ) -> Result<()> { + self.0.invoke_completed(&self.as_interface(), handler) + } + fn Completed(&self) -> Result> { + Err(Error::empty()) + } + fn GetResults(&self) -> Result { + self.0.result.clone() + } + fn SetProgress(&self, _: Ref<'_, AsyncOperationProgressHandler>) -> Result<()> { + Ok(()) + } + fn Progress(&self) -> Result> { + Err(Error::empty()) + } +} + +impl IAsyncAction { + /// Creates an `IAsyncAction` that is immediately ready with a value. + pub fn ready(result: Result<()>) -> Self { + ReadyAction(ReadyState::new(result)).into() + } +} + +impl IAsyncOperation { + /// Creates an `IAsyncOperation` that is immediately ready with a value. + pub fn ready(result: Result) -> Self { + ReadyOperation(ReadyState::new(result)).into() + } +} + +impl IAsyncActionWithProgress

{ + /// Creates an `IAsyncActionWithProgress

` that is immediately ready with a value. + pub fn ready(result: Result<()>) -> Self { + ReadyActionWithProgress(ReadyState::new(result)).into() + } +} + +impl IAsyncOperationWithProgress { + /// Creates an `IAsyncOperationWithProgress` that is immediately ready with a value. + pub fn ready(result: Result) -> Self { + ReadyOperationWithProgress(ReadyState::new(result)).into() + } +} diff --git a/crates/libs/async/src/async_spawn.rs b/crates/libs/async/src/async_spawn.rs new file mode 100644 index 0000000000..3a474bac59 --- /dev/null +++ b/crates/libs/async/src/async_spawn.rs @@ -0,0 +1,352 @@ +use super::*; +use std::ffi::c_void; +use std::sync::Mutex; +use windows_core::*; + +struct State { + result: Option>, + completed: Option, + completed_assigned: bool, +} + +impl State { + fn status(&self) -> AsyncStatus { + match &self.result { + None => AsyncStatus::Started, + Some(Ok(_)) => AsyncStatus::Completed, + Some(Err(_)) => AsyncStatus::Error, + } + } + + fn error_code(&self) -> HRESULT { + match &self.result { + Some(Err(error)) => error.code(), + _ => HRESULT(0), + } + } + + fn get_results(&self) -> Result { + match &self.result { + Some(result) => result.clone(), + None => Err(Error::from_hresult(HRESULT(0x8000000Eu32 as i32))), // E_ILLEGAL_METHOD_CALL + } + } +} + +struct SyncState(Mutex>); + +impl SyncState { + fn new() -> Self { + Self(Mutex::new(State { + result: None, + completed: None, + completed_assigned: false, + })) + } + + fn status(&self) -> AsyncStatus { + self.0.lock().unwrap().status() + } + + fn error_code(&self) -> HRESULT { + self.0.lock().unwrap().error_code() + } + + fn get_results(&self) -> Result { + self.0.lock().unwrap().get_results() + } + + fn set_completed(&self, sender: &T, handler: Ref<'_, T::CompletedHandler>) -> Result<()> { + let mut guard = self.0.lock().unwrap(); + + if guard.completed_assigned { + Err(Error::from_hresult(HRESULT(0x80000018u32 as i32))) // E_ILLEGAL_DELEGATE_ASSIGNMENT + } else { + guard.completed_assigned = true; + let status = guard.status(); + let handler = handler.ok()?; + + if status == AsyncStatus::Started { + guard.completed = Some(handler.clone()); + } else { + drop(guard); + sender.invoke_completed(handler, status); + } + + Ok(()) + } + } + + fn spawn(&self, sender: &T, f: F) + where + F: FnOnce() -> Result + Send + 'static, + { + let result = f(); + let mut guard = self.0.lock().unwrap(); + debug_assert!(guard.result.is_none()); + guard.result = Some(result); + let status = guard.status(); + let completed = guard.completed.take(); + + drop(guard); + + if let Some(completed) = completed { + sender.invoke_completed(&completed, status); + } + } +} + +unsafe impl Send for SyncState {} + +#[implement(IAsyncAction, IAsyncInfo)] +struct Action(SyncState); + +#[implement(IAsyncOperation, IAsyncInfo)] +struct Operation(SyncState>) +where + T: RuntimeType + 'static; + +#[implement(IAsyncActionWithProgress

, IAsyncInfo)] +struct ActionWithProgress

(SyncState>) +where + P: RuntimeType + 'static; + +#[implement(IAsyncOperationWithProgress, IAsyncInfo)] +struct OperationWithProgress(SyncState>) +where + T: RuntimeType + 'static, + P: RuntimeType + 'static; + +impl IAsyncInfo_Impl for Action_Impl { + fn Id(&self) -> Result { + Ok(1) + } + fn Status(&self) -> Result { + Ok(self.0.status()) + } + fn ErrorCode(&self) -> Result { + Ok(self.0.error_code()) + } + fn Cancel(&self) -> Result<()> { + Ok(()) + } + fn Close(&self) -> Result<()> { + Ok(()) + } +} + +impl IAsyncInfo_Impl for Operation_Impl { + fn Id(&self) -> Result { + Ok(1) + } + fn Status(&self) -> Result { + Ok(self.0.status()) + } + fn ErrorCode(&self) -> Result { + Ok(self.0.error_code()) + } + fn Cancel(&self) -> Result<()> { + Ok(()) + } + fn Close(&self) -> Result<()> { + Ok(()) + } +} + +impl IAsyncInfo_Impl for ActionWithProgress_Impl

{ + fn Id(&self) -> Result { + Ok(1) + } + fn Status(&self) -> Result { + Ok(self.0.status()) + } + fn ErrorCode(&self) -> Result { + Ok(self.0.error_code()) + } + fn Cancel(&self) -> Result<()> { + Ok(()) + } + fn Close(&self) -> Result<()> { + Ok(()) + } +} + +impl IAsyncInfo_Impl for OperationWithProgress_Impl { + fn Id(&self) -> Result { + Ok(1) + } + fn Status(&self) -> Result { + Ok(self.0.status()) + } + fn ErrorCode(&self) -> Result { + Ok(self.0.error_code()) + } + fn Cancel(&self) -> Result<()> { + Ok(()) + } + fn Close(&self) -> Result<()> { + Ok(()) + } +} + +impl IAsyncAction_Impl for Action_Impl { + fn SetCompleted(&self, handler: Ref<'_, AsyncActionCompletedHandler>) -> Result<()> { + self.0.set_completed(&self.as_interface(), handler) + } + fn Completed(&self) -> Result { + Err(Error::empty()) + } + fn GetResults(&self) -> Result<()> { + self.0.get_results() + } +} + +impl IAsyncOperation_Impl for Operation_Impl { + fn SetCompleted(&self, handler: Ref<'_, AsyncOperationCompletedHandler>) -> Result<()> { + self.0.set_completed(&self.as_interface(), handler) + } + fn Completed(&self) -> Result> { + Err(Error::empty()) + } + fn GetResults(&self) -> Result { + self.0.get_results() + } +} + +impl IAsyncActionWithProgress_Impl

for ActionWithProgress_Impl

{ + fn SetCompleted( + &self, + handler: Ref<'_, AsyncActionWithProgressCompletedHandler

>, + ) -> Result<()> { + self.0.set_completed(&self.as_interface(), handler) + } + fn Completed(&self) -> Result> { + Err(Error::empty()) + } + fn GetResults(&self) -> Result<()> { + self.0.get_results() + } + fn SetProgress(&self, _: Ref<'_, AsyncActionProgressHandler

>) -> Result<()> { + Ok(()) + } + fn Progress(&self) -> Result> { + Err(Error::empty()) + } +} + +impl IAsyncOperationWithProgress_Impl + for OperationWithProgress_Impl +{ + fn SetCompleted( + &self, + handler: Ref<'_, AsyncOperationWithProgressCompletedHandler>, + ) -> Result<()> { + self.0.set_completed(&self.as_interface(), handler) + } + fn Completed(&self) -> Result> { + Err(Error::empty()) + } + fn GetResults(&self) -> Result { + self.0.get_results() + } + fn SetProgress(&self, _: Ref<'_, AsyncOperationProgressHandler>) -> Result<()> { + Ok(()) + } + fn Progress(&self) -> Result> { + Err(Error::empty()) + } +} + +impl IAsyncAction { + /// Creates an `IAsyncAction` that waits for the closure to execute on the Windows thread pool. + pub fn spawn(f: F) -> Self + where + F: FnOnce() -> Result<()> + Send + 'static, + { + let object = ComObject::new(Action(SyncState::new())); + let interface = object.to_interface(); + + spawn(move || { + object.0.spawn(&object.as_interface(), f); + }); + + interface + } +} + +impl IAsyncOperation { + /// Creates an `IAsyncOperation` that waits for the closure to execute on the Windows thread pool. + pub fn spawn(f: F) -> Self + where + F: FnOnce() -> Result + Send + 'static, + { + let object = ComObject::new(Operation(SyncState::new())); + let interface = object.to_interface(); + + spawn(move || { + object.0.spawn(&object.as_interface(), f); + }); + + interface + } +} + +impl IAsyncActionWithProgress

{ + /// Creates an `IAsyncActionWithProgress

` that waits for the closure to execute on the Windows thread pool. + pub fn spawn(f: F) -> Self + where + F: FnOnce() -> Result<()> + Send + 'static, + { + let object = ComObject::new(ActionWithProgress(SyncState::new())); + let interface = object.to_interface(); + + spawn(move || { + object.0.spawn(&object.as_interface(), f); + }); + + interface + } +} + +impl IAsyncOperationWithProgress { + /// Creates an `IAsyncOperationWithProgress` that waits for the closure to execute on the Windows thread pool. + pub fn spawn(f: F) -> Self + where + F: FnOnce() -> Result + Send + 'static, + { + let object = ComObject::new(OperationWithProgress(SyncState::new())); + let interface = object.to_interface(); + + spawn(move || { + object.0.spawn(&object.as_interface(), f); + }); + + interface + } +} + +fn spawn(f: F) { + type PTP_SIMPLE_CALLBACK = + unsafe extern "system" fn(instance: *const c_void, context: *const c_void); + windows_link::link!("kernel32.dll" "system" fn TrySubmitThreadpoolCallback(callback: PTP_SIMPLE_CALLBACK, context: *const c_void, environment: *const c_void) -> i32); + + unsafe extern "system" fn callback( + _: *const c_void, + callback: *const c_void, + ) { + unsafe { + Box::from_raw(callback as *mut F)(); + } + } + + unsafe { + if TrySubmitThreadpoolCallback( + callback::, + Box::into_raw(Box::new(f)) as _, + core::ptr::null(), + ) == 0 + { + panic!("allocation failed"); + } + } +} diff --git a/crates/libs/async/src/bindings.rs b/crates/libs/async/src/bindings.rs new file mode 100644 index 0000000000..d5f9631119 --- /dev/null +++ b/crates/libs/async/src/bindings.rs @@ -0,0 +1,2220 @@ +windows_core::imp::define_interface!( + AsyncActionCompletedHandler, + AsyncActionCompletedHandler_Vtbl, + 0xa4ed5c81_76c9_40bd_8be6_b1d90fb20ae7 +); +impl windows_core::RuntimeType for AsyncActionCompletedHandler { + const SIGNATURE: windows_core::imp::ConstBuffer = + windows_core::imp::ConstBuffer::for_interface::(); +} +impl AsyncActionCompletedHandler { + pub fn new< + F: FnMut(windows_core::Ref<'_, IAsyncAction>, AsyncStatus) -> windows_core::Result<()> + + Send + + 'static, + >( + invoke: F, + ) -> Self { + let com = AsyncActionCompletedHandlerBox { + vtable: &AsyncActionCompletedHandlerBox::::VTABLE, + count: windows_core::imp::RefCount::new(1), + invoke, + }; + unsafe { core::mem::transmute(windows_core::imp::Box::new(com)) } + } + pub fn Invoke(&self, asyncinfo: P0, asyncstatus: AsyncStatus) -> windows_core::Result<()> + where + P0: windows_core::Param, + { + let this = self; + unsafe { + (windows_core::Interface::vtable(this).Invoke)( + windows_core::Interface::as_raw(this), + asyncinfo.param().abi(), + asyncstatus, + ) + .ok() + } + } +} +#[repr(C)] +pub struct AsyncActionCompletedHandler_Vtbl { + base__: windows_core::IUnknown_Vtbl, + Invoke: unsafe extern "system" fn( + this: *mut core::ffi::c_void, + asyncinfo: *mut core::ffi::c_void, + asyncstatus: AsyncStatus, + ) -> windows_core::HRESULT, +} +#[repr(C)] +struct AsyncActionCompletedHandlerBox< + F: FnMut(windows_core::Ref<'_, IAsyncAction>, AsyncStatus) -> windows_core::Result<()> + + Send + + 'static, +> { + vtable: *const AsyncActionCompletedHandler_Vtbl, + invoke: F, + count: windows_core::imp::RefCount, +} +impl< + F: FnMut(windows_core::Ref<'_, IAsyncAction>, AsyncStatus) -> windows_core::Result<()> + + Send + + 'static, + > AsyncActionCompletedHandlerBox +{ + const VTABLE: AsyncActionCompletedHandler_Vtbl = AsyncActionCompletedHandler_Vtbl { + base__: windows_core::IUnknown_Vtbl { + QueryInterface: Self::QueryInterface, + AddRef: Self::AddRef, + Release: Self::Release, + }, + Invoke: Self::Invoke, + }; + unsafe extern "system" fn QueryInterface( + this: *mut core::ffi::c_void, + iid: *const windows_core::GUID, + interface: *mut *mut core::ffi::c_void, + ) -> windows_core::HRESULT { + unsafe { + let this = this as *mut *mut core::ffi::c_void as *mut Self; + if iid.is_null() || interface.is_null() { + return windows_core::HRESULT(-2147467261); + } + *interface = if *iid == ::IID + || *iid == ::IID + || *iid == ::IID + { + &mut (*this).vtable as *mut _ as _ + } else { + core::ptr::null_mut() + }; + if (*interface).is_null() { + windows_core::HRESULT(-2147467262) + } else { + (*this).count.add_ref(); + windows_core::HRESULT(0) + } + } + } + unsafe extern "system" fn AddRef(this: *mut core::ffi::c_void) -> u32 { + unsafe { + let this = this as *mut *mut core::ffi::c_void as *mut Self; + (*this).count.add_ref() + } + } + unsafe extern "system" fn Release(this: *mut core::ffi::c_void) -> u32 { + unsafe { + let this = this as *mut *mut core::ffi::c_void as *mut Self; + let remaining = (*this).count.release(); + if remaining == 0 { + let _ = windows_core::imp::Box::from_raw(this); + } + remaining + } + } + unsafe extern "system" fn Invoke( + this: *mut core::ffi::c_void, + asyncinfo: *mut core::ffi::c_void, + asyncstatus: AsyncStatus, + ) -> windows_core::HRESULT { + unsafe { + let this = &mut *(this as *mut *mut core::ffi::c_void as *mut Self); + (this.invoke)(core::mem::transmute_copy(&asyncinfo), asyncstatus).into() + } + } +} +#[repr(transparent)] +#[derive(Clone, Debug, Eq, PartialEq)] +pub struct AsyncActionProgressHandler( + windows_core::IUnknown, + core::marker::PhantomData, +) +where + TProgress: windows_core::RuntimeType + 'static; +unsafe impl windows_core::Interface + for AsyncActionProgressHandler +{ + type Vtable = AsyncActionProgressHandler_Vtbl; + const IID: windows_core::GUID = + windows_core::GUID::from_signature(::SIGNATURE); +} +impl windows_core::RuntimeType + for AsyncActionProgressHandler +{ + const SIGNATURE: windows_core::imp::ConstBuffer = windows_core::imp::ConstBuffer::new() + .push_slice(b"pinterface({6d844858-0cff-4590-ae89-95a5a5c8b4b8}") + .push_slice(b";") + .push_other(TProgress::SIGNATURE) + .push_slice(b")"); +} +impl AsyncActionProgressHandler { + pub fn new< + F: FnMut( + windows_core::Ref<'_, IAsyncActionWithProgress>, + windows_core::Ref<'_, TProgress>, + ) -> windows_core::Result<()> + + Send + + 'static, + >( + invoke: F, + ) -> Self { + let com = AsyncActionProgressHandlerBox { + vtable: &AsyncActionProgressHandlerBox::::VTABLE, + count: windows_core::imp::RefCount::new(1), + invoke, + }; + unsafe { core::mem::transmute(windows_core::imp::Box::new(com)) } + } + pub fn Invoke(&self, asyncinfo: P0, progressinfo: P1) -> windows_core::Result<()> + where + P0: windows_core::Param>, + P1: windows_core::Param, + { + let this = self; + unsafe { + (windows_core::Interface::vtable(this).Invoke)( + windows_core::Interface::as_raw(this), + asyncinfo.param().abi(), + progressinfo.param().abi(), + ) + .ok() + } + } +} +#[repr(C)] +pub struct AsyncActionProgressHandler_Vtbl +where + TProgress: windows_core::RuntimeType + 'static, +{ + base__: windows_core::IUnknown_Vtbl, + Invoke: unsafe extern "system" fn( + this: *mut core::ffi::c_void, + asyncinfo: *mut core::ffi::c_void, + progressinfo: windows_core::AbiType, + ) -> windows_core::HRESULT, + TProgress: core::marker::PhantomData, +} +#[repr(C)] +struct AsyncActionProgressHandlerBox< + TProgress, + F: FnMut( + windows_core::Ref<'_, IAsyncActionWithProgress>, + windows_core::Ref<'_, TProgress>, + ) -> windows_core::Result<()> + + Send + + 'static, +> where + TProgress: windows_core::RuntimeType + 'static, +{ + vtable: *const AsyncActionProgressHandler_Vtbl, + invoke: F, + count: windows_core::imp::RefCount, +} +impl< + TProgress: windows_core::RuntimeType + 'static, + F: FnMut( + windows_core::Ref<'_, IAsyncActionWithProgress>, + windows_core::Ref<'_, TProgress>, + ) -> windows_core::Result<()> + + Send + + 'static, + > AsyncActionProgressHandlerBox +{ + const VTABLE: AsyncActionProgressHandler_Vtbl = + AsyncActionProgressHandler_Vtbl:: { + base__: windows_core::IUnknown_Vtbl { + QueryInterface: Self::QueryInterface, + AddRef: Self::AddRef, + Release: Self::Release, + }, + Invoke: Self::Invoke, + TProgress: core::marker::PhantomData::, + }; + unsafe extern "system" fn QueryInterface( + this: *mut core::ffi::c_void, + iid: *const windows_core::GUID, + interface: *mut *mut core::ffi::c_void, + ) -> windows_core::HRESULT { + unsafe { + let this = this as *mut *mut core::ffi::c_void as *mut Self; + if iid.is_null() || interface.is_null() { + return windows_core::HRESULT(-2147467261); + } + *interface = if *iid + == as windows_core::Interface>::IID + || *iid == ::IID + || *iid == ::IID + { + &mut (*this).vtable as *mut _ as _ + } else { + core::ptr::null_mut() + }; + if (*interface).is_null() { + windows_core::HRESULT(-2147467262) + } else { + (*this).count.add_ref(); + windows_core::HRESULT(0) + } + } + } + unsafe extern "system" fn AddRef(this: *mut core::ffi::c_void) -> u32 { + unsafe { + let this = this as *mut *mut core::ffi::c_void as *mut Self; + (*this).count.add_ref() + } + } + unsafe extern "system" fn Release(this: *mut core::ffi::c_void) -> u32 { + unsafe { + let this = this as *mut *mut core::ffi::c_void as *mut Self; + let remaining = (*this).count.release(); + if remaining == 0 { + let _ = windows_core::imp::Box::from_raw(this); + } + remaining + } + } + unsafe extern "system" fn Invoke( + this: *mut core::ffi::c_void, + asyncinfo: *mut core::ffi::c_void, + progressinfo: windows_core::AbiType, + ) -> windows_core::HRESULT { + unsafe { + let this = &mut *(this as *mut *mut core::ffi::c_void as *mut Self); + (this.invoke)( + core::mem::transmute_copy(&asyncinfo), + core::mem::transmute_copy(&progressinfo), + ) + .into() + } + } +} +#[repr(transparent)] +#[derive(Clone, Debug, Eq, PartialEq)] +pub struct AsyncActionWithProgressCompletedHandler( + windows_core::IUnknown, + core::marker::PhantomData, +) +where + TProgress: windows_core::RuntimeType + 'static; +unsafe impl windows_core::Interface + for AsyncActionWithProgressCompletedHandler +{ + type Vtable = AsyncActionWithProgressCompletedHandler_Vtbl; + const IID: windows_core::GUID = + windows_core::GUID::from_signature(::SIGNATURE); +} +impl windows_core::RuntimeType + for AsyncActionWithProgressCompletedHandler +{ + const SIGNATURE: windows_core::imp::ConstBuffer = windows_core::imp::ConstBuffer::new() + .push_slice(b"pinterface({9c029f91-cc84-44fd-ac26-0a6c4e555281}") + .push_slice(b";") + .push_other(TProgress::SIGNATURE) + .push_slice(b")"); +} +impl + AsyncActionWithProgressCompletedHandler +{ + pub fn new< + F: FnMut( + windows_core::Ref<'_, IAsyncActionWithProgress>, + AsyncStatus, + ) -> windows_core::Result<()> + + Send + + 'static, + >( + invoke: F, + ) -> Self { + let com = AsyncActionWithProgressCompletedHandlerBox { + vtable: &AsyncActionWithProgressCompletedHandlerBox::::VTABLE, + count: windows_core::imp::RefCount::new(1), + invoke, + }; + unsafe { core::mem::transmute(windows_core::imp::Box::new(com)) } + } + pub fn Invoke(&self, asyncinfo: P0, asyncstatus: AsyncStatus) -> windows_core::Result<()> + where + P0: windows_core::Param>, + { + let this = self; + unsafe { + (windows_core::Interface::vtable(this).Invoke)( + windows_core::Interface::as_raw(this), + asyncinfo.param().abi(), + asyncstatus, + ) + .ok() + } + } +} +#[repr(C)] +pub struct AsyncActionWithProgressCompletedHandler_Vtbl +where + TProgress: windows_core::RuntimeType + 'static, +{ + base__: windows_core::IUnknown_Vtbl, + Invoke: unsafe extern "system" fn( + this: *mut core::ffi::c_void, + asyncinfo: *mut core::ffi::c_void, + asyncstatus: AsyncStatus, + ) -> windows_core::HRESULT, + TProgress: core::marker::PhantomData, +} +#[repr(C)] +struct AsyncActionWithProgressCompletedHandlerBox< + TProgress, + F: FnMut( + windows_core::Ref<'_, IAsyncActionWithProgress>, + AsyncStatus, + ) -> windows_core::Result<()> + + Send + + 'static, +> where + TProgress: windows_core::RuntimeType + 'static, +{ + vtable: *const AsyncActionWithProgressCompletedHandler_Vtbl, + invoke: F, + count: windows_core::imp::RefCount, +} +impl< + TProgress: windows_core::RuntimeType + 'static, + F: FnMut( + windows_core::Ref<'_, IAsyncActionWithProgress>, + AsyncStatus, + ) -> windows_core::Result<()> + + Send + + 'static, + > AsyncActionWithProgressCompletedHandlerBox +{ + const VTABLE: AsyncActionWithProgressCompletedHandler_Vtbl = + AsyncActionWithProgressCompletedHandler_Vtbl:: { + base__: windows_core::IUnknown_Vtbl { + QueryInterface: Self::QueryInterface, + AddRef: Self::AddRef, + Release: Self::Release, + }, + Invoke: Self::Invoke, + TProgress: core::marker::PhantomData::, + }; + unsafe extern "system" fn QueryInterface( + this: *mut core::ffi::c_void, + iid: *const windows_core::GUID, + interface: *mut *mut core::ffi::c_void, + ) -> windows_core::HRESULT { + unsafe { + let this = this as *mut *mut core::ffi::c_void as *mut Self; + if iid.is_null() || interface.is_null() { + return windows_core::HRESULT(-2147467261); + } + * interface = if * iid == < AsyncActionWithProgressCompletedHandler < TProgress > as windows_core::Interface >::IID || * iid == < windows_core::IUnknown as windows_core::Interface >::IID || * iid == < windows_core::imp::IAgileObject as windows_core::Interface >::IID { & mut ( * this ) . vtable as * mut _ as _ } else { core::ptr::null_mut ( ) } ; + if (*interface).is_null() { + windows_core::HRESULT(-2147467262) + } else { + (*this).count.add_ref(); + windows_core::HRESULT(0) + } + } + } + unsafe extern "system" fn AddRef(this: *mut core::ffi::c_void) -> u32 { + unsafe { + let this = this as *mut *mut core::ffi::c_void as *mut Self; + (*this).count.add_ref() + } + } + unsafe extern "system" fn Release(this: *mut core::ffi::c_void) -> u32 { + unsafe { + let this = this as *mut *mut core::ffi::c_void as *mut Self; + let remaining = (*this).count.release(); + if remaining == 0 { + let _ = windows_core::imp::Box::from_raw(this); + } + remaining + } + } + unsafe extern "system" fn Invoke( + this: *mut core::ffi::c_void, + asyncinfo: *mut core::ffi::c_void, + asyncstatus: AsyncStatus, + ) -> windows_core::HRESULT { + unsafe { + let this = &mut *(this as *mut *mut core::ffi::c_void as *mut Self); + (this.invoke)(core::mem::transmute_copy(&asyncinfo), asyncstatus).into() + } + } +} +#[repr(transparent)] +#[derive(Clone, Debug, Eq, PartialEq)] +pub struct AsyncOperationCompletedHandler( + windows_core::IUnknown, + core::marker::PhantomData, +) +where + TResult: windows_core::RuntimeType + 'static; +unsafe impl windows_core::Interface + for AsyncOperationCompletedHandler +{ + type Vtable = AsyncOperationCompletedHandler_Vtbl; + const IID: windows_core::GUID = + windows_core::GUID::from_signature(::SIGNATURE); +} +impl windows_core::RuntimeType + for AsyncOperationCompletedHandler +{ + const SIGNATURE: windows_core::imp::ConstBuffer = windows_core::imp::ConstBuffer::new() + .push_slice(b"pinterface({fcdcf02c-e5d8-4478-915a-4d90b74b83a5}") + .push_slice(b";") + .push_other(TResult::SIGNATURE) + .push_slice(b")"); +} +impl AsyncOperationCompletedHandler { + pub fn new< + F: FnMut( + windows_core::Ref<'_, IAsyncOperation>, + AsyncStatus, + ) -> windows_core::Result<()> + + Send + + 'static, + >( + invoke: F, + ) -> Self { + let com = AsyncOperationCompletedHandlerBox { + vtable: &AsyncOperationCompletedHandlerBox::::VTABLE, + count: windows_core::imp::RefCount::new(1), + invoke, + }; + unsafe { core::mem::transmute(windows_core::imp::Box::new(com)) } + } + pub fn Invoke(&self, asyncinfo: P0, asyncstatus: AsyncStatus) -> windows_core::Result<()> + where + P0: windows_core::Param>, + { + let this = self; + unsafe { + (windows_core::Interface::vtable(this).Invoke)( + windows_core::Interface::as_raw(this), + asyncinfo.param().abi(), + asyncstatus, + ) + .ok() + } + } +} +#[repr(C)] +pub struct AsyncOperationCompletedHandler_Vtbl +where + TResult: windows_core::RuntimeType + 'static, +{ + base__: windows_core::IUnknown_Vtbl, + Invoke: unsafe extern "system" fn( + this: *mut core::ffi::c_void, + asyncinfo: *mut core::ffi::c_void, + asyncstatus: AsyncStatus, + ) -> windows_core::HRESULT, + TResult: core::marker::PhantomData, +} +#[repr(C)] +struct AsyncOperationCompletedHandlerBox< + TResult, + F: FnMut( + windows_core::Ref<'_, IAsyncOperation>, + AsyncStatus, + ) -> windows_core::Result<()> + + Send + + 'static, +> where + TResult: windows_core::RuntimeType + 'static, +{ + vtable: *const AsyncOperationCompletedHandler_Vtbl, + invoke: F, + count: windows_core::imp::RefCount, +} +impl< + TResult: windows_core::RuntimeType + 'static, + F: FnMut( + windows_core::Ref<'_, IAsyncOperation>, + AsyncStatus, + ) -> windows_core::Result<()> + + Send + + 'static, + > AsyncOperationCompletedHandlerBox +{ + const VTABLE: AsyncOperationCompletedHandler_Vtbl = + AsyncOperationCompletedHandler_Vtbl:: { + base__: windows_core::IUnknown_Vtbl { + QueryInterface: Self::QueryInterface, + AddRef: Self::AddRef, + Release: Self::Release, + }, + Invoke: Self::Invoke, + TResult: core::marker::PhantomData::, + }; + unsafe extern "system" fn QueryInterface( + this: *mut core::ffi::c_void, + iid: *const windows_core::GUID, + interface: *mut *mut core::ffi::c_void, + ) -> windows_core::HRESULT { + unsafe { + let this = this as *mut *mut core::ffi::c_void as *mut Self; + if iid.is_null() || interface.is_null() { + return windows_core::HRESULT(-2147467261); + } + *interface = if *iid + == as windows_core::Interface>::IID + || *iid == ::IID + || *iid == ::IID + { + &mut (*this).vtable as *mut _ as _ + } else { + core::ptr::null_mut() + }; + if (*interface).is_null() { + windows_core::HRESULT(-2147467262) + } else { + (*this).count.add_ref(); + windows_core::HRESULT(0) + } + } + } + unsafe extern "system" fn AddRef(this: *mut core::ffi::c_void) -> u32 { + unsafe { + let this = this as *mut *mut core::ffi::c_void as *mut Self; + (*this).count.add_ref() + } + } + unsafe extern "system" fn Release(this: *mut core::ffi::c_void) -> u32 { + unsafe { + let this = this as *mut *mut core::ffi::c_void as *mut Self; + let remaining = (*this).count.release(); + if remaining == 0 { + let _ = windows_core::imp::Box::from_raw(this); + } + remaining + } + } + unsafe extern "system" fn Invoke( + this: *mut core::ffi::c_void, + asyncinfo: *mut core::ffi::c_void, + asyncstatus: AsyncStatus, + ) -> windows_core::HRESULT { + unsafe { + let this = &mut *(this as *mut *mut core::ffi::c_void as *mut Self); + (this.invoke)(core::mem::transmute_copy(&asyncinfo), asyncstatus).into() + } + } +} +#[repr(transparent)] +#[derive(Clone, Debug, Eq, PartialEq)] +pub struct AsyncOperationProgressHandler( + windows_core::IUnknown, + core::marker::PhantomData, + core::marker::PhantomData, +) +where + TResult: windows_core::RuntimeType + 'static, + TProgress: windows_core::RuntimeType + 'static; +unsafe impl< + TResult: windows_core::RuntimeType + 'static, + TProgress: windows_core::RuntimeType + 'static, + > windows_core::Interface for AsyncOperationProgressHandler +{ + type Vtable = AsyncOperationProgressHandler_Vtbl; + const IID: windows_core::GUID = + windows_core::GUID::from_signature(::SIGNATURE); +} +impl< + TResult: windows_core::RuntimeType + 'static, + TProgress: windows_core::RuntimeType + 'static, + > windows_core::RuntimeType for AsyncOperationProgressHandler +{ + const SIGNATURE: windows_core::imp::ConstBuffer = windows_core::imp::ConstBuffer::new() + .push_slice(b"pinterface({55690902-0aab-421a-8778-f8ce5026d758}") + .push_slice(b";") + .push_other(TResult::SIGNATURE) + .push_slice(b";") + .push_other(TProgress::SIGNATURE) + .push_slice(b")"); +} +impl< + TResult: windows_core::RuntimeType + 'static, + TProgress: windows_core::RuntimeType + 'static, + > AsyncOperationProgressHandler +{ + pub fn new< + F: FnMut( + windows_core::Ref<'_, IAsyncOperationWithProgress>, + windows_core::Ref<'_, TProgress>, + ) -> windows_core::Result<()> + + Send + + 'static, + >( + invoke: F, + ) -> Self { + let com = AsyncOperationProgressHandlerBox { + vtable: &AsyncOperationProgressHandlerBox::::VTABLE, + count: windows_core::imp::RefCount::new(1), + invoke, + }; + unsafe { core::mem::transmute(windows_core::imp::Box::new(com)) } + } + pub fn Invoke(&self, asyncinfo: P0, progressinfo: P1) -> windows_core::Result<()> + where + P0: windows_core::Param>, + P1: windows_core::Param, + { + let this = self; + unsafe { + (windows_core::Interface::vtable(this).Invoke)( + windows_core::Interface::as_raw(this), + asyncinfo.param().abi(), + progressinfo.param().abi(), + ) + .ok() + } + } +} +#[repr(C)] +pub struct AsyncOperationProgressHandler_Vtbl +where + TResult: windows_core::RuntimeType + 'static, + TProgress: windows_core::RuntimeType + 'static, +{ + base__: windows_core::IUnknown_Vtbl, + Invoke: unsafe extern "system" fn( + this: *mut core::ffi::c_void, + asyncinfo: *mut core::ffi::c_void, + progressinfo: windows_core::AbiType, + ) -> windows_core::HRESULT, + TResult: core::marker::PhantomData, + TProgress: core::marker::PhantomData, +} +#[repr(C)] +struct AsyncOperationProgressHandlerBox< + TResult, + TProgress, + F: FnMut( + windows_core::Ref<'_, IAsyncOperationWithProgress>, + windows_core::Ref<'_, TProgress>, + ) -> windows_core::Result<()> + + Send + + 'static, +> where + TResult: windows_core::RuntimeType + 'static, + TProgress: windows_core::RuntimeType + 'static, +{ + vtable: *const AsyncOperationProgressHandler_Vtbl, + invoke: F, + count: windows_core::imp::RefCount, +} +impl< + TResult: windows_core::RuntimeType + 'static, + TProgress: windows_core::RuntimeType + 'static, + F: FnMut( + windows_core::Ref<'_, IAsyncOperationWithProgress>, + windows_core::Ref<'_, TProgress>, + ) -> windows_core::Result<()> + + Send + + 'static, + > AsyncOperationProgressHandlerBox +{ + const VTABLE: AsyncOperationProgressHandler_Vtbl = + AsyncOperationProgressHandler_Vtbl:: { + base__: windows_core::IUnknown_Vtbl { + QueryInterface: Self::QueryInterface, + AddRef: Self::AddRef, + Release: Self::Release, + }, + Invoke: Self::Invoke, + TResult: core::marker::PhantomData::, + TProgress: core::marker::PhantomData::, + }; + unsafe extern "system" fn QueryInterface( + this: *mut core::ffi::c_void, + iid: *const windows_core::GUID, + interface: *mut *mut core::ffi::c_void, + ) -> windows_core::HRESULT { + unsafe { + let this = this as *mut *mut core::ffi::c_void as *mut Self; + if iid.is_null() || interface.is_null() { + return windows_core::HRESULT(-2147467261); + } + * interface = if * iid == < AsyncOperationProgressHandler < TResult , TProgress > as windows_core::Interface >::IID || * iid == < windows_core::IUnknown as windows_core::Interface >::IID || * iid == < windows_core::imp::IAgileObject as windows_core::Interface >::IID { & mut ( * this ) . vtable as * mut _ as _ } else { core::ptr::null_mut ( ) } ; + if (*interface).is_null() { + windows_core::HRESULT(-2147467262) + } else { + (*this).count.add_ref(); + windows_core::HRESULT(0) + } + } + } + unsafe extern "system" fn AddRef(this: *mut core::ffi::c_void) -> u32 { + unsafe { + let this = this as *mut *mut core::ffi::c_void as *mut Self; + (*this).count.add_ref() + } + } + unsafe extern "system" fn Release(this: *mut core::ffi::c_void) -> u32 { + unsafe { + let this = this as *mut *mut core::ffi::c_void as *mut Self; + let remaining = (*this).count.release(); + if remaining == 0 { + let _ = windows_core::imp::Box::from_raw(this); + } + remaining + } + } + unsafe extern "system" fn Invoke( + this: *mut core::ffi::c_void, + asyncinfo: *mut core::ffi::c_void, + progressinfo: windows_core::AbiType, + ) -> windows_core::HRESULT { + unsafe { + let this = &mut *(this as *mut *mut core::ffi::c_void as *mut Self); + (this.invoke)( + core::mem::transmute_copy(&asyncinfo), + core::mem::transmute_copy(&progressinfo), + ) + .into() + } + } +} +#[repr(transparent)] +#[derive(Clone, Debug, Eq, PartialEq)] +pub struct AsyncOperationWithProgressCompletedHandler( + windows_core::IUnknown, + core::marker::PhantomData, + core::marker::PhantomData, +) +where + TResult: windows_core::RuntimeType + 'static, + TProgress: windows_core::RuntimeType + 'static; +unsafe impl< + TResult: windows_core::RuntimeType + 'static, + TProgress: windows_core::RuntimeType + 'static, + > windows_core::Interface for AsyncOperationWithProgressCompletedHandler +{ + type Vtable = AsyncOperationWithProgressCompletedHandler_Vtbl; + const IID: windows_core::GUID = + windows_core::GUID::from_signature(::SIGNATURE); +} +impl< + TResult: windows_core::RuntimeType + 'static, + TProgress: windows_core::RuntimeType + 'static, + > windows_core::RuntimeType for AsyncOperationWithProgressCompletedHandler +{ + const SIGNATURE: windows_core::imp::ConstBuffer = windows_core::imp::ConstBuffer::new() + .push_slice(b"pinterface({e85df41d-6aa7-46e3-a8e2-f009d840c627}") + .push_slice(b";") + .push_other(TResult::SIGNATURE) + .push_slice(b";") + .push_other(TProgress::SIGNATURE) + .push_slice(b")"); +} +impl< + TResult: windows_core::RuntimeType + 'static, + TProgress: windows_core::RuntimeType + 'static, + > AsyncOperationWithProgressCompletedHandler +{ + pub fn new< + F: FnMut( + windows_core::Ref<'_, IAsyncOperationWithProgress>, + AsyncStatus, + ) -> windows_core::Result<()> + + Send + + 'static, + >( + invoke: F, + ) -> Self { + let com = AsyncOperationWithProgressCompletedHandlerBox { + vtable: &AsyncOperationWithProgressCompletedHandlerBox::::VTABLE, + count: windows_core::imp::RefCount::new(1), + invoke, + }; + unsafe { core::mem::transmute(windows_core::imp::Box::new(com)) } + } + pub fn Invoke(&self, asyncinfo: P0, asyncstatus: AsyncStatus) -> windows_core::Result<()> + where + P0: windows_core::Param>, + { + let this = self; + unsafe { + (windows_core::Interface::vtable(this).Invoke)( + windows_core::Interface::as_raw(this), + asyncinfo.param().abi(), + asyncstatus, + ) + .ok() + } + } +} +#[repr(C)] +pub struct AsyncOperationWithProgressCompletedHandler_Vtbl +where + TResult: windows_core::RuntimeType + 'static, + TProgress: windows_core::RuntimeType + 'static, +{ + base__: windows_core::IUnknown_Vtbl, + Invoke: unsafe extern "system" fn( + this: *mut core::ffi::c_void, + asyncinfo: *mut core::ffi::c_void, + asyncstatus: AsyncStatus, + ) -> windows_core::HRESULT, + TResult: core::marker::PhantomData, + TProgress: core::marker::PhantomData, +} +#[repr(C)] +struct AsyncOperationWithProgressCompletedHandlerBox< + TResult, + TProgress, + F: FnMut( + windows_core::Ref<'_, IAsyncOperationWithProgress>, + AsyncStatus, + ) -> windows_core::Result<()> + + Send + + 'static, +> where + TResult: windows_core::RuntimeType + 'static, + TProgress: windows_core::RuntimeType + 'static, +{ + vtable: *const AsyncOperationWithProgressCompletedHandler_Vtbl, + invoke: F, + count: windows_core::imp::RefCount, +} +impl< + TResult: windows_core::RuntimeType + 'static, + TProgress: windows_core::RuntimeType + 'static, + F: FnMut( + windows_core::Ref<'_, IAsyncOperationWithProgress>, + AsyncStatus, + ) -> windows_core::Result<()> + + Send + + 'static, + > AsyncOperationWithProgressCompletedHandlerBox +{ + const VTABLE: AsyncOperationWithProgressCompletedHandler_Vtbl = + AsyncOperationWithProgressCompletedHandler_Vtbl:: { + base__: windows_core::IUnknown_Vtbl { + QueryInterface: Self::QueryInterface, + AddRef: Self::AddRef, + Release: Self::Release, + }, + Invoke: Self::Invoke, + TResult: core::marker::PhantomData::, + TProgress: core::marker::PhantomData::, + }; + unsafe extern "system" fn QueryInterface( + this: *mut core::ffi::c_void, + iid: *const windows_core::GUID, + interface: *mut *mut core::ffi::c_void, + ) -> windows_core::HRESULT { + unsafe { + let this = this as *mut *mut core::ffi::c_void as *mut Self; + if iid.is_null() || interface.is_null() { + return windows_core::HRESULT(-2147467261); + } + * interface = if * iid == < AsyncOperationWithProgressCompletedHandler < TResult , TProgress > as windows_core::Interface >::IID || * iid == < windows_core::IUnknown as windows_core::Interface >::IID || * iid == < windows_core::imp::IAgileObject as windows_core::Interface >::IID { & mut ( * this ) . vtable as * mut _ as _ } else { core::ptr::null_mut ( ) } ; + if (*interface).is_null() { + windows_core::HRESULT(-2147467262) + } else { + (*this).count.add_ref(); + windows_core::HRESULT(0) + } + } + } + unsafe extern "system" fn AddRef(this: *mut core::ffi::c_void) -> u32 { + unsafe { + let this = this as *mut *mut core::ffi::c_void as *mut Self; + (*this).count.add_ref() + } + } + unsafe extern "system" fn Release(this: *mut core::ffi::c_void) -> u32 { + unsafe { + let this = this as *mut *mut core::ffi::c_void as *mut Self; + let remaining = (*this).count.release(); + if remaining == 0 { + let _ = windows_core::imp::Box::from_raw(this); + } + remaining + } + } + unsafe extern "system" fn Invoke( + this: *mut core::ffi::c_void, + asyncinfo: *mut core::ffi::c_void, + asyncstatus: AsyncStatus, + ) -> windows_core::HRESULT { + unsafe { + let this = &mut *(this as *mut *mut core::ffi::c_void as *mut Self); + (this.invoke)(core::mem::transmute_copy(&asyncinfo), asyncstatus).into() + } + } +} +#[repr(transparent)] +#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)] +pub struct AsyncStatus(pub i32); +impl AsyncStatus { + pub const Canceled: Self = Self(2i32); + pub const Completed: Self = Self(1i32); + pub const Error: Self = Self(3i32); + pub const Started: Self = Self(0i32); +} +impl windows_core::TypeKind for AsyncStatus { + type TypeKind = windows_core::CopyType; +} +impl windows_core::RuntimeType for AsyncStatus { + const SIGNATURE: windows_core::imp::ConstBuffer = + windows_core::imp::ConstBuffer::from_slice(b"enum(Windows.Foundation.AsyncStatus;i4)"); +} +windows_core::imp::define_interface!( + IAsyncAction, + IAsyncAction_Vtbl, + 0x5a648006_843a_4da9_865b_9d26e5dfad7b +); +impl windows_core::RuntimeType for IAsyncAction { + const SIGNATURE: windows_core::imp::ConstBuffer = + windows_core::imp::ConstBuffer::for_interface::(); +} +windows_core::imp::interface_hierarchy!( + IAsyncAction, + windows_core::IUnknown, + windows_core::IInspectable +); +windows_core::imp::required_hierarchy!(IAsyncAction, IAsyncInfo); +impl IAsyncAction { + pub fn SetCompleted(&self, handler: P0) -> windows_core::Result<()> + where + P0: windows_core::Param, + { + let this = self; + unsafe { + (windows_core::Interface::vtable(this).SetCompleted)( + windows_core::Interface::as_raw(this), + handler.param().abi(), + ) + .ok() + } + } + pub fn Completed(&self) -> windows_core::Result { + let this = self; + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(this).Completed)( + windows_core::Interface::as_raw(this), + &mut result__, + ) + .and_then(|| windows_core::Type::from_abi(result__)) + } + } + pub fn GetResults(&self) -> windows_core::Result<()> { + let this = self; + unsafe { + (windows_core::Interface::vtable(this).GetResults)(windows_core::Interface::as_raw( + this, + )) + .ok() + } + } + pub fn Id(&self) -> windows_core::Result { + let this = &windows_core::Interface::cast::(self)?; + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(this).Id)( + windows_core::Interface::as_raw(this), + &mut result__, + ) + .map(|| result__) + } + } + pub fn Status(&self) -> windows_core::Result { + let this = &windows_core::Interface::cast::(self)?; + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(this).Status)( + windows_core::Interface::as_raw(this), + &mut result__, + ) + .map(|| result__) + } + } + pub fn ErrorCode(&self) -> windows_core::Result { + let this = &windows_core::Interface::cast::(self)?; + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(this).ErrorCode)( + windows_core::Interface::as_raw(this), + &mut result__, + ) + .map(|| result__) + } + } + pub fn Cancel(&self) -> windows_core::Result<()> { + let this = &windows_core::Interface::cast::(self)?; + unsafe { + (windows_core::Interface::vtable(this).Cancel)(windows_core::Interface::as_raw(this)) + .ok() + } + } + pub fn Close(&self) -> windows_core::Result<()> { + let this = &windows_core::Interface::cast::(self)?; + unsafe { + (windows_core::Interface::vtable(this).Close)(windows_core::Interface::as_raw(this)) + .ok() + } + } +} +unsafe impl Send for IAsyncAction {} +unsafe impl Sync for IAsyncAction {} +impl windows_core::RuntimeName for IAsyncAction { + const NAME: &'static str = "Windows.Foundation.IAsyncAction"; +} +pub trait IAsyncAction_Impl: IAsyncInfo_Impl { + fn SetCompleted( + &self, + handler: windows_core::Ref<'_, AsyncActionCompletedHandler>, + ) -> windows_core::Result<()>; + fn Completed(&self) -> windows_core::Result; + fn GetResults(&self) -> windows_core::Result<()>; +} +impl IAsyncAction_Vtbl { + pub const fn new() -> Self { + unsafe extern "system" fn SetCompleted( + this: *mut core::ffi::c_void, + handler: *mut core::ffi::c_void, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IAsyncAction_Impl::SetCompleted(this, core::mem::transmute_copy(&handler)).into() + } + } + unsafe extern "system" fn Completed( + this: *mut core::ffi::c_void, + result__: *mut *mut core::ffi::c_void, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IAsyncAction_Impl::Completed(this) { + Ok(ok__) => { + result__.write(core::mem::transmute_copy(&ok__)); + core::mem::forget(ok__); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn GetResults( + this: *mut core::ffi::c_void, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IAsyncAction_Impl::GetResults(this).into() + } + } + Self { + base__: windows_core::IInspectable_Vtbl::new::(), + SetCompleted: SetCompleted::, + Completed: Completed::, + GetResults: GetResults::, + } + } + pub fn matches(iid: &windows_core::GUID) -> bool { + iid == &::IID + } +} +#[repr(C)] +pub struct IAsyncAction_Vtbl { + pub base__: windows_core::IInspectable_Vtbl, + pub SetCompleted: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut core::ffi::c_void, + ) -> windows_core::HRESULT, + pub Completed: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut *mut core::ffi::c_void, + ) -> windows_core::HRESULT, + pub GetResults: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT, +} +#[repr(transparent)] +#[derive(Clone, Debug, Eq, PartialEq)] +pub struct IAsyncActionWithProgress( + windows_core::IUnknown, + core::marker::PhantomData, +) +where + TProgress: windows_core::RuntimeType + 'static; +impl + windows_core::imp::CanInto for IAsyncActionWithProgress +{ +} +impl + windows_core::imp::CanInto for IAsyncActionWithProgress +{ +} +unsafe impl windows_core::Interface + for IAsyncActionWithProgress +{ + type Vtable = IAsyncActionWithProgress_Vtbl; + const IID: windows_core::GUID = + windows_core::GUID::from_signature(::SIGNATURE); +} +impl windows_core::RuntimeType + for IAsyncActionWithProgress +{ + const SIGNATURE: windows_core::imp::ConstBuffer = windows_core::imp::ConstBuffer::new() + .push_slice(b"pinterface({1f6db258-e803-48a1-9546-eb7353398884}") + .push_slice(b";") + .push_other(TProgress::SIGNATURE) + .push_slice(b")"); +} +impl windows_core::imp::CanInto + for IAsyncActionWithProgress +{ + const QUERY: bool = true; +} +impl IAsyncActionWithProgress { + pub fn SetProgress(&self, handler: P0) -> windows_core::Result<()> + where + P0: windows_core::Param>, + { + let this = self; + unsafe { + (windows_core::Interface::vtable(this).SetProgress)( + windows_core::Interface::as_raw(this), + handler.param().abi(), + ) + .ok() + } + } + pub fn Progress(&self) -> windows_core::Result> { + let this = self; + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(this).Progress)( + windows_core::Interface::as_raw(this), + &mut result__, + ) + .and_then(|| windows_core::Type::from_abi(result__)) + } + } + pub fn SetCompleted(&self, handler: P0) -> windows_core::Result<()> + where + P0: windows_core::Param>, + { + let this = self; + unsafe { + (windows_core::Interface::vtable(this).SetCompleted)( + windows_core::Interface::as_raw(this), + handler.param().abi(), + ) + .ok() + } + } + pub fn Completed( + &self, + ) -> windows_core::Result> { + let this = self; + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(this).Completed)( + windows_core::Interface::as_raw(this), + &mut result__, + ) + .and_then(|| windows_core::Type::from_abi(result__)) + } + } + pub fn GetResults(&self) -> windows_core::Result<()> { + let this = self; + unsafe { + (windows_core::Interface::vtable(this).GetResults)(windows_core::Interface::as_raw( + this, + )) + .ok() + } + } + pub fn Id(&self) -> windows_core::Result { + let this = &windows_core::Interface::cast::(self)?; + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(this).Id)( + windows_core::Interface::as_raw(this), + &mut result__, + ) + .map(|| result__) + } + } + pub fn Status(&self) -> windows_core::Result { + let this = &windows_core::Interface::cast::(self)?; + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(this).Status)( + windows_core::Interface::as_raw(this), + &mut result__, + ) + .map(|| result__) + } + } + pub fn ErrorCode(&self) -> windows_core::Result { + let this = &windows_core::Interface::cast::(self)?; + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(this).ErrorCode)( + windows_core::Interface::as_raw(this), + &mut result__, + ) + .map(|| result__) + } + } + pub fn Cancel(&self) -> windows_core::Result<()> { + let this = &windows_core::Interface::cast::(self)?; + unsafe { + (windows_core::Interface::vtable(this).Cancel)(windows_core::Interface::as_raw(this)) + .ok() + } + } + pub fn Close(&self) -> windows_core::Result<()> { + let this = &windows_core::Interface::cast::(self)?; + unsafe { + (windows_core::Interface::vtable(this).Close)(windows_core::Interface::as_raw(this)) + .ok() + } + } +} +unsafe impl Send + for IAsyncActionWithProgress +{ +} +unsafe impl Sync + for IAsyncActionWithProgress +{ +} +impl windows_core::RuntimeName + for IAsyncActionWithProgress +{ + const NAME: &'static str = "Windows.Foundation.IAsyncActionWithProgress"; +} +pub trait IAsyncActionWithProgress_Impl: IAsyncInfo_Impl +where + TProgress: windows_core::RuntimeType + 'static, +{ + fn SetProgress( + &self, + handler: windows_core::Ref<'_, AsyncActionProgressHandler>, + ) -> windows_core::Result<()>; + fn Progress(&self) -> windows_core::Result>; + fn SetCompleted( + &self, + handler: windows_core::Ref<'_, AsyncActionWithProgressCompletedHandler>, + ) -> windows_core::Result<()>; + fn Completed(&self) + -> windows_core::Result>; + fn GetResults(&self) -> windows_core::Result<()>; +} +impl IAsyncActionWithProgress_Vtbl { + pub const fn new, const OFFSET: isize>( + ) -> Self { + unsafe extern "system" fn SetProgress< + TProgress: windows_core::RuntimeType + 'static, + Identity: IAsyncActionWithProgress_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + handler: *mut core::ffi::c_void, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IAsyncActionWithProgress_Impl::SetProgress( + this, + core::mem::transmute_copy(&handler), + ) + .into() + } + } + unsafe extern "system" fn Progress< + TProgress: windows_core::RuntimeType + 'static, + Identity: IAsyncActionWithProgress_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + result__: *mut *mut core::ffi::c_void, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IAsyncActionWithProgress_Impl::Progress(this) { + Ok(ok__) => { + result__.write(core::mem::transmute_copy(&ok__)); + core::mem::forget(ok__); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn SetCompleted< + TProgress: windows_core::RuntimeType + 'static, + Identity: IAsyncActionWithProgress_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + handler: *mut core::ffi::c_void, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IAsyncActionWithProgress_Impl::SetCompleted( + this, + core::mem::transmute_copy(&handler), + ) + .into() + } + } + unsafe extern "system" fn Completed< + TProgress: windows_core::RuntimeType + 'static, + Identity: IAsyncActionWithProgress_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + result__: *mut *mut core::ffi::c_void, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IAsyncActionWithProgress_Impl::Completed(this) { + Ok(ok__) => { + result__.write(core::mem::transmute_copy(&ok__)); + core::mem::forget(ok__); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn GetResults< + TProgress: windows_core::RuntimeType + 'static, + Identity: IAsyncActionWithProgress_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IAsyncActionWithProgress_Impl::GetResults(this).into() + } + } + Self { + base__: windows_core::IInspectable_Vtbl::new::< + Identity, + IAsyncActionWithProgress, + OFFSET, + >(), + SetProgress: SetProgress::, + Progress: Progress::, + SetCompleted: SetCompleted::, + Completed: Completed::, + GetResults: GetResults::, + TProgress: core::marker::PhantomData::, + } + } + pub fn matches(iid: &windows_core::GUID) -> bool { + iid == & as windows_core::Interface>::IID + } +} +#[repr(C)] +pub struct IAsyncActionWithProgress_Vtbl +where + TProgress: windows_core::RuntimeType + 'static, +{ + pub base__: windows_core::IInspectable_Vtbl, + pub SetProgress: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut core::ffi::c_void, + ) -> windows_core::HRESULT, + pub Progress: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut *mut core::ffi::c_void, + ) -> windows_core::HRESULT, + pub SetCompleted: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut core::ffi::c_void, + ) -> windows_core::HRESULT, + pub Completed: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut *mut core::ffi::c_void, + ) -> windows_core::HRESULT, + pub GetResults: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT, + TProgress: core::marker::PhantomData, +} +windows_core::imp::define_interface!( + IAsyncInfo, + IAsyncInfo_Vtbl, + 0x00000036_0000_0000_c000_000000000046 +); +impl windows_core::RuntimeType for IAsyncInfo { + const SIGNATURE: windows_core::imp::ConstBuffer = + windows_core::imp::ConstBuffer::for_interface::(); +} +windows_core::imp::interface_hierarchy!( + IAsyncInfo, + windows_core::IUnknown, + windows_core::IInspectable +); +impl IAsyncInfo { + pub fn Id(&self) -> windows_core::Result { + let this = self; + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(this).Id)( + windows_core::Interface::as_raw(this), + &mut result__, + ) + .map(|| result__) + } + } + pub fn Status(&self) -> windows_core::Result { + let this = self; + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(this).Status)( + windows_core::Interface::as_raw(this), + &mut result__, + ) + .map(|| result__) + } + } + pub fn ErrorCode(&self) -> windows_core::Result { + let this = self; + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(this).ErrorCode)( + windows_core::Interface::as_raw(this), + &mut result__, + ) + .map(|| result__) + } + } + pub fn Cancel(&self) -> windows_core::Result<()> { + let this = self; + unsafe { + (windows_core::Interface::vtable(this).Cancel)(windows_core::Interface::as_raw(this)) + .ok() + } + } + pub fn Close(&self) -> windows_core::Result<()> { + let this = self; + unsafe { + (windows_core::Interface::vtable(this).Close)(windows_core::Interface::as_raw(this)) + .ok() + } + } +} +impl windows_core::RuntimeName for IAsyncInfo { + const NAME: &'static str = "Windows.Foundation.IAsyncInfo"; +} +pub trait IAsyncInfo_Impl: windows_core::IUnknownImpl { + fn Id(&self) -> windows_core::Result; + fn Status(&self) -> windows_core::Result; + fn ErrorCode(&self) -> windows_core::Result; + fn Cancel(&self) -> windows_core::Result<()>; + fn Close(&self) -> windows_core::Result<()>; +} +impl IAsyncInfo_Vtbl { + pub const fn new() -> Self { + unsafe extern "system" fn Id( + this: *mut core::ffi::c_void, + result__: *mut u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IAsyncInfo_Impl::Id(this) { + Ok(ok__) => { + result__.write(core::mem::transmute_copy(&ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn Status( + this: *mut core::ffi::c_void, + result__: *mut AsyncStatus, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IAsyncInfo_Impl::Status(this) { + Ok(ok__) => { + result__.write(core::mem::transmute_copy(&ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn ErrorCode( + this: *mut core::ffi::c_void, + result__: *mut windows_core::HRESULT, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IAsyncInfo_Impl::ErrorCode(this) { + Ok(ok__) => { + result__.write(core::mem::transmute_copy(&ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn Cancel( + this: *mut core::ffi::c_void, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IAsyncInfo_Impl::Cancel(this).into() + } + } + unsafe extern "system" fn Close( + this: *mut core::ffi::c_void, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IAsyncInfo_Impl::Close(this).into() + } + } + Self { + base__: windows_core::IInspectable_Vtbl::new::(), + Id: Id::, + Status: Status::, + ErrorCode: ErrorCode::, + Cancel: Cancel::, + Close: Close::, + } + } + pub fn matches(iid: &windows_core::GUID) -> bool { + iid == &::IID + } +} +#[repr(C)] +pub struct IAsyncInfo_Vtbl { + pub base__: windows_core::IInspectable_Vtbl, + pub Id: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, + pub Status: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut AsyncStatus, + ) -> windows_core::HRESULT, + pub ErrorCode: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows_core::HRESULT, + ) -> windows_core::HRESULT, + pub Cancel: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT, + pub Close: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT, +} +#[repr(transparent)] +#[derive(Clone, Debug, Eq, PartialEq)] +pub struct IAsyncOperation(windows_core::IUnknown, core::marker::PhantomData) +where + TResult: windows_core::RuntimeType + 'static; +impl + windows_core::imp::CanInto for IAsyncOperation +{ +} +impl + windows_core::imp::CanInto for IAsyncOperation +{ +} +unsafe impl windows_core::Interface + for IAsyncOperation +{ + type Vtable = IAsyncOperation_Vtbl; + const IID: windows_core::GUID = + windows_core::GUID::from_signature(::SIGNATURE); +} +impl windows_core::RuntimeType + for IAsyncOperation +{ + const SIGNATURE: windows_core::imp::ConstBuffer = windows_core::imp::ConstBuffer::new() + .push_slice(b"pinterface({9fc2b0bb-e446-44e2-aa61-9cab8f636af2}") + .push_slice(b";") + .push_other(TResult::SIGNATURE) + .push_slice(b")"); +} +impl windows_core::imp::CanInto + for IAsyncOperation +{ + const QUERY: bool = true; +} +impl IAsyncOperation { + pub fn SetCompleted(&self, handler: P0) -> windows_core::Result<()> + where + P0: windows_core::Param>, + { + let this = self; + unsafe { + (windows_core::Interface::vtable(this).SetCompleted)( + windows_core::Interface::as_raw(this), + handler.param().abi(), + ) + .ok() + } + } + pub fn Completed(&self) -> windows_core::Result> { + let this = self; + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(this).Completed)( + windows_core::Interface::as_raw(this), + &mut result__, + ) + .and_then(|| windows_core::Type::from_abi(result__)) + } + } + pub fn GetResults(&self) -> windows_core::Result { + let this = self; + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(this).GetResults)( + windows_core::Interface::as_raw(this), + &mut result__, + ) + .and_then(|| windows_core::Type::from_abi(result__)) + } + } + pub fn Id(&self) -> windows_core::Result { + let this = &windows_core::Interface::cast::(self)?; + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(this).Id)( + windows_core::Interface::as_raw(this), + &mut result__, + ) + .map(|| result__) + } + } + pub fn Status(&self) -> windows_core::Result { + let this = &windows_core::Interface::cast::(self)?; + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(this).Status)( + windows_core::Interface::as_raw(this), + &mut result__, + ) + .map(|| result__) + } + } + pub fn ErrorCode(&self) -> windows_core::Result { + let this = &windows_core::Interface::cast::(self)?; + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(this).ErrorCode)( + windows_core::Interface::as_raw(this), + &mut result__, + ) + .map(|| result__) + } + } + pub fn Cancel(&self) -> windows_core::Result<()> { + let this = &windows_core::Interface::cast::(self)?; + unsafe { + (windows_core::Interface::vtable(this).Cancel)(windows_core::Interface::as_raw(this)) + .ok() + } + } + pub fn Close(&self) -> windows_core::Result<()> { + let this = &windows_core::Interface::cast::(self)?; + unsafe { + (windows_core::Interface::vtable(this).Close)(windows_core::Interface::as_raw(this)) + .ok() + } + } +} +unsafe impl Send for IAsyncOperation {} +unsafe impl Sync for IAsyncOperation {} +impl windows_core::RuntimeName + for IAsyncOperation +{ + const NAME: &'static str = "Windows.Foundation.IAsyncOperation"; +} +pub trait IAsyncOperation_Impl: IAsyncInfo_Impl +where + TResult: windows_core::RuntimeType + 'static, +{ + fn SetCompleted( + &self, + handler: windows_core::Ref<'_, AsyncOperationCompletedHandler>, + ) -> windows_core::Result<()>; + fn Completed(&self) -> windows_core::Result>; + fn GetResults(&self) -> windows_core::Result; +} +impl IAsyncOperation_Vtbl { + pub const fn new, const OFFSET: isize>() -> Self { + unsafe extern "system" fn SetCompleted< + TResult: windows_core::RuntimeType + 'static, + Identity: IAsyncOperation_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + handler: *mut core::ffi::c_void, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IAsyncOperation_Impl::SetCompleted(this, core::mem::transmute_copy(&handler)).into() + } + } + unsafe extern "system" fn Completed< + TResult: windows_core::RuntimeType + 'static, + Identity: IAsyncOperation_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + result__: *mut *mut core::ffi::c_void, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IAsyncOperation_Impl::Completed(this) { + Ok(ok__) => { + result__.write(core::mem::transmute_copy(&ok__)); + core::mem::forget(ok__); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn GetResults< + TResult: windows_core::RuntimeType + 'static, + Identity: IAsyncOperation_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + result__: *mut windows_core::AbiType, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IAsyncOperation_Impl::GetResults(this) { + Ok(ok__) => { + result__.write(core::mem::transmute_copy(&ok__)); + core::mem::forget(ok__); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + Self { + base__: windows_core::IInspectable_Vtbl::new::< + Identity, + IAsyncOperation, + OFFSET, + >(), + SetCompleted: SetCompleted::, + Completed: Completed::, + GetResults: GetResults::, + TResult: core::marker::PhantomData::, + } + } + pub fn matches(iid: &windows_core::GUID) -> bool { + iid == & as windows_core::Interface>::IID + } +} +#[repr(C)] +pub struct IAsyncOperation_Vtbl +where + TResult: windows_core::RuntimeType + 'static, +{ + pub base__: windows_core::IInspectable_Vtbl, + pub SetCompleted: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut core::ffi::c_void, + ) -> windows_core::HRESULT, + pub Completed: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut *mut core::ffi::c_void, + ) -> windows_core::HRESULT, + pub GetResults: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows_core::AbiType, + ) -> windows_core::HRESULT, + TResult: core::marker::PhantomData, +} +#[repr(transparent)] +#[derive(Clone, Debug, Eq, PartialEq)] +pub struct IAsyncOperationWithProgress( + windows_core::IUnknown, + core::marker::PhantomData, + core::marker::PhantomData, +) +where + TResult: windows_core::RuntimeType + 'static, + TProgress: windows_core::RuntimeType + 'static; +impl< + TResult: windows_core::RuntimeType + 'static, + TProgress: windows_core::RuntimeType + 'static, + > windows_core::imp::CanInto + for IAsyncOperationWithProgress +{ +} +impl< + TResult: windows_core::RuntimeType + 'static, + TProgress: windows_core::RuntimeType + 'static, + > windows_core::imp::CanInto + for IAsyncOperationWithProgress +{ +} +unsafe impl< + TResult: windows_core::RuntimeType + 'static, + TProgress: windows_core::RuntimeType + 'static, + > windows_core::Interface for IAsyncOperationWithProgress +{ + type Vtable = IAsyncOperationWithProgress_Vtbl; + const IID: windows_core::GUID = + windows_core::GUID::from_signature(::SIGNATURE); +} +impl< + TResult: windows_core::RuntimeType + 'static, + TProgress: windows_core::RuntimeType + 'static, + > windows_core::RuntimeType for IAsyncOperationWithProgress +{ + const SIGNATURE: windows_core::imp::ConstBuffer = windows_core::imp::ConstBuffer::new() + .push_slice(b"pinterface({b5d036d7-e297-498f-ba60-0289e76e23dd}") + .push_slice(b";") + .push_other(TResult::SIGNATURE) + .push_slice(b";") + .push_other(TProgress::SIGNATURE) + .push_slice(b")"); +} +impl< + TResult: windows_core::RuntimeType + 'static, + TProgress: windows_core::RuntimeType + 'static, + > windows_core::imp::CanInto for IAsyncOperationWithProgress +{ + const QUERY: bool = true; +} +impl< + TResult: windows_core::RuntimeType + 'static, + TProgress: windows_core::RuntimeType + 'static, + > IAsyncOperationWithProgress +{ + pub fn SetProgress(&self, handler: P0) -> windows_core::Result<()> + where + P0: windows_core::Param>, + { + let this = self; + unsafe { + (windows_core::Interface::vtable(this).SetProgress)( + windows_core::Interface::as_raw(this), + handler.param().abi(), + ) + .ok() + } + } + pub fn Progress( + &self, + ) -> windows_core::Result> { + let this = self; + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(this).Progress)( + windows_core::Interface::as_raw(this), + &mut result__, + ) + .and_then(|| windows_core::Type::from_abi(result__)) + } + } + pub fn SetCompleted(&self, handler: P0) -> windows_core::Result<()> + where + P0: windows_core::Param>, + { + let this = self; + unsafe { + (windows_core::Interface::vtable(this).SetCompleted)( + windows_core::Interface::as_raw(this), + handler.param().abi(), + ) + .ok() + } + } + pub fn Completed( + &self, + ) -> windows_core::Result> { + let this = self; + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(this).Completed)( + windows_core::Interface::as_raw(this), + &mut result__, + ) + .and_then(|| windows_core::Type::from_abi(result__)) + } + } + pub fn GetResults(&self) -> windows_core::Result { + let this = self; + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(this).GetResults)( + windows_core::Interface::as_raw(this), + &mut result__, + ) + .and_then(|| windows_core::Type::from_abi(result__)) + } + } + pub fn Id(&self) -> windows_core::Result { + let this = &windows_core::Interface::cast::(self)?; + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(this).Id)( + windows_core::Interface::as_raw(this), + &mut result__, + ) + .map(|| result__) + } + } + pub fn Status(&self) -> windows_core::Result { + let this = &windows_core::Interface::cast::(self)?; + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(this).Status)( + windows_core::Interface::as_raw(this), + &mut result__, + ) + .map(|| result__) + } + } + pub fn ErrorCode(&self) -> windows_core::Result { + let this = &windows_core::Interface::cast::(self)?; + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(this).ErrorCode)( + windows_core::Interface::as_raw(this), + &mut result__, + ) + .map(|| result__) + } + } + pub fn Cancel(&self) -> windows_core::Result<()> { + let this = &windows_core::Interface::cast::(self)?; + unsafe { + (windows_core::Interface::vtable(this).Cancel)(windows_core::Interface::as_raw(this)) + .ok() + } + } + pub fn Close(&self) -> windows_core::Result<()> { + let this = &windows_core::Interface::cast::(self)?; + unsafe { + (windows_core::Interface::vtable(this).Close)(windows_core::Interface::as_raw(this)) + .ok() + } + } +} +unsafe impl< + TResult: windows_core::RuntimeType + 'static, + TProgress: windows_core::RuntimeType + 'static, + > Send for IAsyncOperationWithProgress +{ +} +unsafe impl< + TResult: windows_core::RuntimeType + 'static, + TProgress: windows_core::RuntimeType + 'static, + > Sync for IAsyncOperationWithProgress +{ +} +impl< + TResult: windows_core::RuntimeType + 'static, + TProgress: windows_core::RuntimeType + 'static, + > windows_core::RuntimeName for IAsyncOperationWithProgress +{ + const NAME: &'static str = "Windows.Foundation.IAsyncOperationWithProgress"; +} +pub trait IAsyncOperationWithProgress_Impl: IAsyncInfo_Impl +where + TResult: windows_core::RuntimeType + 'static, + TProgress: windows_core::RuntimeType + 'static, +{ + fn SetProgress( + &self, + handler: windows_core::Ref<'_, AsyncOperationProgressHandler>, + ) -> windows_core::Result<()>; + fn Progress(&self) -> windows_core::Result>; + fn SetCompleted( + &self, + handler: windows_core::Ref< + '_, + AsyncOperationWithProgressCompletedHandler, + >, + ) -> windows_core::Result<()>; + fn Completed( + &self, + ) -> windows_core::Result>; + fn GetResults(&self) -> windows_core::Result; +} +impl< + TResult: windows_core::RuntimeType + 'static, + TProgress: windows_core::RuntimeType + 'static, + > IAsyncOperationWithProgress_Vtbl +{ + pub const fn new< + Identity: IAsyncOperationWithProgress_Impl, + const OFFSET: isize, + >() -> Self { + unsafe extern "system" fn SetProgress< + TResult: windows_core::RuntimeType + 'static, + TProgress: windows_core::RuntimeType + 'static, + Identity: IAsyncOperationWithProgress_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + handler: *mut core::ffi::c_void, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IAsyncOperationWithProgress_Impl::SetProgress( + this, + core::mem::transmute_copy(&handler), + ) + .into() + } + } + unsafe extern "system" fn Progress< + TResult: windows_core::RuntimeType + 'static, + TProgress: windows_core::RuntimeType + 'static, + Identity: IAsyncOperationWithProgress_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + result__: *mut *mut core::ffi::c_void, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IAsyncOperationWithProgress_Impl::Progress(this) { + Ok(ok__) => { + result__.write(core::mem::transmute_copy(&ok__)); + core::mem::forget(ok__); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn SetCompleted< + TResult: windows_core::RuntimeType + 'static, + TProgress: windows_core::RuntimeType + 'static, + Identity: IAsyncOperationWithProgress_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + handler: *mut core::ffi::c_void, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IAsyncOperationWithProgress_Impl::SetCompleted( + this, + core::mem::transmute_copy(&handler), + ) + .into() + } + } + unsafe extern "system" fn Completed< + TResult: windows_core::RuntimeType + 'static, + TProgress: windows_core::RuntimeType + 'static, + Identity: IAsyncOperationWithProgress_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + result__: *mut *mut core::ffi::c_void, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IAsyncOperationWithProgress_Impl::Completed(this) { + Ok(ok__) => { + result__.write(core::mem::transmute_copy(&ok__)); + core::mem::forget(ok__); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn GetResults< + TResult: windows_core::RuntimeType + 'static, + TProgress: windows_core::RuntimeType + 'static, + Identity: IAsyncOperationWithProgress_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + result__: *mut windows_core::AbiType, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IAsyncOperationWithProgress_Impl::GetResults(this) { + Ok(ok__) => { + result__.write(core::mem::transmute_copy(&ok__)); + core::mem::forget(ok__); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + Self { + base__: windows_core::IInspectable_Vtbl::new::< + Identity, + IAsyncOperationWithProgress, + OFFSET, + >(), + SetProgress: SetProgress::, + Progress: Progress::, + SetCompleted: SetCompleted::, + Completed: Completed::, + GetResults: GetResults::, + TResult: core::marker::PhantomData::, + TProgress: core::marker::PhantomData::, + } + } + pub fn matches(iid: &windows_core::GUID) -> bool { + iid == & as windows_core::Interface>::IID + } +} +#[repr(C)] +pub struct IAsyncOperationWithProgress_Vtbl +where + TResult: windows_core::RuntimeType + 'static, + TProgress: windows_core::RuntimeType + 'static, +{ + pub base__: windows_core::IInspectable_Vtbl, + pub SetProgress: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut core::ffi::c_void, + ) -> windows_core::HRESULT, + pub Progress: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut *mut core::ffi::c_void, + ) -> windows_core::HRESULT, + pub SetCompleted: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut core::ffi::c_void, + ) -> windows_core::HRESULT, + pub Completed: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut *mut core::ffi::c_void, + ) -> windows_core::HRESULT, + pub GetResults: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows_core::AbiType, + ) -> windows_core::HRESULT, + TResult: core::marker::PhantomData, + TProgress: core::marker::PhantomData, +} diff --git a/crates/libs/async/src/lib.rs b/crates/libs/async/src/lib.rs new file mode 100644 index 0000000000..d7476d15ad --- /dev/null +++ b/crates/libs/async/src/lib.rs @@ -0,0 +1,22 @@ +#![allow( + non_snake_case, + non_camel_case_types, + non_upper_case_globals, + clippy::all +)] +#![doc = include_str!("../readme.md")] +#![allow(missing_docs)] +#![cfg_attr(all(not(feature = "std")), no_std)] + +mod bindings; +pub use bindings::*; + +#[cfg(feature = "std")] +mod r#async; +#[cfg(feature = "std")] +mod async_ready; +#[cfg(feature = "std")] +mod async_spawn; + +#[cfg(feature = "std")] +pub(crate) use r#async::*; From 3a061eaabd11c85843298c7a43e8a12553454719 Mon Sep 17 00:00:00 2001 From: Kenny Kerr Date: Fri, 14 Feb 2025 08:45:54 -0600 Subject: [PATCH 2/9] windows --- crates/libs/windows/Cargo.toml | 4 + .../src/Windows/AI/MachineLearning/mod.rs | 12 +- .../ApplicationModel/AppExtensions/mod.rs | 8 +- .../ApplicationModel/AppService/mod.rs | 14 +- .../Appointments/DataProvider/mod.rs | 24 +- .../ApplicationModel/Appointments/mod.rs | 138 +- .../ApplicationModel/Background/mod.rs | 30 +- .../ApplicationModel/Calls/Provider/mod.rs | 2 +- .../src/Windows/ApplicationModel/Calls/mod.rs | 74 +- .../src/Windows/ApplicationModel/Chat/mod.rs | 100 +- .../CommunicationBlocking/mod.rs | 4 +- .../Contacts/DataProvider/mod.rs | 18 +- .../Windows/ApplicationModel/Contacts/mod.rs | 126 +- .../ConversationalAgent/mod.rs | 68 +- .../src/Windows/ApplicationModel/Core/mod.rs | 8 +- .../DataTransfer/DragDrop/Core/mod.rs | 18 +- .../ApplicationModel/DataTransfer/mod.rs | 30 +- .../Email/DataProvider/mod.rs | 62 +- .../src/Windows/ApplicationModel/Email/mod.rs | 116 +- .../ExtendedExecution/Foreground/mod.rs | 2 +- .../ApplicationModel/ExtendedExecution/mod.rs | 2 +- .../ApplicationModel/PackageExtensions/mod.rs | 8 +- .../ApplicationModel/Payments/Provider/mod.rs | 12 +- .../Windows/ApplicationModel/Payments/mod.rs | 10 +- .../Preview/InkWorkspace/mod.rs | 2 +- .../ApplicationModel/Preview/Notes/mod.rs | 4 +- .../ApplicationModel/Resources/Core/mod.rs | 4 +- .../Resources/Management/mod.rs | 2 +- .../UserActivities/Core/mod.rs | 2 +- .../ApplicationModel/UserActivities/mod.rs | 12 +- .../UserDataAccounts/SystemAccess/mod.rs | 10 +- .../ApplicationModel/UserDataAccounts/mod.rs | 38 +- .../UserDataTasks/DataProvider/mod.rs | 20 +- .../ApplicationModel/UserDataTasks/mod.rs | 34 +- .../ApplicationModel/VoiceCommands/mod.rs | 18 +- .../ApplicationModel/Wallet/System/mod.rs | 10 +- .../Windows/ApplicationModel/Wallet/mod.rs | 24 +- .../src/Windows/ApplicationModel/mod.rs | 42 +- .../libs/windows/src/Windows/Data/Pdf/mod.rs | 14 +- .../libs/windows/src/Windows/Data/Text/mod.rs | 16 +- .../windows/src/Windows/Data/Xml/Dom/mod.rs | 10 +- .../windows/src/Windows/Devices/Adc/mod.rs | 4 +- .../Bluetooth/GenericAttributeProfile/mod.rs | 78 +- .../Windows/Devices/Bluetooth/Rfcomm/mod.rs | 10 +- .../src/Windows/Devices/Bluetooth/mod.rs | 38 +- .../windows/src/Windows/Devices/Custom/mod.rs | 6 +- .../src/Windows/Devices/Display/Core/mod.rs | 6 +- .../src/Windows/Devices/Display/mod.rs | 4 +- .../Windows/Devices/Enumeration/Pnp/mod.rs | 6 +- .../src/Windows/Devices/Enumeration/mod.rs | 48 +- .../src/Windows/Devices/Geolocation/mod.rs | 12 +- .../windows/src/Windows/Devices/Gpio/mod.rs | 6 +- .../src/Windows/Devices/Haptics/mod.rs | 8 +- .../Devices/HumanInterfaceDevice/mod.rs | 14 +- .../src/Windows/Devices/I2c/Provider/mod.rs | 4 +- .../windows/src/Windows/Devices/I2c/mod.rs | 10 +- .../src/Windows/Devices/Input/Preview/mod.rs | 2 +- .../windows/src/Windows/Devices/Lights/mod.rs | 10 +- .../windows/src/Windows/Devices/Midi/mod.rs | 8 +- .../Devices/PointOfService/Provider/mod.rs | 84 +- .../src/Windows/Devices/PointOfService/mod.rs | 188 +-- .../windows/src/Windows/Devices/Power/mod.rs | 2 +- .../src/Windows/Devices/Printers/mod.rs | 8 +- .../windows/src/Windows/Devices/Pwm/mod.rs | 6 +- .../windows/src/Windows/Devices/Radios/mod.rs | 8 +- .../src/Windows/Devices/Scanners/mod.rs | 6 +- .../src/Windows/Devices/Sensors/Custom/mod.rs | 2 +- .../src/Windows/Devices/Sensors/mod.rs | 54 +- .../Devices/SerialCommunication/mod.rs | 2 +- .../src/Windows/Devices/SmartCards/mod.rs | 98 +- .../windows/src/Windows/Devices/Sms/mod.rs | 28 +- .../src/Windows/Devices/Spi/Provider/mod.rs | 4 +- .../windows/src/Windows/Devices/Spi/mod.rs | 10 +- .../windows/src/Windows/Devices/Usb/mod.rs | 20 +- .../windows/src/Windows/Devices/WiFi/mod.rs | 20 +- .../Devices/WiFiDirect/Services/mod.rs | 16 +- .../src/Windows/Devices/WiFiDirect/mod.rs | 4 +- .../Windows/Embedded/DeviceLockdown/mod.rs | 2 +- .../src/Windows/Foundation/Diagnostics/mod.rs | 18 +- .../windows/src/Windows/Foundation/mod.rs | 1456 ++--------------- .../src/Windows/Gaming/Input/Custom/mod.rs | 2 +- .../Windows/Gaming/Input/ForceFeedback/mod.rs | 10 +- .../Gaming/Preview/GamesEnumeration/mod.rs | 30 +- .../Windows/Gaming/XboxLive/Storage/mod.rs | 28 +- .../src/Windows/Graphics/Capture/mod.rs | 4 +- .../src/Windows/Graphics/Display/Core/mod.rs | 8 +- .../src/Windows/Graphics/Display/mod.rs | 6 +- .../src/Windows/Graphics/Imaging/mod.rs | 96 +- .../Graphics/Printing/PrintTicket/mod.rs | 4 +- .../Windows/Graphics/Printing/Workflow/mod.rs | 16 +- .../src/Windows/Graphics/Printing/mod.rs | 2 +- .../src/Windows/Graphics/Printing3D/mod.rs | 26 +- .../src/Windows/Management/Deployment/mod.rs | 80 +- .../src/Windows/Management/Setup/mod.rs | 2 +- .../src/Windows/Management/Update/mod.rs | 4 +- .../windows/src/Windows/Management/mod.rs | 6 +- .../src/Windows/Media/AppRecording/mod.rs | 6 +- .../windows/src/Windows/Media/Audio/mod.rs | 36 +- .../src/Windows/Media/Capture/Core/mod.rs | 8 +- .../src/Windows/Media/Capture/Frames/mod.rs | 22 +- .../windows/src/Windows/Media/Capture/mod.rs | 116 +- .../windows/src/Windows/Media/Casting/mod.rs | 12 +- .../Windows/Media/ContentRestrictions/mod.rs | 6 +- .../windows/src/Windows/Media/Control/mod.rs | 34 +- .../windows/src/Windows/Media/Core/mod.rs | 8 +- .../windows/src/Windows/Media/Devices/mod.rs | 46 +- .../src/Windows/Media/DialProtocol/mod.rs | 20 +- .../windows/src/Windows/Media/Editing/mod.rs | 20 +- .../src/Windows/Media/FaceAnalysis/mod.rs | 10 +- .../windows/src/Windows/Media/Import/mod.rs | 22 +- .../src/Windows/Media/MediaProperties/mod.rs | 4 +- .../windows/src/Windows/Media/Miracast/mod.rs | 18 +- .../libs/windows/src/Windows/Media/Ocr/mod.rs | 2 +- .../windows/src/Windows/Media/PlayTo/mod.rs | 4 +- .../src/Windows/Media/Playlists/mod.rs | 8 +- .../Windows/Media/Protection/PlayReady/mod.rs | 54 +- .../src/Windows/Media/Protection/mod.rs | 4 +- .../Windows/Media/SpeechRecognition/mod.rs | 24 +- .../src/Windows/Media/SpeechSynthesis/mod.rs | 12 +- .../Windows/Media/Streaming/Adaptive/mod.rs | 8 +- .../src/Windows/Media/Transcoding/mod.rs | 8 +- crates/libs/windows/src/Windows/Media/mod.rs | 6 +- .../Networking/BackgroundTransfer/mod.rs | 34 +- .../Windows/Networking/Connectivity/mod.rs | 18 +- .../Networking/NetworkOperators/mod.rs | 110 +- .../src/Windows/Networking/Proximity/mod.rs | 4 +- .../Networking/PushNotifications/mod.rs | 16 +- .../Networking/ServiceDiscovery/Dnssd/mod.rs | 8 +- .../src/Windows/Networking/Sockets/mod.rs | 60 +- .../windows/src/Windows/Networking/Vpn/mod.rs | 26 +- .../src/Windows/Networking/XboxLive/mod.rs | 12 +- .../src/Windows/Perception/People/mod.rs | 2 +- .../Perception/Spatial/Surfaces/mod.rs | 6 +- .../src/Windows/Perception/Spatial/mod.rs | 20 +- .../Phone/Management/Deployment/mod.rs | 16 +- .../PersonalInformation/Provisioning/mod.rs | 10 +- .../Windows/Phone/PersonalInformation/mod.rs | 74 +- .../src/Windows/Phone/StartScreen/mod.rs | 8 +- .../UserProfile/GameServices/Core/mod.rs | 10 +- .../Authentication/Identity/Core/mod.rs | 20 +- .../Security/Authentication/Identity/mod.rs | 2 +- .../Security/Authentication/OnlineId/mod.rs | 6 +- .../Security/Authentication/Web/Core/mod.rs | 30 +- .../Authentication/Web/Provider/mod.rs | 52 +- .../Security/Authentication/Web/mod.rs | 8 +- .../Authorization/AppCapabilityAccess/mod.rs | 6 +- .../Windows/Security/Credentials/UI/mod.rs | 10 +- .../src/Windows/Security/Credentials/mod.rs | 20 +- .../Security/Cryptography/Certificates/mod.rs | 42 +- .../Windows/Security/Cryptography/Core/mod.rs | 8 +- .../Cryptography/DataProtection/mod.rs | 8 +- .../Windows/Security/DataProtection/mod.rs | 8 +- .../Windows/Security/EnterpriseData/mod.rs | 72 +- .../ExchangeActiveSyncProvisioning/mod.rs | 2 +- .../src/Windows/Security/Isolation/mod.rs | 34 +- .../Windows/Services/Maps/LocalSearch/mod.rs | 2 +- .../Windows/Services/Maps/OfflineMaps/mod.rs | 8 +- .../windows/src/Windows/Services/Maps/mod.rs | 34 +- .../windows/src/Windows/Services/Store/mod.rs | 100 +- .../Windows/Services/TargetedContent/mod.rs | 12 +- .../src/Windows/Storage/AccessCache/mod.rs | 48 +- .../src/Windows/Storage/BulkAccess/mod.rs | 110 +- .../src/Windows/Storage/Compression/mod.rs | 8 +- .../src/Windows/Storage/FileProperties/mod.rs | 68 +- .../src/Windows/Storage/Pickers/mod.rs | 12 +- .../src/Windows/Storage/Provider/mod.rs | 14 +- .../windows/src/Windows/Storage/Search/mod.rs | 78 +- .../src/Windows/Storage/Streams/mod.rs | 96 +- .../libs/windows/src/Windows/Storage/mod.rs | 434 ++--- .../src/Windows/System/Diagnostics/mod.rs | 4 +- .../System/Implementation/FileExplorer/mod.rs | 4 +- .../src/Windows/System/Inventory/mod.rs | 2 +- .../windows/src/Windows/System/Profile/mod.rs | 2 +- .../src/Windows/System/RemoteSystems/mod.rs | 22 +- .../src/Windows/System/Threading/Core/mod.rs | 2 +- .../src/Windows/System/Threading/mod.rs | 14 +- .../windows/src/Windows/System/Update/mod.rs | 4 +- .../src/Windows/System/UserProfile/mod.rs | 30 +- crates/libs/windows/src/Windows/System/mod.rs | 108 +- .../src/Windows/UI/ApplicationSettings/mod.rs | 8 +- .../src/Windows/UI/Composition/Core/mod.rs | 2 +- .../windows/src/Windows/UI/Composition/mod.rs | 4 +- .../libs/windows/src/Windows/UI/Core/mod.rs | 12 +- .../Windows/UI/Input/Inking/Analysis/mod.rs | 2 +- .../src/Windows/UI/Input/Inking/mod.rs | 28 +- .../src/Windows/UI/Input/Spatial/mod.rs | 4 +- .../UI/Notifications/Management/mod.rs | 4 +- .../src/Windows/UI/Notifications/mod.rs | 14 +- .../libs/windows/src/Windows/UI/Popups/mod.rs | 8 +- .../libs/windows/src/Windows/UI/Shell/mod.rs | 14 +- .../windows/src/Windows/UI/StartScreen/mod.rs | 36 +- .../src/Windows/UI/UIAutomation/Core/mod.rs | 4 +- .../src/Windows/UI/ViewManagement/Core/mod.rs | 2 +- .../src/Windows/UI/ViewManagement/mod.rs | 48 +- .../libs/windows/src/Windows/UI/WebUI/mod.rs | 14 +- .../src/Windows/UI/WindowManagement/mod.rs | 6 +- .../windows/src/Windows/Web/AtomPub/mod.rs | 22 +- .../src/Windows/Web/Http/Filters/mod.rs | 6 +- .../libs/windows/src/Windows/Web/Http/mod.rs | 120 +- .../src/Windows/Web/Syndication/mod.rs | 6 +- .../windows/src/Windows/Web/UI/Interop/mod.rs | 8 +- crates/libs/windows/src/Windows/Web/UI/mod.rs | 12 +- crates/libs/windows/src/Windows/Web/mod.rs | 4 +- .../libs/windows/src/extensions/Foundation.rs | 6 - 204 files changed, 2713 insertions(+), 3963 deletions(-) diff --git a/crates/libs/windows/Cargo.toml b/crates/libs/windows/Cargo.toml index b4f053f431..73d0e484a0 100644 --- a/crates/libs/windows/Cargo.toml +++ b/crates/libs/windows/Cargo.toml @@ -45,6 +45,10 @@ version = "0.1.0" path = "../numerics" default-features = false +[dependencies.windows-async] +version = "0.1.0" +path = "../async" +default-features = false [features] default = ["std"] diff --git a/crates/libs/windows/src/Windows/AI/MachineLearning/mod.rs b/crates/libs/windows/src/Windows/AI/MachineLearning/mod.rs index 6ec9f95e91..6456dc5da7 100644 --- a/crates/libs/windows/src/Windows/AI/MachineLearning/mod.rs +++ b/crates/libs/windows/src/Windows/AI/MachineLearning/mod.rs @@ -1164,7 +1164,7 @@ impl LearningModel { } } #[cfg(feature = "Storage_Streams")] - pub fn LoadFromStorageFileAsync(modelfile: P0) -> windows_core::Result> + pub fn LoadFromStorageFileAsync(modelfile: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1174,7 +1174,7 @@ impl LearningModel { }) } #[cfg(feature = "Storage_Streams")] - pub fn LoadFromStreamAsync(modelstream: P0) -> windows_core::Result> + pub fn LoadFromStreamAsync(modelstream: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1200,7 +1200,7 @@ impl LearningModel { }) } #[cfg(feature = "Storage_Streams")] - pub fn LoadFromStorageFileWithOperatorProviderAsync(modelfile: P0, operatorprovider: P1) -> windows_core::Result> + pub fn LoadFromStorageFileWithOperatorProviderAsync(modelfile: P0, operatorprovider: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -1211,7 +1211,7 @@ impl LearningModel { }) } #[cfg(feature = "Storage_Streams")] - pub fn LoadFromStreamWithOperatorProviderAsync(modelstream: P0, operatorprovider: P1) -> windows_core::Result> + pub fn LoadFromStreamWithOperatorProviderAsync(modelstream: P0, operatorprovider: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -1537,7 +1537,7 @@ impl LearningModelSession { (windows_core::Interface::vtable(this).EvaluationProperties)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn EvaluateAsync(&self, bindings: P0, correlationid: &windows_core::HSTRING) -> windows_core::Result> + pub fn EvaluateAsync(&self, bindings: P0, correlationid: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -1547,7 +1547,7 @@ impl LearningModelSession { (windows_core::Interface::vtable(this).EvaluateAsync)(windows_core::Interface::as_raw(this), bindings.param().abi(), core::mem::transmute_copy(correlationid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn EvaluateFeaturesAsync(&self, features: P0, correlationid: &windows_core::HSTRING) -> windows_core::Result> + pub fn EvaluateFeaturesAsync(&self, features: P0, correlationid: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param>, { diff --git a/crates/libs/windows/src/Windows/ApplicationModel/AppExtensions/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/AppExtensions/mod.rs index e1ea0df6df..0f8addff10 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/AppExtensions/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/AppExtensions/mod.rs @@ -39,7 +39,7 @@ impl AppExtension { } } #[cfg(feature = "Foundation_Collections")] - pub fn GetExtensionPropertiesAsync(&self) -> windows_core::Result> { + pub fn GetExtensionPropertiesAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -47,7 +47,7 @@ impl AppExtension { } } #[cfg(feature = "Storage_Search")] - pub fn GetPublicFolderAsync(&self) -> windows_core::Result> { + pub fn GetPublicFolderAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -102,14 +102,14 @@ unsafe impl Sync for AppExtension {} pub struct AppExtensionCatalog(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(AppExtensionCatalog, windows_core::IUnknown, windows_core::IInspectable); impl AppExtensionCatalog { - pub fn FindAllAsync(&self) -> windows_core::Result>> { + pub fn FindAllAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAllAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestRemovePackageAsync(&self, packagefullname: &windows_core::HSTRING) -> windows_core::Result> { + pub fn RequestRemovePackageAsync(&self, packagefullname: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/ApplicationModel/AppService/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/AppService/mod.rs index c623fe57d8..6f5eec9758 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/AppService/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/AppService/mod.rs @@ -1,6 +1,6 @@ pub struct AppServiceCatalog; impl AppServiceCatalog { - pub fn FindAppServiceProvidersAsync(appservicename: &windows_core::HSTRING) -> windows_core::Result>> { + pub fn FindAppServiceProvidersAsync(appservicename: &windows_core::HSTRING) -> windows_core::Result>> { Self::IAppServiceCatalogStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAppServiceProvidersAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(appservicename), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -89,7 +89,7 @@ impl AppServiceConnection { let this = self; unsafe { (windows_core::Interface::vtable(this).SetPackageFamilyName)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(value)).ok() } } - pub fn OpenAsync(&self) -> windows_core::Result> { + pub fn OpenAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -97,7 +97,7 @@ impl AppServiceConnection { } } #[cfg(feature = "Foundation_Collections")] - pub fn SendMessageAsync(&self, message: P0) -> windows_core::Result> + pub fn SendMessageAsync(&self, message: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -136,7 +136,7 @@ impl AppServiceConnection { unsafe { (windows_core::Interface::vtable(this).RemoveServiceClosed)(windows_core::Interface::as_raw(this), token).ok() } } #[cfg(feature = "System_RemoteSystems")] - pub fn OpenRemoteAsync(&self, remotesystemconnectionrequest: P0) -> windows_core::Result> + pub fn OpenRemoteAsync(&self, remotesystemconnectionrequest: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -163,7 +163,7 @@ impl AppServiceConnection { unsafe { (windows_core::Interface::vtable(this).SetUser)(windows_core::Interface::as_raw(this), value.param().abi()).ok() } } #[cfg(all(feature = "Foundation_Collections", feature = "System_RemoteSystems"))] - pub fn SendStatelessMessageAsync(connection: P0, connectionrequest: P1, message: P2) -> windows_core::Result> + pub fn SendStatelessMessageAsync(connection: P0, connectionrequest: P1, message: P2) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -254,7 +254,7 @@ impl AppServiceRequest { } } #[cfg(feature = "Foundation_Collections")] - pub fn SendResponseAsync(&self, message: P0) -> windows_core::Result> + pub fn SendResponseAsync(&self, message: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -397,7 +397,7 @@ impl AppServiceTriggerDetails { (windows_core::Interface::vtable(this).IsRemoteSystemConnection)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn CheckCallerForCapabilityAsync(&self, capabilityname: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CheckCallerForCapabilityAsync(&self, capabilityname: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/ApplicationModel/Appointments/DataProvider/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/Appointments/DataProvider/mod.rs index 3e10c1ab64..d4941b2777 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/Appointments/DataProvider/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/Appointments/DataProvider/mod.rs @@ -45,14 +45,14 @@ impl AppointmentCalendarCancelMeetingRequest { (windows_core::Interface::vtable(this).NotifyInvitees)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn ReportCompletedAsync(&self) -> windows_core::Result { + pub fn ReportCompletedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -137,7 +137,7 @@ impl AppointmentCalendarCreateOrUpdateAppointmentRequest { (windows_core::Interface::vtable(this).ChangedProperties)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportCompletedAsync(&self, createdorupdatedappointment: P0) -> windows_core::Result + pub fn ReportCompletedAsync(&self, createdorupdatedappointment: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -147,7 +147,7 @@ impl AppointmentCalendarCreateOrUpdateAppointmentRequest { (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), createdorupdatedappointment.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -253,14 +253,14 @@ impl AppointmentCalendarForwardMeetingRequest { (windows_core::Interface::vtable(this).Comment)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn ReportCompletedAsync(&self) -> windows_core::Result { + pub fn ReportCompletedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -366,14 +366,14 @@ impl AppointmentCalendarProposeNewTimeForMeetingRequest { (windows_core::Interface::vtable(this).Comment)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn ReportCompletedAsync(&self) -> windows_core::Result { + pub fn ReportCompletedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -437,14 +437,14 @@ impl AppointmentCalendarSyncManagerSyncRequest { (windows_core::Interface::vtable(this).AppointmentCalendarLocalId)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn ReportCompletedAsync(&self) -> windows_core::Result { + pub fn ReportCompletedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -550,14 +550,14 @@ impl AppointmentCalendarUpdateMeetingResponseRequest { (windows_core::Interface::vtable(this).SendUpdate)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn ReportCompletedAsync(&self) -> windows_core::Result { + pub fn ReportCompletedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/ApplicationModel/Appointments/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/Appointments/mod.rs index d09d8cbc33..1985556a26 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/Appointments/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/Appointments/mod.rs @@ -420,14 +420,14 @@ impl AppointmentCalendar { let this = self; unsafe { (windows_core::Interface::vtable(this).SetSummaryCardView)(windows_core::Interface::as_raw(this), value).ok() } } - pub fn FindAppointmentsAsync(&self, rangestart: super::super::Foundation::DateTime, rangelength: super::super::Foundation::TimeSpan) -> windows_core::Result>> { + pub fn FindAppointmentsAsync(&self, rangestart: super::super::Foundation::DateTime, rangelength: super::super::Foundation::TimeSpan) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAppointmentsAsync)(windows_core::Interface::as_raw(this), rangestart, rangelength, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FindAppointmentsAsyncWithOptions(&self, rangestart: super::super::Foundation::DateTime, rangelength: super::super::Foundation::TimeSpan, options: P2) -> windows_core::Result>> + pub fn FindAppointmentsAsyncWithOptions(&self, rangestart: super::super::Foundation::DateTime, rangelength: super::super::Foundation::TimeSpan, options: P2) -> windows_core::Result>> where P2: windows_core::Param, { @@ -437,21 +437,21 @@ impl AppointmentCalendar { (windows_core::Interface::vtable(this).FindAppointmentsAsyncWithOptions)(windows_core::Interface::as_raw(this), rangestart, rangelength, options.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FindExceptionsFromMasterAsync(&self, masterlocalid: &windows_core::HSTRING) -> windows_core::Result>> { + pub fn FindExceptionsFromMasterAsync(&self, masterlocalid: &windows_core::HSTRING) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindExceptionsFromMasterAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(masterlocalid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FindAllInstancesAsync(&self, masterlocalid: &windows_core::HSTRING, rangestart: super::super::Foundation::DateTime, rangelength: super::super::Foundation::TimeSpan) -> windows_core::Result>> { + pub fn FindAllInstancesAsync(&self, masterlocalid: &windows_core::HSTRING, rangestart: super::super::Foundation::DateTime, rangelength: super::super::Foundation::TimeSpan) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAllInstancesAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(masterlocalid), rangestart, rangelength, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FindAllInstancesAsyncWithOptions(&self, masterlocalid: &windows_core::HSTRING, rangestart: super::super::Foundation::DateTime, rangelength: super::super::Foundation::TimeSpan, poptions: P3) -> windows_core::Result>> + pub fn FindAllInstancesAsyncWithOptions(&self, masterlocalid: &windows_core::HSTRING, rangestart: super::super::Foundation::DateTime, rangelength: super::super::Foundation::TimeSpan, poptions: P3) -> windows_core::Result>> where P3: windows_core::Param, { @@ -461,28 +461,28 @@ impl AppointmentCalendar { (windows_core::Interface::vtable(this).FindAllInstancesAsyncWithOptions)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(masterlocalid), rangestart, rangelength, poptions.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAppointmentAsync(&self, localid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetAppointmentAsync(&self, localid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetAppointmentAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(localid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAppointmentInstanceAsync(&self, localid: &windows_core::HSTRING, instancestarttime: super::super::Foundation::DateTime) -> windows_core::Result> { + pub fn GetAppointmentInstanceAsync(&self, localid: &windows_core::HSTRING, instancestarttime: super::super::Foundation::DateTime) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetAppointmentInstanceAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(localid), instancestarttime, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FindUnexpandedAppointmentsAsync(&self) -> windows_core::Result>> { + pub fn FindUnexpandedAppointmentsAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindUnexpandedAppointmentsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FindUnexpandedAppointmentsAsyncWithOptions(&self, options: P0) -> windows_core::Result>> + pub fn FindUnexpandedAppointmentsAsyncWithOptions(&self, options: P0) -> windows_core::Result>> where P0: windows_core::Param, { @@ -492,35 +492,35 @@ impl AppointmentCalendar { (windows_core::Interface::vtable(this).FindUnexpandedAppointmentsAsyncWithOptions)(windows_core::Interface::as_raw(this), options.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAsync(&self) -> windows_core::Result { + pub fn DeleteAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeleteAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SaveAsync(&self) -> windows_core::Result { + pub fn SaveAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).SaveAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAppointmentAsync(&self, localid: &windows_core::HSTRING) -> windows_core::Result { + pub fn DeleteAppointmentAsync(&self, localid: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeleteAppointmentAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(localid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAppointmentInstanceAsync(&self, localid: &windows_core::HSTRING, instancestarttime: super::super::Foundation::DateTime) -> windows_core::Result { + pub fn DeleteAppointmentInstanceAsync(&self, localid: &windows_core::HSTRING, instancestarttime: super::super::Foundation::DateTime) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeleteAppointmentInstanceAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(localid), instancestarttime, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SaveAppointmentAsync(&self, pappointment: P0) -> windows_core::Result + pub fn SaveAppointmentAsync(&self, pappointment: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -641,7 +641,7 @@ impl AppointmentCalendar { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).SetMustNofityInvitees)(windows_core::Interface::as_raw(this), value).ok() } } - pub fn TryCreateOrUpdateAppointmentAsync(&self, appointment: P0, notifyinvitees: bool) -> windows_core::Result> + pub fn TryCreateOrUpdateAppointmentAsync(&self, appointment: P0, notifyinvitees: bool) -> windows_core::Result> where P0: windows_core::Param, { @@ -651,7 +651,7 @@ impl AppointmentCalendar { (windows_core::Interface::vtable(this).TryCreateOrUpdateAppointmentAsync)(windows_core::Interface::as_raw(this), appointment.param().abi(), notifyinvitees, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryCancelMeetingAsync(&self, meeting: P0, subject: &windows_core::HSTRING, comment: &windows_core::HSTRING, notifyinvitees: bool) -> windows_core::Result> + pub fn TryCancelMeetingAsync(&self, meeting: P0, subject: &windows_core::HSTRING, comment: &windows_core::HSTRING, notifyinvitees: bool) -> windows_core::Result> where P0: windows_core::Param, { @@ -661,7 +661,7 @@ impl AppointmentCalendar { (windows_core::Interface::vtable(this).TryCancelMeetingAsync)(windows_core::Interface::as_raw(this), meeting.param().abi(), core::mem::transmute_copy(subject), core::mem::transmute_copy(comment), notifyinvitees, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryForwardMeetingAsync(&self, meeting: P0, invitees: P1, subject: &windows_core::HSTRING, forwardheader: &windows_core::HSTRING, comment: &windows_core::HSTRING) -> windows_core::Result> + pub fn TryForwardMeetingAsync(&self, meeting: P0, invitees: P1, subject: &windows_core::HSTRING, forwardheader: &windows_core::HSTRING, comment: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param>, @@ -672,7 +672,7 @@ impl AppointmentCalendar { (windows_core::Interface::vtable(this).TryForwardMeetingAsync)(windows_core::Interface::as_raw(this), meeting.param().abi(), invitees.param().abi(), core::mem::transmute_copy(subject), core::mem::transmute_copy(forwardheader), core::mem::transmute_copy(comment), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryProposeNewTimeForMeetingAsync(&self, meeting: P0, newstarttime: super::super::Foundation::DateTime, newduration: super::super::Foundation::TimeSpan, subject: &windows_core::HSTRING, comment: &windows_core::HSTRING) -> windows_core::Result> + pub fn TryProposeNewTimeForMeetingAsync(&self, meeting: P0, newstarttime: super::super::Foundation::DateTime, newduration: super::super::Foundation::TimeSpan, subject: &windows_core::HSTRING, comment: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -682,7 +682,7 @@ impl AppointmentCalendar { (windows_core::Interface::vtable(this).TryProposeNewTimeForMeetingAsync)(windows_core::Interface::as_raw(this), meeting.param().abi(), newstarttime, newduration, core::mem::transmute_copy(subject), core::mem::transmute_copy(comment), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryUpdateMeetingResponseAsync(&self, meeting: P0, response: AppointmentParticipantResponse, subject: &windows_core::HSTRING, comment: &windows_core::HSTRING, sendupdate: bool) -> windows_core::Result> + pub fn TryUpdateMeetingResponseAsync(&self, meeting: P0, response: AppointmentParticipantResponse, subject: &windows_core::HSTRING, comment: &windows_core::HSTRING, sendupdate: bool) -> windows_core::Result> where P0: windows_core::Param, { @@ -692,7 +692,7 @@ impl AppointmentCalendar { (windows_core::Interface::vtable(this).TryUpdateMeetingResponseAsync)(windows_core::Interface::as_raw(this), meeting.param().abi(), response, core::mem::transmute_copy(subject), core::mem::transmute_copy(comment), sendupdate, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RegisterSyncManagerAsync(&self) -> windows_core::Result { + pub fn RegisterSyncManagerAsync(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -767,7 +767,7 @@ impl AppointmentCalendarSyncManager { (windows_core::Interface::vtable(this).LastAttemptedSyncTime)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn SyncAsync(&self) -> windows_core::Result> { + pub fn SyncAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1053,7 +1053,7 @@ unsafe impl Send for AppointmentInvitee {} unsafe impl Sync for AppointmentInvitee {} pub struct AppointmentManager; impl AppointmentManager { - pub fn ShowAddAppointmentAsync(appointment: P0, selection: super::super::Foundation::Rect) -> windows_core::Result> + pub fn ShowAddAppointmentAsync(appointment: P0, selection: super::super::Foundation::Rect) -> windows_core::Result> where P0: windows_core::Param, { @@ -1063,7 +1063,7 @@ impl AppointmentManager { }) } #[cfg(feature = "UI_Popups")] - pub fn ShowAddAppointmentWithPlacementAsync(appointment: P0, selection: super::super::Foundation::Rect, preferredplacement: super::super::UI::Popups::Placement) -> windows_core::Result> + pub fn ShowAddAppointmentWithPlacementAsync(appointment: P0, selection: super::super::Foundation::Rect, preferredplacement: super::super::UI::Popups::Placement) -> windows_core::Result> where P0: windows_core::Param, { @@ -1072,7 +1072,7 @@ impl AppointmentManager { (windows_core::Interface::vtable(this).ShowAddAppointmentWithPlacementAsync)(windows_core::Interface::as_raw(this), appointment.param().abi(), selection, preferredplacement, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn ShowReplaceAppointmentAsync(appointmentid: &windows_core::HSTRING, appointment: P1, selection: super::super::Foundation::Rect) -> windows_core::Result> + pub fn ShowReplaceAppointmentAsync(appointmentid: &windows_core::HSTRING, appointment: P1, selection: super::super::Foundation::Rect) -> windows_core::Result> where P1: windows_core::Param, { @@ -1082,7 +1082,7 @@ impl AppointmentManager { }) } #[cfg(feature = "UI_Popups")] - pub fn ShowReplaceAppointmentWithPlacementAsync(appointmentid: &windows_core::HSTRING, appointment: P1, selection: super::super::Foundation::Rect, preferredplacement: super::super::UI::Popups::Placement) -> windows_core::Result> + pub fn ShowReplaceAppointmentWithPlacementAsync(appointmentid: &windows_core::HSTRING, appointment: P1, selection: super::super::Foundation::Rect, preferredplacement: super::super::UI::Popups::Placement) -> windows_core::Result> where P1: windows_core::Param, { @@ -1092,7 +1092,7 @@ impl AppointmentManager { }) } #[cfg(feature = "UI_Popups")] - pub fn ShowReplaceAppointmentWithPlacementAndDateAsync(appointmentid: &windows_core::HSTRING, appointment: P1, selection: super::super::Foundation::Rect, preferredplacement: super::super::UI::Popups::Placement, instancestartdate: super::super::Foundation::DateTime) -> windows_core::Result> + pub fn ShowReplaceAppointmentWithPlacementAndDateAsync(appointmentid: &windows_core::HSTRING, appointment: P1, selection: super::super::Foundation::Rect, preferredplacement: super::super::UI::Popups::Placement, instancestartdate: super::super::Foundation::DateTime) -> windows_core::Result> where P1: windows_core::Param, { @@ -1101,45 +1101,45 @@ impl AppointmentManager { (windows_core::Interface::vtable(this).ShowReplaceAppointmentWithPlacementAndDateAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(appointmentid), appointment.param().abi(), selection, preferredplacement, instancestartdate, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn ShowRemoveAppointmentAsync(appointmentid: &windows_core::HSTRING, selection: super::super::Foundation::Rect) -> windows_core::Result> { + pub fn ShowRemoveAppointmentAsync(appointmentid: &windows_core::HSTRING, selection: super::super::Foundation::Rect) -> windows_core::Result> { Self::IAppointmentManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ShowRemoveAppointmentAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(appointmentid), selection, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "UI_Popups")] - pub fn ShowRemoveAppointmentWithPlacementAsync(appointmentid: &windows_core::HSTRING, selection: super::super::Foundation::Rect, preferredplacement: super::super::UI::Popups::Placement) -> windows_core::Result> { + pub fn ShowRemoveAppointmentWithPlacementAsync(appointmentid: &windows_core::HSTRING, selection: super::super::Foundation::Rect, preferredplacement: super::super::UI::Popups::Placement) -> windows_core::Result> { Self::IAppointmentManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ShowRemoveAppointmentWithPlacementAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(appointmentid), selection, preferredplacement, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "UI_Popups")] - pub fn ShowRemoveAppointmentWithPlacementAndDateAsync(appointmentid: &windows_core::HSTRING, selection: super::super::Foundation::Rect, preferredplacement: super::super::UI::Popups::Placement, instancestartdate: super::super::Foundation::DateTime) -> windows_core::Result> { + pub fn ShowRemoveAppointmentWithPlacementAndDateAsync(appointmentid: &windows_core::HSTRING, selection: super::super::Foundation::Rect, preferredplacement: super::super::UI::Popups::Placement, instancestartdate: super::super::Foundation::DateTime) -> windows_core::Result> { Self::IAppointmentManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ShowRemoveAppointmentWithPlacementAndDateAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(appointmentid), selection, preferredplacement, instancestartdate, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn ShowTimeFrameAsync(timetoshow: super::super::Foundation::DateTime, duration: super::super::Foundation::TimeSpan) -> windows_core::Result { + pub fn ShowTimeFrameAsync(timetoshow: super::super::Foundation::DateTime, duration: super::super::Foundation::TimeSpan) -> windows_core::Result { Self::IAppointmentManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ShowTimeFrameAsync)(windows_core::Interface::as_raw(this), timetoshow, duration, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn ShowAppointmentDetailsAsync(appointmentid: &windows_core::HSTRING) -> windows_core::Result { + pub fn ShowAppointmentDetailsAsync(appointmentid: &windows_core::HSTRING) -> windows_core::Result { Self::IAppointmentManagerStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ShowAppointmentDetailsAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(appointmentid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn ShowAppointmentDetailsWithDateAsync(appointmentid: &windows_core::HSTRING, instancestartdate: super::super::Foundation::DateTime) -> windows_core::Result { + pub fn ShowAppointmentDetailsWithDateAsync(appointmentid: &windows_core::HSTRING, instancestartdate: super::super::Foundation::DateTime) -> windows_core::Result { Self::IAppointmentManagerStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ShowAppointmentDetailsWithDateAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(appointmentid), instancestartdate, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn ShowEditNewAppointmentAsync(appointment: P0) -> windows_core::Result> + pub fn ShowEditNewAppointmentAsync(appointment: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1148,7 +1148,7 @@ impl AppointmentManager { (windows_core::Interface::vtable(this).ShowEditNewAppointmentAsync)(windows_core::Interface::as_raw(this), appointment.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RequestStoreAsync(options: AppointmentStoreAccessType) -> windows_core::Result> { + pub fn RequestStoreAsync(options: AppointmentStoreAccessType) -> windows_core::Result> { Self::IAppointmentManagerStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestStoreAsync)(windows_core::Interface::as_raw(this), options, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -1185,7 +1185,7 @@ impl windows_core::RuntimeName for AppointmentManager { pub struct AppointmentManagerForUser(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(AppointmentManagerForUser, windows_core::IUnknown, windows_core::IInspectable); impl AppointmentManagerForUser { - pub fn ShowAddAppointmentAsync(&self, appointment: P0, selection: super::super::Foundation::Rect) -> windows_core::Result> + pub fn ShowAddAppointmentAsync(&self, appointment: P0, selection: super::super::Foundation::Rect) -> windows_core::Result> where P0: windows_core::Param, { @@ -1196,7 +1196,7 @@ impl AppointmentManagerForUser { } } #[cfg(feature = "UI_Popups")] - pub fn ShowAddAppointmentWithPlacementAsync(&self, appointment: P0, selection: super::super::Foundation::Rect, preferredplacement: super::super::UI::Popups::Placement) -> windows_core::Result> + pub fn ShowAddAppointmentWithPlacementAsync(&self, appointment: P0, selection: super::super::Foundation::Rect, preferredplacement: super::super::UI::Popups::Placement) -> windows_core::Result> where P0: windows_core::Param, { @@ -1206,7 +1206,7 @@ impl AppointmentManagerForUser { (windows_core::Interface::vtable(this).ShowAddAppointmentWithPlacementAsync)(windows_core::Interface::as_raw(this), appointment.param().abi(), selection, preferredplacement, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ShowReplaceAppointmentAsync(&self, appointmentid: &windows_core::HSTRING, appointment: P1, selection: super::super::Foundation::Rect) -> windows_core::Result> + pub fn ShowReplaceAppointmentAsync(&self, appointmentid: &windows_core::HSTRING, appointment: P1, selection: super::super::Foundation::Rect) -> windows_core::Result> where P1: windows_core::Param, { @@ -1217,7 +1217,7 @@ impl AppointmentManagerForUser { } } #[cfg(feature = "UI_Popups")] - pub fn ShowReplaceAppointmentWithPlacementAsync(&self, appointmentid: &windows_core::HSTRING, appointment: P1, selection: super::super::Foundation::Rect, preferredplacement: super::super::UI::Popups::Placement) -> windows_core::Result> + pub fn ShowReplaceAppointmentWithPlacementAsync(&self, appointmentid: &windows_core::HSTRING, appointment: P1, selection: super::super::Foundation::Rect, preferredplacement: super::super::UI::Popups::Placement) -> windows_core::Result> where P1: windows_core::Param, { @@ -1228,7 +1228,7 @@ impl AppointmentManagerForUser { } } #[cfg(feature = "UI_Popups")] - pub fn ShowReplaceAppointmentWithPlacementAndDateAsync(&self, appointmentid: &windows_core::HSTRING, appointment: P1, selection: super::super::Foundation::Rect, preferredplacement: super::super::UI::Popups::Placement, instancestartdate: super::super::Foundation::DateTime) -> windows_core::Result> + pub fn ShowReplaceAppointmentWithPlacementAndDateAsync(&self, appointmentid: &windows_core::HSTRING, appointment: P1, selection: super::super::Foundation::Rect, preferredplacement: super::super::UI::Popups::Placement, instancestartdate: super::super::Foundation::DateTime) -> windows_core::Result> where P1: windows_core::Param, { @@ -1238,7 +1238,7 @@ impl AppointmentManagerForUser { (windows_core::Interface::vtable(this).ShowReplaceAppointmentWithPlacementAndDateAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(appointmentid), appointment.param().abi(), selection, preferredplacement, instancestartdate, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ShowRemoveAppointmentAsync(&self, appointmentid: &windows_core::HSTRING, selection: super::super::Foundation::Rect) -> windows_core::Result> { + pub fn ShowRemoveAppointmentAsync(&self, appointmentid: &windows_core::HSTRING, selection: super::super::Foundation::Rect) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1246,7 +1246,7 @@ impl AppointmentManagerForUser { } } #[cfg(feature = "UI_Popups")] - pub fn ShowRemoveAppointmentWithPlacementAsync(&self, appointmentid: &windows_core::HSTRING, selection: super::super::Foundation::Rect, preferredplacement: super::super::UI::Popups::Placement) -> windows_core::Result> { + pub fn ShowRemoveAppointmentWithPlacementAsync(&self, appointmentid: &windows_core::HSTRING, selection: super::super::Foundation::Rect, preferredplacement: super::super::UI::Popups::Placement) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1254,35 +1254,35 @@ impl AppointmentManagerForUser { } } #[cfg(feature = "UI_Popups")] - pub fn ShowRemoveAppointmentWithPlacementAndDateAsync(&self, appointmentid: &windows_core::HSTRING, selection: super::super::Foundation::Rect, preferredplacement: super::super::UI::Popups::Placement, instancestartdate: super::super::Foundation::DateTime) -> windows_core::Result> { + pub fn ShowRemoveAppointmentWithPlacementAndDateAsync(&self, appointmentid: &windows_core::HSTRING, selection: super::super::Foundation::Rect, preferredplacement: super::super::UI::Popups::Placement, instancestartdate: super::super::Foundation::DateTime) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ShowRemoveAppointmentWithPlacementAndDateAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(appointmentid), selection, preferredplacement, instancestartdate, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ShowTimeFrameAsync(&self, timetoshow: super::super::Foundation::DateTime, duration: super::super::Foundation::TimeSpan) -> windows_core::Result { + pub fn ShowTimeFrameAsync(&self, timetoshow: super::super::Foundation::DateTime, duration: super::super::Foundation::TimeSpan) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ShowTimeFrameAsync)(windows_core::Interface::as_raw(this), timetoshow, duration, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ShowAppointmentDetailsAsync(&self, appointmentid: &windows_core::HSTRING) -> windows_core::Result { + pub fn ShowAppointmentDetailsAsync(&self, appointmentid: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ShowAppointmentDetailsAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(appointmentid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ShowAppointmentDetailsWithDateAsync(&self, appointmentid: &windows_core::HSTRING, instancestartdate: super::super::Foundation::DateTime) -> windows_core::Result { + pub fn ShowAppointmentDetailsWithDateAsync(&self, appointmentid: &windows_core::HSTRING, instancestartdate: super::super::Foundation::DateTime) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ShowAppointmentDetailsWithDateAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(appointmentid), instancestartdate, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ShowEditNewAppointmentAsync(&self, appointment: P0) -> windows_core::Result> + pub fn ShowEditNewAppointmentAsync(&self, appointment: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1292,7 +1292,7 @@ impl AppointmentManagerForUser { (windows_core::Interface::vtable(this).ShowEditNewAppointmentAsync)(windows_core::Interface::as_raw(this), appointment.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestStoreAsync(&self, options: AppointmentStoreAccessType) -> windows_core::Result> { + pub fn RequestStoreAsync(&self, options: AppointmentStoreAccessType) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1753,56 +1753,56 @@ impl AppointmentStore { (windows_core::Interface::vtable(this).ChangeTracker)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateAppointmentCalendarAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CreateAppointmentCalendarAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreateAppointmentCalendarAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(name), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAppointmentCalendarAsync(&self, calendarid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetAppointmentCalendarAsync(&self, calendarid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetAppointmentCalendarAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(calendarid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAppointmentAsync(&self, localid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetAppointmentAsync(&self, localid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetAppointmentAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(localid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAppointmentInstanceAsync(&self, localid: &windows_core::HSTRING, instancestarttime: super::super::Foundation::DateTime) -> windows_core::Result> { + pub fn GetAppointmentInstanceAsync(&self, localid: &windows_core::HSTRING, instancestarttime: super::super::Foundation::DateTime) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetAppointmentInstanceAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(localid), instancestarttime, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FindAppointmentCalendarsAsync(&self) -> windows_core::Result>> { + pub fn FindAppointmentCalendarsAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAppointmentCalendarsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FindAppointmentCalendarsAsyncWithOptions(&self, options: FindAppointmentCalendarsOptions) -> windows_core::Result>> { + pub fn FindAppointmentCalendarsAsyncWithOptions(&self, options: FindAppointmentCalendarsOptions) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAppointmentCalendarsAsyncWithOptions)(windows_core::Interface::as_raw(this), options, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FindAppointmentsAsync(&self, rangestart: super::super::Foundation::DateTime, rangelength: super::super::Foundation::TimeSpan) -> windows_core::Result>> { + pub fn FindAppointmentsAsync(&self, rangestart: super::super::Foundation::DateTime, rangelength: super::super::Foundation::TimeSpan) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAppointmentsAsync)(windows_core::Interface::as_raw(this), rangestart, rangelength, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FindAppointmentsAsyncWithOptions(&self, rangestart: super::super::Foundation::DateTime, rangelength: super::super::Foundation::TimeSpan, options: P2) -> windows_core::Result>> + pub fn FindAppointmentsAsyncWithOptions(&self, rangestart: super::super::Foundation::DateTime, rangelength: super::super::Foundation::TimeSpan, options: P2) -> windows_core::Result>> where P2: windows_core::Param, { @@ -1812,7 +1812,7 @@ impl AppointmentStore { (windows_core::Interface::vtable(this).FindAppointmentsAsyncWithOptions)(windows_core::Interface::as_raw(this), rangestart, rangelength, options.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FindConflictAsync(&self, appointment: P0) -> windows_core::Result> + pub fn FindConflictAsync(&self, appointment: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1822,7 +1822,7 @@ impl AppointmentStore { (windows_core::Interface::vtable(this).FindConflictAsync)(windows_core::Interface::as_raw(this), appointment.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FindConflictAsyncWithInstanceStart(&self, appointment: P0, instancestarttime: super::super::Foundation::DateTime) -> windows_core::Result> + pub fn FindConflictAsyncWithInstanceStart(&self, appointment: P0, instancestarttime: super::super::Foundation::DateTime) -> windows_core::Result> where P0: windows_core::Param, { @@ -1832,7 +1832,7 @@ impl AppointmentStore { (windows_core::Interface::vtable(this).FindConflictAsyncWithInstanceStart)(windows_core::Interface::as_raw(this), appointment.param().abi(), instancestarttime, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn MoveAppointmentAsync(&self, appointment: P0, destinationcalendar: P1) -> windows_core::Result + pub fn MoveAppointmentAsync(&self, appointment: P0, destinationcalendar: P1) -> windows_core::Result where P0: windows_core::Param, P1: windows_core::Param, @@ -1843,7 +1843,7 @@ impl AppointmentStore { (windows_core::Interface::vtable(this).MoveAppointmentAsync)(windows_core::Interface::as_raw(this), appointment.param().abi(), destinationcalendar.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ShowAddAppointmentAsync(&self, appointment: P0, selection: super::super::Foundation::Rect) -> windows_core::Result> + pub fn ShowAddAppointmentAsync(&self, appointment: P0, selection: super::super::Foundation::Rect) -> windows_core::Result> where P0: windows_core::Param, { @@ -1853,7 +1853,7 @@ impl AppointmentStore { (windows_core::Interface::vtable(this).ShowAddAppointmentAsync)(windows_core::Interface::as_raw(this), appointment.param().abi(), selection, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ShowReplaceAppointmentAsync(&self, localid: &windows_core::HSTRING, appointment: P1, selection: super::super::Foundation::Rect) -> windows_core::Result> + pub fn ShowReplaceAppointmentAsync(&self, localid: &windows_core::HSTRING, appointment: P1, selection: super::super::Foundation::Rect) -> windows_core::Result> where P1: windows_core::Param, { @@ -1864,7 +1864,7 @@ impl AppointmentStore { } } #[cfg(feature = "UI_Popups")] - pub fn ShowReplaceAppointmentWithPlacementAndDateAsync(&self, localid: &windows_core::HSTRING, appointment: P1, selection: super::super::Foundation::Rect, preferredplacement: super::super::UI::Popups::Placement, instancestartdate: super::super::Foundation::DateTime) -> windows_core::Result> + pub fn ShowReplaceAppointmentWithPlacementAndDateAsync(&self, localid: &windows_core::HSTRING, appointment: P1, selection: super::super::Foundation::Rect, preferredplacement: super::super::UI::Popups::Placement, instancestartdate: super::super::Foundation::DateTime) -> windows_core::Result> where P1: windows_core::Param, { @@ -1874,7 +1874,7 @@ impl AppointmentStore { (windows_core::Interface::vtable(this).ShowReplaceAppointmentWithPlacementAndDateAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(localid), appointment.param().abi(), selection, preferredplacement, instancestartdate, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ShowRemoveAppointmentAsync(&self, localid: &windows_core::HSTRING, selection: super::super::Foundation::Rect) -> windows_core::Result> { + pub fn ShowRemoveAppointmentAsync(&self, localid: &windows_core::HSTRING, selection: super::super::Foundation::Rect) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1882,28 +1882,28 @@ impl AppointmentStore { } } #[cfg(feature = "UI_Popups")] - pub fn ShowRemoveAppointmentWithPlacementAndDateAsync(&self, localid: &windows_core::HSTRING, selection: super::super::Foundation::Rect, preferredplacement: super::super::UI::Popups::Placement, instancestartdate: super::super::Foundation::DateTime) -> windows_core::Result> { + pub fn ShowRemoveAppointmentWithPlacementAndDateAsync(&self, localid: &windows_core::HSTRING, selection: super::super::Foundation::Rect, preferredplacement: super::super::UI::Popups::Placement, instancestartdate: super::super::Foundation::DateTime) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ShowRemoveAppointmentWithPlacementAndDateAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(localid), selection, preferredplacement, instancestartdate, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ShowAppointmentDetailsAsync(&self, localid: &windows_core::HSTRING) -> windows_core::Result { + pub fn ShowAppointmentDetailsAsync(&self, localid: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ShowAppointmentDetailsAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(localid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ShowAppointmentDetailsWithDateAsync(&self, localid: &windows_core::HSTRING, instancestartdate: super::super::Foundation::DateTime) -> windows_core::Result { + pub fn ShowAppointmentDetailsWithDateAsync(&self, localid: &windows_core::HSTRING, instancestartdate: super::super::Foundation::DateTime) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ShowAppointmentDetailsWithDateAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(localid), instancestartdate, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ShowEditNewAppointmentAsync(&self, appointment: P0) -> windows_core::Result> + pub fn ShowEditNewAppointmentAsync(&self, appointment: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1913,7 +1913,7 @@ impl AppointmentStore { (windows_core::Interface::vtable(this).ShowEditNewAppointmentAsync)(windows_core::Interface::as_raw(this), appointment.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FindLocalIdsFromRoamingIdAsync(&self, roamingid: &windows_core::HSTRING) -> windows_core::Result>> { + pub fn FindLocalIdsFromRoamingIdAsync(&self, roamingid: &windows_core::HSTRING) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1934,7 +1934,7 @@ impl AppointmentStore { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).RemoveStoreChanged)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn CreateAppointmentCalendarInAccountAsync(&self, name: &windows_core::HSTRING, userdataaccountid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CreateAppointmentCalendarInAccountAsync(&self, name: &windows_core::HSTRING, userdataaccountid: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -2019,7 +2019,7 @@ unsafe impl Sync for AppointmentStoreChange {} pub struct AppointmentStoreChangeReader(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(AppointmentStoreChangeReader, windows_core::IUnknown, windows_core::IInspectable); impl AppointmentStoreChangeReader { - pub fn ReadBatchAsync(&self) -> windows_core::Result>> { + pub fn ReadBatchAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/ApplicationModel/Background/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/Background/mod.rs index de81f6e9f7..b2c0f57c76 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/Background/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/Background/mod.rs @@ -74,7 +74,7 @@ impl windows_core::RuntimeType for AlarmAccessStatus { } pub struct AlarmApplicationManager; impl AlarmApplicationManager { - pub fn RequestAccessAsync() -> windows_core::Result> { + pub fn RequestAccessAsync() -> windows_core::Result> { Self::IAlarmApplicationManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestAccessAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -234,7 +234,7 @@ impl ApplicationTrigger { static SHARED: windows_core::imp::FactoryCache = windows_core::imp::FactoryCache::new(); SHARED.call(callback) } - pub fn RequestAsync(&self) -> windows_core::Result> { + pub fn RequestAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -242,7 +242,7 @@ impl ApplicationTrigger { } } #[cfg(feature = "Foundation_Collections")] - pub fn RequestAsyncWithArguments(&self, arguments: P0) -> windows_core::Result> + pub fn RequestAsyncWithArguments(&self, arguments: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -366,13 +366,13 @@ impl windows_core::RuntimeType for BackgroundAccessStatus { } pub struct BackgroundExecutionManager; impl BackgroundExecutionManager { - pub fn RequestAccessAsync() -> windows_core::Result> { + pub fn RequestAccessAsync() -> windows_core::Result> { Self::IBackgroundExecutionManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestAccessAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RequestAccessForApplicationAsync(applicationid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn RequestAccessForApplicationAsync(applicationid: &windows_core::HSTRING) -> windows_core::Result> { Self::IBackgroundExecutionManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestAccessForApplicationAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(applicationid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -396,13 +396,13 @@ impl BackgroundExecutionManager { (windows_core::Interface::vtable(this).GetAccessStatusForApplication)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(applicationid), &mut result__).map(|| result__) }) } - pub fn RequestAccessKindAsync(requestedaccess: BackgroundAccessRequestKind, reason: &windows_core::HSTRING) -> windows_core::Result> { + pub fn RequestAccessKindAsync(requestedaccess: BackgroundAccessRequestKind, reason: &windows_core::HSTRING) -> windows_core::Result> { Self::IBackgroundExecutionManagerStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestAccessKindAsync)(windows_core::Interface::as_raw(this), requestedaccess, core::mem::transmute_copy(reason), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RequestAccessKindForModernStandbyAsync(requestedaccess: BackgroundAccessRequestKind, reason: &windows_core::HSTRING) -> windows_core::Result> { + pub fn RequestAccessKindForModernStandbyAsync(requestedaccess: BackgroundAccessRequestKind, reason: &windows_core::HSTRING) -> windows_core::Result> { Self::IBackgroundExecutionManagerStatics3(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestAccessKindForModernStandbyAsync)(windows_core::Interface::as_raw(this), requestedaccess, core::mem::transmute_copy(reason), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -1642,7 +1642,7 @@ impl DeviceConnectionChangeTrigger { let this = self; unsafe { (windows_core::Interface::vtable(this).SetMaintainConnection)(windows_core::Interface::as_raw(this), value).ok() } } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IDeviceConnectionChangeTriggerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -1726,14 +1726,14 @@ impl DeviceServicingTrigger { static SHARED: windows_core::imp::FactoryCache = windows_core::imp::FactoryCache::new(); SHARED.call(callback) } - pub fn RequestAsyncSimple(&self, deviceid: &windows_core::HSTRING, expectedduration: super::super::Foundation::TimeSpan) -> windows_core::Result> { + pub fn RequestAsyncSimple(&self, deviceid: &windows_core::HSTRING, expectedduration: super::super::Foundation::TimeSpan) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestAsyncSimple)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), expectedduration, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestAsyncWithArguments(&self, deviceid: &windows_core::HSTRING, expectedduration: super::super::Foundation::TimeSpan, arguments: &windows_core::HSTRING) -> windows_core::Result> { + pub fn RequestAsyncWithArguments(&self, deviceid: &windows_core::HSTRING, expectedduration: super::super::Foundation::TimeSpan, arguments: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1781,14 +1781,14 @@ impl DeviceUseTrigger { static SHARED: windows_core::imp::FactoryCache = windows_core::imp::FactoryCache::new(); SHARED.call(callback) } - pub fn RequestAsyncSimple(&self, deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn RequestAsyncSimple(&self, deviceid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestAsyncSimple)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestAsyncWithArguments(&self, deviceid: &windows_core::HSTRING, arguments: &windows_core::HSTRING) -> windows_core::Result> { + pub fn RequestAsyncWithArguments(&self, deviceid: &windows_core::HSTRING, arguments: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1965,7 +1965,7 @@ impl GattServiceProviderTrigger { (windows_core::Interface::vtable(this).AdvertisingParameters)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateAsync(triggerid: &windows_core::HSTRING, serviceuuid: windows_core::GUID) -> windows_core::Result> { + pub fn CreateAsync(triggerid: &windows_core::HSTRING, serviceuuid: windows_core::GUID) -> windows_core::Result> { Self::IGattServiceProviderTriggerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreateAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(triggerid), serviceuuid, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -4045,7 +4045,7 @@ impl MediaProcessingTrigger { static SHARED: windows_core::imp::FactoryCache = windows_core::imp::FactoryCache::new(); SHARED.call(callback) } - pub fn RequestAsync(&self) -> windows_core::Result> { + pub fn RequestAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -4053,7 +4053,7 @@ impl MediaProcessingTrigger { } } #[cfg(feature = "Foundation_Collections")] - pub fn RequestAsyncWithArguments(&self, arguments: P0) -> windows_core::Result> + pub fn RequestAsyncWithArguments(&self, arguments: P0) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/ApplicationModel/Calls/Provider/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/Calls/Provider/mod.rs index 0552ab42d4..4f6ca2e551 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/Calls/Provider/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/Calls/Provider/mod.rs @@ -197,7 +197,7 @@ impl PhoneCallOriginManager { { Self::IPhoneCallOriginManagerStatics(|this| unsafe { (windows_core::Interface::vtable(this).SetCallOrigin)(windows_core::Interface::as_raw(this), requestid, callorigin.param().abi()).ok() }) } - pub fn RequestSetAsActiveCallOriginAppAsync() -> windows_core::Result> { + pub fn RequestSetAsActiveCallOriginAppAsync() -> windows_core::Result> { Self::IPhoneCallOriginManagerStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestSetAsActiveCallOriginAppAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/ApplicationModel/Calls/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/Calls/mod.rs index 42f67b16c2..e6d78f4d01 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/Calls/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/Calls/mod.rs @@ -1670,7 +1670,7 @@ impl PhoneCall { (windows_core::Interface::vtable(this).GetPhoneCallInfo)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetPhoneCallInfoAsync(&self) -> windows_core::Result> { + pub fn GetPhoneCallInfoAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1684,7 +1684,7 @@ impl PhoneCall { (windows_core::Interface::vtable(this).End)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn EndAsync(&self) -> windows_core::Result> { + pub fn EndAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1698,7 +1698,7 @@ impl PhoneCall { (windows_core::Interface::vtable(this).SendDtmfKey)(windows_core::Interface::as_raw(this), key, dtmftoneaudioplayback, &mut result__).map(|| result__) } } - pub fn SendDtmfKeyAsync(&self, key: DtmfKey, dtmftoneaudioplayback: DtmfToneAudioPlayback) -> windows_core::Result> { + pub fn SendDtmfKeyAsync(&self, key: DtmfKey, dtmftoneaudioplayback: DtmfToneAudioPlayback) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1712,7 +1712,7 @@ impl PhoneCall { (windows_core::Interface::vtable(this).AcceptIncoming)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn AcceptIncomingAsync(&self) -> windows_core::Result> { + pub fn AcceptIncomingAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1726,7 +1726,7 @@ impl PhoneCall { (windows_core::Interface::vtable(this).Hold)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn HoldAsync(&self) -> windows_core::Result> { + pub fn HoldAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1740,7 +1740,7 @@ impl PhoneCall { (windows_core::Interface::vtable(this).ResumeFromHold)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn ResumeFromHoldAsync(&self) -> windows_core::Result> { + pub fn ResumeFromHoldAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1754,7 +1754,7 @@ impl PhoneCall { (windows_core::Interface::vtable(this).Mute)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn MuteAsync(&self) -> windows_core::Result> { + pub fn MuteAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1768,7 +1768,7 @@ impl PhoneCall { (windows_core::Interface::vtable(this).Unmute)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn UnmuteAsync(&self) -> windows_core::Result> { + pub fn UnmuteAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1782,7 +1782,7 @@ impl PhoneCall { (windows_core::Interface::vtable(this).RejectIncoming)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn RejectIncomingAsync(&self) -> windows_core::Result> { + pub fn RejectIncomingAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1796,7 +1796,7 @@ impl PhoneCall { (windows_core::Interface::vtable(this).ChangeAudioDevice)(windows_core::Interface::as_raw(this), endpoint, &mut result__).map(|| result__) } } - pub fn ChangeAudioDeviceAsync(&self, endpoint: PhoneCallAudioDevice) -> windows_core::Result> { + pub fn ChangeAudioDeviceAsync(&self, endpoint: PhoneCallAudioDevice) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1860,7 +1860,7 @@ impl PhoneCallBlocking { pub fn SetBlockPrivateNumbers(value: bool) -> windows_core::Result<()> { Self::IPhoneCallBlockingStatics(|this| unsafe { (windows_core::Interface::vtable(this).SetBlockPrivateNumbers)(windows_core::Interface::as_raw(this), value).ok() }) } - pub fn SetCallBlockingListAsync(phonenumberlist: P0) -> windows_core::Result> + pub fn SetCallBlockingListAsync(phonenumberlist: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -2326,7 +2326,7 @@ impl windows_core::RuntimeType for PhoneCallHistoryEntryRawAddressKind { pub struct PhoneCallHistoryEntryReader(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(PhoneCallHistoryEntryReader, windows_core::IUnknown, windows_core::IInspectable); impl PhoneCallHistoryEntryReader { - pub fn ReadBatchAsync(&self) -> windows_core::Result>> { + pub fn ReadBatchAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2348,7 +2348,7 @@ unsafe impl Send for PhoneCallHistoryEntryReader {} unsafe impl Sync for PhoneCallHistoryEntryReader {} pub struct PhoneCallHistoryManager; impl PhoneCallHistoryManager { - pub fn RequestStoreAsync(accesstype: PhoneCallHistoryStoreAccessType) -> windows_core::Result> { + pub fn RequestStoreAsync(accesstype: PhoneCallHistoryStoreAccessType) -> windows_core::Result> { Self::IPhoneCallHistoryManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestStoreAsync)(windows_core::Interface::as_raw(this), accesstype, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -2381,7 +2381,7 @@ impl windows_core::RuntimeName for PhoneCallHistoryManager { pub struct PhoneCallHistoryManagerForUser(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(PhoneCallHistoryManagerForUser, windows_core::IUnknown, windows_core::IInspectable); impl PhoneCallHistoryManagerForUser { - pub fn RequestStoreAsync(&self, accesstype: PhoneCallHistoryStoreAccessType) -> windows_core::Result> { + pub fn RequestStoreAsync(&self, accesstype: PhoneCallHistoryStoreAccessType) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2427,7 +2427,7 @@ impl windows_core::RuntimeType for PhoneCallHistorySourceIdKind { pub struct PhoneCallHistoryStore(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(PhoneCallHistoryStore, windows_core::IUnknown, windows_core::IInspectable); impl PhoneCallHistoryStore { - pub fn GetEntryAsync(&self, callhistoryentryid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetEntryAsync(&self, callhistoryentryid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2451,7 +2451,7 @@ impl PhoneCallHistoryStore { (windows_core::Interface::vtable(this).GetEntryReaderWithOptions)(windows_core::Interface::as_raw(this), queryoptions.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SaveEntryAsync(&self, callhistoryentry: P0) -> windows_core::Result + pub fn SaveEntryAsync(&self, callhistoryentry: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -2461,7 +2461,7 @@ impl PhoneCallHistoryStore { (windows_core::Interface::vtable(this).SaveEntryAsync)(windows_core::Interface::as_raw(this), callhistoryentry.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteEntryAsync(&self, callhistoryentry: P0) -> windows_core::Result + pub fn DeleteEntryAsync(&self, callhistoryentry: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -2471,7 +2471,7 @@ impl PhoneCallHistoryStore { (windows_core::Interface::vtable(this).DeleteEntryAsync)(windows_core::Interface::as_raw(this), callhistoryentry.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteEntriesAsync(&self, callhistoryentries: P0) -> windows_core::Result + pub fn DeleteEntriesAsync(&self, callhistoryentries: P0) -> windows_core::Result where P0: windows_core::Param>, { @@ -2481,7 +2481,7 @@ impl PhoneCallHistoryStore { (windows_core::Interface::vtable(this).DeleteEntriesAsync)(windows_core::Interface::as_raw(this), callhistoryentries.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn MarkEntryAsSeenAsync(&self, callhistoryentry: P0) -> windows_core::Result + pub fn MarkEntryAsSeenAsync(&self, callhistoryentry: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -2491,7 +2491,7 @@ impl PhoneCallHistoryStore { (windows_core::Interface::vtable(this).MarkEntryAsSeenAsync)(windows_core::Interface::as_raw(this), callhistoryentry.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn MarkEntriesAsSeenAsync(&self, callhistoryentries: P0) -> windows_core::Result + pub fn MarkEntriesAsSeenAsync(&self, callhistoryentries: P0) -> windows_core::Result where P0: windows_core::Param>, { @@ -2501,21 +2501,21 @@ impl PhoneCallHistoryStore { (windows_core::Interface::vtable(this).MarkEntriesAsSeenAsync)(windows_core::Interface::as_raw(this), callhistoryentries.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetUnseenCountAsync(&self) -> windows_core::Result> { + pub fn GetUnseenCountAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetUnseenCountAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn MarkAllAsSeenAsync(&self) -> windows_core::Result { + pub fn MarkAllAsSeenAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).MarkAllAsSeenAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetSourcesUnseenCountAsync(&self, sourceids: P0) -> windows_core::Result> + pub fn GetSourcesUnseenCountAsync(&self, sourceids: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -2525,7 +2525,7 @@ impl PhoneCallHistoryStore { (windows_core::Interface::vtable(this).GetSourcesUnseenCountAsync)(windows_core::Interface::as_raw(this), sourceids.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn MarkSourcesAsSeenAsync(&self, sourceids: P0) -> windows_core::Result + pub fn MarkSourcesAsSeenAsync(&self, sourceids: P0) -> windows_core::Result where P0: windows_core::Param>, { @@ -2654,7 +2654,7 @@ impl PhoneCallManager { pub fn ShowPhoneCallSettingsUI() -> windows_core::Result<()> { Self::IPhoneCallManagerStatics2(|this| unsafe { (windows_core::Interface::vtable(this).ShowPhoneCallSettingsUI)(windows_core::Interface::as_raw(this)).ok() }) } - pub fn RequestStoreAsync() -> windows_core::Result> { + pub fn RequestStoreAsync() -> windows_core::Result> { Self::IPhoneCallManagerStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestStoreAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -2724,14 +2724,14 @@ impl windows_core::RuntimeType for PhoneCallStatus { pub struct PhoneCallStore(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(PhoneCallStore, windows_core::IUnknown, windows_core::IInspectable); impl PhoneCallStore { - pub fn IsEmergencyPhoneNumberAsync(&self, number: &windows_core::HSTRING) -> windows_core::Result> { + pub fn IsEmergencyPhoneNumberAsync(&self, number: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).IsEmergencyPhoneNumberAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(number), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetDefaultLineAsync(&self) -> windows_core::Result> { + pub fn GetDefaultLineAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2785,7 +2785,7 @@ unsafe impl Send for PhoneCallVideoCapabilities {} unsafe impl Sync for PhoneCallVideoCapabilities {} pub struct PhoneCallVideoCapabilitiesManager; impl PhoneCallVideoCapabilitiesManager { - pub fn GetCapabilitiesAsync(phonenumber: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetCapabilitiesAsync(phonenumber: &windows_core::HSTRING) -> windows_core::Result> { Self::IPhoneCallVideoCapabilitiesManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetCapabilitiesAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(phonenumber), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -3036,7 +3036,7 @@ impl PhoneLine { (windows_core::Interface::vtable(this).LineConfiguration)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn IsImmediateDialNumberAsync(&self, number: &windows_core::HSTRING) -> windows_core::Result> { + pub fn IsImmediateDialNumberAsync(&self, number: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -3073,7 +3073,7 @@ impl PhoneLine { (windows_core::Interface::vtable(this).DialWithResult)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(number), core::mem::transmute_copy(displayname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DialWithResultAsync(&self, number: &windows_core::HSTRING, displayname: &windows_core::HSTRING) -> windows_core::Result> { + pub fn DialWithResultAsync(&self, number: &windows_core::HSTRING, displayname: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -3087,14 +3087,14 @@ impl PhoneLine { (windows_core::Interface::vtable(this).GetAllActivePhoneCalls)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAllActivePhoneCallsAsync(&self) -> windows_core::Result> { + pub fn GetAllActivePhoneCallsAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetAllActivePhoneCallsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FromIdAsync(lineid: windows_core::GUID) -> windows_core::Result> { + pub fn FromIdAsync(lineid: windows_core::GUID) -> windows_core::Result> { Self::IPhoneLineStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), lineid, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -3299,7 +3299,7 @@ impl PhoneLineTransportDevice { } } #[cfg(feature = "Devices_Enumeration")] - pub fn RequestAccessAsync(&self) -> windows_core::Result> { + pub fn RequestAccessAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -3344,7 +3344,7 @@ impl PhoneLineTransportDevice { (windows_core::Interface::vtable(this).Connect)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn ConnectAsync(&self) -> windows_core::Result> { + pub fn ConnectAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -3635,7 +3635,7 @@ impl PhoneVoicemail { (windows_core::Interface::vtable(this).Type)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn DialVoicemailAsync(&self) -> windows_core::Result { + pub fn DialVoicemailAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -3701,7 +3701,7 @@ impl windows_core::RuntimeType for VoipCallControlDeviceKind { pub struct VoipCallCoordinator(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(VoipCallCoordinator, windows_core::IUnknown, windows_core::IInspectable); impl VoipCallCoordinator { - pub fn ReserveCallResourcesAsync(&self, taskentrypoint: &windows_core::HSTRING) -> windows_core::Result> { + pub fn ReserveCallResourcesAsync(&self, taskentrypoint: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -3802,7 +3802,7 @@ impl VoipCallCoordinator { (windows_core::Interface::vtable(this).RequestNewIncomingCallWithContactRemoteId)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(context), core::mem::transmute_copy(contactname), core::mem::transmute_copy(contactnumber), contactimage.param().abi(), core::mem::transmute_copy(servicename), brandingimage.param().abi(), core::mem::transmute_copy(calldetails), ringtone.param().abi(), media, ringtimeout, core::mem::transmute_copy(contactremoteid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReserveOneProcessCallResourcesAsync(&self) -> windows_core::Result> { + pub fn ReserveOneProcessCallResourcesAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/ApplicationModel/Chat/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/Chat/mod.rs index 9cdd43681a..f41360e3a8 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/Chat/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/Chat/mod.rs @@ -53,25 +53,25 @@ unsafe impl Send for ChatCapabilities {} unsafe impl Sync for ChatCapabilities {} pub struct ChatCapabilitiesManager; impl ChatCapabilitiesManager { - pub fn GetCachedCapabilitiesAsync(address: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetCachedCapabilitiesAsync(address: &windows_core::HSTRING) -> windows_core::Result> { Self::IChatCapabilitiesManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetCachedCapabilitiesAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(address), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetCapabilitiesFromNetworkAsync(address: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetCapabilitiesFromNetworkAsync(address: &windows_core::HSTRING) -> windows_core::Result> { Self::IChatCapabilitiesManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetCapabilitiesFromNetworkAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(address), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetCachedCapabilitiesForTransportAsync(address: &windows_core::HSTRING, transportid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetCachedCapabilitiesForTransportAsync(address: &windows_core::HSTRING, transportid: &windows_core::HSTRING) -> windows_core::Result> { Self::IChatCapabilitiesManagerStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetCachedCapabilitiesForTransportAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(address), core::mem::transmute_copy(transportid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetCapabilitiesFromNetworkForTransportAsync(address: &windows_core::HSTRING, transportid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetCapabilitiesFromNetworkForTransportAsync(address: &windows_core::HSTRING, transportid: &windows_core::HSTRING) -> windows_core::Result> { Self::IChatCapabilitiesManagerStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetCapabilitiesFromNetworkForTransportAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(address), core::mem::transmute_copy(transportid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -152,7 +152,7 @@ impl ChatConversation { (windows_core::Interface::vtable(this).ThreadingInfo)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAsync(&self) -> windows_core::Result { + pub fn DeleteAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -166,21 +166,21 @@ impl ChatConversation { (windows_core::Interface::vtable(this).GetMessageReader)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn MarkAllMessagesAsReadAsync(&self) -> windows_core::Result { + pub fn MarkAllMessagesAsReadAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).MarkAllMessagesAsReadAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn MarkMessagesAsReadAsync(&self, value: super::super::Foundation::DateTime) -> windows_core::Result { + pub fn MarkMessagesAsReadAsync(&self, value: super::super::Foundation::DateTime) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).MarkMessagesAsReadAsync)(windows_core::Interface::as_raw(this), value, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SaveAsync(&self) -> windows_core::Result { + pub fn SaveAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -245,14 +245,14 @@ unsafe impl Sync for ChatConversation {} pub struct ChatConversationReader(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(ChatConversationReader, windows_core::IUnknown, windows_core::IInspectable); impl ChatConversationReader { - pub fn ReadBatchAsync(&self) -> windows_core::Result>> { + pub fn ReadBatchAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReadBatchAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReadBatchWithCountAsync(&self, count: i32) -> windows_core::Result>> { + pub fn ReadBatchWithCountAsync(&self, count: i32) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -809,7 +809,7 @@ unsafe impl Send for ChatMessageAttachment {} unsafe impl Sync for ChatMessageAttachment {} pub struct ChatMessageBlocking; impl ChatMessageBlocking { - pub fn MarkMessageAsBlockedAsync(localchatmessageid: &windows_core::HSTRING, blocked: bool) -> windows_core::Result { + pub fn MarkMessageAsBlockedAsync(localchatmessageid: &windows_core::HSTRING, blocked: bool) -> windows_core::Result { Self::IChatMessageBlockingStatic(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).MarkMessageAsBlockedAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(localchatmessageid), blocked, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -871,7 +871,7 @@ impl ChatMessageChangeReader { let this = self; unsafe { (windows_core::Interface::vtable(this).AcceptChangesThrough)(windows_core::Interface::as_raw(this), lastchangetoacknowledge.param().abi()).ok() } } - pub fn ReadBatchAsync(&self) -> windows_core::Result>> { + pub fn ReadBatchAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1006,31 +1006,31 @@ impl windows_core::RuntimeType for ChatMessageKind { } pub struct ChatMessageManager; impl ChatMessageManager { - pub fn RegisterTransportAsync() -> windows_core::Result> { + pub fn RegisterTransportAsync() -> windows_core::Result> { Self::IChatMessageManager2Statics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RegisterTransportAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetTransportAsync(transportid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetTransportAsync(transportid: &windows_core::HSTRING) -> windows_core::Result> { Self::IChatMessageManager2Statics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetTransportAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(transportid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetTransportsAsync() -> windows_core::Result>> { + pub fn GetTransportsAsync() -> windows_core::Result>> { Self::IChatMessageManagerStatic(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetTransportsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RequestStoreAsync() -> windows_core::Result> { + pub fn RequestStoreAsync() -> windows_core::Result> { Self::IChatMessageManagerStatic(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestStoreAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn ShowComposeSmsMessageAsync(message: P0) -> windows_core::Result + pub fn ShowComposeSmsMessageAsync(message: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -1042,7 +1042,7 @@ impl ChatMessageManager { pub fn ShowSmsSettings() -> windows_core::Result<()> { Self::IChatMessageManagerStatic(|this| unsafe { (windows_core::Interface::vtable(this).ShowSmsSettings)(windows_core::Interface::as_raw(this)).ok() }) } - pub fn RequestSyncManagerAsync() -> windows_core::Result> { + pub fn RequestSyncManagerAsync() -> windows_core::Result> { Self::IChatMessageManagerStatics3(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestSyncManagerAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -1137,14 +1137,14 @@ impl windows_core::RuntimeType for ChatMessageOperatorKind { pub struct ChatMessageReader(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(ChatMessageReader, windows_core::IUnknown, windows_core::IInspectable); impl ChatMessageReader { - pub fn ReadBatchAsync(&self) -> windows_core::Result>> { + pub fn ReadBatchAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReadBatchAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReadBatchWithCountAsync(&self, count: i32) -> windows_core::Result>> { + pub fn ReadBatchWithCountAsync(&self, count: i32) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1201,21 +1201,21 @@ impl ChatMessageStore { (windows_core::Interface::vtable(this).ChangeTracker)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteMessageAsync(&self, localmessageid: &windows_core::HSTRING) -> windows_core::Result { + pub fn DeleteMessageAsync(&self, localmessageid: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeleteMessageAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(localmessageid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DownloadMessageAsync(&self, localchatmessageid: &windows_core::HSTRING) -> windows_core::Result { + pub fn DownloadMessageAsync(&self, localchatmessageid: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DownloadMessageAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(localchatmessageid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetMessageAsync(&self, localchatmessageid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetMessageAsync(&self, localchatmessageid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1236,21 +1236,21 @@ impl ChatMessageStore { (windows_core::Interface::vtable(this).GetMessageReader2)(windows_core::Interface::as_raw(this), recenttimelimit, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn MarkMessageReadAsync(&self, localchatmessageid: &windows_core::HSTRING) -> windows_core::Result { + pub fn MarkMessageReadAsync(&self, localchatmessageid: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).MarkMessageReadAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(localchatmessageid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RetrySendMessageAsync(&self, localchatmessageid: &windows_core::HSTRING) -> windows_core::Result { + pub fn RetrySendMessageAsync(&self, localchatmessageid: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RetrySendMessageAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(localchatmessageid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SendMessageAsync(&self, chatmessage: P0) -> windows_core::Result + pub fn SendMessageAsync(&self, chatmessage: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -1284,7 +1284,7 @@ impl ChatMessageStore { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveMessageChanged)(windows_core::Interface::as_raw(this), value).ok() } } - pub fn ForwardMessageAsync(&self, localchatmessageid: &windows_core::HSTRING, addresses: P1) -> windows_core::Result> + pub fn ForwardMessageAsync(&self, localchatmessageid: &windows_core::HSTRING, addresses: P1) -> windows_core::Result> where P1: windows_core::Param>, { @@ -1294,14 +1294,14 @@ impl ChatMessageStore { (windows_core::Interface::vtable(this).ForwardMessageAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(localchatmessageid), addresses.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetConversationAsync(&self, conversationid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetConversationAsync(&self, conversationid: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetConversationAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(conversationid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetConversationForTransportsAsync(&self, conversationid: &windows_core::HSTRING, transportids: P1) -> windows_core::Result> + pub fn GetConversationForTransportsAsync(&self, conversationid: &windows_core::HSTRING, transportids: P1) -> windows_core::Result> where P1: windows_core::Param>, { @@ -1311,7 +1311,7 @@ impl ChatMessageStore { (windows_core::Interface::vtable(this).GetConversationForTransportsAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(conversationid), transportids.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetConversationFromThreadingInfoAsync(&self, threadinginfo: P0) -> windows_core::Result> + pub fn GetConversationFromThreadingInfoAsync(&self, threadinginfo: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1338,21 +1338,21 @@ impl ChatMessageStore { (windows_core::Interface::vtable(this).GetConversationForTransportsReader)(windows_core::Interface::as_raw(this), transportids.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetMessageByRemoteIdAsync(&self, transportid: &windows_core::HSTRING, remoteid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetMessageByRemoteIdAsync(&self, transportid: &windows_core::HSTRING, remoteid: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetMessageByRemoteIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(transportid), core::mem::transmute_copy(remoteid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetUnseenCountAsync(&self) -> windows_core::Result> { + pub fn GetUnseenCountAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetUnseenCountAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetUnseenCountForTransportsReaderAsync(&self, transportids: P0) -> windows_core::Result> + pub fn GetUnseenCountForTransportsReaderAsync(&self, transportids: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -1362,14 +1362,14 @@ impl ChatMessageStore { (windows_core::Interface::vtable(this).GetUnseenCountForTransportsReaderAsync)(windows_core::Interface::as_raw(this), transportids.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn MarkAsSeenAsync(&self) -> windows_core::Result { + pub fn MarkAsSeenAsync(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).MarkAsSeenAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn MarkAsSeenForTransportsAsync(&self, transportids: P0) -> windows_core::Result + pub fn MarkAsSeenForTransportsAsync(&self, transportids: P0) -> windows_core::Result where P0: windows_core::Param>, { @@ -1389,7 +1389,7 @@ impl ChatMessageStore { (windows_core::Interface::vtable(this).GetSearchReader)(windows_core::Interface::as_raw(this), value.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SaveMessageAsync(&self, chatmessage: P0) -> windows_core::Result + pub fn SaveMessageAsync(&self, chatmessage: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -1399,14 +1399,14 @@ impl ChatMessageStore { (windows_core::Interface::vtable(this).SaveMessageAsync)(windows_core::Interface::as_raw(this), chatmessage.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryCancelDownloadMessageAsync(&self, localchatmessageid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn TryCancelDownloadMessageAsync(&self, localchatmessageid: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryCancelDownloadMessageAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(localchatmessageid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryCancelSendMessageAsync(&self, localchatmessageid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn TryCancelSendMessageAsync(&self, localchatmessageid: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1427,7 +1427,7 @@ impl ChatMessageStore { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).RemoveStoreChanged)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn GetMessageBySyncIdAsync(&self, syncid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetMessageBySyncIdAsync(&self, syncid: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1512,7 +1512,7 @@ impl ChatMessageTransport { (windows_core::Interface::vtable(this).TransportId)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn RequestSetAsNotificationProviderAsync(&self) -> windows_core::Result { + pub fn RequestSetAsNotificationProviderAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1840,14 +1840,14 @@ impl windows_core::RuntimeType for ChatRestoreHistorySpan { pub struct ChatSearchReader(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(ChatSearchReader, windows_core::IUnknown, windows_core::IInspectable); impl ChatSearchReader { - pub fn ReadBatchAsync(&self) -> windows_core::Result>> { + pub fn ReadBatchAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReadBatchAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReadBatchWithCountAsync(&self, count: i32) -> windows_core::Result>> { + pub fn ReadBatchWithCountAsync(&self, count: i32) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1939,7 +1939,7 @@ impl ChatSyncManager { } } #[cfg(feature = "Security_Credentials")] - pub fn AssociateAccountAsync(&self, webaccount: P0) -> windows_core::Result + pub fn AssociateAccountAsync(&self, webaccount: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -1949,7 +1949,7 @@ impl ChatSyncManager { (windows_core::Interface::vtable(this).AssociateAccountAsync)(windows_core::Interface::as_raw(this), webaccount.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn UnassociateAccountAsync(&self) -> windows_core::Result { + pub fn UnassociateAccountAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1971,7 +1971,7 @@ impl ChatSyncManager { let this = self; unsafe { (windows_core::Interface::vtable(this).StartSync)(windows_core::Interface::as_raw(this)).ok() } } - pub fn SetConfigurationAsync(&self, configuration: P0) -> windows_core::Result + pub fn SetConfigurationAsync(&self, configuration: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -2783,7 +2783,7 @@ impl RcsEndUserMessage { (windows_core::Interface::vtable(this).Actions)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SendResponseAsync(&self, action: P0) -> windows_core::Result + pub fn SendResponseAsync(&self, action: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -2793,7 +2793,7 @@ impl RcsEndUserMessage { (windows_core::Interface::vtable(this).SendResponseAsync)(windows_core::Interface::as_raw(this), action.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SendResponseWithPinAsync(&self, action: P0, pin: &windows_core::HSTRING) -> windows_core::Result + pub fn SendResponseWithPinAsync(&self, action: P0, pin: &windows_core::HSTRING) -> windows_core::Result where P0: windows_core::Param, { @@ -2945,19 +2945,19 @@ impl RcsManager { (windows_core::Interface::vtable(this).GetEndUserMessageManager)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetTransportsAsync() -> windows_core::Result>> { + pub fn GetTransportsAsync() -> windows_core::Result>> { Self::IRcsManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetTransportsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetTransportAsync(transportid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetTransportAsync(transportid: &windows_core::HSTRING) -> windows_core::Result> { Self::IRcsManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetTransportAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(transportid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn LeaveConversationAsync(conversation: P0) -> windows_core::Result + pub fn LeaveConversationAsync(conversation: P0) -> windows_core::Result where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/ApplicationModel/CommunicationBlocking/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/CommunicationBlocking/mod.rs index afa9d107f0..88291d029a 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/CommunicationBlocking/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/CommunicationBlocking/mod.rs @@ -6,7 +6,7 @@ impl CommunicationBlockingAccessManager { (windows_core::Interface::vtable(this).IsBlockingActive)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) }) } - pub fn IsBlockedNumberAsync(number: &windows_core::HSTRING) -> windows_core::Result> { + pub fn IsBlockedNumberAsync(number: &windows_core::HSTRING) -> windows_core::Result> { Self::ICommunicationBlockingAccessManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).IsBlockedNumberAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(number), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -55,7 +55,7 @@ impl CommunicationBlockingAppManager { pub fn ShowCommunicationBlockingSettingsUI() -> windows_core::Result<()> { Self::ICommunicationBlockingAppManagerStatics(|this| unsafe { (windows_core::Interface::vtable(this).ShowCommunicationBlockingSettingsUI)(windows_core::Interface::as_raw(this)).ok() }) } - pub fn RequestSetAsActiveBlockingAppAsync() -> windows_core::Result> { + pub fn RequestSetAsActiveBlockingAppAsync() -> windows_core::Result> { Self::ICommunicationBlockingAppManagerStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestSetAsActiveBlockingAppAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/ApplicationModel/Contacts/DataProvider/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/Contacts/DataProvider/mod.rs index ec20b2c3d6..0697b3ea9d 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/Contacts/DataProvider/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/Contacts/DataProvider/mod.rs @@ -120,7 +120,7 @@ impl ContactListCreateOrUpdateContactRequest { (windows_core::Interface::vtable(this).Contact)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportCompletedAsync(&self, createdorupdatedcontact: P0) -> windows_core::Result + pub fn ReportCompletedAsync(&self, createdorupdatedcontact: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -130,7 +130,7 @@ impl ContactListCreateOrUpdateContactRequest { (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), createdorupdatedcontact.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -201,14 +201,14 @@ impl ContactListDeleteContactRequest { (windows_core::Interface::vtable(this).ContactId)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn ReportCompletedAsync(&self) -> windows_core::Result { + pub fn ReportCompletedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -293,7 +293,7 @@ impl ContactListServerSearchReadBatchRequest { (windows_core::Interface::vtable(this).SuggestedBatchSize)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn SaveContactAsync(&self, contact: P0) -> windows_core::Result + pub fn SaveContactAsync(&self, contact: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -303,14 +303,14 @@ impl ContactListServerSearchReadBatchRequest { (windows_core::Interface::vtable(this).SaveContactAsync)(windows_core::Interface::as_raw(this), contact.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportCompletedAsync(&self) -> windows_core::Result { + pub fn ReportCompletedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self, batchstatus: super::ContactBatchStatus) -> windows_core::Result { + pub fn ReportFailedAsync(&self, batchstatus: super::ContactBatchStatus) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -374,14 +374,14 @@ impl ContactListSyncManagerSyncRequest { (windows_core::Interface::vtable(this).ContactListId)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn ReportCompletedAsync(&self) -> windows_core::Result { + pub fn ReportCompletedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/ApplicationModel/Contacts/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/Contacts/mod.rs index 146a87e85e..180ea7caed 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/Contacts/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/Contacts/mod.rs @@ -7,7 +7,7 @@ pub mod Provider; pub struct AggregateContactManager(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(AggregateContactManager, windows_core::IUnknown, windows_core::IInspectable); impl AggregateContactManager { - pub fn FindRawContactsAsync(&self, contact: P0) -> windows_core::Result>> + pub fn FindRawContactsAsync(&self, contact: P0) -> windows_core::Result>> where P0: windows_core::Param, { @@ -17,7 +17,7 @@ impl AggregateContactManager { (windows_core::Interface::vtable(this).FindRawContactsAsync)(windows_core::Interface::as_raw(this), contact.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryLinkContactsAsync(&self, primarycontact: P0, secondarycontact: P1) -> windows_core::Result> + pub fn TryLinkContactsAsync(&self, primarycontact: P0, secondarycontact: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -28,7 +28,7 @@ impl AggregateContactManager { (windows_core::Interface::vtable(this).TryLinkContactsAsync)(windows_core::Interface::as_raw(this), primarycontact.param().abi(), secondarycontact.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn UnlinkRawContactAsync(&self, contact: P0) -> windows_core::Result + pub fn UnlinkRawContactAsync(&self, contact: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -38,7 +38,7 @@ impl AggregateContactManager { (windows_core::Interface::vtable(this).UnlinkRawContactAsync)(windows_core::Interface::as_raw(this), contact.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TrySetPreferredSourceForPictureAsync(&self, aggregatecontact: P0, rawcontact: P1) -> windows_core::Result> + pub fn TrySetPreferredSourceForPictureAsync(&self, aggregatecontact: P0, rawcontact: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -49,7 +49,7 @@ impl AggregateContactManager { (windows_core::Interface::vtable(this).TrySetPreferredSourceForPictureAsync)(windows_core::Interface::as_raw(this), aggregatecontact.param().abi(), rawcontact.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SetRemoteIdentificationInformationAsync(&self, contactlistid: &windows_core::HSTRING, remotesourceid: &windows_core::HSTRING, accountid: &windows_core::HSTRING) -> windows_core::Result { + pub fn SetRemoteIdentificationInformationAsync(&self, contactlistid: &windows_core::HSTRING, remotesourceid: &windows_core::HSTRING, accountid: &windows_core::HSTRING) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -699,14 +699,14 @@ impl ContactAnnotationList { (windows_core::Interface::vtable(this).UserDataAccountId)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn DeleteAsync(&self) -> windows_core::Result { + pub fn DeleteAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeleteAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TrySaveAnnotationAsync(&self, annotation: P0) -> windows_core::Result> + pub fn TrySaveAnnotationAsync(&self, annotation: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -716,28 +716,28 @@ impl ContactAnnotationList { (windows_core::Interface::vtable(this).TrySaveAnnotationAsync)(windows_core::Interface::as_raw(this), annotation.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAnnotationAsync(&self, annotationid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetAnnotationAsync(&self, annotationid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetAnnotationAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(annotationid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FindAnnotationsByRemoteIdAsync(&self, remoteid: &windows_core::HSTRING) -> windows_core::Result>> { + pub fn FindAnnotationsByRemoteIdAsync(&self, remoteid: &windows_core::HSTRING) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAnnotationsByRemoteIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(remoteid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FindAnnotationsAsync(&self) -> windows_core::Result>> { + pub fn FindAnnotationsAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAnnotationsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAnnotationAsync(&self, annotation: P0) -> windows_core::Result + pub fn DeleteAnnotationAsync(&self, annotation: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -816,21 +816,21 @@ impl core::ops::Not for ContactAnnotationOperations { pub struct ContactAnnotationStore(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(ContactAnnotationStore, windows_core::IUnknown, windows_core::IInspectable); impl ContactAnnotationStore { - pub fn FindContactIdsByEmailAsync(&self, emailaddress: &windows_core::HSTRING) -> windows_core::Result>> { + pub fn FindContactIdsByEmailAsync(&self, emailaddress: &windows_core::HSTRING) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindContactIdsByEmailAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(emailaddress), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FindContactIdsByPhoneNumberAsync(&self, phonenumber: &windows_core::HSTRING) -> windows_core::Result>> { + pub fn FindContactIdsByPhoneNumberAsync(&self, phonenumber: &windows_core::HSTRING) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindContactIdsByPhoneNumberAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(phonenumber), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FindAnnotationsForContactAsync(&self, contact: P0) -> windows_core::Result>> + pub fn FindAnnotationsForContactAsync(&self, contact: P0) -> windows_core::Result>> where P0: windows_core::Param, { @@ -840,7 +840,7 @@ impl ContactAnnotationStore { (windows_core::Interface::vtable(this).FindAnnotationsForContactAsync)(windows_core::Interface::as_raw(this), contact.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DisableAnnotationAsync(&self, annotation: P0) -> windows_core::Result + pub fn DisableAnnotationAsync(&self, annotation: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -850,35 +850,35 @@ impl ContactAnnotationStore { (windows_core::Interface::vtable(this).DisableAnnotationAsync)(windows_core::Interface::as_raw(this), annotation.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateAnnotationListAsync(&self) -> windows_core::Result> { + pub fn CreateAnnotationListAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreateAnnotationListAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateAnnotationListInAccountAsync(&self, userdataaccountid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CreateAnnotationListInAccountAsync(&self, userdataaccountid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreateAnnotationListInAccountAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(userdataaccountid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAnnotationListAsync(&self, annotationlistid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetAnnotationListAsync(&self, annotationlistid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetAnnotationListAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(annotationlistid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FindAnnotationListsAsync(&self) -> windows_core::Result>> { + pub fn FindAnnotationListsAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAnnotationListsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FindAnnotationsForContactListAsync(&self, contactlistid: &windows_core::HSTRING) -> windows_core::Result>> { + pub fn FindAnnotationsForContactListAsync(&self, contactlistid: &windows_core::HSTRING) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1120,7 +1120,7 @@ impl ContactChangeReader { let this = self; unsafe { (windows_core::Interface::vtable(this).AcceptChangesThrough)(windows_core::Interface::as_raw(this), lastchangetoaccept.param().abi()).ok() } } - pub fn ReadBatchAsync(&self) -> windows_core::Result>> { + pub fn ReadBatchAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1694,7 +1694,7 @@ impl ContactInformation { } } #[cfg(feature = "Storage_Streams")] - pub fn GetThumbnailAsync(&self) -> windows_core::Result> { + pub fn GetThumbnailAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2112,28 +2112,28 @@ impl ContactList { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveContactChanged)(windows_core::Interface::as_raw(this), value).ok() } } - pub fn SaveAsync(&self) -> windows_core::Result { + pub fn SaveAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).SaveAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAsync(&self) -> windows_core::Result { + pub fn DeleteAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeleteAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetContactFromRemoteIdAsync(&self, remoteid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetContactFromRemoteIdAsync(&self, remoteid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetContactFromRemoteIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(remoteid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetMeContactAsync(&self) -> windows_core::Result> { + pub fn GetMeContactAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2157,7 +2157,7 @@ impl ContactList { (windows_core::Interface::vtable(this).GetContactReaderWithOptions)(windows_core::Interface::as_raw(this), options.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SaveContactAsync(&self, contact: P0) -> windows_core::Result + pub fn SaveContactAsync(&self, contact: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -2167,7 +2167,7 @@ impl ContactList { (windows_core::Interface::vtable(this).SaveContactAsync)(windows_core::Interface::as_raw(this), contact.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteContactAsync(&self, contact: P0) -> windows_core::Result + pub fn DeleteContactAsync(&self, contact: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -2177,14 +2177,14 @@ impl ContactList { (windows_core::Interface::vtable(this).DeleteContactAsync)(windows_core::Interface::as_raw(this), contact.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetContactAsync(&self, contactid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetContactAsync(&self, contactid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetContactAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(contactid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RegisterSyncManagerAsync(&self) -> windows_core::Result { + pub fn RegisterSyncManagerAsync(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -2234,7 +2234,7 @@ unsafe impl Sync for ContactList {} pub struct ContactListLimitedWriteOperations(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(ContactListLimitedWriteOperations, windows_core::IUnknown, windows_core::IInspectable); impl ContactListLimitedWriteOperations { - pub fn TryCreateOrUpdateContactAsync(&self, contact: P0) -> windows_core::Result> + pub fn TryCreateOrUpdateContactAsync(&self, contact: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2244,7 +2244,7 @@ impl ContactListLimitedWriteOperations { (windows_core::Interface::vtable(this).TryCreateOrUpdateContactAsync)(windows_core::Interface::as_raw(this), contact.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryDeleteContactAsync(&self, contactid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn TryDeleteContactAsync(&self, contactid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2726,7 +2726,7 @@ impl ContactListSyncManager { (windows_core::Interface::vtable(this).LastAttemptedSyncTime)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn SyncAsync(&self) -> windows_core::Result> { + pub fn SyncAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2926,14 +2926,14 @@ impl ContactManager { (windows_core::Interface::vtable(this).ShowDelayLoadedContactCard)(windows_core::Interface::as_raw(this), contact.param().abi(), selection, preferredplacement, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RequestStoreAsync() -> windows_core::Result> { + pub fn RequestStoreAsync() -> windows_core::Result> { Self::IContactManagerStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestStoreAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "Storage_Streams")] - pub fn ConvertContactToVCardAsync(contact: P0) -> windows_core::Result> + pub fn ConvertContactToVCardAsync(contact: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2943,7 +2943,7 @@ impl ContactManager { }) } #[cfg(feature = "Storage_Streams")] - pub fn ConvertContactToVCardAsyncWithMaxBytes(contact: P0, maxbytes: u32) -> windows_core::Result> + pub fn ConvertContactToVCardAsyncWithMaxBytes(contact: P0, maxbytes: u32) -> windows_core::Result> where P0: windows_core::Param, { @@ -2953,7 +2953,7 @@ impl ContactManager { }) } #[cfg(feature = "Storage_Streams")] - pub fn ConvertVCardToContactAsync(vcard: P0) -> windows_core::Result> + pub fn ConvertVCardToContactAsync(vcard: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2962,13 +2962,13 @@ impl ContactManager { (windows_core::Interface::vtable(this).ConvertVCardToContactAsync)(windows_core::Interface::as_raw(this), vcard.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RequestStoreAsyncWithAccessType(accesstype: ContactStoreAccessType) -> windows_core::Result> { + pub fn RequestStoreAsyncWithAccessType(accesstype: ContactStoreAccessType) -> windows_core::Result> { Self::IContactManagerStatics3(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestStoreAsyncWithAccessType)(windows_core::Interface::as_raw(this), accesstype, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RequestAnnotationStoreAsync(accesstype: ContactAnnotationStoreAccessType) -> windows_core::Result> { + pub fn RequestAnnotationStoreAsync(accesstype: ContactAnnotationStoreAccessType) -> windows_core::Result> { Self::IContactManagerStatics3(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestAnnotationStoreAsync)(windows_core::Interface::as_raw(this), accesstype, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -3040,7 +3040,7 @@ impl ContactManager { (windows_core::Interface::vtable(this).GetForUser)(windows_core::Interface::as_raw(this), user.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn IsShowFullContactCardSupportedAsync() -> windows_core::Result> { + pub fn IsShowFullContactCardSupportedAsync() -> windows_core::Result> { Self::IContactManagerStatics5(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).IsShowFullContactCardSupportedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -3085,7 +3085,7 @@ pub struct ContactManagerForUser(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(ContactManagerForUser, windows_core::IUnknown, windows_core::IInspectable); impl ContactManagerForUser { #[cfg(feature = "Storage_Streams")] - pub fn ConvertContactToVCardAsync(&self, contact: P0) -> windows_core::Result> + pub fn ConvertContactToVCardAsync(&self, contact: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -3096,7 +3096,7 @@ impl ContactManagerForUser { } } #[cfg(feature = "Storage_Streams")] - pub fn ConvertContactToVCardAsyncWithMaxBytes(&self, contact: P0, maxbytes: u32) -> windows_core::Result> + pub fn ConvertContactToVCardAsyncWithMaxBytes(&self, contact: P0, maxbytes: u32) -> windows_core::Result> where P0: windows_core::Param, { @@ -3107,7 +3107,7 @@ impl ContactManagerForUser { } } #[cfg(feature = "Storage_Streams")] - pub fn ConvertVCardToContactAsync(&self, vcard: P0) -> windows_core::Result> + pub fn ConvertVCardToContactAsync(&self, vcard: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -3117,14 +3117,14 @@ impl ContactManagerForUser { (windows_core::Interface::vtable(this).ConvertVCardToContactAsync)(windows_core::Interface::as_raw(this), vcard.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestStoreAsync(&self, accesstype: ContactStoreAccessType) -> windows_core::Result> { + pub fn RequestStoreAsync(&self, accesstype: ContactStoreAccessType) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestStoreAsync)(windows_core::Interface::as_raw(this), accesstype, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestAnnotationStoreAsync(&self, accesstype: ContactAnnotationStoreAccessType) -> windows_core::Result> { + pub fn RequestAnnotationStoreAsync(&self, accesstype: ContactAnnotationStoreAccessType) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -3492,14 +3492,14 @@ impl ContactPicker { (windows_core::Interface::vtable(this).DesiredFields)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn PickSingleContactAsync(&self) -> windows_core::Result> { + pub fn PickSingleContactAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).PickSingleContactAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn PickMultipleContactsAsync(&self) -> windows_core::Result>> { + pub fn PickMultipleContactsAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -3513,14 +3513,14 @@ impl ContactPicker { (windows_core::Interface::vtable(this).DesiredFieldsWithContactFieldType)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn PickContactAsync(&self) -> windows_core::Result> { + pub fn PickContactAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).PickContactAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn PickContactsAsync(&self) -> windows_core::Result>> { + pub fn PickContactsAsync(&self) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -3545,7 +3545,7 @@ impl ContactPicker { (windows_core::Interface::vtable(this).CreateForUser)(windows_core::Interface::as_raw(this), user.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn IsSupportedAsync() -> windows_core::Result> { + pub fn IsSupportedAsync() -> windows_core::Result> { Self::IContactPickerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).IsSupportedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -3827,7 +3827,7 @@ unsafe impl Sync for ContactQueryTextSearch {} pub struct ContactReader(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(ContactReader, windows_core::IUnknown, windows_core::IInspectable); impl ContactReader { - pub fn ReadBatchAsync(&self) -> windows_core::Result> { + pub fn ReadBatchAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -3950,21 +3950,21 @@ unsafe impl Sync for ContactSignificantOther {} pub struct ContactStore(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(ContactStore, windows_core::IUnknown, windows_core::IInspectable); impl ContactStore { - pub fn FindContactsAsync(&self) -> windows_core::Result>> { + pub fn FindContactsAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindContactsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FindContactsWithSearchTextAsync(&self, searchtext: &windows_core::HSTRING) -> windows_core::Result>> { + pub fn FindContactsWithSearchTextAsync(&self, searchtext: &windows_core::HSTRING) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindContactsWithSearchTextAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(searchtext), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetContactAsync(&self, contactid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetContactAsync(&self, contactid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -3999,28 +3999,28 @@ impl ContactStore { (windows_core::Interface::vtable(this).AggregateContactManager)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FindContactListsAsync(&self) -> windows_core::Result>> { + pub fn FindContactListsAsync(&self) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindContactListsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetContactListAsync(&self, contactlistid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetContactListAsync(&self, contactlistid: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetContactListAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(contactlistid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateContactListAsync(&self, displayname: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CreateContactListAsync(&self, displayname: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreateContactListAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(displayname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetMeContactAsync(&self) -> windows_core::Result> { + pub fn GetMeContactAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -4044,7 +4044,7 @@ impl ContactStore { (windows_core::Interface::vtable(this).GetContactReaderWithOptions)(windows_core::Interface::as_raw(this), options.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateContactListInAccountAsync(&self, displayname: &windows_core::HSTRING, userdataaccountid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CreateContactListInAccountAsync(&self, displayname: &windows_core::HSTRING, userdataaccountid: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -5783,7 +5783,7 @@ impl PinnedContactManager { (windows_core::Interface::vtable(this).IsContactPinned)(windows_core::Interface::as_raw(this), contact.param().abi(), surface, &mut result__).map(|| result__) } } - pub fn RequestPinContactAsync(&self, contact: P0, surface: PinnedContactSurface) -> windows_core::Result> + pub fn RequestPinContactAsync(&self, contact: P0, surface: PinnedContactSurface) -> windows_core::Result> where P0: windows_core::Param, { @@ -5793,7 +5793,7 @@ impl PinnedContactManager { (windows_core::Interface::vtable(this).RequestPinContactAsync)(windows_core::Interface::as_raw(this), contact.param().abi(), surface, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestPinContactsAsync(&self, contacts: P0, surface: PinnedContactSurface) -> windows_core::Result> + pub fn RequestPinContactsAsync(&self, contacts: P0, surface: PinnedContactSurface) -> windows_core::Result> where P0: windows_core::Param>, { @@ -5803,7 +5803,7 @@ impl PinnedContactManager { (windows_core::Interface::vtable(this).RequestPinContactsAsync)(windows_core::Interface::as_raw(this), contacts.param().abi(), surface, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestUnpinContactAsync(&self, contact: P0, surface: PinnedContactSurface) -> windows_core::Result> + pub fn RequestUnpinContactAsync(&self, contact: P0, surface: PinnedContactSurface) -> windows_core::Result> where P0: windows_core::Param, { @@ -5820,7 +5820,7 @@ impl PinnedContactManager { let this = self; unsafe { (windows_core::Interface::vtable(this).SignalContactActivity)(windows_core::Interface::as_raw(this), contact.param().abi()).ok() } } - pub fn GetPinnedContactIdsAsync(&self) -> windows_core::Result> { + pub fn GetPinnedContactIdsAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/ApplicationModel/ConversationalAgent/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/ConversationalAgent/mod.rs index 395cacf6a1..a2da6bd310 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/ConversationalAgent/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/ConversationalAgent/mod.rs @@ -36,7 +36,7 @@ impl ActivationSignalDetectionConfiguration { let this = self; unsafe { (windows_core::Interface::vtable(this).SetEnabled)(windows_core::Interface::as_raw(this), value).ok() } } - pub fn SetEnabledAsync(&self, value: bool) -> windows_core::Result { + pub fn SetEnabledAsync(&self, value: bool) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -73,7 +73,7 @@ impl ActivationSignalDetectionConfiguration { unsafe { (windows_core::Interface::vtable(this).SetModelData)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(datatype), data.param().abi()).ok() } } #[cfg(feature = "Storage_Streams")] - pub fn SetModelDataAsync(&self, datatype: &windows_core::HSTRING, data: P1) -> windows_core::Result + pub fn SetModelDataAsync(&self, datatype: &windows_core::HSTRING, data: P1) -> windows_core::Result where P1: windows_core::Param, { @@ -90,7 +90,7 @@ impl ActivationSignalDetectionConfiguration { (windows_core::Interface::vtable(this).GetModelDataType)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn GetModelDataTypeAsync(&self) -> windows_core::Result> { + pub fn GetModelDataTypeAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -106,7 +106,7 @@ impl ActivationSignalDetectionConfiguration { } } #[cfg(feature = "Storage_Streams")] - pub fn GetModelDataAsync(&self) -> windows_core::Result> { + pub fn GetModelDataAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -117,7 +117,7 @@ impl ActivationSignalDetectionConfiguration { let this = self; unsafe { (windows_core::Interface::vtable(this).ClearModelData)(windows_core::Interface::as_raw(this)).ok() } } - pub fn ClearModelDataAsync(&self) -> windows_core::Result { + pub fn ClearModelDataAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -157,7 +157,7 @@ impl ActivationSignalDetectionConfiguration { } } #[cfg(feature = "Storage_Streams")] - pub fn ApplyTrainingDataAsync(&self, trainingdataformat: ActivationSignalDetectionTrainingDataFormat, trainingdata: P1) -> windows_core::Result> + pub fn ApplyTrainingDataAsync(&self, trainingdataformat: ActivationSignalDetectionTrainingDataFormat, trainingdata: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -171,7 +171,7 @@ impl ActivationSignalDetectionConfiguration { let this = self; unsafe { (windows_core::Interface::vtable(this).ClearTrainingData)(windows_core::Interface::as_raw(this)).ok() } } - pub fn ClearTrainingDataAsync(&self) -> windows_core::Result { + pub fn ClearTrainingDataAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -190,7 +190,7 @@ impl ActivationSignalDetectionConfiguration { } } #[cfg(feature = "Storage_Streams")] - pub fn SetModelDataWithResultAsync(&self, datatype: &windows_core::HSTRING, data: P1) -> windows_core::Result> + pub fn SetModelDataWithResultAsync(&self, datatype: &windows_core::HSTRING, data: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -200,7 +200,7 @@ impl ActivationSignalDetectionConfiguration { (windows_core::Interface::vtable(this).SetModelDataWithResultAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(datatype), data.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SetEnabledWithResultAsync(&self, value: bool) -> windows_core::Result> { + pub fn SetEnabledWithResultAsync(&self, value: bool) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -413,7 +413,7 @@ impl ActivationSignalDetector { (windows_core::Interface::vtable(this).GetSupportedModelIdsForSignalId)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(signalid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetSupportedModelIdsForSignalIdAsync(&self, signalid: &windows_core::HSTRING) -> windows_core::Result>> { + pub fn GetSupportedModelIdsForSignalIdAsync(&self, signalid: &windows_core::HSTRING) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -424,7 +424,7 @@ impl ActivationSignalDetector { let this = self; unsafe { (windows_core::Interface::vtable(this).CreateConfiguration)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(signalid), core::mem::transmute_copy(modelid), core::mem::transmute_copy(displayname)).ok() } } - pub fn CreateConfigurationAsync(&self, signalid: &windows_core::HSTRING, modelid: &windows_core::HSTRING, displayname: &windows_core::HSTRING) -> windows_core::Result { + pub fn CreateConfigurationAsync(&self, signalid: &windows_core::HSTRING, modelid: &windows_core::HSTRING, displayname: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -438,7 +438,7 @@ impl ActivationSignalDetector { (windows_core::Interface::vtable(this).GetConfigurations)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetConfigurationsAsync(&self) -> windows_core::Result>> { + pub fn GetConfigurationsAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -452,7 +452,7 @@ impl ActivationSignalDetector { (windows_core::Interface::vtable(this).GetConfiguration)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(signalid), core::mem::transmute_copy(modelid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetConfigurationAsync(&self, signalid: &windows_core::HSTRING, modelid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetConfigurationAsync(&self, signalid: &windows_core::HSTRING, modelid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -463,14 +463,14 @@ impl ActivationSignalDetector { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveConfiguration)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(signalid), core::mem::transmute_copy(modelid)).ok() } } - pub fn RemoveConfigurationAsync(&self, signalid: &windows_core::HSTRING, modelid: &windows_core::HSTRING) -> windows_core::Result { + pub fn RemoveConfigurationAsync(&self, signalid: &windows_core::HSTRING, modelid: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RemoveConfigurationAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(signalid), core::mem::transmute_copy(modelid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAvailableModelIdsForSignalIdAsync(&self, signalid: &windows_core::HSTRING) -> windows_core::Result>> { + pub fn GetAvailableModelIdsForSignalIdAsync(&self, signalid: &windows_core::HSTRING) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -484,7 +484,7 @@ impl ActivationSignalDetector { (windows_core::Interface::vtable(this).GetAvailableModelIdsForSignalId)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(signalid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateConfigurationWithResultAsync(&self, signalid: &windows_core::HSTRING, modelid: &windows_core::HSTRING, displayname: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CreateConfigurationWithResultAsync(&self, signalid: &windows_core::HSTRING, modelid: &windows_core::HSTRING, displayname: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -498,7 +498,7 @@ impl ActivationSignalDetector { (windows_core::Interface::vtable(this).CreateConfigurationWithResult)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(signalid), core::mem::transmute_copy(modelid), core::mem::transmute_copy(displayname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RemoveConfigurationWithResultAsync(&self, signalid: &windows_core::HSTRING, modelid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn RemoveConfigurationWithResultAsync(&self, signalid: &windows_core::HSTRING, modelid: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -600,7 +600,7 @@ impl ConversationalAgentDetectorManager { (windows_core::Interface::vtable(this).GetAllActivationSignalDetectors)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAllActivationSignalDetectorsAsync(&self) -> windows_core::Result>> { + pub fn GetAllActivationSignalDetectorsAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -614,7 +614,7 @@ impl ConversationalAgentDetectorManager { (windows_core::Interface::vtable(this).GetActivationSignalDetectors)(windows_core::Interface::as_raw(this), kind, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetActivationSignalDetectorsAsync(&self, kind: ActivationSignalDetectorKind) -> windows_core::Result>> { + pub fn GetActivationSignalDetectorsAsync(&self, kind: ActivationSignalDetectorKind) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -628,7 +628,7 @@ impl ConversationalAgentDetectorManager { (windows_core::Interface::vtable(this).GetActivationSignalDetectorFromId)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(detectorid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetActivationSignalDetectorFromIdAsync(&self, detectorid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetActivationSignalDetectorFromIdAsync(&self, detectorid: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -766,7 +766,7 @@ impl ConversationalAgentSession { (windows_core::Interface::vtable(this).IsInterrupted)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn RequestInterruptibleAsync(&self, interruptible: bool) -> windows_core::Result> { + pub fn RequestInterruptibleAsync(&self, interruptible: bool) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -780,7 +780,7 @@ impl ConversationalAgentSession { (windows_core::Interface::vtable(this).RequestInterruptible)(windows_core::Interface::as_raw(this), interruptible, &mut result__).map(|| result__) } } - pub fn RequestAgentStateChangeAsync(&self, state: ConversationalAgentState) -> windows_core::Result> { + pub fn RequestAgentStateChangeAsync(&self, state: ConversationalAgentState) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -794,7 +794,7 @@ impl ConversationalAgentSession { (windows_core::Interface::vtable(this).RequestAgentStateChange)(windows_core::Interface::as_raw(this), state, &mut result__).map(|| result__) } } - pub fn RequestForegroundActivationAsync(&self) -> windows_core::Result> { + pub fn RequestForegroundActivationAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -808,7 +808,7 @@ impl ConversationalAgentSession { (windows_core::Interface::vtable(this).RequestForegroundActivation)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn GetAudioClientAsync(&self) -> windows_core::Result> { + pub fn GetAudioClientAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -823,7 +823,7 @@ impl ConversationalAgentSession { } } #[cfg(feature = "Media_Audio")] - pub fn CreateAudioDeviceInputNodeAsync(&self, graph: P0) -> windows_core::Result> + pub fn CreateAudioDeviceInputNodeAsync(&self, graph: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -844,7 +844,7 @@ impl ConversationalAgentSession { (windows_core::Interface::vtable(this).CreateAudioDeviceInputNode)(windows_core::Interface::as_raw(this), graph.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAudioCaptureDeviceIdAsync(&self) -> windows_core::Result> { + pub fn GetAudioCaptureDeviceIdAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -858,7 +858,7 @@ impl ConversationalAgentSession { (windows_core::Interface::vtable(this).GetAudioCaptureDeviceId)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn GetAudioRenderDeviceIdAsync(&self) -> windows_core::Result> { + pub fn GetAudioRenderDeviceIdAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -872,7 +872,7 @@ impl ConversationalAgentSession { (windows_core::Interface::vtable(this).GetAudioRenderDeviceId)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn GetSignalModelIdAsync(&self) -> windows_core::Result> { + pub fn GetSignalModelIdAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -886,7 +886,7 @@ impl ConversationalAgentSession { (windows_core::Interface::vtable(this).GetSignalModelId)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn SetSignalModelIdAsync(&self, signalmodelid: u32) -> windows_core::Result> { + pub fn SetSignalModelIdAsync(&self, signalmodelid: u32) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -900,7 +900,7 @@ impl ConversationalAgentSession { (windows_core::Interface::vtable(this).SetSignalModelId)(windows_core::Interface::as_raw(this), signalmodelid, &mut result__).map(|| result__) } } - pub fn GetSupportedSignalModelIdsAsync(&self) -> windows_core::Result>> { + pub fn GetSupportedSignalModelIdsAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -914,7 +914,7 @@ impl ConversationalAgentSession { (windows_core::Interface::vtable(this).GetSupportedSignalModelIds)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestActivationAsync(&self, activationkind: ConversationalAgentActivationKind) -> windows_core::Result> { + pub fn RequestActivationAsync(&self, activationkind: ConversationalAgentActivationKind) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -928,7 +928,7 @@ impl ConversationalAgentSession { (windows_core::Interface::vtable(this).RequestActivation)(windows_core::Interface::as_raw(this), activationkind, &mut result__).map(|| result__) } } - pub fn SetSupportLockScreenActivationAsync(&self, lockscreenactivationsupported: bool) -> windows_core::Result { + pub fn SetSupportLockScreenActivationAsync(&self, lockscreenactivationsupported: bool) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -946,14 +946,14 @@ impl ConversationalAgentSession { (windows_core::Interface::vtable(this).GetMissingPrerequisites)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetMissingPrerequisitesAsync(&self) -> windows_core::Result>> { + pub fn GetMissingPrerequisitesAsync(&self) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetMissingPrerequisitesAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetCurrentSessionAsync() -> windows_core::Result> { + pub fn GetCurrentSessionAsync() -> windows_core::Result> { Self::IConversationalAgentSessionStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetCurrentSessionAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/ApplicationModel/Core/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/Core/mod.rs index d9fc60ddf7..689f727d85 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/Core/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/Core/mod.rs @@ -10,7 +10,7 @@ impl AppListEntry { (windows_core::Interface::vtable(this).DisplayInfo)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn LaunchAsync(&self) -> windows_core::Result> { + pub fn LaunchAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -25,7 +25,7 @@ impl AppListEntry { } } #[cfg(feature = "System")] - pub fn LaunchForUserAsync(&self, user: P0) -> windows_core::Result> + pub fn LaunchForUserAsync(&self, user: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -167,14 +167,14 @@ impl CoreApplication { pub fn EnablePrelaunch(value: bool) -> windows_core::Result<()> { Self::ICoreApplication2(|this| unsafe { (windows_core::Interface::vtable(this).EnablePrelaunch)(windows_core::Interface::as_raw(this), value).ok() }) } - pub fn RequestRestartAsync(launcharguments: &windows_core::HSTRING) -> windows_core::Result> { + pub fn RequestRestartAsync(launcharguments: &windows_core::HSTRING) -> windows_core::Result> { Self::ICoreApplication3(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestRestartAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(launcharguments), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "System")] - pub fn RequestRestartForUserAsync(user: P0, launcharguments: &windows_core::HSTRING) -> windows_core::Result> + pub fn RequestRestartForUserAsync(user: P0, launcharguments: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/ApplicationModel/DataTransfer/DragDrop/Core/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/DataTransfer/DragDrop/Core/mod.rs index 9b9fce70d9..09601c948c 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/DataTransfer/DragDrop/Core/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/DataTransfer/DragDrop/Core/mod.rs @@ -147,7 +147,7 @@ impl CoreDragOperation { let this = self; unsafe { (windows_core::Interface::vtable(this).SetDragUIContentMode)(windows_core::Interface::as_raw(this), value).ok() } } - pub fn StartAsync(&self) -> windows_core::Result> { + pub fn StartAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -434,7 +434,7 @@ impl windows_core::RuntimeType for ICoreDropOperationTarget { } windows_core::imp::interface_hierarchy!(ICoreDropOperationTarget, windows_core::IUnknown, windows_core::IInspectable); impl ICoreDropOperationTarget { - pub fn EnterAsync(&self, draginfo: P0, draguioverride: P1) -> windows_core::Result> + pub fn EnterAsync(&self, draginfo: P0, draguioverride: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -445,7 +445,7 @@ impl ICoreDropOperationTarget { (windows_core::Interface::vtable(this).EnterAsync)(windows_core::Interface::as_raw(this), draginfo.param().abi(), draguioverride.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn OverAsync(&self, draginfo: P0, draguioverride: P1) -> windows_core::Result> + pub fn OverAsync(&self, draginfo: P0, draguioverride: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -456,7 +456,7 @@ impl ICoreDropOperationTarget { (windows_core::Interface::vtable(this).OverAsync)(windows_core::Interface::as_raw(this), draginfo.param().abi(), draguioverride.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn LeaveAsync(&self, draginfo: P0) -> windows_core::Result + pub fn LeaveAsync(&self, draginfo: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -466,7 +466,7 @@ impl ICoreDropOperationTarget { (windows_core::Interface::vtable(this).LeaveAsync)(windows_core::Interface::as_raw(this), draginfo.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DropAsync(&self, draginfo: P0) -> windows_core::Result> + pub fn DropAsync(&self, draginfo: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -481,10 +481,10 @@ impl windows_core::RuntimeName for ICoreDropOperationTarget { const NAME: &'static str = "Windows.ApplicationModel.DataTransfer.DragDrop.Core.ICoreDropOperationTarget"; } pub trait ICoreDropOperationTarget_Impl: windows_core::IUnknownImpl { - fn EnterAsync(&self, dragInfo: windows_core::Ref<'_, CoreDragInfo>, dragUIOverride: windows_core::Ref<'_, CoreDragUIOverride>) -> windows_core::Result>; - fn OverAsync(&self, dragInfo: windows_core::Ref<'_, CoreDragInfo>, dragUIOverride: windows_core::Ref<'_, CoreDragUIOverride>) -> windows_core::Result>; - fn LeaveAsync(&self, dragInfo: windows_core::Ref<'_, CoreDragInfo>) -> windows_core::Result; - fn DropAsync(&self, dragInfo: windows_core::Ref<'_, CoreDragInfo>) -> windows_core::Result>; + fn EnterAsync(&self, dragInfo: windows_core::Ref<'_, CoreDragInfo>, dragUIOverride: windows_core::Ref<'_, CoreDragUIOverride>) -> windows_core::Result>; + fn OverAsync(&self, dragInfo: windows_core::Ref<'_, CoreDragInfo>, dragUIOverride: windows_core::Ref<'_, CoreDragUIOverride>) -> windows_core::Result>; + fn LeaveAsync(&self, dragInfo: windows_core::Ref<'_, CoreDragInfo>) -> windows_core::Result; + fn DropAsync(&self, dragInfo: windows_core::Ref<'_, CoreDragInfo>) -> windows_core::Result>; } impl ICoreDropOperationTarget_Vtbl { pub const fn new() -> Self { diff --git a/crates/libs/windows/src/Windows/ApplicationModel/DataTransfer/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/DataTransfer/mod.rs index e8d12558e3..cf4430f3db 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/DataTransfer/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/DataTransfer/mod.rs @@ -34,7 +34,7 @@ impl Clipboard { pub fn RemoveContentChanged(token: i64) -> windows_core::Result<()> { Self::IClipboardStatics(|this| unsafe { (windows_core::Interface::vtable(this).RemoveContentChanged)(windows_core::Interface::as_raw(this), token).ok() }) } - pub fn GetHistoryItemsAsync() -> windows_core::Result> { + pub fn GetHistoryItemsAsync() -> windows_core::Result> { Self::IClipboardStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetHistoryItemsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -980,21 +980,21 @@ impl DataPackageView { (windows_core::Interface::vtable(this).Contains)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(formatid), &mut result__).map(|| result__) } } - pub fn GetDataAsync(&self, formatid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetDataAsync(&self, formatid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetDataAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(formatid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetTextAsync(&self) -> windows_core::Result> { + pub fn GetTextAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetTextAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetCustomTextAsync(&self, formatid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetCustomTextAsync(&self, formatid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1002,14 +1002,14 @@ impl DataPackageView { } } #[cfg(feature = "deprecated")] - pub fn GetUriAsync(&self) -> windows_core::Result> { + pub fn GetUriAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetUriAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetHtmlFormatAsync(&self) -> windows_core::Result> { + pub fn GetHtmlFormatAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1017,14 +1017,14 @@ impl DataPackageView { } } #[cfg(feature = "Storage_Streams")] - pub fn GetResourceMapAsync(&self) -> windows_core::Result>> { + pub fn GetResourceMapAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetResourceMapAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetRtfAsync(&self) -> windows_core::Result> { + pub fn GetRtfAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1032,7 +1032,7 @@ impl DataPackageView { } } #[cfg(feature = "Storage_Streams")] - pub fn GetBitmapAsync(&self) -> windows_core::Result> { + pub fn GetBitmapAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1040,21 +1040,21 @@ impl DataPackageView { } } #[cfg(feature = "Storage")] - pub fn GetStorageItemsAsync(&self) -> windows_core::Result>> { + pub fn GetStorageItemsAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetStorageItemsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetApplicationLinkAsync(&self) -> windows_core::Result> { + pub fn GetApplicationLinkAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetApplicationLinkAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetWebLinkAsync(&self) -> windows_core::Result> { + pub fn GetWebLinkAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1062,7 +1062,7 @@ impl DataPackageView { } } #[cfg(feature = "Security_EnterpriseData")] - pub fn RequestAccessAsync(&self) -> windows_core::Result> { + pub fn RequestAccessAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1070,7 +1070,7 @@ impl DataPackageView { } } #[cfg(feature = "Security_EnterpriseData")] - pub fn RequestAccessWithEnterpriseIdAsync(&self, enterpriseid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn RequestAccessWithEnterpriseIdAsync(&self, enterpriseid: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -2477,7 +2477,7 @@ impl SharedStorageAccessManager { }) } #[cfg(feature = "Storage_Streams")] - pub fn RedeemTokenForFileAsync(token: &windows_core::HSTRING) -> windows_core::Result> { + pub fn RedeemTokenForFileAsync(token: &windows_core::HSTRING) -> windows_core::Result> { Self::ISharedStorageAccessManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RedeemTokenForFileAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(token), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/ApplicationModel/Email/DataProvider/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/Email/DataProvider/mod.rs index d796b4a965..210c39d884 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/Email/DataProvider/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/Email/DataProvider/mod.rs @@ -281,7 +281,7 @@ impl EmailMailboxCreateFolderRequest { (windows_core::Interface::vtable(this).Name)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn ReportCompletedAsync(&self, folder: P0) -> windows_core::Result + pub fn ReportCompletedAsync(&self, folder: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -291,7 +291,7 @@ impl EmailMailboxCreateFolderRequest { (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), folder.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self, status: super::EmailMailboxCreateFolderStatus) -> windows_core::Result { + pub fn ReportFailedAsync(&self, status: super::EmailMailboxCreateFolderStatus) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -362,14 +362,14 @@ impl EmailMailboxDeleteFolderRequest { (windows_core::Interface::vtable(this).EmailFolderId)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn ReportCompletedAsync(&self) -> windows_core::Result { + pub fn ReportCompletedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self, status: super::EmailMailboxDeleteFolderStatus) -> windows_core::Result { + pub fn ReportFailedAsync(&self, status: super::EmailMailboxDeleteFolderStatus) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -447,14 +447,14 @@ impl EmailMailboxDownloadAttachmentRequest { (windows_core::Interface::vtable(this).EmailAttachmentId)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn ReportCompletedAsync(&self) -> windows_core::Result { + pub fn ReportCompletedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -525,14 +525,14 @@ impl EmailMailboxDownloadMessageRequest { (windows_core::Interface::vtable(this).EmailMessageId)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn ReportCompletedAsync(&self) -> windows_core::Result { + pub fn ReportCompletedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -603,14 +603,14 @@ impl EmailMailboxEmptyFolderRequest { (windows_core::Interface::vtable(this).EmailFolderId)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn ReportCompletedAsync(&self) -> windows_core::Result { + pub fn ReportCompletedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self, status: super::EmailMailboxEmptyFolderStatus) -> windows_core::Result { + pub fn ReportFailedAsync(&self, status: super::EmailMailboxEmptyFolderStatus) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -716,14 +716,14 @@ impl EmailMailboxForwardMeetingRequest { (windows_core::Interface::vtable(this).Comment)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn ReportCompletedAsync(&self) -> windows_core::Result { + pub fn ReportCompletedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -794,7 +794,7 @@ impl EmailMailboxGetAutoReplySettingsRequest { (windows_core::Interface::vtable(this).RequestedFormat)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn ReportCompletedAsync(&self, autoreplysettings: P0) -> windows_core::Result + pub fn ReportCompletedAsync(&self, autoreplysettings: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -804,7 +804,7 @@ impl EmailMailboxGetAutoReplySettingsRequest { (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), autoreplysettings.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -889,14 +889,14 @@ impl EmailMailboxMoveFolderRequest { (windows_core::Interface::vtable(this).NewFolderName)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn ReportCompletedAsync(&self) -> windows_core::Result { + pub fn ReportCompletedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -995,14 +995,14 @@ impl EmailMailboxProposeNewTimeForMeetingRequest { (windows_core::Interface::vtable(this).Comment)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn ReportCompletedAsync(&self) -> windows_core::Result { + pub fn ReportCompletedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1073,7 +1073,7 @@ impl EmailMailboxResolveRecipientsRequest { (windows_core::Interface::vtable(this).Recipients)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportCompletedAsync(&self, resolutionresults: P0) -> windows_core::Result + pub fn ReportCompletedAsync(&self, resolutionresults: P0) -> windows_core::Result where P0: windows_core::Param>, { @@ -1083,7 +1083,7 @@ impl EmailMailboxResolveRecipientsRequest { (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), resolutionresults.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1175,7 +1175,7 @@ impl EmailMailboxServerSearchReadBatchRequest { (windows_core::Interface::vtable(this).SuggestedBatchSize)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn SaveMessageAsync(&self, message: P0) -> windows_core::Result + pub fn SaveMessageAsync(&self, message: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -1185,14 +1185,14 @@ impl EmailMailboxServerSearchReadBatchRequest { (windows_core::Interface::vtable(this).SaveMessageAsync)(windows_core::Interface::as_raw(this), message.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportCompletedAsync(&self) -> windows_core::Result { + pub fn ReportCompletedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self, batchstatus: super::EmailBatchStatus) -> windows_core::Result { + pub fn ReportFailedAsync(&self, batchstatus: super::EmailBatchStatus) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1263,14 +1263,14 @@ impl EmailMailboxSetAutoReplySettingsRequest { (windows_core::Interface::vtable(this).AutoReplySettings)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportCompletedAsync(&self) -> windows_core::Result { + pub fn ReportCompletedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1334,14 +1334,14 @@ impl EmailMailboxSyncManagerSyncRequest { (windows_core::Interface::vtable(this).EmailMailboxId)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn ReportCompletedAsync(&self) -> windows_core::Result { + pub fn ReportCompletedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1440,14 +1440,14 @@ impl EmailMailboxUpdateMeetingResponseRequest { (windows_core::Interface::vtable(this).SendUpdate)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn ReportCompletedAsync(&self) -> windows_core::Result { + pub fn ReportCompletedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1519,7 +1519,7 @@ impl EmailMailboxValidateCertificatesRequest { (windows_core::Interface::vtable(this).Certificates)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportCompletedAsync(&self, validationstatuses: P0) -> windows_core::Result + pub fn ReportCompletedAsync(&self, validationstatuses: P0) -> windows_core::Result where P0: windows_core::Param>, { @@ -1529,7 +1529,7 @@ impl EmailMailboxValidateCertificatesRequest { (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), validationstatuses.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/ApplicationModel/Email/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/Email/mod.rs index 3951776fa7..17114bd04a 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/Email/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/Email/mod.rs @@ -307,14 +307,14 @@ impl EmailConversation { (windows_core::Interface::vtable(this).UnreadMessageCount)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn FindMessagesAsync(&self) -> windows_core::Result>> { + pub fn FindMessagesAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindMessagesAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FindMessagesWithCountAsync(&self, count: u32) -> windows_core::Result>> { + pub fn FindMessagesWithCountAsync(&self, count: u32) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -371,7 +371,7 @@ unsafe impl Sync for EmailConversationBatch {} pub struct EmailConversationReader(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(EmailConversationReader, windows_core::IUnknown, windows_core::IInspectable); impl EmailConversationReader { - pub fn ReadBatchAsync(&self) -> windows_core::Result> { + pub fn ReadBatchAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -483,21 +483,21 @@ impl EmailFolder { (windows_core::Interface::vtable(this).Kind)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn CreateFolderAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CreateFolderAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreateFolderAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(name), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAsync(&self) -> windows_core::Result { + pub fn DeleteAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeleteAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FindChildFoldersAsync(&self) -> windows_core::Result>> { + pub fn FindChildFoldersAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -521,7 +521,7 @@ impl EmailFolder { (windows_core::Interface::vtable(this).GetConversationReaderWithOptions)(windows_core::Interface::as_raw(this), options.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetMessageAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetMessageAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -545,14 +545,14 @@ impl EmailFolder { (windows_core::Interface::vtable(this).GetMessageReaderWithOptions)(windows_core::Interface::as_raw(this), options.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetMessageCountsAsync(&self) -> windows_core::Result> { + pub fn GetMessageCountsAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetMessageCountsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryMoveAsync(&self, newparentfolder: P0) -> windows_core::Result> + pub fn TryMoveAsync(&self, newparentfolder: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -562,7 +562,7 @@ impl EmailFolder { (windows_core::Interface::vtable(this).TryMoveAsync)(windows_core::Interface::as_raw(this), newparentfolder.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryMoveWithNewNameAsync(&self, newparentfolder: P0, newfoldername: &windows_core::HSTRING) -> windows_core::Result> + pub fn TryMoveWithNewNameAsync(&self, newparentfolder: P0, newfoldername: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -572,14 +572,14 @@ impl EmailFolder { (windows_core::Interface::vtable(this).TryMoveWithNewNameAsync)(windows_core::Interface::as_raw(this), newparentfolder.param().abi(), core::mem::transmute_copy(newfoldername), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TrySaveAsync(&self) -> windows_core::Result> { + pub fn TrySaveAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TrySaveAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SaveMessageAsync(&self, message: P0) -> windows_core::Result + pub fn SaveMessageAsync(&self, message: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -1056,112 +1056,112 @@ impl EmailMailbox { (windows_core::Interface::vtable(this).GetMessageReaderWithOptions)(windows_core::Interface::as_raw(this), options.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAsync(&self) -> windows_core::Result { + pub fn DeleteAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeleteAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetConversationAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetConversationAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetConversationAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(id), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetFolderAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetFolderAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFolderAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(id), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetMessageAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetMessageAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetMessageAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(id), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetSpecialFolderAsync(&self, foldertype: EmailSpecialFolderKind) -> windows_core::Result> { + pub fn GetSpecialFolderAsync(&self, foldertype: EmailSpecialFolderKind) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetSpecialFolderAsync)(windows_core::Interface::as_raw(this), foldertype, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SaveAsync(&self) -> windows_core::Result { + pub fn SaveAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).SaveAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn MarkMessageAsSeenAsync(&self, messageid: &windows_core::HSTRING) -> windows_core::Result { + pub fn MarkMessageAsSeenAsync(&self, messageid: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).MarkMessageAsSeenAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(messageid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn MarkFolderAsSeenAsync(&self, folderid: &windows_core::HSTRING) -> windows_core::Result { + pub fn MarkFolderAsSeenAsync(&self, folderid: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).MarkFolderAsSeenAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(folderid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn MarkMessageReadAsync(&self, messageid: &windows_core::HSTRING, isread: bool) -> windows_core::Result { + pub fn MarkMessageReadAsync(&self, messageid: &windows_core::HSTRING, isread: bool) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).MarkMessageReadAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(messageid), isread, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ChangeMessageFlagStateAsync(&self, messageid: &windows_core::HSTRING, flagstate: EmailFlagState) -> windows_core::Result { + pub fn ChangeMessageFlagStateAsync(&self, messageid: &windows_core::HSTRING, flagstate: EmailFlagState) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ChangeMessageFlagStateAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(messageid), flagstate, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryMoveMessageAsync(&self, messageid: &windows_core::HSTRING, newparentfolderid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn TryMoveMessageAsync(&self, messageid: &windows_core::HSTRING, newparentfolderid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryMoveMessageAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(messageid), core::mem::transmute_copy(newparentfolderid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryMoveFolderAsync(&self, folderid: &windows_core::HSTRING, newparentfolderid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn TryMoveFolderAsync(&self, folderid: &windows_core::HSTRING, newparentfolderid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryMoveFolderAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(folderid), core::mem::transmute_copy(newparentfolderid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryMoveFolderWithNewNameAsync(&self, folderid: &windows_core::HSTRING, newparentfolderid: &windows_core::HSTRING, newfoldername: &windows_core::HSTRING) -> windows_core::Result> { + pub fn TryMoveFolderWithNewNameAsync(&self, folderid: &windows_core::HSTRING, newparentfolderid: &windows_core::HSTRING, newfoldername: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryMoveFolderWithNewNameAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(folderid), core::mem::transmute_copy(newparentfolderid), core::mem::transmute_copy(newfoldername), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteMessageAsync(&self, messageid: &windows_core::HSTRING) -> windows_core::Result { + pub fn DeleteMessageAsync(&self, messageid: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeleteMessageAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(messageid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn MarkFolderSyncEnabledAsync(&self, folderid: &windows_core::HSTRING, issyncenabled: bool) -> windows_core::Result { + pub fn MarkFolderSyncEnabledAsync(&self, folderid: &windows_core::HSTRING, issyncenabled: bool) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).MarkFolderSyncEnabledAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(folderid), issyncenabled, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SendMessageAsync(&self, message: P0) -> windows_core::Result + pub fn SendMessageAsync(&self, message: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -1171,7 +1171,7 @@ impl EmailMailbox { (windows_core::Interface::vtable(this).SendMessageAsync)(windows_core::Interface::as_raw(this), message.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SaveDraftAsync(&self, message: P0) -> windows_core::Result + pub fn SaveDraftAsync(&self, message: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -1181,28 +1181,28 @@ impl EmailMailbox { (windows_core::Interface::vtable(this).SaveDraftAsync)(windows_core::Interface::as_raw(this), message.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DownloadMessageAsync(&self, messageid: &windows_core::HSTRING) -> windows_core::Result { + pub fn DownloadMessageAsync(&self, messageid: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DownloadMessageAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(messageid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DownloadAttachmentAsync(&self, attachmentid: &windows_core::HSTRING) -> windows_core::Result { + pub fn DownloadAttachmentAsync(&self, attachmentid: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DownloadAttachmentAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(attachmentid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateResponseMessageAsync(&self, messageid: &windows_core::HSTRING, responsetype: EmailMessageResponseKind, subject: &windows_core::HSTRING, responseheadertype: EmailMessageBodyKind, responseheader: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CreateResponseMessageAsync(&self, messageid: &windows_core::HSTRING, responsetype: EmailMessageResponseKind, subject: &windows_core::HSTRING, responseheadertype: EmailMessageBodyKind, responseheader: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreateResponseMessageAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(messageid), responsetype, core::mem::transmute_copy(subject), responseheadertype, core::mem::transmute_copy(responseheader), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryUpdateMeetingResponseAsync(&self, meeting: P0, response: EmailMeetingResponseType, subject: &windows_core::HSTRING, comment: &windows_core::HSTRING, sendupdate: bool) -> windows_core::Result> + pub fn TryUpdateMeetingResponseAsync(&self, meeting: P0, response: EmailMeetingResponseType, subject: &windows_core::HSTRING, comment: &windows_core::HSTRING, sendupdate: bool) -> windows_core::Result> where P0: windows_core::Param, { @@ -1212,7 +1212,7 @@ impl EmailMailbox { (windows_core::Interface::vtable(this).TryUpdateMeetingResponseAsync)(windows_core::Interface::as_raw(this), meeting.param().abi(), response, core::mem::transmute_copy(subject), core::mem::transmute_copy(comment), sendupdate, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryForwardMeetingAsync(&self, meeting: P0, recipients: P1, subject: &windows_core::HSTRING, forwardheadertype: EmailMessageBodyKind, forwardheader: &windows_core::HSTRING, comment: &windows_core::HSTRING) -> windows_core::Result> + pub fn TryForwardMeetingAsync(&self, meeting: P0, recipients: P1, subject: &windows_core::HSTRING, forwardheadertype: EmailMessageBodyKind, forwardheader: &windows_core::HSTRING, comment: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param>, @@ -1223,7 +1223,7 @@ impl EmailMailbox { (windows_core::Interface::vtable(this).TryForwardMeetingAsync)(windows_core::Interface::as_raw(this), meeting.param().abi(), recipients.param().abi(), core::mem::transmute_copy(subject), forwardheadertype, core::mem::transmute_copy(forwardheader), core::mem::transmute_copy(comment), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryProposeNewTimeForMeetingAsync(&self, meeting: P0, newstarttime: super::super::Foundation::DateTime, newduration: super::super::Foundation::TimeSpan, subject: &windows_core::HSTRING, comment: &windows_core::HSTRING) -> windows_core::Result> + pub fn TryProposeNewTimeForMeetingAsync(&self, meeting: P0, newstarttime: super::super::Foundation::DateTime, newduration: super::super::Foundation::TimeSpan, subject: &windows_core::HSTRING, comment: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -1247,7 +1247,7 @@ impl EmailMailbox { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveMailboxChanged)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn SmartSendMessageAsync(&self, message: P0, smartsend: bool) -> windows_core::Result + pub fn SmartSendMessageAsync(&self, message: P0, smartsend: bool) -> windows_core::Result where P0: windows_core::Param, { @@ -1257,7 +1257,7 @@ impl EmailMailbox { (windows_core::Interface::vtable(this).SmartSendMessageAsync)(windows_core::Interface::as_raw(this), message.param().abi(), smartsend, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TrySetAutoReplySettingsAsync(&self, autoreplysettings: P0) -> windows_core::Result> + pub fn TrySetAutoReplySettingsAsync(&self, autoreplysettings: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1267,7 +1267,7 @@ impl EmailMailbox { (windows_core::Interface::vtable(this).TrySetAutoReplySettingsAsync)(windows_core::Interface::as_raw(this), autoreplysettings.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryGetAutoReplySettingsAsync(&self, requestedformat: EmailMailboxAutoReplyMessageResponseKind) -> windows_core::Result> { + pub fn TryGetAutoReplySettingsAsync(&self, requestedformat: EmailMailboxAutoReplyMessageResponseKind) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1295,7 +1295,7 @@ impl EmailMailbox { (windows_core::Interface::vtable(this).NetworkId)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn ResolveRecipientsAsync(&self, recipients: P0) -> windows_core::Result>> + pub fn ResolveRecipientsAsync(&self, recipients: P0) -> windows_core::Result>> where P0: windows_core::Param>, { @@ -1306,7 +1306,7 @@ impl EmailMailbox { } } #[cfg(feature = "Security_Cryptography_Certificates")] - pub fn ValidateCertificatesAsync(&self, certificates: P0) -> windows_core::Result>> + pub fn ValidateCertificatesAsync(&self, certificates: P0) -> windows_core::Result>> where P0: windows_core::Param>, { @@ -1316,28 +1316,28 @@ impl EmailMailbox { (windows_core::Interface::vtable(this).ValidateCertificatesAsync)(windows_core::Interface::as_raw(this), certificates.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryEmptyFolderAsync(&self, folderid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn TryEmptyFolderAsync(&self, folderid: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryEmptyFolderAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(folderid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryCreateFolderAsync(&self, parentfolderid: &windows_core::HSTRING, name: &windows_core::HSTRING) -> windows_core::Result> { + pub fn TryCreateFolderAsync(&self, parentfolderid: &windows_core::HSTRING, name: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryCreateFolderAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(parentfolderid), core::mem::transmute_copy(name), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryDeleteFolderAsync(&self, folderid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn TryDeleteFolderAsync(&self, folderid: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryDeleteFolderAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(folderid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RegisterSyncManagerAsync(&self) -> windows_core::Result { + pub fn RegisterSyncManagerAsync(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1815,7 +1815,7 @@ impl EmailMailboxChangeReader { let this = self; unsafe { (windows_core::Interface::vtable(this).AcceptChangesThrough)(windows_core::Interface::as_raw(this), lastchangetoacknowledge.param().abi()).ok() } } - pub fn ReadBatchAsync(&self) -> windows_core::Result>> { + pub fn ReadBatchAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2198,7 +2198,7 @@ impl EmailMailboxSyncManager { (windows_core::Interface::vtable(this).LastAttemptedSyncTime)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn SyncAsync(&self) -> windows_core::Result> { + pub fn SyncAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2264,7 +2264,7 @@ impl windows_core::RuntimeType for EmailMailboxSyncStatus { } pub struct EmailManager; impl EmailManager { - pub fn ShowComposeNewEmailAsync(message: P0) -> windows_core::Result + pub fn ShowComposeNewEmailAsync(message: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -2273,7 +2273,7 @@ impl EmailManager { (windows_core::Interface::vtable(this).ShowComposeNewEmailAsync)(windows_core::Interface::as_raw(this), message.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RequestStoreAsync(accesstype: EmailStoreAccessType) -> windows_core::Result> { + pub fn RequestStoreAsync(accesstype: EmailStoreAccessType) -> windows_core::Result> { Self::IEmailManagerStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestStoreAsync)(windows_core::Interface::as_raw(this), accesstype, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -2310,7 +2310,7 @@ impl windows_core::RuntimeName for EmailManager { pub struct EmailManagerForUser(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(EmailManagerForUser, windows_core::IUnknown, windows_core::IInspectable); impl EmailManagerForUser { - pub fn ShowComposeNewEmailAsync(&self, message: P0) -> windows_core::Result + pub fn ShowComposeNewEmailAsync(&self, message: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -2320,7 +2320,7 @@ impl EmailManagerForUser { (windows_core::Interface::vtable(this).ShowComposeNewEmailAsync)(windows_core::Interface::as_raw(this), message.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestStoreAsync(&self, accesstype: EmailStoreAccessType) -> windows_core::Result> { + pub fn RequestStoreAsync(&self, accesstype: EmailStoreAccessType) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -3023,7 +3023,7 @@ impl windows_core::RuntimeType for EmailMessageDownloadState { pub struct EmailMessageReader(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(EmailMessageReader, windows_core::IUnknown, windows_core::IInspectable); impl EmailMessageReader { - pub fn ReadBatchAsync(&self) -> windows_core::Result> { + pub fn ReadBatchAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -3474,7 +3474,7 @@ impl windows_core::RuntimeType for EmailSpecialFolderKind { pub struct EmailStore(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(EmailStore, windows_core::IUnknown, windows_core::IInspectable); impl EmailStore { - pub fn FindMailboxesAsync(&self) -> windows_core::Result>> { + pub fn FindMailboxesAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -3515,42 +3515,42 @@ impl EmailStore { (windows_core::Interface::vtable(this).GetMessageReaderWithOptions)(windows_core::Interface::as_raw(this), options.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetMailboxAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetMailboxAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetMailboxAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(id), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetConversationAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetConversationAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetConversationAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(id), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetFolderAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetFolderAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFolderAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(id), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetMessageAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetMessageAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetMessageAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(id), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateMailboxAsync(&self, accountname: &windows_core::HSTRING, accountaddress: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CreateMailboxAsync(&self, accountname: &windows_core::HSTRING, accountaddress: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreateMailboxAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(accountname), core::mem::transmute_copy(accountaddress), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateMailboxInAccountAsync(&self, accountname: &windows_core::HSTRING, accountaddress: &windows_core::HSTRING, userdataaccountid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CreateMailboxInAccountAsync(&self, accountname: &windows_core::HSTRING, accountaddress: &windows_core::HSTRING, userdataaccountid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/ApplicationModel/ExtendedExecution/Foreground/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/ExtendedExecution/Foreground/mod.rs index 4cb13eba64..71e98857e2 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/ExtendedExecution/Foreground/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/ExtendedExecution/Foreground/mod.rs @@ -106,7 +106,7 @@ impl ExtendedExecutionForegroundSession { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveRevoked)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn RequestExtensionAsync(&self) -> windows_core::Result> { + pub fn RequestExtensionAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/ApplicationModel/ExtendedExecution/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/ExtendedExecution/mod.rs index 3c3898fff1..c9a49aa5a5 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/ExtendedExecution/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/ExtendedExecution/mod.rs @@ -129,7 +129,7 @@ impl ExtendedExecutionSession { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveRevoked)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn RequestExtensionAsync(&self) -> windows_core::Result> { + pub fn RequestExtensionAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/ApplicationModel/PackageExtensions/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/PackageExtensions/mod.rs index 504e6c5c0d..d665ec1307 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/PackageExtensions/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/PackageExtensions/mod.rs @@ -151,7 +151,7 @@ impl PackageExtension { } } #[cfg(feature = "Foundation_Collections")] - pub fn GetExtensionPropertiesAsync(&self) -> windows_core::Result> { + pub fn GetExtensionPropertiesAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -174,7 +174,7 @@ impl PackageExtension { } } #[cfg(feature = "Storage_Search")] - pub fn GetPublicFolderAsync(&self) -> windows_core::Result> { + pub fn GetPublicFolderAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -206,14 +206,14 @@ impl PackageExtensionCatalog { (windows_core::Interface::vtable(this).FindAll)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FindAllAsync(&self) -> windows_core::Result>> { + pub fn FindAllAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAllAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestRemovePackageAsync(&self, packagefullname: &windows_core::HSTRING) -> windows_core::Result> { + pub fn RequestRemovePackageAsync(&self, packagefullname: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/ApplicationModel/Payments/Provider/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/Payments/Provider/mod.rs index 0ffe9d5a92..9c6ea6ef18 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/Payments/Provider/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/Payments/Provider/mod.rs @@ -101,7 +101,7 @@ unsafe impl Sync for PaymentAppCanMakePaymentTriggerDetails {} pub struct PaymentAppManager(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(PaymentAppManager, windows_core::IUnknown, windows_core::IInspectable); impl PaymentAppManager { - pub fn RegisterAsync(&self, supportedpaymentmethodids: P0) -> windows_core::Result + pub fn RegisterAsync(&self, supportedpaymentmethodids: P0) -> windows_core::Result where P0: windows_core::Param>, { @@ -111,7 +111,7 @@ impl PaymentAppManager { (windows_core::Interface::vtable(this).RegisterAsync)(windows_core::Interface::as_raw(this), supportedpaymentmethodids.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn UnregisterAsync(&self) -> windows_core::Result { + pub fn UnregisterAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -186,7 +186,7 @@ impl PaymentTransaction { let this = self; unsafe { (windows_core::Interface::vtable(this).SetPayerPhoneNumber)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(value)).ok() } } - pub fn UpdateShippingAddressAsync(&self, shippingaddress: P0) -> windows_core::Result> + pub fn UpdateShippingAddressAsync(&self, shippingaddress: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -196,7 +196,7 @@ impl PaymentTransaction { (windows_core::Interface::vtable(this).UpdateShippingAddressAsync)(windows_core::Interface::as_raw(this), shippingaddress.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn UpdateSelectedShippingOptionAsync(&self, selectedshippingoption: P0) -> windows_core::Result> + pub fn UpdateSelectedShippingOptionAsync(&self, selectedshippingoption: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -206,7 +206,7 @@ impl PaymentTransaction { (windows_core::Interface::vtable(this).UpdateSelectedShippingOptionAsync)(windows_core::Interface::as_raw(this), selectedshippingoption.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn AcceptAsync(&self, paymenttoken: P0) -> windows_core::Result> + pub fn AcceptAsync(&self, paymenttoken: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -220,7 +220,7 @@ impl PaymentTransaction { let this = self; unsafe { (windows_core::Interface::vtable(this).Reject)(windows_core::Interface::as_raw(this)).ok() } } - pub fn FromIdAsync(id: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(id: &windows_core::HSTRING) -> windows_core::Result> { Self::IPaymentTransactionStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(id), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/ApplicationModel/Payments/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/Payments/mod.rs index e379a9f425..399d5a23aa 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/Payments/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/Payments/mod.rs @@ -916,14 +916,14 @@ impl PaymentMediator { static SHARED: windows_core::imp::FactoryCache = windows_core::imp::FactoryCache::new(); SHARED.call(callback) } - pub fn GetSupportedMethodIdsAsync(&self) -> windows_core::Result>> { + pub fn GetSupportedMethodIdsAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetSupportedMethodIdsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SubmitPaymentRequestAsync(&self, paymentrequest: P0) -> windows_core::Result> + pub fn SubmitPaymentRequestAsync(&self, paymentrequest: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -933,7 +933,7 @@ impl PaymentMediator { (windows_core::Interface::vtable(this).SubmitPaymentRequestAsync)(windows_core::Interface::as_raw(this), paymentrequest.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SubmitPaymentRequestWithChangeHandlerAsync(&self, paymentrequest: P0, changehandler: P1) -> windows_core::Result> + pub fn SubmitPaymentRequestWithChangeHandlerAsync(&self, paymentrequest: P0, changehandler: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -944,7 +944,7 @@ impl PaymentMediator { (windows_core::Interface::vtable(this).SubmitPaymentRequestWithChangeHandlerAsync)(windows_core::Interface::as_raw(this), paymentrequest.param().abi(), changehandler.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CanMakePaymentAsync(&self, paymentrequest: P0) -> windows_core::Result> + pub fn CanMakePaymentAsync(&self, paymentrequest: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1581,7 +1581,7 @@ impl PaymentResponse { (windows_core::Interface::vtable(this).PayerPhoneNumber)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn CompleteAsync(&self, status: PaymentRequestCompletionStatus) -> windows_core::Result { + pub fn CompleteAsync(&self, status: PaymentRequestCompletionStatus) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/ApplicationModel/Preview/InkWorkspace/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/Preview/InkWorkspace/mod.rs index bfdd93f377..16d96eb32a 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/Preview/InkWorkspace/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/Preview/InkWorkspace/mod.rs @@ -25,7 +25,7 @@ pub struct InkWorkspaceHostedAppManager(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(InkWorkspaceHostedAppManager, windows_core::IUnknown, windows_core::IInspectable); impl InkWorkspaceHostedAppManager { #[cfg(feature = "Graphics_Imaging")] - pub fn SetThumbnailAsync(&self, bitmap: P0) -> windows_core::Result + pub fn SetThumbnailAsync(&self, bitmap: P0) -> windows_core::Result where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/ApplicationModel/Preview/Notes/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/Preview/Notes/mod.rs index 593ad9824e..8a9e69601a 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/Preview/Notes/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/Preview/Notes/mod.rs @@ -195,7 +195,7 @@ impl NotesWindowManagerPreview { unsafe { (windows_core::Interface::vtable(this).SetFocusToNextView)(windows_core::Interface::as_raw(this)).ok() } } #[cfg(feature = "Storage_Streams")] - pub fn SetNotesThumbnailAsync(&self, thumbnail: P0) -> windows_core::Result + pub fn SetNotesThumbnailAsync(&self, thumbnail: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -268,7 +268,7 @@ impl NotesWindowManagerPreview { unsafe { (windows_core::Interface::vtable(this).SetFocusToPreviousView)(windows_core::Interface::as_raw(this)).ok() } } #[cfg(feature = "Graphics_Imaging")] - pub fn SetThumbnailImageForTaskSwitcherAsync(&self, bitmap: P0) -> windows_core::Result + pub fn SetThumbnailImageForTaskSwitcherAsync(&self, bitmap: P0) -> windows_core::Result where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/ApplicationModel/Resources/Core/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/Resources/Core/mod.rs index 62c9c29547..072b37c523 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/Resources/Core/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/Resources/Core/mod.rs @@ -283,7 +283,7 @@ impl ResourceCandidate { } } #[cfg(feature = "Storage_Streams")] - pub fn GetValueAsFileAsync(&self) -> windows_core::Result> { + pub fn GetValueAsFileAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -298,7 +298,7 @@ impl ResourceCandidate { } } #[cfg(feature = "Storage_Streams")] - pub fn GetValueAsStreamAsync(&self) -> windows_core::Result> { + pub fn GetValueAsStreamAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/ApplicationModel/Resources/Management/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/Resources/Management/mod.rs index 02a8652fd3..d00b8d9d32 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/Resources/Management/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/Resources/Management/mod.rs @@ -183,7 +183,7 @@ impl ResourceIndexer { (windows_core::Interface::vtable(this).IndexFilePath)(windows_core::Interface::as_raw(this), filepath.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn IndexFileContentsAsync(&self, file: P0) -> windows_core::Result>> + pub fn IndexFileContentsAsync(&self, file: P0) -> windows_core::Result>> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/ApplicationModel/UserActivities/Core/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/UserActivities/Core/mod.rs index d31b7bc7a5..dbcba434cd 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/UserActivities/Core/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/UserActivities/Core/mod.rs @@ -9,7 +9,7 @@ impl CoreUserActivityManager { (windows_core::Interface::vtable(this).CreateUserActivitySessionInBackground)(windows_core::Interface::as_raw(this), activity.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn DeleteUserActivitySessionsInTimeRangeAsync(channel: P0, starttime: super::super::super::Foundation::DateTime, endtime: super::super::super::Foundation::DateTime) -> windows_core::Result + pub fn DeleteUserActivitySessionsInTimeRangeAsync(channel: P0, starttime: super::super::super::Foundation::DateTime, endtime: super::super::super::Foundation::DateTime) -> windows_core::Result where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/ApplicationModel/UserActivities/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/UserActivities/mod.rs index 3d629fe121..50d5627307 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/UserActivities/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/UserActivities/mod.rs @@ -386,7 +386,7 @@ impl UserActivity { let this = self; unsafe { (windows_core::Interface::vtable(this).SetContentInfo)(windows_core::Interface::as_raw(this), value.param().abi()).ok() } } - pub fn SaveAsync(&self) -> windows_core::Result { + pub fn SaveAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -545,35 +545,35 @@ unsafe impl Sync for UserActivityAttribution {} pub struct UserActivityChannel(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(UserActivityChannel, windows_core::IUnknown, windows_core::IInspectable); impl UserActivityChannel { - pub fn GetOrCreateUserActivityAsync(&self, activityid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetOrCreateUserActivityAsync(&self, activityid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetOrCreateUserActivityAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(activityid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteActivityAsync(&self, activityid: &windows_core::HSTRING) -> windows_core::Result { + pub fn DeleteActivityAsync(&self, activityid: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeleteActivityAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(activityid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAllActivitiesAsync(&self) -> windows_core::Result { + pub fn DeleteAllActivitiesAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeleteAllActivitiesAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetRecentUserActivitiesAsync(&self, maxuniqueactivities: i32) -> windows_core::Result>> { + pub fn GetRecentUserActivitiesAsync(&self, maxuniqueactivities: i32) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetRecentUserActivitiesAsync)(windows_core::Interface::as_raw(this), maxuniqueactivities, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetSessionHistoryItemsForUserActivityAsync(&self, activityid: &windows_core::HSTRING, starttime: super::super::Foundation::DateTime) -> windows_core::Result>> { + pub fn GetSessionHistoryItemsForUserActivityAsync(&self, activityid: &windows_core::HSTRING, starttime: super::super::Foundation::DateTime) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/ApplicationModel/UserDataAccounts/SystemAccess/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/UserDataAccounts/SystemAccess/mod.rs index 791136e3ac..4ff59b0e92 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/UserDataAccounts/SystemAccess/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/UserDataAccounts/SystemAccess/mod.rs @@ -744,7 +744,7 @@ pub struct IUserDataAccountSystemAccessManagerStatics2_Vtbl { } pub struct UserDataAccountSystemAccessManager; impl UserDataAccountSystemAccessManager { - pub fn AddAndShowDeviceAccountsAsync(accounts: P0) -> windows_core::Result>> + pub fn AddAndShowDeviceAccountsAsync(accounts: P0) -> windows_core::Result>> where P0: windows_core::Param>, { @@ -753,13 +753,13 @@ impl UserDataAccountSystemAccessManager { (windows_core::Interface::vtable(this).AddAndShowDeviceAccountsAsync)(windows_core::Interface::as_raw(this), accounts.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn SuppressLocalAccountWithAccountAsync(userdataaccountid: &windows_core::HSTRING) -> windows_core::Result { + pub fn SuppressLocalAccountWithAccountAsync(userdataaccountid: &windows_core::HSTRING) -> windows_core::Result { Self::IUserDataAccountSystemAccessManagerStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).SuppressLocalAccountWithAccountAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(userdataaccountid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn CreateDeviceAccountAsync(account: P0) -> windows_core::Result> + pub fn CreateDeviceAccountAsync(account: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -768,13 +768,13 @@ impl UserDataAccountSystemAccessManager { (windows_core::Interface::vtable(this).CreateDeviceAccountAsync)(windows_core::Interface::as_raw(this), account.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn DeleteDeviceAccountAsync(accountid: &windows_core::HSTRING) -> windows_core::Result { + pub fn DeleteDeviceAccountAsync(accountid: &windows_core::HSTRING) -> windows_core::Result { Self::IUserDataAccountSystemAccessManagerStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeleteDeviceAccountAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(accountid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetDeviceAccountConfigurationAsync(accountid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetDeviceAccountConfigurationAsync(accountid: &windows_core::HSTRING) -> windows_core::Result> { Self::IUserDataAccountSystemAccessManagerStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetDeviceAccountConfigurationAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(accountid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/ApplicationModel/UserDataAccounts/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/UserDataAccounts/mod.rs index f548fd5f01..6714cae3fc 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/UserDataAccounts/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/UserDataAccounts/mod.rs @@ -221,14 +221,14 @@ impl UserDataAccount { (windows_core::Interface::vtable(this).PackageFamilyName)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn SaveAsync(&self) -> windows_core::Result { + pub fn SaveAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).SaveAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAsync(&self) -> windows_core::Result { + pub fn DeleteAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -236,7 +236,7 @@ impl UserDataAccount { } } #[cfg(feature = "ApplicationModel_Appointments")] - pub fn FindAppointmentCalendarsAsync(&self) -> windows_core::Result>> { + pub fn FindAppointmentCalendarsAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -244,7 +244,7 @@ impl UserDataAccount { } } #[cfg(feature = "ApplicationModel_Email")] - pub fn FindEmailMailboxesAsync(&self) -> windows_core::Result>> { + pub fn FindEmailMailboxesAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -252,7 +252,7 @@ impl UserDataAccount { } } #[cfg(feature = "ApplicationModel_Contacts")] - pub fn FindContactListsAsync(&self) -> windows_core::Result>> { + pub fn FindContactListsAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -260,7 +260,7 @@ impl UserDataAccount { } } #[cfg(feature = "ApplicationModel_Contacts")] - pub fn FindContactAnnotationListsAsync(&self) -> windows_core::Result>> { + pub fn FindContactAnnotationListsAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -319,7 +319,7 @@ impl UserDataAccount { } } #[cfg(feature = "ApplicationModel_UserDataTasks")] - pub fn FindUserDataTaskListsAsync(&self) -> windows_core::Result>> { + pub fn FindUserDataTaskListsAsync(&self) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -327,14 +327,14 @@ impl UserDataAccount { } } #[cfg(feature = "ApplicationModel_Contacts")] - pub fn FindContactGroupsAsync(&self) -> windows_core::Result>> { + pub fn FindContactGroupsAsync(&self) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindContactGroupsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryShowCreateContactGroupAsync(&self) -> windows_core::Result> { + pub fn TryShowCreateContactGroupAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -415,25 +415,25 @@ impl core::ops::Not for UserDataAccountContentKinds { } pub struct UserDataAccountManager; impl UserDataAccountManager { - pub fn RequestStoreAsync(storeaccesstype: UserDataAccountStoreAccessType) -> windows_core::Result> { + pub fn RequestStoreAsync(storeaccesstype: UserDataAccountStoreAccessType) -> windows_core::Result> { Self::IUserDataAccountManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestStoreAsync)(windows_core::Interface::as_raw(this), storeaccesstype, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn ShowAddAccountAsync(contentkinds: UserDataAccountContentKinds) -> windows_core::Result> { + pub fn ShowAddAccountAsync(contentkinds: UserDataAccountContentKinds) -> windows_core::Result> { Self::IUserDataAccountManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ShowAddAccountAsync)(windows_core::Interface::as_raw(this), contentkinds, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn ShowAccountSettingsAsync(id: &windows_core::HSTRING) -> windows_core::Result { + pub fn ShowAccountSettingsAsync(id: &windows_core::HSTRING) -> windows_core::Result { Self::IUserDataAccountManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ShowAccountSettingsAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(id), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn ShowAccountErrorResolverAsync(id: &windows_core::HSTRING) -> windows_core::Result { + pub fn ShowAccountErrorResolverAsync(id: &windows_core::HSTRING) -> windows_core::Result { Self::IUserDataAccountManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ShowAccountErrorResolverAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(id), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -466,7 +466,7 @@ impl windows_core::RuntimeName for UserDataAccountManager { pub struct UserDataAccountManagerForUser(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(UserDataAccountManagerForUser, windows_core::IUnknown, windows_core::IInspectable); impl UserDataAccountManagerForUser { - pub fn RequestStoreAsync(&self, storeaccesstype: UserDataAccountStoreAccessType) -> windows_core::Result> { + pub fn RequestStoreAsync(&self, storeaccesstype: UserDataAccountStoreAccessType) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -513,28 +513,28 @@ impl windows_core::RuntimeType for UserDataAccountOtherAppReadAccess { pub struct UserDataAccountStore(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(UserDataAccountStore, windows_core::IUnknown, windows_core::IInspectable); impl UserDataAccountStore { - pub fn FindAccountsAsync(&self) -> windows_core::Result>> { + pub fn FindAccountsAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAccountsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAccountAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetAccountAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetAccountAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(id), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateAccountAsync(&self, userdisplayname: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CreateAccountAsync(&self, userdisplayname: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreateAccountAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(userdisplayname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateAccountWithPackageRelativeAppIdAsync(&self, userdisplayname: &windows_core::HSTRING, packagerelativeappid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CreateAccountWithPackageRelativeAppIdAsync(&self, userdisplayname: &windows_core::HSTRING, packagerelativeappid: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -555,7 +555,7 @@ impl UserDataAccountStore { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).RemoveStoreChanged)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn CreateAccountWithPackageRelativeAppIdAndEnterpriseIdAsync(&self, userdisplayname: &windows_core::HSTRING, packagerelativeappid: &windows_core::HSTRING, enterpriseid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CreateAccountWithPackageRelativeAppIdAndEnterpriseIdAsync(&self, userdisplayname: &windows_core::HSTRING, packagerelativeappid: &windows_core::HSTRING, enterpriseid: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/ApplicationModel/UserDataTasks/DataProvider/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/UserDataTasks/DataProvider/mod.rs index fb0613d91d..c8dbd1afcc 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/UserDataTasks/DataProvider/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/UserDataTasks/DataProvider/mod.rs @@ -271,14 +271,14 @@ impl UserDataTaskListCompleteTaskRequest { (windows_core::Interface::vtable(this).TaskId)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn ReportCompletedAsync(&self, completedtaskid: &windows_core::HSTRING) -> windows_core::Result { + pub fn ReportCompletedAsync(&self, completedtaskid: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(completedtaskid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -349,7 +349,7 @@ impl UserDataTaskListCreateOrUpdateTaskRequest { (windows_core::Interface::vtable(this).Task)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportCompletedAsync(&self, createdorupdateduserdatatask: P0) -> windows_core::Result + pub fn ReportCompletedAsync(&self, createdorupdateduserdatatask: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -359,7 +359,7 @@ impl UserDataTaskListCreateOrUpdateTaskRequest { (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), createdorupdateduserdatatask.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -430,14 +430,14 @@ impl UserDataTaskListDeleteTaskRequest { (windows_core::Interface::vtable(this).TaskId)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn ReportCompletedAsync(&self) -> windows_core::Result { + pub fn ReportCompletedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -508,14 +508,14 @@ impl UserDataTaskListSkipOccurrenceRequest { (windows_core::Interface::vtable(this).TaskId)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn ReportCompletedAsync(&self) -> windows_core::Result { + pub fn ReportCompletedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -579,14 +579,14 @@ impl UserDataTaskListSyncManagerSyncRequest { (windows_core::Interface::vtable(this).TaskListId)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn ReportCompletedAsync(&self) -> windows_core::Result { + pub fn ReportCompletedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/ApplicationModel/UserDataTasks/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/UserDataTasks/mod.rs index 54d0bfabb0..00728b4633 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/UserDataTasks/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/UserDataTasks/mod.rs @@ -572,7 +572,7 @@ impl UserDataTaskList { (windows_core::Interface::vtable(this).SyncManager)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RegisterSyncManagerAsync(&self) -> windows_core::Result { + pub fn RegisterSyncManagerAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -596,14 +596,14 @@ impl UserDataTaskList { (windows_core::Interface::vtable(this).GetTaskReaderWithOptions)(windows_core::Interface::as_raw(this), options.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetTaskAsync(&self, userdatatask: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetTaskAsync(&self, userdatatask: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetTaskAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(userdatatask), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SaveTaskAsync(&self, userdatatask: P0) -> windows_core::Result + pub fn SaveTaskAsync(&self, userdatatask: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -613,21 +613,21 @@ impl UserDataTaskList { (windows_core::Interface::vtable(this).SaveTaskAsync)(windows_core::Interface::as_raw(this), userdatatask.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteTaskAsync(&self, userdatataskid: &windows_core::HSTRING) -> windows_core::Result { + pub fn DeleteTaskAsync(&self, userdatataskid: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeleteTaskAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(userdatataskid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAsync(&self) -> windows_core::Result { + pub fn DeleteAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeleteAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SaveAsync(&self) -> windows_core::Result { + pub fn SaveAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -652,14 +652,14 @@ unsafe impl Sync for UserDataTaskList {} pub struct UserDataTaskListLimitedWriteOperations(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(UserDataTaskListLimitedWriteOperations, windows_core::IUnknown, windows_core::IInspectable); impl UserDataTaskListLimitedWriteOperations { - pub fn TryCompleteTaskAsync(&self, userdatataskid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn TryCompleteTaskAsync(&self, userdatataskid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryCompleteTaskAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(userdatataskid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryCreateOrUpdateTaskAsync(&self, userdatatask: P0) -> windows_core::Result> + pub fn TryCreateOrUpdateTaskAsync(&self, userdatatask: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -669,14 +669,14 @@ impl UserDataTaskListLimitedWriteOperations { (windows_core::Interface::vtable(this).TryCreateOrUpdateTaskAsync)(windows_core::Interface::as_raw(this), userdatatask.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryDeleteTaskAsync(&self, userdatataskid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn TryDeleteTaskAsync(&self, userdatataskid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryDeleteTaskAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(userdatataskid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TrySkipOccurrenceAsync(&self, userdatataskid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn TrySkipOccurrenceAsync(&self, userdatataskid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -761,7 +761,7 @@ impl UserDataTaskListSyncManager { let this = self; unsafe { (windows_core::Interface::vtable(this).SetStatus)(windows_core::Interface::as_raw(this), value).ok() } } - pub fn SyncAsync(&self) -> windows_core::Result> { + pub fn SyncAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -817,7 +817,7 @@ impl windows_core::RuntimeType for UserDataTaskListSyncStatus { pub struct UserDataTaskManager(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(UserDataTaskManager, windows_core::IUnknown, windows_core::IInspectable); impl UserDataTaskManager { - pub fn RequestStoreAsync(&self, accesstype: UserDataTaskStoreAccessType) -> windows_core::Result> { + pub fn RequestStoreAsync(&self, accesstype: UserDataTaskStoreAccessType) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -957,7 +957,7 @@ impl windows_core::RuntimeType for UserDataTaskQuerySortProperty { pub struct UserDataTaskReader(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(UserDataTaskReader, windows_core::IUnknown, windows_core::IInspectable); impl UserDataTaskReader { - pub fn ReadBatchAsync(&self) -> windows_core::Result> { + pub fn ReadBatchAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1233,28 +1233,28 @@ impl windows_core::RuntimeType for UserDataTaskSensitivity { pub struct UserDataTaskStore(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(UserDataTaskStore, windows_core::IUnknown, windows_core::IInspectable); impl UserDataTaskStore { - pub fn CreateListAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CreateListAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreateListAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(name), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateListInAccountAsync(&self, name: &windows_core::HSTRING, userdataaccountid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CreateListInAccountAsync(&self, name: &windows_core::HSTRING, userdataaccountid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreateListInAccountAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(name), core::mem::transmute_copy(userdataaccountid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FindListsAsync(&self) -> windows_core::Result>> { + pub fn FindListsAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindListsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetListAsync(&self, tasklistid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetListAsync(&self, tasklistid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/ApplicationModel/VoiceCommands/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/VoiceCommands/mod.rs index 98a8cb18d3..c24e5984ed 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/VoiceCommands/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/VoiceCommands/mod.rs @@ -433,7 +433,7 @@ impl VoiceCommandDefinition { (windows_core::Interface::vtable(this).Name)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn SetPhraseListAsync(&self, phraselistname: &windows_core::HSTRING, phraselist: P1) -> windows_core::Result + pub fn SetPhraseListAsync(&self, phraselistname: &windows_core::HSTRING, phraselist: P1) -> windows_core::Result where P1: windows_core::Param>, { @@ -459,7 +459,7 @@ unsafe impl Sync for VoiceCommandDefinition {} pub struct VoiceCommandDefinitionManager; impl VoiceCommandDefinitionManager { #[cfg(feature = "Storage_Streams")] - pub fn InstallCommandDefinitionsFromStorageFileAsync(file: P0) -> windows_core::Result + pub fn InstallCommandDefinitionsFromStorageFileAsync(file: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -626,14 +626,14 @@ unsafe impl Sync for VoiceCommandResponse {} pub struct VoiceCommandServiceConnection(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(VoiceCommandServiceConnection, windows_core::IUnknown, windows_core::IInspectable); impl VoiceCommandServiceConnection { - pub fn GetVoiceCommandAsync(&self) -> windows_core::Result> { + pub fn GetVoiceCommandAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetVoiceCommandAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestConfirmationAsync(&self, response: P0) -> windows_core::Result> + pub fn RequestConfirmationAsync(&self, response: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -643,7 +643,7 @@ impl VoiceCommandServiceConnection { (windows_core::Interface::vtable(this).RequestConfirmationAsync)(windows_core::Interface::as_raw(this), response.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestDisambiguationAsync(&self, response: P0) -> windows_core::Result> + pub fn RequestDisambiguationAsync(&self, response: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -653,7 +653,7 @@ impl VoiceCommandServiceConnection { (windows_core::Interface::vtable(this).RequestDisambiguationAsync)(windows_core::Interface::as_raw(this), response.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportProgressAsync(&self, response: P0) -> windows_core::Result + pub fn ReportProgressAsync(&self, response: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -663,7 +663,7 @@ impl VoiceCommandServiceConnection { (windows_core::Interface::vtable(this).ReportProgressAsync)(windows_core::Interface::as_raw(this), response.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportSuccessAsync(&self, response: P0) -> windows_core::Result + pub fn ReportSuccessAsync(&self, response: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -673,7 +673,7 @@ impl VoiceCommandServiceConnection { (windows_core::Interface::vtable(this).ReportSuccessAsync)(windows_core::Interface::as_raw(this), response.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailureAsync(&self, response: P0) -> windows_core::Result + pub fn ReportFailureAsync(&self, response: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -683,7 +683,7 @@ impl VoiceCommandServiceConnection { (windows_core::Interface::vtable(this).ReportFailureAsync)(windows_core::Interface::as_raw(this), response.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestAppLaunchAsync(&self, response: P0) -> windows_core::Result + pub fn RequestAppLaunchAsync(&self, response: P0) -> windows_core::Result where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/ApplicationModel/Wallet/System/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/Wallet/System/mod.rs index 60af98e130..4dd3fde841 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/Wallet/System/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/Wallet/System/mod.rs @@ -64,14 +64,14 @@ pub struct WalletItemSystemStore(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(WalletItemSystemStore, windows_core::IUnknown, windows_core::IInspectable); #[cfg(feature = "deprecated")] impl WalletItemSystemStore { - pub fn GetItemsAsync(&self) -> windows_core::Result>> { + pub fn GetItemsAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetItemsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAsync(&self, item: P0) -> windows_core::Result + pub fn DeleteAsync(&self, item: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -82,7 +82,7 @@ impl WalletItemSystemStore { } } #[cfg(feature = "Storage_Streams")] - pub fn ImportItemAsync(&self, stream: P0) -> windows_core::Result> + pub fn ImportItemAsync(&self, stream: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -102,7 +102,7 @@ impl WalletItemSystemStore { (windows_core::Interface::vtable(this).GetAppStatusForItem)(windows_core::Interface::as_raw(this), item.param().abi(), &mut result__).map(|| result__) } } - pub fn LaunchAppForItemAsync(&self, item: P0) -> windows_core::Result> + pub fn LaunchAppForItemAsync(&self, item: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -148,7 +148,7 @@ unsafe impl Sync for WalletItemSystemStore {} pub struct WalletManagerSystem; #[cfg(feature = "deprecated")] impl WalletManagerSystem { - pub fn RequestStoreAsync() -> windows_core::Result> { + pub fn RequestStoreAsync() -> windows_core::Result> { Self::IWalletManagerSystemStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestStoreAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/ApplicationModel/Wallet/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/Wallet/mod.rs index 9a089b4a3a..f02b781aa1 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/Wallet/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/Wallet/mod.rs @@ -364,7 +364,7 @@ impl WalletBarcode { } } #[cfg(feature = "Storage_Streams")] - pub fn GetImageAsync(&self) -> windows_core::Result> { + pub fn GetImageAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -961,7 +961,7 @@ pub struct WalletItemStore(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(WalletItemStore, windows_core::IUnknown, windows_core::IInspectable); #[cfg(feature = "deprecated")] impl WalletItemStore { - pub fn AddAsync(&self, id: &windows_core::HSTRING, item: P1) -> windows_core::Result + pub fn AddAsync(&self, id: &windows_core::HSTRING, item: P1) -> windows_core::Result where P1: windows_core::Param, { @@ -971,28 +971,28 @@ impl WalletItemStore { (windows_core::Interface::vtable(this).AddAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(id), item.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ClearAsync(&self) -> windows_core::Result { + pub fn ClearAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ClearAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetWalletItemAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetWalletItemAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetWalletItemAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(id), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetItemsAsync(&self) -> windows_core::Result>> { + pub fn GetItemsAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetItemsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetItemsWithKindAsync(&self, kind: WalletItemKind) -> windows_core::Result>> { + pub fn GetItemsWithKindAsync(&self, kind: WalletItemKind) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1000,7 +1000,7 @@ impl WalletItemStore { } } #[cfg(feature = "Storage_Streams")] - pub fn ImportItemAsync(&self, stream: P0) -> windows_core::Result> + pub fn ImportItemAsync(&self, stream: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1010,28 +1010,28 @@ impl WalletItemStore { (windows_core::Interface::vtable(this).ImportItemAsync)(windows_core::Interface::as_raw(this), stream.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result { + pub fn DeleteAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeleteAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(id), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ShowAsync(&self) -> windows_core::Result { + pub fn ShowAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ShowAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ShowItemAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result { + pub fn ShowItemAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ShowItemAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(id), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn UpdateAsync(&self, item: P0) -> windows_core::Result + pub fn UpdateAsync(&self, item: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -1063,7 +1063,7 @@ unsafe impl Sync for WalletItemStore {} pub struct WalletManager; #[cfg(feature = "deprecated")] impl WalletManager { - pub fn RequestStoreAsync() -> windows_core::Result> { + pub fn RequestStoreAsync() -> windows_core::Result> { Self::IWalletManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestStoreAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/ApplicationModel/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/mod.rs index abefe4660a..5c003cafa1 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/mod.rs @@ -651,37 +651,37 @@ unsafe impl Send for FullTrustProcessLaunchResult {} unsafe impl Sync for FullTrustProcessLaunchResult {} pub struct FullTrustProcessLauncher; impl FullTrustProcessLauncher { - pub fn LaunchFullTrustProcessForCurrentAppAsync() -> windows_core::Result { + pub fn LaunchFullTrustProcessForCurrentAppAsync() -> windows_core::Result { Self::IFullTrustProcessLauncherStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).LaunchFullTrustProcessForCurrentAppAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn LaunchFullTrustProcessForCurrentAppWithParametersAsync(parametergroupid: &windows_core::HSTRING) -> windows_core::Result { + pub fn LaunchFullTrustProcessForCurrentAppWithParametersAsync(parametergroupid: &windows_core::HSTRING) -> windows_core::Result { Self::IFullTrustProcessLauncherStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).LaunchFullTrustProcessForCurrentAppWithParametersAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(parametergroupid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn LaunchFullTrustProcessForAppAsync(fulltrustpackagerelativeappid: &windows_core::HSTRING) -> windows_core::Result { + pub fn LaunchFullTrustProcessForAppAsync(fulltrustpackagerelativeappid: &windows_core::HSTRING) -> windows_core::Result { Self::IFullTrustProcessLauncherStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).LaunchFullTrustProcessForAppAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(fulltrustpackagerelativeappid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn LaunchFullTrustProcessForAppWithParametersAsync(fulltrustpackagerelativeappid: &windows_core::HSTRING, parametergroupid: &windows_core::HSTRING) -> windows_core::Result { + pub fn LaunchFullTrustProcessForAppWithParametersAsync(fulltrustpackagerelativeappid: &windows_core::HSTRING, parametergroupid: &windows_core::HSTRING) -> windows_core::Result { Self::IFullTrustProcessLauncherStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).LaunchFullTrustProcessForAppWithParametersAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(fulltrustpackagerelativeappid), core::mem::transmute_copy(parametergroupid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn LaunchFullTrustProcessForCurrentAppWithArgumentsAsync(commandline: &windows_core::HSTRING) -> windows_core::Result> { + pub fn LaunchFullTrustProcessForCurrentAppWithArgumentsAsync(commandline: &windows_core::HSTRING) -> windows_core::Result> { Self::IFullTrustProcessLauncherStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).LaunchFullTrustProcessForCurrentAppWithArgumentsAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(commandline), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn LaunchFullTrustProcessForAppWithArgumentsAsync(fulltrustpackagerelativeappid: &windows_core::HSTRING, commandline: &windows_core::HSTRING) -> windows_core::Result> { + pub fn LaunchFullTrustProcessForAppWithArgumentsAsync(fulltrustpackagerelativeappid: &windows_core::HSTRING, commandline: &windows_core::HSTRING) -> windows_core::Result> { Self::IFullTrustProcessLauncherStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).LaunchFullTrustProcessForAppWithArgumentsAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(fulltrustpackagerelativeappid), core::mem::transmute_copy(commandline), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -1870,7 +1870,7 @@ impl Package { } } #[cfg(feature = "ApplicationModel_Core")] - pub fn GetAppListEntriesAsync(&self) -> windows_core::Result>> { + pub fn GetAppListEntriesAsync(&self) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1891,28 +1891,28 @@ impl Package { (windows_core::Interface::vtable(this).IsOptional)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn VerifyContentIntegrityAsync(&self) -> windows_core::Result> { + pub fn VerifyContentIntegrityAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).VerifyContentIntegrityAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetContentGroupsAsync(&self) -> windows_core::Result>> { + pub fn GetContentGroupsAsync(&self) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetContentGroupsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetContentGroupAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetContentGroupAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetContentGroupAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(name), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StageContentGroupsAsync(&self, names: P0) -> windows_core::Result>> + pub fn StageContentGroupsAsync(&self, names: P0) -> windows_core::Result>> where P0: windows_core::Param>, { @@ -1922,7 +1922,7 @@ impl Package { (windows_core::Interface::vtable(this).StageContentGroupsAsync)(windows_core::Interface::as_raw(this), names.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StageContentGroupsWithPriorityAsync(&self, names: P0, movetoheadofqueue: bool) -> windows_core::Result>> + pub fn StageContentGroupsWithPriorityAsync(&self, names: P0, movetoheadofqueue: bool) -> windows_core::Result>> where P0: windows_core::Param>, { @@ -1932,7 +1932,7 @@ impl Package { (windows_core::Interface::vtable(this).StageContentGroupsWithPriorityAsync)(windows_core::Interface::as_raw(this), names.param().abi(), movetoheadofqueue, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SetInUseAsync(&self, inuse: bool) -> windows_core::Result> { + pub fn SetInUseAsync(&self, inuse: bool) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1946,7 +1946,7 @@ impl Package { (windows_core::Interface::vtable(this).GetAppInstallerInfo)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CheckUpdateAvailabilityAsync(&self) -> windows_core::Result> { + pub fn CheckUpdateAvailabilityAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -2207,14 +2207,14 @@ impl PackageCatalog { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).RemovePackageContentGroupStaging)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn AddOptionalPackageAsync(&self, optionalpackagefamilyname: &windows_core::HSTRING) -> windows_core::Result> { + pub fn AddOptionalPackageAsync(&self, optionalpackagefamilyname: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).AddOptionalPackageAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(optionalpackagefamilyname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RemoveOptionalPackagesAsync(&self, optionalpackagefamilynames: P0) -> windows_core::Result> + pub fn RemoveOptionalPackagesAsync(&self, optionalpackagefamilynames: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -2224,14 +2224,14 @@ impl PackageCatalog { (windows_core::Interface::vtable(this).RemoveOptionalPackagesAsync)(windows_core::Interface::as_raw(this), optionalpackagefamilynames.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn AddResourcePackageAsync(&self, resourcepackagefamilyname: &windows_core::HSTRING, resourceid: &windows_core::HSTRING, options: AddResourcePackageOptions) -> windows_core::Result> { + pub fn AddResourcePackageAsync(&self, resourcepackagefamilyname: &windows_core::HSTRING, resourceid: &windows_core::HSTRING, options: AddResourcePackageOptions) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).AddResourcePackageAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(resourcepackagefamilyname), core::mem::transmute_copy(resourceid), options, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RemoveResourcePackagesAsync(&self, resourcepackages: P0) -> windows_core::Result> + pub fn RemoveResourcePackagesAsync(&self, resourcepackages: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -3100,7 +3100,7 @@ impl windows_core::RuntimeType for PackageVersion { pub struct StartupTask(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(StartupTask, windows_core::IUnknown, windows_core::IInspectable); impl StartupTask { - pub fn RequestEnableAsync(&self) -> windows_core::Result> { + pub fn RequestEnableAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -3125,13 +3125,13 @@ impl StartupTask { (windows_core::Interface::vtable(this).TaskId)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn GetForCurrentPackageAsync() -> windows_core::Result>> { + pub fn GetForCurrentPackageAsync() -> windows_core::Result>> { Self::IStartupTaskStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetForCurrentPackageAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetAsync(taskid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetAsync(taskid: &windows_core::HSTRING) -> windows_core::Result> { Self::IStartupTaskStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(taskid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/Data/Pdf/mod.rs b/crates/libs/windows/src/Windows/Data/Pdf/mod.rs index 199588b65c..c9bfe2483d 100644 --- a/crates/libs/windows/src/Windows/Data/Pdf/mod.rs +++ b/crates/libs/windows/src/Windows/Data/Pdf/mod.rs @@ -121,7 +121,7 @@ impl PdfDocument { } } #[cfg(feature = "Storage_Streams")] - pub fn LoadFromFileAsync(file: P0) -> windows_core::Result> + pub fn LoadFromFileAsync(file: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -131,7 +131,7 @@ impl PdfDocument { }) } #[cfg(feature = "Storage_Streams")] - pub fn LoadFromFileWithPasswordAsync(file: P0, password: &windows_core::HSTRING) -> windows_core::Result> + pub fn LoadFromFileWithPasswordAsync(file: P0, password: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -141,7 +141,7 @@ impl PdfDocument { }) } #[cfg(feature = "Storage_Streams")] - pub fn LoadFromStreamAsync(inputstream: P0) -> windows_core::Result> + pub fn LoadFromStreamAsync(inputstream: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -151,7 +151,7 @@ impl PdfDocument { }) } #[cfg(feature = "Storage_Streams")] - pub fn LoadFromStreamWithPasswordAsync(inputstream: P0, password: &windows_core::HSTRING) -> windows_core::Result> + pub fn LoadFromStreamWithPasswordAsync(inputstream: P0, password: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -188,7 +188,7 @@ impl PdfPage { unsafe { (windows_core::Interface::vtable(this).Close)(windows_core::Interface::as_raw(this)).ok() } } #[cfg(feature = "Storage_Streams")] - pub fn RenderToStreamAsync(&self, outputstream: P0) -> windows_core::Result + pub fn RenderToStreamAsync(&self, outputstream: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -199,7 +199,7 @@ impl PdfPage { } } #[cfg(feature = "Storage_Streams")] - pub fn RenderWithOptionsToStreamAsync(&self, outputstream: P0, options: P1) -> windows_core::Result + pub fn RenderWithOptionsToStreamAsync(&self, outputstream: P0, options: P1) -> windows_core::Result where P0: windows_core::Param, P1: windows_core::Param, @@ -210,7 +210,7 @@ impl PdfPage { (windows_core::Interface::vtable(this).RenderWithOptionsToStreamAsync)(windows_core::Interface::as_raw(this), outputstream.param().abi(), options.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn PreparePageAsync(&self) -> windows_core::Result { + pub fn PreparePageAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Data/Text/mod.rs b/crates/libs/windows/src/Windows/Data/Text/mod.rs index 5d435bcad7..f3396548ab 100644 --- a/crates/libs/windows/src/Windows/Data/Text/mod.rs +++ b/crates/libs/windows/src/Windows/Data/Text/mod.rs @@ -495,14 +495,14 @@ impl TextConversionGenerator { (windows_core::Interface::vtable(this).LanguageAvailableButNotInstalled)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn GetCandidatesAsync(&self, input: &windows_core::HSTRING) -> windows_core::Result>> { + pub fn GetCandidatesAsync(&self, input: &windows_core::HSTRING) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetCandidatesAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(input), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetCandidatesWithMaxCountAsync(&self, input: &windows_core::HSTRING, maxcandidates: u32) -> windows_core::Result>> { + pub fn GetCandidatesWithMaxCountAsync(&self, input: &windows_core::HSTRING, maxcandidates: u32) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -583,21 +583,21 @@ impl TextPredictionGenerator { (windows_core::Interface::vtable(this).LanguageAvailableButNotInstalled)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn GetCandidatesAsync(&self, input: &windows_core::HSTRING) -> windows_core::Result>> { + pub fn GetCandidatesAsync(&self, input: &windows_core::HSTRING) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetCandidatesAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(input), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetCandidatesWithMaxCountAsync(&self, input: &windows_core::HSTRING, maxcandidates: u32) -> windows_core::Result>> { + pub fn GetCandidatesWithMaxCountAsync(&self, input: &windows_core::HSTRING, maxcandidates: u32) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetCandidatesWithMaxCountAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(input), maxcandidates, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetCandidatesWithParametersAsync(&self, input: &windows_core::HSTRING, maxcandidates: u32, predictionoptions: TextPredictionOptions, previousstrings: P3) -> windows_core::Result>> + pub fn GetCandidatesWithParametersAsync(&self, input: &windows_core::HSTRING, maxcandidates: u32, predictionoptions: TextPredictionOptions, previousstrings: P3) -> windows_core::Result>> where P3: windows_core::Param>, { @@ -607,7 +607,7 @@ impl TextPredictionGenerator { (windows_core::Interface::vtable(this).GetCandidatesWithParametersAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(input), maxcandidates, predictionoptions, previousstrings.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetNextWordCandidatesAsync(&self, maxcandidates: u32, previousstrings: P1) -> windows_core::Result>> + pub fn GetNextWordCandidatesAsync(&self, maxcandidates: u32, previousstrings: P1) -> windows_core::Result>> where P1: windows_core::Param>, { @@ -719,14 +719,14 @@ impl TextReverseConversionGenerator { (windows_core::Interface::vtable(this).LanguageAvailableButNotInstalled)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn ConvertBackAsync(&self, input: &windows_core::HSTRING) -> windows_core::Result> { + pub fn ConvertBackAsync(&self, input: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ConvertBackAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(input), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetPhonemesAsync(&self, input: &windows_core::HSTRING) -> windows_core::Result>> { + pub fn GetPhonemesAsync(&self, input: &windows_core::HSTRING) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Data/Xml/Dom/mod.rs b/crates/libs/windows/src/Windows/Data/Xml/Dom/mod.rs index c545b286df..45f9fd8347 100644 --- a/crates/libs/windows/src/Windows/Data/Xml/Dom/mod.rs +++ b/crates/libs/windows/src/Windows/Data/Xml/Dom/mod.rs @@ -3274,7 +3274,7 @@ impl XmlDocument { unsafe { (windows_core::Interface::vtable(this).LoadXmlWithSettings)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(xml), loadsettings.param().abi()).ok() } } #[cfg(feature = "Storage_Streams")] - pub fn SaveToFileAsync(&self, file: P0) -> windows_core::Result + pub fn SaveToFileAsync(&self, file: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -3301,7 +3301,7 @@ impl XmlDocument { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).LoadXmlFromBufferWithSettings)(windows_core::Interface::as_raw(this), buffer.param().abi(), loadsettings.param().abi()).ok() } } - pub fn LoadFromUriAsync(uri: P0) -> windows_core::Result> + pub fn LoadFromUriAsync(uri: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -3310,7 +3310,7 @@ impl XmlDocument { (windows_core::Interface::vtable(this).LoadFromUriAsync)(windows_core::Interface::as_raw(this), uri.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn LoadFromUriWithSettingsAsync(uri: P0, loadsettings: P1) -> windows_core::Result> + pub fn LoadFromUriWithSettingsAsync(uri: P0, loadsettings: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -3321,7 +3321,7 @@ impl XmlDocument { }) } #[cfg(feature = "Storage_Streams")] - pub fn LoadFromFileAsync(file: P0) -> windows_core::Result> + pub fn LoadFromFileAsync(file: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -3331,7 +3331,7 @@ impl XmlDocument { }) } #[cfg(feature = "Storage_Streams")] - pub fn LoadFromFileWithSettingsAsync(file: P0, loadsettings: P1) -> windows_core::Result> + pub fn LoadFromFileWithSettingsAsync(file: P0, loadsettings: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, diff --git a/crates/libs/windows/src/Windows/Devices/Adc/mod.rs b/crates/libs/windows/src/Windows/Devices/Adc/mod.rs index 496d832e3f..95213c2bfc 100644 --- a/crates/libs/windows/src/Windows/Devices/Adc/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/Adc/mod.rs @@ -116,7 +116,7 @@ impl AdcController { } } #[cfg(feature = "Devices_Adc_Provider")] - pub fn GetControllersAsync(provider: P0) -> windows_core::Result>> + pub fn GetControllersAsync(provider: P0) -> windows_core::Result>> where P0: windows_core::Param, { @@ -125,7 +125,7 @@ impl AdcController { (windows_core::Interface::vtable(this).GetControllersAsync)(windows_core::Interface::as_raw(this), provider.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetDefaultAsync() -> windows_core::Result> { + pub fn GetDefaultAsync() -> windows_core::Result> { Self::IAdcControllerStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetDefaultAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/Devices/Bluetooth/GenericAttributeProfile/mod.rs b/crates/libs/windows/src/Windows/Devices/Bluetooth/GenericAttributeProfile/mod.rs index ca9d623a3f..432137f2e8 100644 --- a/crates/libs/windows/src/Windows/Devices/Bluetooth/GenericAttributeProfile/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/Bluetooth/GenericAttributeProfile/mod.rs @@ -57,14 +57,14 @@ impl GattCharacteristic { (windows_core::Interface::vtable(this).PresentationFormats)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReadValueAsync(&self) -> windows_core::Result> { + pub fn ReadValueAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReadValueAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReadValueWithCacheModeAsync(&self, cachemode: super::BluetoothCacheMode) -> windows_core::Result> { + pub fn ReadValueWithCacheModeAsync(&self, cachemode: super::BluetoothCacheMode) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -72,7 +72,7 @@ impl GattCharacteristic { } } #[cfg(feature = "Storage_Streams")] - pub fn WriteValueAsync(&self, value: P0) -> windows_core::Result> + pub fn WriteValueAsync(&self, value: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -83,7 +83,7 @@ impl GattCharacteristic { } } #[cfg(feature = "Storage_Streams")] - pub fn WriteValueWithOptionAsync(&self, value: P0, writeoption: GattWriteOption) -> windows_core::Result> + pub fn WriteValueWithOptionAsync(&self, value: P0, writeoption: GattWriteOption) -> windows_core::Result> where P0: windows_core::Param, { @@ -93,14 +93,14 @@ impl GattCharacteristic { (windows_core::Interface::vtable(this).WriteValueWithOptionAsync)(windows_core::Interface::as_raw(this), value.param().abi(), writeoption, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReadClientCharacteristicConfigurationDescriptorAsync(&self) -> windows_core::Result> { + pub fn ReadClientCharacteristicConfigurationDescriptorAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReadClientCharacteristicConfigurationDescriptorAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn WriteClientCharacteristicConfigurationDescriptorAsync(&self, clientcharacteristicconfigurationdescriptorvalue: GattClientCharacteristicConfigurationDescriptorValue) -> windows_core::Result> { + pub fn WriteClientCharacteristicConfigurationDescriptorAsync(&self, clientcharacteristicconfigurationdescriptorvalue: GattClientCharacteristicConfigurationDescriptorValue) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -136,28 +136,28 @@ impl GattCharacteristic { (windows_core::Interface::vtable(this).GetAllDescriptors)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetDescriptorsAsync(&self) -> windows_core::Result> { + pub fn GetDescriptorsAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetDescriptorsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetDescriptorsWithCacheModeAsync(&self, cachemode: super::BluetoothCacheMode) -> windows_core::Result> { + pub fn GetDescriptorsWithCacheModeAsync(&self, cachemode: super::BluetoothCacheMode) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetDescriptorsWithCacheModeAsync)(windows_core::Interface::as_raw(this), cachemode, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetDescriptorsForUuidAsync(&self, descriptoruuid: windows_core::GUID) -> windows_core::Result> { + pub fn GetDescriptorsForUuidAsync(&self, descriptoruuid: windows_core::GUID) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetDescriptorsForUuidAsync)(windows_core::Interface::as_raw(this), descriptoruuid, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetDescriptorsForUuidWithCacheModeAsync(&self, descriptoruuid: windows_core::GUID, cachemode: super::BluetoothCacheMode) -> windows_core::Result> { + pub fn GetDescriptorsForUuidWithCacheModeAsync(&self, descriptoruuid: windows_core::GUID, cachemode: super::BluetoothCacheMode) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -165,7 +165,7 @@ impl GattCharacteristic { } } #[cfg(feature = "Storage_Streams")] - pub fn WriteValueWithResultAsync(&self, value: P0) -> windows_core::Result> + pub fn WriteValueWithResultAsync(&self, value: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -176,7 +176,7 @@ impl GattCharacteristic { } } #[cfg(feature = "Storage_Streams")] - pub fn WriteValueWithResultAndOptionAsync(&self, value: P0, writeoption: GattWriteOption) -> windows_core::Result> + pub fn WriteValueWithResultAndOptionAsync(&self, value: P0, writeoption: GattWriteOption) -> windows_core::Result> where P0: windows_core::Param, { @@ -186,7 +186,7 @@ impl GattCharacteristic { (windows_core::Interface::vtable(this).WriteValueWithResultAndOptionAsync)(windows_core::Interface::as_raw(this), value.param().abi(), writeoption, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn WriteClientCharacteristicConfigurationDescriptorWithResultAsync(&self, clientcharacteristicconfigurationdescriptorvalue: GattClientCharacteristicConfigurationDescriptorValue) -> windows_core::Result> { + pub fn WriteClientCharacteristicConfigurationDescriptorWithResultAsync(&self, clientcharacteristicconfigurationdescriptorvalue: GattClientCharacteristicConfigurationDescriptorValue) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -916,14 +916,14 @@ impl GattDescriptor { (windows_core::Interface::vtable(this).AttributeHandle)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn ReadValueAsync(&self) -> windows_core::Result> { + pub fn ReadValueAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReadValueAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReadValueWithCacheModeAsync(&self, cachemode: super::BluetoothCacheMode) -> windows_core::Result> { + pub fn ReadValueWithCacheModeAsync(&self, cachemode: super::BluetoothCacheMode) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -931,7 +931,7 @@ impl GattDescriptor { } } #[cfg(feature = "Storage_Streams")] - pub fn WriteValueAsync(&self, value: P0) -> windows_core::Result> + pub fn WriteValueAsync(&self, value: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -942,7 +942,7 @@ impl GattDescriptor { } } #[cfg(feature = "Storage_Streams")] - pub fn WriteValueWithResultAsync(&self, value: P0) -> windows_core::Result> + pub fn WriteValueWithResultAsync(&self, value: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1163,77 +1163,77 @@ impl GattDeviceService { } } #[cfg(feature = "Devices_Enumeration")] - pub fn RequestAccessAsync(&self) -> windows_core::Result> { + pub fn RequestAccessAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestAccessAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn OpenAsync(&self, sharingmode: GattSharingMode) -> windows_core::Result> { + pub fn OpenAsync(&self, sharingmode: GattSharingMode) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).OpenAsync)(windows_core::Interface::as_raw(this), sharingmode, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetCharacteristicsAsync(&self) -> windows_core::Result> { + pub fn GetCharacteristicsAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetCharacteristicsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetCharacteristicsWithCacheModeAsync(&self, cachemode: super::BluetoothCacheMode) -> windows_core::Result> { + pub fn GetCharacteristicsWithCacheModeAsync(&self, cachemode: super::BluetoothCacheMode) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetCharacteristicsWithCacheModeAsync)(windows_core::Interface::as_raw(this), cachemode, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetCharacteristicsForUuidAsync(&self, characteristicuuid: windows_core::GUID) -> windows_core::Result> { + pub fn GetCharacteristicsForUuidAsync(&self, characteristicuuid: windows_core::GUID) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetCharacteristicsForUuidAsync)(windows_core::Interface::as_raw(this), characteristicuuid, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetCharacteristicsForUuidWithCacheModeAsync(&self, characteristicuuid: windows_core::GUID, cachemode: super::BluetoothCacheMode) -> windows_core::Result> { + pub fn GetCharacteristicsForUuidWithCacheModeAsync(&self, characteristicuuid: windows_core::GUID, cachemode: super::BluetoothCacheMode) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetCharacteristicsForUuidWithCacheModeAsync)(windows_core::Interface::as_raw(this), characteristicuuid, cachemode, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetIncludedServicesAsync(&self) -> windows_core::Result> { + pub fn GetIncludedServicesAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetIncludedServicesAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetIncludedServicesWithCacheModeAsync(&self, cachemode: super::BluetoothCacheMode) -> windows_core::Result> { + pub fn GetIncludedServicesWithCacheModeAsync(&self, cachemode: super::BluetoothCacheMode) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetIncludedServicesWithCacheModeAsync)(windows_core::Interface::as_raw(this), cachemode, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetIncludedServicesForUuidAsync(&self, serviceuuid: windows_core::GUID) -> windows_core::Result> { + pub fn GetIncludedServicesForUuidAsync(&self, serviceuuid: windows_core::GUID) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetIncludedServicesForUuidAsync)(windows_core::Interface::as_raw(this), serviceuuid, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetIncludedServicesForUuidWithCacheModeAsync(&self, serviceuuid: windows_core::GUID, cachemode: super::BluetoothCacheMode) -> windows_core::Result> { + pub fn GetIncludedServicesForUuidWithCacheModeAsync(&self, serviceuuid: windows_core::GUID, cachemode: super::BluetoothCacheMode) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetIncludedServicesForUuidWithCacheModeAsync)(windows_core::Interface::as_raw(this), serviceuuid, cachemode, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IGattDeviceServiceStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -1259,7 +1259,7 @@ impl GattDeviceService { (windows_core::Interface::vtable(this).ConvertShortIdToUuid)(windows_core::Interface::as_raw(this), shortid, &mut result__).map(|| result__) }) } - pub fn FromIdWithSharingModeAsync(deviceid: &windows_core::HSTRING, sharingmode: GattSharingMode) -> windows_core::Result> { + pub fn FromIdWithSharingModeAsync(deviceid: &windows_core::HSTRING, sharingmode: GattSharingMode) -> windows_core::Result> { Self::IGattDeviceServiceStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdWithSharingModeAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), sharingmode, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -1402,7 +1402,7 @@ impl GattLocalCharacteristic { (windows_core::Interface::vtable(this).WriteProtectionLevel)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn CreateDescriptorAsync(&self, descriptoruuid: windows_core::GUID, parameters: P1) -> windows_core::Result> + pub fn CreateDescriptorAsync(&self, descriptoruuid: windows_core::GUID, parameters: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -1483,7 +1483,7 @@ impl GattLocalCharacteristic { unsafe { (windows_core::Interface::vtable(this).RemoveWriteRequested)(windows_core::Interface::as_raw(this), token).ok() } } #[cfg(feature = "Storage_Streams")] - pub fn NotifyValueAsync(&self, value: P0) -> windows_core::Result>> + pub fn NotifyValueAsync(&self, value: P0) -> windows_core::Result>> where P0: windows_core::Param, { @@ -1494,7 +1494,7 @@ impl GattLocalCharacteristic { } } #[cfg(feature = "Storage_Streams")] - pub fn NotifyValueForSubscribedClientAsync(&self, value: P0, subscribedclient: P1) -> windows_core::Result> + pub fn NotifyValueForSubscribedClientAsync(&self, value: P0, subscribedclient: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -1824,7 +1824,7 @@ impl GattLocalService { (windows_core::Interface::vtable(this).Uuid)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn CreateCharacteristicAsync(&self, characteristicuuid: windows_core::GUID, parameters: P1) -> windows_core::Result> + pub fn CreateCharacteristicAsync(&self, characteristicuuid: windows_core::GUID, parameters: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -2366,7 +2366,7 @@ impl GattReadRequestedEventArgs { (windows_core::Interface::vtable(this).GetDeferral)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetRequestAsync(&self) -> windows_core::Result> { + pub fn GetRequestAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2447,14 +2447,14 @@ impl GattReliableWriteTransaction { let this = self; unsafe { (windows_core::Interface::vtable(this).WriteValue)(windows_core::Interface::as_raw(this), characteristic.param().abi(), value.param().abi()).ok() } } - pub fn CommitAsync(&self) -> windows_core::Result> { + pub fn CommitAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CommitAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CommitWithResultAsync(&self) -> windows_core::Result> { + pub fn CommitWithResultAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -2568,7 +2568,7 @@ impl GattServiceProvider { let this = self; unsafe { (windows_core::Interface::vtable(this).StopAdvertising)(windows_core::Interface::as_raw(this)).ok() } } - pub fn CreateAsync(serviceuuid: windows_core::GUID) -> windows_core::Result> { + pub fn CreateAsync(serviceuuid: windows_core::GUID) -> windows_core::Result> { Self::IGattServiceProviderStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreateAsync)(windows_core::Interface::as_raw(this), serviceuuid, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -2957,7 +2957,7 @@ impl GattSession { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveSessionStatusChanged)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn FromDeviceIdAsync(deviceid: P0) -> windows_core::Result> + pub fn FromDeviceIdAsync(deviceid: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -3223,7 +3223,7 @@ impl GattWriteRequestedEventArgs { (windows_core::Interface::vtable(this).GetDeferral)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetRequestAsync(&self) -> windows_core::Result> { + pub fn GetRequestAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Devices/Bluetooth/Rfcomm/mod.rs b/crates/libs/windows/src/Windows/Devices/Bluetooth/Rfcomm/mod.rs index 2e91d0ea42..d4a6994134 100644 --- a/crates/libs/windows/src/Windows/Devices/Bluetooth/Rfcomm/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/Bluetooth/Rfcomm/mod.rs @@ -200,7 +200,7 @@ impl RfcommDeviceService { } } #[cfg(feature = "Storage_Streams")] - pub fn GetSdpRawAttributesAsync(&self) -> windows_core::Result>> { + pub fn GetSdpRawAttributesAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -208,7 +208,7 @@ impl RfcommDeviceService { } } #[cfg(feature = "Storage_Streams")] - pub fn GetSdpRawAttributesWithCacheModeAsync(&self, cachemode: super::BluetoothCacheMode) -> windows_core::Result>> { + pub fn GetSdpRawAttributesWithCacheModeAsync(&self, cachemode: super::BluetoothCacheMode) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -231,14 +231,14 @@ impl RfcommDeviceService { } } #[cfg(feature = "Devices_Enumeration")] - pub fn RequestAccessAsync(&self) -> windows_core::Result> { + pub fn RequestAccessAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestAccessAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IRfcommDeviceServiceStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -475,7 +475,7 @@ impl RfcommServiceProvider { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).StartAdvertisingWithRadioDiscoverability)(windows_core::Interface::as_raw(this), listener.param().abi(), radiodiscoverable).ok() } } - pub fn CreateAsync(serviceid: P0) -> windows_core::Result> + pub fn CreateAsync(serviceid: P0) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Devices/Bluetooth/mod.rs b/crates/libs/windows/src/Windows/Devices/Bluetooth/mod.rs index 0e2c61e17f..fc426428fa 100644 --- a/crates/libs/windows/src/Windows/Devices/Bluetooth/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/Bluetooth/mod.rs @@ -61,7 +61,7 @@ impl BluetoothAdapter { } } #[cfg(feature = "Devices_Radios")] - pub fn GetRadioAsync(&self) -> windows_core::Result> { + pub fn GetRadioAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -102,13 +102,13 @@ impl BluetoothAdapter { (windows_core::Interface::vtable(this).GetDeviceSelector)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IBluetoothAdapterStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetDefaultAsync() -> windows_core::Result> { + pub fn GetDefaultAsync() -> windows_core::Result> { Self::IBluetoothAdapterStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetDefaultAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -357,7 +357,7 @@ impl BluetoothDevice { } } #[cfg(feature = "Devices_Enumeration")] - pub fn RequestAccessAsync(&self) -> windows_core::Result> { + pub fn RequestAccessAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -365,7 +365,7 @@ impl BluetoothDevice { } } #[cfg(feature = "Devices_Bluetooth_Rfcomm")] - pub fn GetRfcommServicesAsync(&self) -> windows_core::Result> { + pub fn GetRfcommServicesAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -373,7 +373,7 @@ impl BluetoothDevice { } } #[cfg(feature = "Devices_Bluetooth_Rfcomm")] - pub fn GetRfcommServicesWithCacheModeAsync(&self, cachemode: BluetoothCacheMode) -> windows_core::Result> { + pub fn GetRfcommServicesWithCacheModeAsync(&self, cachemode: BluetoothCacheMode) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -381,7 +381,7 @@ impl BluetoothDevice { } } #[cfg(feature = "Devices_Bluetooth_Rfcomm")] - pub fn GetRfcommServicesForIdAsync(&self, serviceid: P0) -> windows_core::Result> + pub fn GetRfcommServicesForIdAsync(&self, serviceid: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -392,7 +392,7 @@ impl BluetoothDevice { } } #[cfg(feature = "Devices_Bluetooth_Rfcomm")] - pub fn GetRfcommServicesForIdWithCacheModeAsync(&self, serviceid: P0, cachemode: BluetoothCacheMode) -> windows_core::Result> + pub fn GetRfcommServicesForIdWithCacheModeAsync(&self, serviceid: P0, cachemode: BluetoothCacheMode) -> windows_core::Result> where P0: windows_core::Param, { @@ -416,14 +416,14 @@ impl BluetoothDevice { (windows_core::Interface::vtable(this).WasSecureConnectionUsedForPairing)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IBluetoothDeviceStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "Networking")] - pub fn FromHostNameAsync(hostname: P0) -> windows_core::Result> + pub fn FromHostNameAsync(hostname: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -432,7 +432,7 @@ impl BluetoothDevice { (windows_core::Interface::vtable(this).FromHostNameAsync)(windows_core::Interface::as_raw(this), hostname.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn FromBluetoothAddressAsync(address: u64) -> windows_core::Result> { + pub fn FromBluetoothAddressAsync(address: u64) -> windows_core::Result> { Self::IBluetoothDeviceStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromBluetoothAddressAsync)(windows_core::Interface::as_raw(this), address, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -1180,7 +1180,7 @@ impl BluetoothLEDevice { } } #[cfg(feature = "Devices_Enumeration")] - pub fn RequestAccessAsync(&self) -> windows_core::Result> { + pub fn RequestAccessAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1188,7 +1188,7 @@ impl BluetoothLEDevice { } } #[cfg(feature = "Devices_Bluetooth_GenericAttributeProfile")] - pub fn GetGattServicesAsync(&self) -> windows_core::Result> { + pub fn GetGattServicesAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1196,7 +1196,7 @@ impl BluetoothLEDevice { } } #[cfg(feature = "Devices_Bluetooth_GenericAttributeProfile")] - pub fn GetGattServicesWithCacheModeAsync(&self, cachemode: BluetoothCacheMode) -> windows_core::Result> { + pub fn GetGattServicesWithCacheModeAsync(&self, cachemode: BluetoothCacheMode) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1204,7 +1204,7 @@ impl BluetoothLEDevice { } } #[cfg(feature = "Devices_Bluetooth_GenericAttributeProfile")] - pub fn GetGattServicesForUuidAsync(&self, serviceuuid: windows_core::GUID) -> windows_core::Result> { + pub fn GetGattServicesForUuidAsync(&self, serviceuuid: windows_core::GUID) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1212,7 +1212,7 @@ impl BluetoothLEDevice { } } #[cfg(feature = "Devices_Bluetooth_GenericAttributeProfile")] - pub fn GetGattServicesForUuidWithCacheModeAsync(&self, serviceuuid: windows_core::GUID, cachemode: BluetoothCacheMode) -> windows_core::Result> { + pub fn GetGattServicesForUuidWithCacheModeAsync(&self, serviceuuid: windows_core::GUID, cachemode: BluetoothCacheMode) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1285,13 +1285,13 @@ impl BluetoothLEDevice { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).RemoveConnectionPhyChanged)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IBluetoothLEDeviceStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn FromBluetoothAddressAsync(bluetoothaddress: u64) -> windows_core::Result> { + pub fn FromBluetoothAddressAsync(bluetoothaddress: u64) -> windows_core::Result> { Self::IBluetoothLEDeviceStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromBluetoothAddressAsync)(windows_core::Interface::as_raw(this), bluetoothaddress, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -1342,7 +1342,7 @@ impl BluetoothLEDevice { (windows_core::Interface::vtable(this).GetDeviceSelectorFromAppearance)(windows_core::Interface::as_raw(this), appearance.param().abi(), &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn FromBluetoothAddressWithBluetoothAddressTypeAsync(bluetoothaddress: u64, bluetoothaddresstype: BluetoothAddressType) -> windows_core::Result> { + pub fn FromBluetoothAddressWithBluetoothAddressTypeAsync(bluetoothaddress: u64, bluetoothaddresstype: BluetoothAddressType) -> windows_core::Result> { Self::IBluetoothLEDeviceStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromBluetoothAddressWithBluetoothAddressTypeAsync)(windows_core::Interface::as_raw(this), bluetoothaddress, bluetoothaddresstype, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/Devices/Custom/mod.rs b/crates/libs/windows/src/Windows/Devices/Custom/mod.rs index d6e43652eb..4b2aa6f756 100644 --- a/crates/libs/windows/src/Windows/Devices/Custom/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/Custom/mod.rs @@ -20,7 +20,7 @@ impl CustomDevice { } } #[cfg(feature = "Storage_Streams")] - pub fn SendIOControlAsync(&self, iocontrolcode: P0, inputbuffer: P1, outputbuffer: P2) -> windows_core::Result> + pub fn SendIOControlAsync(&self, iocontrolcode: P0, inputbuffer: P1, outputbuffer: P2) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -33,7 +33,7 @@ impl CustomDevice { } } #[cfg(feature = "Storage_Streams")] - pub fn TrySendIOControlAsync(&self, iocontrolcode: P0, inputbuffer: P1, outputbuffer: P2) -> windows_core::Result> + pub fn TrySendIOControlAsync(&self, iocontrolcode: P0, inputbuffer: P1, outputbuffer: P2) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -51,7 +51,7 @@ impl CustomDevice { (windows_core::Interface::vtable(this).GetDeviceSelector)(windows_core::Interface::as_raw(this), classguid, &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING, desiredaccess: DeviceAccessMode, sharingmode: DeviceSharingMode) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING, desiredaccess: DeviceAccessMode, sharingmode: DeviceSharingMode) -> windows_core::Result> { Self::ICustomDeviceStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), desiredaccess, sharingmode, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/Devices/Display/Core/mod.rs b/crates/libs/windows/src/Windows/Devices/Display/Core/mod.rs index 070a0bcd2d..06e9ef068b 100644 --- a/crates/libs/windows/src/Windows/Devices/Display/Core/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/Display/Core/mod.rs @@ -914,7 +914,7 @@ impl DisplayMuxDevice { (windows_core::Interface::vtable(this).IsAutomaticTargetSwitchingEnabled)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn SetPreferredTarget(&self, target: P0) -> windows_core::Result + pub fn SetPreferredTarget(&self, target: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -924,7 +924,7 @@ impl DisplayMuxDevice { (windows_core::Interface::vtable(this).SetPreferredTarget)(windows_core::Interface::as_raw(this), target.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SetAutomaticTargetSwitching(&self) -> windows_core::Result { + pub fn SetAutomaticTargetSwitching(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -951,7 +951,7 @@ impl DisplayMuxDevice { (windows_core::Interface::vtable(this).GetDeviceSelector)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn FromIdAsync(deviceinterfaceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceinterfaceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IDisplayMuxDeviceStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceinterfaceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/Devices/Display/mod.rs b/crates/libs/windows/src/Windows/Devices/Display/mod.rs index af373c36a9..29cc689e46 100644 --- a/crates/libs/windows/src/Windows/Devices/Display/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/Display/mod.rs @@ -160,13 +160,13 @@ impl DisplayMonitor { (windows_core::Interface::vtable(this).GetDeviceSelector)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IDisplayMonitorStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn FromInterfaceIdAsync(deviceinterfaceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromInterfaceIdAsync(deviceinterfaceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IDisplayMonitorStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromInterfaceIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceinterfaceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/Devices/Enumeration/Pnp/mod.rs b/crates/libs/windows/src/Windows/Devices/Enumeration/Pnp/mod.rs index 6fb29c2758..5517801bb4 100644 --- a/crates/libs/windows/src/Windows/Devices/Enumeration/Pnp/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/Enumeration/Pnp/mod.rs @@ -88,7 +88,7 @@ impl PnpObject { let this = self; unsafe { (windows_core::Interface::vtable(this).Update)(windows_core::Interface::as_raw(this), updateinfo.param().abi()).ok() } } - pub fn CreateFromIdAsync(r#type: PnpObjectType, id: &windows_core::HSTRING, requestedproperties: P2) -> windows_core::Result> + pub fn CreateFromIdAsync(r#type: PnpObjectType, id: &windows_core::HSTRING, requestedproperties: P2) -> windows_core::Result> where P2: windows_core::Param>, { @@ -97,7 +97,7 @@ impl PnpObject { (windows_core::Interface::vtable(this).CreateFromIdAsync)(windows_core::Interface::as_raw(this), r#type, core::mem::transmute_copy(id), requestedproperties.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn FindAllAsync(r#type: PnpObjectType, requestedproperties: P1) -> windows_core::Result> + pub fn FindAllAsync(r#type: PnpObjectType, requestedproperties: P1) -> windows_core::Result> where P1: windows_core::Param>, { @@ -106,7 +106,7 @@ impl PnpObject { (windows_core::Interface::vtable(this).FindAllAsync)(windows_core::Interface::as_raw(this), r#type, requestedproperties.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn FindAllAsyncAqsFilter(r#type: PnpObjectType, requestedproperties: P1, aqsfilter: &windows_core::HSTRING) -> windows_core::Result> + pub fn FindAllAsyncAqsFilter(r#type: PnpObjectType, requestedproperties: P1, aqsfilter: &windows_core::HSTRING) -> windows_core::Result> where P1: windows_core::Param>, { diff --git a/crates/libs/windows/src/Windows/Devices/Enumeration/mod.rs b/crates/libs/windows/src/Windows/Devices/Enumeration/mod.rs index 9bdf8c5ae9..ffd5a8280a 100644 --- a/crates/libs/windows/src/Windows/Devices/Enumeration/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/Enumeration/mod.rs @@ -245,7 +245,7 @@ impl DeviceInformation { unsafe { (windows_core::Interface::vtable(this).Update)(windows_core::Interface::as_raw(this), updateinfo.param().abi()).ok() } } #[cfg(feature = "Storage_Streams")] - pub fn GetThumbnailAsync(&self) -> windows_core::Result> { + pub fn GetThumbnailAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -253,7 +253,7 @@ impl DeviceInformation { } } #[cfg(feature = "Storage_Streams")] - pub fn GetGlyphThumbnailAsync(&self) -> windows_core::Result> { + pub fn GetGlyphThumbnailAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -274,13 +274,13 @@ impl DeviceInformation { (windows_core::Interface::vtable(this).Pairing)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateFromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CreateFromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IDeviceInformationStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreateFromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn CreateFromIdAsyncAdditionalProperties(deviceid: &windows_core::HSTRING, additionalproperties: P1) -> windows_core::Result> + pub fn CreateFromIdAsyncAdditionalProperties(deviceid: &windows_core::HSTRING, additionalproperties: P1) -> windows_core::Result> where P1: windows_core::Param>, { @@ -289,25 +289,25 @@ impl DeviceInformation { (windows_core::Interface::vtable(this).CreateFromIdAsyncAdditionalProperties)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), additionalproperties.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn FindAllAsync() -> windows_core::Result> { + pub fn FindAllAsync() -> windows_core::Result> { Self::IDeviceInformationStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAllAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn FindAllAsyncDeviceClass(deviceclass: DeviceClass) -> windows_core::Result> { + pub fn FindAllAsyncDeviceClass(deviceclass: DeviceClass) -> windows_core::Result> { Self::IDeviceInformationStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAllAsyncDeviceClass)(windows_core::Interface::as_raw(this), deviceclass, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn FindAllAsyncAqsFilter(aqsfilter: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FindAllAsyncAqsFilter(aqsfilter: &windows_core::HSTRING) -> windows_core::Result> { Self::IDeviceInformationStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAllAsyncAqsFilter)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(aqsfilter), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn FindAllAsyncAqsFilterAndAdditionalProperties(aqsfilter: &windows_core::HSTRING, additionalproperties: P1) -> windows_core::Result> + pub fn FindAllAsyncAqsFilterAndAdditionalProperties(aqsfilter: &windows_core::HSTRING, additionalproperties: P1) -> windows_core::Result> where P1: windows_core::Param>, { @@ -349,7 +349,7 @@ impl DeviceInformation { (windows_core::Interface::vtable(this).GetAqsFilterFromDeviceClass)(windows_core::Interface::as_raw(this), deviceclass, &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn CreateFromIdAsyncWithKindAndAdditionalProperties(deviceid: &windows_core::HSTRING, additionalproperties: P1, kind: DeviceInformationKind) -> windows_core::Result> + pub fn CreateFromIdAsyncWithKindAndAdditionalProperties(deviceid: &windows_core::HSTRING, additionalproperties: P1, kind: DeviceInformationKind) -> windows_core::Result> where P1: windows_core::Param>, { @@ -358,7 +358,7 @@ impl DeviceInformation { (windows_core::Interface::vtable(this).CreateFromIdAsyncWithKindAndAdditionalProperties)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), additionalproperties.param().abi(), kind, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn FindAllAsyncWithKindAqsFilterAndAdditionalProperties(aqsfilter: &windows_core::HSTRING, additionalproperties: P1, kind: DeviceInformationKind) -> windows_core::Result> + pub fn FindAllAsyncWithKindAqsFilterAndAdditionalProperties(aqsfilter: &windows_core::HSTRING, additionalproperties: P1, kind: DeviceInformationKind) -> windows_core::Result> where P1: windows_core::Param>, { @@ -376,7 +376,7 @@ impl DeviceInformation { (windows_core::Interface::vtable(this).CreateWatcherWithKindAqsFilterAndAdditionalProperties)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(aqsfilter), additionalproperties.param().abi(), kind, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn CreateFromIdAsyncWithAdditionalPropertiesKindAndSettings(deviceid: &windows_core::HSTRING, additionalproperties: P1, kind: DeviceInformationKind, settings: P3) -> windows_core::Result> + pub fn CreateFromIdAsyncWithAdditionalPropertiesKindAndSettings(deviceid: &windows_core::HSTRING, additionalproperties: P1, kind: DeviceInformationKind, settings: P3) -> windows_core::Result> where P1: windows_core::Param>, P3: windows_core::Param, @@ -386,7 +386,7 @@ impl DeviceInformation { (windows_core::Interface::vtable(this).CreateFromIdAsyncWithAdditionalPropertiesKindAndSettings)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), additionalproperties.param().abi(), kind, settings.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn FindAllAsyncWithAqsFilterAdditionalPropertiesKindAndSettings(aqsfilter: &windows_core::HSTRING, additionalproperties: P1, kind: DeviceInformationKind, settings: P3) -> windows_core::Result> + pub fn FindAllAsyncWithAqsFilterAdditionalPropertiesKindAndSettings(aqsfilter: &windows_core::HSTRING, additionalproperties: P1, kind: DeviceInformationKind, settings: P3) -> windows_core::Result> where P1: windows_core::Param>, P3: windows_core::Param, @@ -507,21 +507,21 @@ impl IntoIterator for &DeviceInformationCollection { pub struct DeviceInformationCustomPairing(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(DeviceInformationCustomPairing, windows_core::IUnknown, windows_core::IInspectable); impl DeviceInformationCustomPairing { - pub fn PairAsync(&self, pairingkindssupported: DevicePairingKinds) -> windows_core::Result> { + pub fn PairAsync(&self, pairingkindssupported: DevicePairingKinds) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).PairAsync)(windows_core::Interface::as_raw(this), pairingkindssupported, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn PairWithProtectionLevelAsync(&self, pairingkindssupported: DevicePairingKinds, minprotectionlevel: DevicePairingProtectionLevel) -> windows_core::Result> { + pub fn PairWithProtectionLevelAsync(&self, pairingkindssupported: DevicePairingKinds, minprotectionlevel: DevicePairingProtectionLevel) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).PairWithProtectionLevelAsync)(windows_core::Interface::as_raw(this), pairingkindssupported, minprotectionlevel, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn PairWithProtectionLevelAndSettingsAsync(&self, pairingkindssupported: DevicePairingKinds, minprotectionlevel: DevicePairingProtectionLevel, devicepairingsettings: P2) -> windows_core::Result> + pub fn PairWithProtectionLevelAndSettingsAsync(&self, pairingkindssupported: DevicePairingKinds, minprotectionlevel: DevicePairingProtectionLevel, devicepairingsettings: P2) -> windows_core::Result> where P2: windows_core::Param, { @@ -619,14 +619,14 @@ impl DeviceInformationPairing { (windows_core::Interface::vtable(this).CanPair)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn PairAsync(&self) -> windows_core::Result> { + pub fn PairAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).PairAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn PairWithProtectionLevelAsync(&self, minprotectionlevel: DevicePairingProtectionLevel) -> windows_core::Result> { + pub fn PairWithProtectionLevelAsync(&self, minprotectionlevel: DevicePairingProtectionLevel) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -647,7 +647,7 @@ impl DeviceInformationPairing { (windows_core::Interface::vtable(this).Custom)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn PairWithProtectionLevelAndSettingsAsync(&self, minprotectionlevel: DevicePairingProtectionLevel, devicepairingsettings: P1) -> windows_core::Result> + pub fn PairWithProtectionLevelAndSettingsAsync(&self, minprotectionlevel: DevicePairingProtectionLevel, devicepairingsettings: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -657,7 +657,7 @@ impl DeviceInformationPairing { (windows_core::Interface::vtable(this).PairWithProtectionLevelAndSettingsAsync)(windows_core::Interface::as_raw(this), minprotectionlevel, devicepairingsettings.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn UnpairAsync(&self) -> windows_core::Result> { + pub fn UnpairAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1071,7 +1071,7 @@ impl DevicePicker { let this = self; unsafe { (windows_core::Interface::vtable(this).ShowWithPlacement)(windows_core::Interface::as_raw(this), selection, placement).ok() } } - pub fn PickSingleDeviceAsync(&self, selection: super::super::Foundation::Rect) -> windows_core::Result> { + pub fn PickSingleDeviceAsync(&self, selection: super::super::Foundation::Rect) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1079,7 +1079,7 @@ impl DevicePicker { } } #[cfg(feature = "UI_Popups")] - pub fn PickSingleDeviceAsyncWithPlacement(&self, selection: super::super::Foundation::Rect, placement: super::super::UI::Popups::Placement) -> windows_core::Result> { + pub fn PickSingleDeviceAsyncWithPlacement(&self, selection: super::super::Foundation::Rect, placement: super::super::UI::Popups::Placement) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1343,7 +1343,7 @@ impl DeviceThumbnail { (windows_core::Interface::vtable(this).ContentType)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn ReadAsync(&self, buffer: P0, count: u32, options: super::super::Storage::Streams::InputStreamOptions) -> windows_core::Result> + pub fn ReadAsync(&self, buffer: P0, count: u32, options: super::super::Storage::Streams::InputStreamOptions) -> windows_core::Result> where P0: windows_core::Param, { @@ -1353,7 +1353,7 @@ impl DeviceThumbnail { (windows_core::Interface::vtable(this).ReadAsync)(windows_core::Interface::as_raw(this), buffer.param().abi(), count, options, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn WriteAsync(&self, buffer: P0) -> windows_core::Result> + pub fn WriteAsync(&self, buffer: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1363,7 +1363,7 @@ impl DeviceThumbnail { (windows_core::Interface::vtable(this).WriteAsync)(windows_core::Interface::as_raw(this), buffer.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FlushAsync(&self) -> windows_core::Result> { + pub fn FlushAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Devices/Geolocation/mod.rs b/crates/libs/windows/src/Windows/Devices/Geolocation/mod.rs index a2801636a4..477c8bcda6 100644 --- a/crates/libs/windows/src/Windows/Devices/Geolocation/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/Geolocation/mod.rs @@ -519,14 +519,14 @@ impl Geolocator { (windows_core::Interface::vtable(this).LocationStatus)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn GetGeopositionAsync(&self) -> windows_core::Result> { + pub fn GetGeopositionAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetGeopositionAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetGeopositionAsyncWithAgeAndTimeout(&self, maximumage: super::super::Foundation::TimeSpan, timeout: super::super::Foundation::TimeSpan) -> windows_core::Result> { + pub fn GetGeopositionAsyncWithAgeAndTimeout(&self, maximumage: super::super::Foundation::TimeSpan, timeout: super::super::Foundation::TimeSpan) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -565,19 +565,19 @@ impl Geolocator { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).AllowFallbackToConsentlessPositions)(windows_core::Interface::as_raw(this)).ok() } } - pub fn RequestAccessAsync() -> windows_core::Result> { + pub fn RequestAccessAsync() -> windows_core::Result> { Self::IGeolocatorStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestAccessAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetGeopositionHistoryAsync(starttime: super::super::Foundation::DateTime) -> windows_core::Result>> { + pub fn GetGeopositionHistoryAsync(starttime: super::super::Foundation::DateTime) -> windows_core::Result>> { Self::IGeolocatorStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetGeopositionHistoryAsync)(windows_core::Interface::as_raw(this), starttime, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetGeopositionHistoryWithDurationAsync(starttime: super::super::Foundation::DateTime, duration: super::super::Foundation::TimeSpan) -> windows_core::Result>> { + pub fn GetGeopositionHistoryWithDurationAsync(starttime: super::super::Foundation::DateTime, duration: super::super::Foundation::TimeSpan) -> windows_core::Result>> { Self::IGeolocatorStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetGeopositionHistoryWithDurationAsync)(windows_core::Interface::as_raw(this), starttime, duration, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -917,7 +917,7 @@ impl GeovisitMonitor { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveVisitStateChanged)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn GetLastReportAsync() -> windows_core::Result> { + pub fn GetLastReportAsync() -> windows_core::Result> { Self::IGeovisitMonitorStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetLastReportAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/Devices/Gpio/mod.rs b/crates/libs/windows/src/Windows/Devices/Gpio/mod.rs index 82415bb156..c5740e5b02 100644 --- a/crates/libs/windows/src/Windows/Devices/Gpio/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/Gpio/mod.rs @@ -191,7 +191,7 @@ impl GpioChangeReader { (windows_core::Interface::vtable(this).GetAllItems)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn WaitForItemsAsync(&self, count: i32) -> windows_core::Result { + pub fn WaitForItemsAsync(&self, count: i32) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -285,7 +285,7 @@ impl GpioController { }) } #[cfg(feature = "Devices_Gpio_Provider")] - pub fn GetControllersAsync(provider: P0) -> windows_core::Result>> + pub fn GetControllersAsync(provider: P0) -> windows_core::Result>> where P0: windows_core::Param, { @@ -294,7 +294,7 @@ impl GpioController { (windows_core::Interface::vtable(this).GetControllersAsync)(windows_core::Interface::as_raw(this), provider.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetDefaultAsync() -> windows_core::Result> { + pub fn GetDefaultAsync() -> windows_core::Result> { Self::IGpioControllerStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetDefaultAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/Devices/Haptics/mod.rs b/crates/libs/windows/src/Windows/Devices/Haptics/mod.rs index 14bd905796..e9f678c165 100644 --- a/crates/libs/windows/src/Windows/Devices/Haptics/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/Haptics/mod.rs @@ -343,7 +343,7 @@ impl VibrationDevice { (windows_core::Interface::vtable(this).SimpleHapticsController)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestAccessAsync() -> windows_core::Result> { + pub fn RequestAccessAsync() -> windows_core::Result> { Self::IVibrationDeviceStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestAccessAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -355,19 +355,19 @@ impl VibrationDevice { (windows_core::Interface::vtable(this).GetDeviceSelector)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IVibrationDeviceStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetDefaultAsync() -> windows_core::Result> { + pub fn GetDefaultAsync() -> windows_core::Result> { Self::IVibrationDeviceStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetDefaultAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn FindAllAsync() -> windows_core::Result>> { + pub fn FindAllAsync() -> windows_core::Result>> { Self::IVibrationDeviceStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAllAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/Devices/HumanInterfaceDevice/mod.rs b/crates/libs/windows/src/Windows/Devices/HumanInterfaceDevice/mod.rs index c3fdecb1b2..15b75992b6 100644 --- a/crates/libs/windows/src/Windows/Devices/HumanInterfaceDevice/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/HumanInterfaceDevice/mod.rs @@ -232,28 +232,28 @@ impl HidDevice { (windows_core::Interface::vtable(this).UsageId)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn GetInputReportAsync(&self) -> windows_core::Result> { + pub fn GetInputReportAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetInputReportAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetInputReportByIdAsync(&self, reportid: u16) -> windows_core::Result> { + pub fn GetInputReportByIdAsync(&self, reportid: u16) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetInputReportByIdAsync)(windows_core::Interface::as_raw(this), reportid, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetFeatureReportAsync(&self) -> windows_core::Result> { + pub fn GetFeatureReportAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFeatureReportAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetFeatureReportByIdAsync(&self, reportid: u16) -> windows_core::Result> { + pub fn GetFeatureReportByIdAsync(&self, reportid: u16) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -288,7 +288,7 @@ impl HidDevice { (windows_core::Interface::vtable(this).CreateFeatureReportById)(windows_core::Interface::as_raw(this), reportid, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SendOutputReportAsync(&self, outputreport: P0) -> windows_core::Result> + pub fn SendOutputReportAsync(&self, outputreport: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -298,7 +298,7 @@ impl HidDevice { (windows_core::Interface::vtable(this).SendOutputReportAsync)(windows_core::Interface::as_raw(this), outputreport.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SendFeatureReportAsync(&self, featurereport: P0) -> windows_core::Result> + pub fn SendFeatureReportAsync(&self, featurereport: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -349,7 +349,7 @@ impl HidDevice { }) } #[cfg(feature = "Storage")] - pub fn FromIdAsync(deviceid: &windows_core::HSTRING, accessmode: super::super::Storage::FileAccessMode) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING, accessmode: super::super::Storage::FileAccessMode) -> windows_core::Result> { Self::IHidDeviceStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), accessmode, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/Devices/I2c/Provider/mod.rs b/crates/libs/windows/src/Windows/Devices/I2c/Provider/mod.rs index fbdbdac138..d9cd392908 100644 --- a/crates/libs/windows/src/Windows/Devices/I2c/Provider/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/I2c/Provider/mod.rs @@ -215,7 +215,7 @@ impl windows_core::RuntimeType for II2cProvider { } windows_core::imp::interface_hierarchy!(II2cProvider, windows_core::IUnknown, windows_core::IInspectable); impl II2cProvider { - pub fn GetControllersAsync(&self) -> windows_core::Result>> { + pub fn GetControllersAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -227,7 +227,7 @@ impl windows_core::RuntimeName for II2cProvider { const NAME: &'static str = "Windows.Devices.I2c.Provider.II2cProvider"; } pub trait II2cProvider_Impl: windows_core::IUnknownImpl { - fn GetControllersAsync(&self) -> windows_core::Result>>; + fn GetControllersAsync(&self) -> windows_core::Result>>; } impl II2cProvider_Vtbl { pub const fn new() -> Self { diff --git a/crates/libs/windows/src/Windows/Devices/I2c/mod.rs b/crates/libs/windows/src/Windows/Devices/I2c/mod.rs index 24e7b9f6a0..4a7a1aaa9c 100644 --- a/crates/libs/windows/src/Windows/Devices/I2c/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/I2c/mod.rs @@ -90,7 +90,7 @@ impl I2cController { } } #[cfg(feature = "Devices_I2c_Provider")] - pub fn GetControllersAsync(provider: P0) -> windows_core::Result>> + pub fn GetControllersAsync(provider: P0) -> windows_core::Result>> where P0: windows_core::Param, { @@ -99,7 +99,7 @@ impl I2cController { (windows_core::Interface::vtable(this).GetControllersAsync)(windows_core::Interface::as_raw(this), provider.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetDefaultAsync() -> windows_core::Result> { + pub fn GetDefaultAsync() -> windows_core::Result> { Self::II2cControllerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetDefaultAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -191,7 +191,7 @@ impl I2cDevice { (windows_core::Interface::vtable(this).GetDeviceSelectorFromFriendlyName)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(friendlyname), &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING, settings: P1) -> windows_core::Result> + pub fn FromIdAsync(deviceid: &windows_core::HSTRING, settings: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -339,7 +339,7 @@ impl II2cDeviceStatics { (windows_core::Interface::vtable(this).GetDeviceSelectorFromFriendlyName)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(friendlyname), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn FromIdAsync(&self, deviceid: &windows_core::HSTRING, settings: P1) -> windows_core::Result> + pub fn FromIdAsync(&self, deviceid: &windows_core::HSTRING, settings: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -356,7 +356,7 @@ impl windows_core::RuntimeName for II2cDeviceStatics { pub trait II2cDeviceStatics_Impl: windows_core::IUnknownImpl { fn GetDeviceSelector(&self) -> windows_core::Result; fn GetDeviceSelectorFromFriendlyName(&self, friendlyName: &windows_core::HSTRING) -> windows_core::Result; - fn FromIdAsync(&self, deviceId: &windows_core::HSTRING, settings: windows_core::Ref<'_, I2cConnectionSettings>) -> windows_core::Result>; + fn FromIdAsync(&self, deviceId: &windows_core::HSTRING, settings: windows_core::Ref<'_, I2cConnectionSettings>) -> windows_core::Result>; } impl II2cDeviceStatics_Vtbl { pub const fn new() -> Self { diff --git a/crates/libs/windows/src/Windows/Devices/Input/Preview/mod.rs b/crates/libs/windows/src/Windows/Devices/Input/Preview/mod.rs index 211b5625c9..ce313faf11 100644 --- a/crates/libs/windows/src/Windows/Devices/Input/Preview/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/Input/Preview/mod.rs @@ -47,7 +47,7 @@ impl GazeDevicePreview { (windows_core::Interface::vtable(this).ConfigurationState)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn RequestCalibrationAsync(&self) -> windows_core::Result> { + pub fn RequestCalibrationAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Devices/Lights/mod.rs b/crates/libs/windows/src/Windows/Devices/Lights/mod.rs index 40ece7a957..82ed3b71ff 100644 --- a/crates/libs/windows/src/Windows/Devices/Lights/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/Lights/mod.rs @@ -232,13 +232,13 @@ impl Lamp { (windows_core::Interface::vtable(this).GetDeviceSelector)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::ILampStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetDefaultAsync() -> windows_core::Result> { + pub fn GetDefaultAsync() -> windows_core::Result> { Self::ILampStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetDefaultAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -416,7 +416,7 @@ impl LampArray { unsafe { (windows_core::Interface::vtable(this).SetColorsForPurposes)(windows_core::Interface::as_raw(this), desiredcolor, purposes).ok() } } #[cfg(feature = "Storage_Streams")] - pub fn SendMessageAsync(&self, messageid: i32, message: P1) -> windows_core::Result + pub fn SendMessageAsync(&self, messageid: i32, message: P1) -> windows_core::Result where P1: windows_core::Param, { @@ -427,7 +427,7 @@ impl LampArray { } } #[cfg(feature = "Storage_Streams")] - pub fn RequestMessageAsync(&self, messageid: i32) -> windows_core::Result> { + pub fn RequestMessageAsync(&self, messageid: i32) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -461,7 +461,7 @@ impl LampArray { (windows_core::Interface::vtable(this).GetDeviceSelector)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::ILampArrayStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/Devices/Midi/mod.rs b/crates/libs/windows/src/Windows/Devices/Midi/mod.rs index d3fbba1c8e..3063a5f1a1 100644 --- a/crates/libs/windows/src/Windows/Devices/Midi/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/Midi/mod.rs @@ -728,7 +728,7 @@ impl MidiInPort { (windows_core::Interface::vtable(this).DeviceId)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IMidiInPortStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -989,7 +989,7 @@ impl MidiOutPort { (windows_core::Interface::vtable(this).DeviceId)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IMidiOutPortStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -1481,14 +1481,14 @@ impl MidiSynthesizer { let this = self; unsafe { (windows_core::Interface::vtable(this).SetVolume)(windows_core::Interface::as_raw(this), value).ok() } } - pub fn CreateAsync() -> windows_core::Result> { + pub fn CreateAsync() -> windows_core::Result> { Self::IMidiSynthesizerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreateAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "Devices_Enumeration")] - pub fn CreateFromAudioDeviceAsync(audiodevice: P0) -> windows_core::Result> + pub fn CreateFromAudioDeviceAsync(audiodevice: P0) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Devices/PointOfService/Provider/mod.rs b/crates/libs/windows/src/Windows/Devices/PointOfService/Provider/mod.rs index 82be3daaa7..6f48d62aa1 100644 --- a/crates/libs/windows/src/Windows/Devices/PointOfService/Provider/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/PointOfService/Provider/mod.rs @@ -3,28 +3,28 @@ pub struct BarcodeScannerDisableScannerRequest(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(BarcodeScannerDisableScannerRequest, windows_core::IUnknown, windows_core::IInspectable); impl BarcodeScannerDisableScannerRequest { - pub fn ReportCompletedAsync(&self) -> windows_core::Result { + pub fn ReportCompletedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportFailedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedWithFailedReasonAsync(&self, reason: i32) -> windows_core::Result { + pub fn ReportFailedWithFailedReasonAsync(&self, reason: i32) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportFailedWithFailedReasonAsync)(windows_core::Interface::as_raw(this), reason, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedWithFailedReasonAndDescriptionAsync(&self, reason: i32, failedreasondescription: &windows_core::HSTRING) -> windows_core::Result { + pub fn ReportFailedWithFailedReasonAndDescriptionAsync(&self, reason: i32, failedreasondescription: &windows_core::HSTRING) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -81,28 +81,28 @@ unsafe impl Sync for BarcodeScannerDisableScannerRequestEventArgs {} pub struct BarcodeScannerEnableScannerRequest(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(BarcodeScannerEnableScannerRequest, windows_core::IUnknown, windows_core::IInspectable); impl BarcodeScannerEnableScannerRequest { - pub fn ReportCompletedAsync(&self) -> windows_core::Result { + pub fn ReportCompletedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportFailedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedWithFailedReasonAsync(&self, reason: i32) -> windows_core::Result { + pub fn ReportFailedWithFailedReasonAsync(&self, reason: i32) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportFailedWithFailedReasonAsync)(windows_core::Interface::as_raw(this), reason, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedWithFailedReasonAndDescriptionAsync(&self, reason: i32, failedreasondescription: &windows_core::HSTRING) -> windows_core::Result { + pub fn ReportFailedWithFailedReasonAndDescriptionAsync(&self, reason: i32, failedreasondescription: &windows_core::HSTRING) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -160,21 +160,21 @@ pub struct BarcodeScannerFrameReader(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(BarcodeScannerFrameReader, windows_core::IUnknown, windows_core::IInspectable); windows_core::imp::required_hierarchy!(BarcodeScannerFrameReader, super::super::super::Foundation::IClosable); impl BarcodeScannerFrameReader { - pub fn StartAsync(&self) -> windows_core::Result> { + pub fn StartAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).StartAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StopAsync(&self) -> windows_core::Result { + pub fn StopAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).StopAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryAcquireLatestFrameAsync(&self) -> windows_core::Result> { + pub fn TryAcquireLatestFrameAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -256,7 +256,7 @@ impl BarcodeScannerGetSymbologyAttributesRequest { (windows_core::Interface::vtable(this).Symbology)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn ReportCompletedAsync(&self, attributes: P0) -> windows_core::Result + pub fn ReportCompletedAsync(&self, attributes: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -266,21 +266,21 @@ impl BarcodeScannerGetSymbologyAttributesRequest { (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), attributes.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportFailedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedWithFailedReasonAsync(&self, reason: i32) -> windows_core::Result { + pub fn ReportFailedWithFailedReasonAsync(&self, reason: i32) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportFailedWithFailedReasonAsync)(windows_core::Interface::as_raw(this), reason, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedWithFailedReasonAndDescriptionAsync(&self, reason: i32, failedreasondescription: &windows_core::HSTRING) -> windows_core::Result { + pub fn ReportFailedWithFailedReasonAndDescriptionAsync(&self, reason: i32, failedreasondescription: &windows_core::HSTRING) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -337,28 +337,28 @@ unsafe impl Sync for BarcodeScannerGetSymbologyAttributesRequestEventArgs {} pub struct BarcodeScannerHideVideoPreviewRequest(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(BarcodeScannerHideVideoPreviewRequest, windows_core::IUnknown, windows_core::IInspectable); impl BarcodeScannerHideVideoPreviewRequest { - pub fn ReportCompletedAsync(&self) -> windows_core::Result { + pub fn ReportCompletedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportFailedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedWithFailedReasonAsync(&self, reason: i32) -> windows_core::Result { + pub fn ReportFailedWithFailedReasonAsync(&self, reason: i32) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportFailedWithFailedReasonAsync)(windows_core::Interface::as_raw(this), reason, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedWithFailedReasonAndDescriptionAsync(&self, reason: i32, failedreasondescription: &windows_core::HSTRING) -> windows_core::Result { + pub fn ReportFailedWithFailedReasonAndDescriptionAsync(&self, reason: i32, failedreasondescription: &windows_core::HSTRING) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -474,7 +474,7 @@ impl BarcodeScannerProviderConnection { let this = self; unsafe { (windows_core::Interface::vtable(this).Start)(windows_core::Interface::as_raw(this)).ok() } } - pub fn ReportScannedDataAsync(&self, report: P0) -> windows_core::Result + pub fn ReportScannedDataAsync(&self, report: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -484,14 +484,14 @@ impl BarcodeScannerProviderConnection { (windows_core::Interface::vtable(this).ReportScannedDataAsync)(windows_core::Interface::as_raw(this), report.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportTriggerStateAsync(&self, state: BarcodeScannerTriggerState) -> windows_core::Result { + pub fn ReportTriggerStateAsync(&self, state: BarcodeScannerTriggerState) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportTriggerStateAsync)(windows_core::Interface::as_raw(this), state, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportErrorAsync(&self, errordata: P0) -> windows_core::Result + pub fn ReportErrorAsync(&self, errordata: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -501,7 +501,7 @@ impl BarcodeScannerProviderConnection { (windows_core::Interface::vtable(this).ReportErrorAsync)(windows_core::Interface::as_raw(this), errordata.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportErrorAsyncWithScanReport(&self, errordata: P0, isretriable: bool, scanreport: P2) -> windows_core::Result + pub fn ReportErrorAsyncWithScanReport(&self, errordata: P0, isretriable: bool, scanreport: P2) -> windows_core::Result where P0: windows_core::Param, P2: windows_core::Param, @@ -624,7 +624,7 @@ impl BarcodeScannerProviderConnection { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveHideVideoPreviewRequested)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn CreateFrameReaderAsync(&self) -> windows_core::Result> { + pub fn CreateFrameReaderAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -632,7 +632,7 @@ impl BarcodeScannerProviderConnection { } } #[cfg(feature = "Graphics_Imaging")] - pub fn CreateFrameReaderWithFormatAsync(&self, preferredformat: super::super::super::Graphics::Imaging::BitmapPixelFormat) -> windows_core::Result> { + pub fn CreateFrameReaderWithFormatAsync(&self, preferredformat: super::super::super::Graphics::Imaging::BitmapPixelFormat) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -640,7 +640,7 @@ impl BarcodeScannerProviderConnection { } } #[cfg(feature = "Graphics_Imaging")] - pub fn CreateFrameReaderWithFormatAndSizeAsync(&self, preferredformat: super::super::super::Graphics::Imaging::BitmapPixelFormat, preferredsize: super::super::super::Graphics::Imaging::BitmapSize) -> windows_core::Result> { + pub fn CreateFrameReaderWithFormatAndSizeAsync(&self, preferredformat: super::super::super::Graphics::Imaging::BitmapPixelFormat, preferredsize: super::super::super::Graphics::Imaging::BitmapSize) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -701,28 +701,28 @@ impl BarcodeScannerSetActiveSymbologiesRequest { (windows_core::Interface::vtable(this).Symbologies)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportCompletedAsync(&self) -> windows_core::Result { + pub fn ReportCompletedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportFailedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedWithFailedReasonAsync(&self, reason: i32) -> windows_core::Result { + pub fn ReportFailedWithFailedReasonAsync(&self, reason: i32) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportFailedWithFailedReasonAsync)(windows_core::Interface::as_raw(this), reason, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedWithFailedReasonAndDescriptionAsync(&self, reason: i32, failedreasondescription: &windows_core::HSTRING) -> windows_core::Result { + pub fn ReportFailedWithFailedReasonAndDescriptionAsync(&self, reason: i32, failedreasondescription: &windows_core::HSTRING) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -793,28 +793,28 @@ impl BarcodeScannerSetSymbologyAttributesRequest { (windows_core::Interface::vtable(this).Attributes)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportCompletedAsync(&self) -> windows_core::Result { + pub fn ReportCompletedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportFailedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedWithFailedReasonAsync(&self, reason: i32) -> windows_core::Result { + pub fn ReportFailedWithFailedReasonAsync(&self, reason: i32) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportFailedWithFailedReasonAsync)(windows_core::Interface::as_raw(this), reason, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedWithFailedReasonAndDescriptionAsync(&self, reason: i32, failedreasondescription: &windows_core::HSTRING) -> windows_core::Result { + pub fn ReportFailedWithFailedReasonAndDescriptionAsync(&self, reason: i32, failedreasondescription: &windows_core::HSTRING) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -871,28 +871,28 @@ unsafe impl Sync for BarcodeScannerSetSymbologyAttributesRequestEventArgs {} pub struct BarcodeScannerStartSoftwareTriggerRequest(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(BarcodeScannerStartSoftwareTriggerRequest, windows_core::IUnknown, windows_core::IInspectable); impl BarcodeScannerStartSoftwareTriggerRequest { - pub fn ReportCompletedAsync(&self) -> windows_core::Result { + pub fn ReportCompletedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportFailedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedWithFailedReasonAsync(&self, reason: i32) -> windows_core::Result { + pub fn ReportFailedWithFailedReasonAsync(&self, reason: i32) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportFailedWithFailedReasonAsync)(windows_core::Interface::as_raw(this), reason, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedWithFailedReasonAndDescriptionAsync(&self, reason: i32, failedreasondescription: &windows_core::HSTRING) -> windows_core::Result { + pub fn ReportFailedWithFailedReasonAndDescriptionAsync(&self, reason: i32, failedreasondescription: &windows_core::HSTRING) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -949,28 +949,28 @@ unsafe impl Sync for BarcodeScannerStartSoftwareTriggerRequestEventArgs {} pub struct BarcodeScannerStopSoftwareTriggerRequest(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(BarcodeScannerStopSoftwareTriggerRequest, windows_core::IUnknown, windows_core::IInspectable); impl BarcodeScannerStopSoftwareTriggerRequest { - pub fn ReportCompletedAsync(&self) -> windows_core::Result { + pub fn ReportCompletedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportFailedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedWithFailedReasonAsync(&self, reason: i32) -> windows_core::Result { + pub fn ReportFailedWithFailedReasonAsync(&self, reason: i32) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportFailedWithFailedReasonAsync)(windows_core::Interface::as_raw(this), reason, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedWithFailedReasonAndDescriptionAsync(&self, reason: i32, failedreasondescription: &windows_core::HSTRING) -> windows_core::Result { + pub fn ReportFailedWithFailedReasonAndDescriptionAsync(&self, reason: i32, failedreasondescription: &windows_core::HSTRING) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Devices/PointOfService/mod.rs b/crates/libs/windows/src/Windows/Devices/PointOfService/mod.rs index e0687ff066..bad7bb3e7b 100644 --- a/crates/libs/windows/src/Windows/Devices/PointOfService/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/PointOfService/mod.rs @@ -20,28 +20,28 @@ impl BarcodeScanner { (windows_core::Interface::vtable(this).Capabilities)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ClaimScannerAsync(&self) -> windows_core::Result> { + pub fn ClaimScannerAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ClaimScannerAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CheckHealthAsync(&self, level: UnifiedPosHealthCheckLevel) -> windows_core::Result> { + pub fn CheckHealthAsync(&self, level: UnifiedPosHealthCheckLevel) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CheckHealthAsync)(windows_core::Interface::as_raw(this), level, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetSupportedSymbologiesAsync(&self) -> windows_core::Result>> { + pub fn GetSupportedSymbologiesAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetSupportedSymbologiesAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn IsSymbologySupportedAsync(&self, barcodesymbology: u32) -> windows_core::Result> { + pub fn IsSymbologySupportedAsync(&self, barcodesymbology: u32) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -49,7 +49,7 @@ impl BarcodeScanner { } } #[cfg(feature = "Storage_Streams")] - pub fn RetrieveStatisticsAsync(&self, statisticscategories: P0) -> windows_core::Result> + pub fn RetrieveStatisticsAsync(&self, statisticscategories: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -94,13 +94,13 @@ impl BarcodeScanner { (windows_core::Interface::vtable(this).VideoDeviceId)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn GetDefaultAsync() -> windows_core::Result> { + pub fn GetDefaultAsync() -> windows_core::Result> { Self::IBarcodeScannerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetDefaultAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IBarcodeScannerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -1130,21 +1130,21 @@ impl CashDrawer { (windows_core::Interface::vtable(this).DrawerEventSource)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ClaimDrawerAsync(&self) -> windows_core::Result> { + pub fn ClaimDrawerAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ClaimDrawerAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CheckHealthAsync(&self, level: UnifiedPosHealthCheckLevel) -> windows_core::Result> { + pub fn CheckHealthAsync(&self, level: UnifiedPosHealthCheckLevel) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CheckHealthAsync)(windows_core::Interface::as_raw(this), level, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetStatisticsAsync(&self, statisticscategories: P0) -> windows_core::Result> + pub fn GetStatisticsAsync(&self, statisticscategories: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -1168,13 +1168,13 @@ impl CashDrawer { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveStatusUpdated)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn GetDefaultAsync() -> windows_core::Result> { + pub fn GetDefaultAsync() -> windows_core::Result> { Self::ICashDrawerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetDefaultAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::ICashDrawerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -1340,7 +1340,7 @@ impl CashDrawerCloseAlarm { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveAlarmTimeoutExpired)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn StartAsync(&self) -> windows_core::Result> { + pub fn StartAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1571,14 +1571,14 @@ impl ClaimedBarcodeScanner { (windows_core::Interface::vtable(this).IsDecodeDataEnabled)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn EnableAsync(&self) -> windows_core::Result { + pub fn EnableAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).EnableAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DisableAsync(&self) -> windows_core::Result { + pub fn DisableAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1589,7 +1589,7 @@ impl ClaimedBarcodeScanner { let this = self; unsafe { (windows_core::Interface::vtable(this).RetainDevice)(windows_core::Interface::as_raw(this)).ok() } } - pub fn SetActiveSymbologiesAsync(&self, symbologies: P0) -> windows_core::Result + pub fn SetActiveSymbologiesAsync(&self, symbologies: P0) -> windows_core::Result where P0: windows_core::Param>, { @@ -1599,7 +1599,7 @@ impl ClaimedBarcodeScanner { (windows_core::Interface::vtable(this).SetActiveSymbologiesAsync)(windows_core::Interface::as_raw(this), symbologies.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ResetStatisticsAsync(&self, statisticscategories: P0) -> windows_core::Result + pub fn ResetStatisticsAsync(&self, statisticscategories: P0) -> windows_core::Result where P0: windows_core::Param>, { @@ -1609,7 +1609,7 @@ impl ClaimedBarcodeScanner { (windows_core::Interface::vtable(this).ResetStatisticsAsync)(windows_core::Interface::as_raw(this), statisticscategories.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn UpdateStatisticsAsync(&self, statistics: P0) -> windows_core::Result + pub fn UpdateStatisticsAsync(&self, statistics: P0) -> windows_core::Result where P0: windows_core::Param>>, { @@ -1619,7 +1619,7 @@ impl ClaimedBarcodeScanner { (windows_core::Interface::vtable(this).UpdateStatisticsAsync)(windows_core::Interface::as_raw(this), statistics.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SetActiveProfileAsync(&self, profile: &windows_core::HSTRING) -> windows_core::Result { + pub fn SetActiveProfileAsync(&self, profile: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1710,28 +1710,28 @@ impl ClaimedBarcodeScanner { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveErrorOccurred)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn StartSoftwareTriggerAsync(&self) -> windows_core::Result { + pub fn StartSoftwareTriggerAsync(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).StartSoftwareTriggerAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StopSoftwareTriggerAsync(&self) -> windows_core::Result { + pub fn StopSoftwareTriggerAsync(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).StopSoftwareTriggerAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetSymbologyAttributesAsync(&self, barcodesymbology: u32) -> windows_core::Result> { + pub fn GetSymbologyAttributesAsync(&self, barcodesymbology: u32) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetSymbologyAttributesAsync)(windows_core::Interface::as_raw(this), barcodesymbology, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SetSymbologyAttributesAsync(&self, barcodesymbology: u32, attributes: P1) -> windows_core::Result> + pub fn SetSymbologyAttributesAsync(&self, barcodesymbology: u32, attributes: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -1741,7 +1741,7 @@ impl ClaimedBarcodeScanner { (windows_core::Interface::vtable(this).SetSymbologyAttributesAsync)(windows_core::Interface::as_raw(this), barcodesymbology, attributes.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ShowVideoPreviewAsync(&self) -> windows_core::Result> { + pub fn ShowVideoPreviewAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1845,35 +1845,35 @@ impl ClaimedCashDrawer { (windows_core::Interface::vtable(this).CloseAlarm)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn OpenDrawerAsync(&self) -> windows_core::Result> { + pub fn OpenDrawerAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).OpenDrawerAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn EnableAsync(&self) -> windows_core::Result> { + pub fn EnableAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).EnableAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DisableAsync(&self) -> windows_core::Result> { + pub fn DisableAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DisableAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RetainDeviceAsync(&self) -> windows_core::Result> { + pub fn RetainDeviceAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RetainDeviceAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ResetStatisticsAsync(&self, statisticscategories: P0) -> windows_core::Result> + pub fn ResetStatisticsAsync(&self, statisticscategories: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -1883,7 +1883,7 @@ impl ClaimedCashDrawer { (windows_core::Interface::vtable(this).ResetStatisticsAsync)(windows_core::Interface::as_raw(this), statisticscategories.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn UpdateStatisticsAsync(&self, statistics: P0) -> windows_core::Result> + pub fn UpdateStatisticsAsync(&self, statistics: P0) -> windows_core::Result> where P0: windows_core::Param>>, { @@ -2179,7 +2179,7 @@ impl ClaimedLineDisplay { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveReleaseDeviceRequested)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn GetStatisticsAsync(&self, statisticscategories: P0) -> windows_core::Result> + pub fn GetStatisticsAsync(&self, statisticscategories: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -2189,14 +2189,14 @@ impl ClaimedLineDisplay { (windows_core::Interface::vtable(this).GetStatisticsAsync)(windows_core::Interface::as_raw(this), statisticscategories.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CheckHealthAsync(&self, level: UnifiedPosHealthCheckLevel) -> windows_core::Result> { + pub fn CheckHealthAsync(&self, level: UnifiedPosHealthCheckLevel) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CheckHealthAsync)(windows_core::Interface::as_raw(this), level, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CheckPowerStatusAsync(&self) -> windows_core::Result> { + pub fn CheckPowerStatusAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -2252,7 +2252,7 @@ impl ClaimedLineDisplay { (windows_core::Interface::vtable(this).GetAttributes)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryUpdateAttributesAsync(&self, attributes: P0) -> windows_core::Result> + pub fn TryUpdateAttributesAsync(&self, attributes: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2262,21 +2262,21 @@ impl ClaimedLineDisplay { (windows_core::Interface::vtable(this).TryUpdateAttributesAsync)(windows_core::Interface::as_raw(this), attributes.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TrySetDescriptorAsync(&self, descriptor: u32, descriptorstate: LineDisplayDescriptorState) -> windows_core::Result> { + pub fn TrySetDescriptorAsync(&self, descriptor: u32, descriptorstate: LineDisplayDescriptorState) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TrySetDescriptorAsync)(windows_core::Interface::as_raw(this), descriptor, descriptorstate, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryClearDescriptorsAsync(&self) -> windows_core::Result> { + pub fn TryClearDescriptorsAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryClearDescriptorsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryCreateWindowAsync(&self, viewport: super::super::Foundation::Rect, windowsize: super::super::Foundation::Size) -> windows_core::Result> { + pub fn TryCreateWindowAsync(&self, viewport: super::super::Foundation::Rect, windowsize: super::super::Foundation::Size) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -2284,7 +2284,7 @@ impl ClaimedLineDisplay { } } #[cfg(feature = "Storage_Streams")] - pub fn TryStoreStorageFileBitmapAsync(&self, bitmap: P0) -> windows_core::Result> + pub fn TryStoreStorageFileBitmapAsync(&self, bitmap: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2295,7 +2295,7 @@ impl ClaimedLineDisplay { } } #[cfg(feature = "Storage_Streams")] - pub fn TryStoreStorageFileBitmapWithAlignmentAsync(&self, bitmap: P0, horizontalalignment: LineDisplayHorizontalAlignment, verticalalignment: LineDisplayVerticalAlignment) -> windows_core::Result> + pub fn TryStoreStorageFileBitmapWithAlignmentAsync(&self, bitmap: P0, horizontalalignment: LineDisplayHorizontalAlignment, verticalalignment: LineDisplayVerticalAlignment) -> windows_core::Result> where P0: windows_core::Param, { @@ -2306,7 +2306,7 @@ impl ClaimedLineDisplay { } } #[cfg(feature = "Storage_Streams")] - pub fn TryStoreStorageFileBitmapWithAlignmentAndWidthAsync(&self, bitmap: P0, horizontalalignment: LineDisplayHorizontalAlignment, verticalalignment: LineDisplayVerticalAlignment, widthinpixels: i32) -> windows_core::Result> + pub fn TryStoreStorageFileBitmapWithAlignmentAndWidthAsync(&self, bitmap: P0, horizontalalignment: LineDisplayHorizontalAlignment, verticalalignment: LineDisplayVerticalAlignment, widthinpixels: i32) -> windows_core::Result> where P0: windows_core::Param, { @@ -2330,7 +2330,7 @@ impl ClaimedLineDisplay { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).RemoveClosed)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IClaimedLineDisplayStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -2468,14 +2468,14 @@ impl ClaimedMagneticStripeReader { (windows_core::Interface::vtable(this).IsTransmitSentinelsEnabled)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn EnableAsync(&self) -> windows_core::Result { + pub fn EnableAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).EnableAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DisableAsync(&self) -> windows_core::Result { + pub fn DisableAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2491,35 +2491,35 @@ impl ClaimedMagneticStripeReader { unsafe { (windows_core::Interface::vtable(this).SetErrorReportingType)(windows_core::Interface::as_raw(this), value).ok() } } #[cfg(feature = "Storage_Streams")] - pub fn RetrieveDeviceAuthenticationDataAsync(&self) -> windows_core::Result> { + pub fn RetrieveDeviceAuthenticationDataAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RetrieveDeviceAuthenticationDataAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn AuthenticateDeviceAsync(&self, responsetoken: &[u8]) -> windows_core::Result { + pub fn AuthenticateDeviceAsync(&self, responsetoken: &[u8]) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).AuthenticateDeviceAsync)(windows_core::Interface::as_raw(this), responsetoken.len().try_into().unwrap(), responsetoken.as_ptr(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeAuthenticateDeviceAsync(&self, responsetoken: &[u8]) -> windows_core::Result { + pub fn DeAuthenticateDeviceAsync(&self, responsetoken: &[u8]) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeAuthenticateDeviceAsync)(windows_core::Interface::as_raw(this), responsetoken.len().try_into().unwrap(), responsetoken.as_ptr(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn UpdateKeyAsync(&self, key: &windows_core::HSTRING, keyname: &windows_core::HSTRING) -> windows_core::Result { + pub fn UpdateKeyAsync(&self, key: &windows_core::HSTRING, keyname: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).UpdateKeyAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(key), core::mem::transmute_copy(keyname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ResetStatisticsAsync(&self, statisticscategories: P0) -> windows_core::Result + pub fn ResetStatisticsAsync(&self, statisticscategories: P0) -> windows_core::Result where P0: windows_core::Param>, { @@ -2529,7 +2529,7 @@ impl ClaimedMagneticStripeReader { (windows_core::Interface::vtable(this).ResetStatisticsAsync)(windows_core::Interface::as_raw(this), statisticscategories.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn UpdateStatisticsAsync(&self, statistics: P0) -> windows_core::Result + pub fn UpdateStatisticsAsync(&self, statistics: P0) -> windows_core::Result where P0: windows_core::Param>>, { @@ -2738,28 +2738,28 @@ impl ClaimedPosPrinter { (windows_core::Interface::vtable(this).Journal)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn EnableAsync(&self) -> windows_core::Result> { + pub fn EnableAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).EnableAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DisableAsync(&self) -> windows_core::Result> { + pub fn DisableAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DisableAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RetainDeviceAsync(&self) -> windows_core::Result> { + pub fn RetainDeviceAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RetainDeviceAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ResetStatisticsAsync(&self, statisticscategories: P0) -> windows_core::Result> + pub fn ResetStatisticsAsync(&self, statisticscategories: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -2769,7 +2769,7 @@ impl ClaimedPosPrinter { (windows_core::Interface::vtable(this).ResetStatisticsAsync)(windows_core::Interface::as_raw(this), statisticscategories.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn UpdateStatisticsAsync(&self, statistics: P0) -> windows_core::Result> + pub fn UpdateStatisticsAsync(&self, statistics: P0) -> windows_core::Result> where P0: windows_core::Param>>, { @@ -3083,14 +3083,14 @@ impl ClaimedSlipPrinter { let this = self; unsafe { (windows_core::Interface::vtable(this).CloseJaws)(windows_core::Interface::as_raw(this)).ok() } } - pub fn InsertSlipAsync(&self, timeout: super::super::Foundation::TimeSpan) -> windows_core::Result> { + pub fn InsertSlipAsync(&self, timeout: super::super::Foundation::TimeSpan) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).InsertSlipAsync)(windows_core::Interface::as_raw(this), timeout, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RemoveSlipAsync(&self, timeout: super::super::Foundation::TimeSpan) -> windows_core::Result> { + pub fn RemoveSlipAsync(&self, timeout: super::super::Foundation::TimeSpan) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -5613,7 +5613,7 @@ impl IPosPrinterJob { let this = self; unsafe { (windows_core::Interface::vtable(this).PrintNewline)(windows_core::Interface::as_raw(this)).ok() } } - pub fn ExecuteAsync(&self) -> windows_core::Result> { + pub fn ExecuteAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -5628,7 +5628,7 @@ pub trait IPosPrinterJob_Impl: windows_core::IUnknownImpl { fn Print(&self, data: &windows_core::HSTRING) -> windows_core::Result<()>; fn PrintLine(&self, data: &windows_core::HSTRING) -> windows_core::Result<()>; fn PrintNewline(&self) -> windows_core::Result<()>; - fn ExecuteAsync(&self) -> windows_core::Result>; + fn ExecuteAsync(&self) -> windows_core::Result>; } impl IPosPrinterJob_Vtbl { pub const fn new() -> Self { @@ -5875,7 +5875,7 @@ impl IReceiptOrSlipJob { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).PrintNewline)(windows_core::Interface::as_raw(this)).ok() } } - pub fn ExecuteAsync(&self) -> windows_core::Result> { + pub fn ExecuteAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -6200,7 +6200,7 @@ impl JournalPrintJob { let this = self; unsafe { (windows_core::Interface::vtable(this).PrintNewline)(windows_core::Interface::as_raw(this)).ok() } } - pub fn ExecuteAsync(&self) -> windows_core::Result> { + pub fn ExecuteAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -6431,27 +6431,27 @@ impl LineDisplay { (windows_core::Interface::vtable(this).DeviceServiceVersion)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn ClaimAsync(&self) -> windows_core::Result> { + pub fn ClaimAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ClaimAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CheckPowerStatusAsync(&self) -> windows_core::Result> { + pub fn CheckPowerStatusAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CheckPowerStatusAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::ILineDisplayStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetDefaultAsync() -> windows_core::Result> { + pub fn GetDefaultAsync() -> windows_core::Result> { Self::ILineDisplayStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetDefaultAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -6799,7 +6799,7 @@ impl LineDisplayCursor { (windows_core::Interface::vtable(this).GetAttributes)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryUpdateAttributesAsync(&self, attributes: P0) -> windows_core::Result> + pub fn TryUpdateAttributesAsync(&self, attributes: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -6921,7 +6921,7 @@ impl LineDisplayCustomGlyphs { } } #[cfg(feature = "Storage_Streams")] - pub fn TryRedefineAsync(&self, glyphcode: u32, glyphdata: P1) -> windows_core::Result> + pub fn TryRedefineAsync(&self, glyphcode: u32, glyphdata: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -7010,14 +7010,14 @@ impl LineDisplayMarquee { let this = self; unsafe { (windows_core::Interface::vtable(this).SetScrollWaitInterval)(windows_core::Interface::as_raw(this), value).ok() } } - pub fn TryStartScrollingAsync(&self, direction: LineDisplayScrollDirection) -> windows_core::Result> { + pub fn TryStartScrollingAsync(&self, direction: LineDisplayScrollDirection) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryStartScrollingAsync)(windows_core::Interface::as_raw(this), direction, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryStopScrollingAsync(&self) -> windows_core::Result> { + pub fn TryStopScrollingAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -7158,7 +7158,7 @@ impl LineDisplayStoredBitmap { (windows_core::Interface::vtable(this).EscapeSequence)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn TryDeleteAsync(&self) -> windows_core::Result> { + pub fn TryDeleteAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -7249,42 +7249,42 @@ impl LineDisplayWindow { let this = self; unsafe { (windows_core::Interface::vtable(this).SetInterCharacterWaitInterval)(windows_core::Interface::as_raw(this), value).ok() } } - pub fn TryRefreshAsync(&self) -> windows_core::Result> { + pub fn TryRefreshAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryRefreshAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryDisplayTextAsync(&self, text: &windows_core::HSTRING, displayattribute: LineDisplayTextAttribute) -> windows_core::Result> { + pub fn TryDisplayTextAsync(&self, text: &windows_core::HSTRING, displayattribute: LineDisplayTextAttribute) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryDisplayTextAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(text), displayattribute, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryDisplayTextAtPositionAsync(&self, text: &windows_core::HSTRING, displayattribute: LineDisplayTextAttribute, startposition: super::super::Foundation::Point) -> windows_core::Result> { + pub fn TryDisplayTextAtPositionAsync(&self, text: &windows_core::HSTRING, displayattribute: LineDisplayTextAttribute, startposition: super::super::Foundation::Point) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryDisplayTextAtPositionAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(text), displayattribute, startposition, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryDisplayTextNormalAsync(&self, text: &windows_core::HSTRING) -> windows_core::Result> { + pub fn TryDisplayTextNormalAsync(&self, text: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryDisplayTextNormalAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(text), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryScrollTextAsync(&self, direction: LineDisplayScrollDirection, numberofcolumnsorrows: u32) -> windows_core::Result> { + pub fn TryScrollTextAsync(&self, direction: LineDisplayScrollDirection, numberofcolumnsorrows: u32) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryScrollTextAsync)(windows_core::Interface::as_raw(this), direction, numberofcolumnsorrows, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryClearTextAsync(&self) -> windows_core::Result> { + pub fn TryClearTextAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -7305,14 +7305,14 @@ impl LineDisplayWindow { (windows_core::Interface::vtable(this).Marquee)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReadCharacterAtCursorAsync(&self) -> windows_core::Result> { + pub fn ReadCharacterAtCursorAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReadCharacterAtCursorAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryDisplayStoredBitmapAtCursorAsync(&self, bitmap: P0) -> windows_core::Result> + pub fn TryDisplayStoredBitmapAtCursorAsync(&self, bitmap: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -7323,7 +7323,7 @@ impl LineDisplayWindow { } } #[cfg(feature = "Storage_Streams")] - pub fn TryDisplayStorageFileBitmapAtCursorAsync(&self, bitmap: P0) -> windows_core::Result> + pub fn TryDisplayStorageFileBitmapAtCursorAsync(&self, bitmap: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -7334,7 +7334,7 @@ impl LineDisplayWindow { } } #[cfg(feature = "Storage_Streams")] - pub fn TryDisplayStorageFileBitmapAtCursorWithAlignmentAsync(&self, bitmap: P0, horizontalalignment: LineDisplayHorizontalAlignment, verticalalignment: LineDisplayVerticalAlignment) -> windows_core::Result> + pub fn TryDisplayStorageFileBitmapAtCursorWithAlignmentAsync(&self, bitmap: P0, horizontalalignment: LineDisplayHorizontalAlignment, verticalalignment: LineDisplayVerticalAlignment) -> windows_core::Result> where P0: windows_core::Param, { @@ -7345,7 +7345,7 @@ impl LineDisplayWindow { } } #[cfg(feature = "Storage_Streams")] - pub fn TryDisplayStorageFileBitmapAtCursorWithAlignmentAndWidthAsync(&self, bitmap: P0, horizontalalignment: LineDisplayHorizontalAlignment, verticalalignment: LineDisplayVerticalAlignment, widthinpixels: i32) -> windows_core::Result> + pub fn TryDisplayStorageFileBitmapAtCursorWithAlignmentAndWidthAsync(&self, bitmap: P0, horizontalalignment: LineDisplayHorizontalAlignment, verticalalignment: LineDisplayVerticalAlignment, widthinpixels: i32) -> windows_core::Result> where P0: windows_core::Param, { @@ -7356,7 +7356,7 @@ impl LineDisplayWindow { } } #[cfg(feature = "Storage_Streams")] - pub fn TryDisplayStorageFileBitmapAtPointAsync(&self, bitmap: P0, offsetinpixels: super::super::Foundation::Point) -> windows_core::Result> + pub fn TryDisplayStorageFileBitmapAtPointAsync(&self, bitmap: P0, offsetinpixels: super::super::Foundation::Point) -> windows_core::Result> where P0: windows_core::Param, { @@ -7367,7 +7367,7 @@ impl LineDisplayWindow { } } #[cfg(feature = "Storage_Streams")] - pub fn TryDisplayStorageFileBitmapAtPointWithWidthAsync(&self, bitmap: P0, offsetinpixels: super::super::Foundation::Point, widthinpixels: i32) -> windows_core::Result> + pub fn TryDisplayStorageFileBitmapAtPointWithWidthAsync(&self, bitmap: P0, offsetinpixels: super::super::Foundation::Point, widthinpixels: i32) -> windows_core::Result> where P0: windows_core::Param, { @@ -7428,14 +7428,14 @@ impl MagneticStripeReader { (windows_core::Interface::vtable(this).DeviceAuthenticationProtocol)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn CheckHealthAsync(&self, level: UnifiedPosHealthCheckLevel) -> windows_core::Result> { + pub fn CheckHealthAsync(&self, level: UnifiedPosHealthCheckLevel) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CheckHealthAsync)(windows_core::Interface::as_raw(this), level, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ClaimReaderAsync(&self) -> windows_core::Result> { + pub fn ClaimReaderAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -7443,7 +7443,7 @@ impl MagneticStripeReader { } } #[cfg(feature = "Storage_Streams")] - pub fn RetrieveStatisticsAsync(&self, statisticscategories: P0) -> windows_core::Result> + pub fn RetrieveStatisticsAsync(&self, statisticscategories: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -7474,13 +7474,13 @@ impl MagneticStripeReader { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveStatusUpdated)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn GetDefaultAsync() -> windows_core::Result> { + pub fn GetDefaultAsync() -> windows_core::Result> { Self::IMagneticStripeReaderStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetDefaultAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IMagneticStripeReaderStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -8330,21 +8330,21 @@ impl PosPrinter { (windows_core::Interface::vtable(this).Status)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ClaimPrinterAsync(&self) -> windows_core::Result> { + pub fn ClaimPrinterAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ClaimPrinterAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CheckHealthAsync(&self, level: UnifiedPosHealthCheckLevel) -> windows_core::Result> { + pub fn CheckHealthAsync(&self, level: UnifiedPosHealthCheckLevel) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CheckHealthAsync)(windows_core::Interface::as_raw(this), level, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetStatisticsAsync(&self, statisticscategories: P0) -> windows_core::Result> + pub fn GetStatisticsAsync(&self, statisticscategories: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -8382,13 +8382,13 @@ impl PosPrinter { (windows_core::Interface::vtable(this).GetFontProperty)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(typeface), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetDefaultAsync() -> windows_core::Result> { + pub fn GetDefaultAsync() -> windows_core::Result> { Self::IPosPrinterStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetDefaultAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IPosPrinterStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -9196,7 +9196,7 @@ impl ReceiptPrintJob { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).PrintNewline)(windows_core::Interface::as_raw(this)).ok() } } - pub fn ExecuteAsync(&self) -> windows_core::Result> { + pub fn ExecuteAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -9605,7 +9605,7 @@ impl SlipPrintJob { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).PrintNewline)(windows_core::Interface::as_raw(this)).ok() } } - pub fn ExecuteAsync(&self) -> windows_core::Result> { + pub fn ExecuteAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Devices/Power/mod.rs b/crates/libs/windows/src/Windows/Devices/Power/mod.rs index 3277c541bc..4923bdff59 100644 --- a/crates/libs/windows/src/Windows/Devices/Power/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/Power/mod.rs @@ -37,7 +37,7 @@ impl Battery { (windows_core::Interface::vtable(this).AggregateBattery)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IBatteryStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/Devices/Printers/mod.rs b/crates/libs/windows/src/Windows/Devices/Printers/mod.rs index 7508c79315..5c80976f7e 100644 --- a/crates/libs/windows/src/Windows/Devices/Printers/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/Printers/mod.rs @@ -1404,7 +1404,7 @@ impl Print3DDevice { (windows_core::Interface::vtable(this).PrintSchema)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IPrint3DDeviceStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -1439,7 +1439,7 @@ pub struct PrintSchema(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(PrintSchema, windows_core::IUnknown, windows_core::IInspectable); impl PrintSchema { #[cfg(feature = "Storage_Streams")] - pub fn GetDefaultPrintTicketAsync(&self) -> windows_core::Result> { + pub fn GetDefaultPrintTicketAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1447,7 +1447,7 @@ impl PrintSchema { } } #[cfg(feature = "Storage_Streams")] - pub fn GetCapabilitiesAsync(&self, constrainticket: P0) -> windows_core::Result> + pub fn GetCapabilitiesAsync(&self, constrainticket: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1458,7 +1458,7 @@ impl PrintSchema { } } #[cfg(feature = "Storage_Streams")] - pub fn MergeAndValidateWithDefaultPrintTicketAsync(&self, deltaticket: P0) -> windows_core::Result> + pub fn MergeAndValidateWithDefaultPrintTicketAsync(&self, deltaticket: P0) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Devices/Pwm/mod.rs b/crates/libs/windows/src/Windows/Devices/Pwm/mod.rs index e1d1e146f4..0266520bf6 100644 --- a/crates/libs/windows/src/Windows/Devices/Pwm/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/Pwm/mod.rs @@ -110,7 +110,7 @@ impl PwmController { } } #[cfg(feature = "Devices_Pwm_Provider")] - pub fn GetControllersAsync(provider: P0) -> windows_core::Result>> + pub fn GetControllersAsync(provider: P0) -> windows_core::Result>> where P0: windows_core::Param, { @@ -119,7 +119,7 @@ impl PwmController { (windows_core::Interface::vtable(this).GetControllersAsync)(windows_core::Interface::as_raw(this), provider.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetDefaultAsync() -> windows_core::Result> { + pub fn GetDefaultAsync() -> windows_core::Result> { Self::IPwmControllerStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetDefaultAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -137,7 +137,7 @@ impl PwmController { (windows_core::Interface::vtable(this).GetDeviceSelectorFromFriendlyName)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(friendlyname), &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IPwmControllerStatics3(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/Devices/Radios/mod.rs b/crates/libs/windows/src/Windows/Devices/Radios/mod.rs index 617834c4e0..b166100d9f 100644 --- a/crates/libs/windows/src/Windows/Devices/Radios/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/Radios/mod.rs @@ -29,7 +29,7 @@ pub struct IRadioStatics_Vtbl { pub struct Radio(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(Radio, windows_core::IUnknown, windows_core::IInspectable); impl Radio { - pub fn SetStateAsync(&self, value: RadioState) -> windows_core::Result> { + pub fn SetStateAsync(&self, value: RadioState) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -71,7 +71,7 @@ impl Radio { (windows_core::Interface::vtable(this).Kind)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn GetRadiosAsync() -> windows_core::Result>> { + pub fn GetRadiosAsync() -> windows_core::Result>> { Self::IRadioStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetRadiosAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -83,13 +83,13 @@ impl Radio { (windows_core::Interface::vtable(this).GetDeviceSelector)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IRadioStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RequestAccessAsync() -> windows_core::Result> { + pub fn RequestAccessAsync() -> windows_core::Result> { Self::IRadioStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestAccessAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/Devices/Scanners/mod.rs b/crates/libs/windows/src/Windows/Devices/Scanners/mod.rs index f9ec03ec63..678625d392 100644 --- a/crates/libs/windows/src/Windows/Devices/Scanners/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/Scanners/mod.rs @@ -889,7 +889,7 @@ impl ImageScanner { } } #[cfg(feature = "Storage_Streams")] - pub fn ScanPreviewToStreamAsync(&self, scansource: ImageScannerScanSource, targetstream: P1) -> windows_core::Result> + pub fn ScanPreviewToStreamAsync(&self, scansource: ImageScannerScanSource, targetstream: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -900,7 +900,7 @@ impl ImageScanner { } } #[cfg(feature = "Storage_Search")] - pub fn ScanFilesToFolderAsync(&self, scansource: ImageScannerScanSource, storagefolder: P1) -> windows_core::Result> + pub fn ScanFilesToFolderAsync(&self, scansource: ImageScannerScanSource, storagefolder: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -910,7 +910,7 @@ impl ImageScanner { (windows_core::Interface::vtable(this).ScanFilesToFolderAsync)(windows_core::Interface::as_raw(this), scansource, storagefolder.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IImageScannerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/Devices/Sensors/Custom/mod.rs b/crates/libs/windows/src/Windows/Devices/Sensors/Custom/mod.rs index 4996eae1f5..71310ca650 100644 --- a/crates/libs/windows/src/Windows/Devices/Sensors/Custom/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/Sensors/Custom/mod.rs @@ -73,7 +73,7 @@ impl CustomSensor { (windows_core::Interface::vtable(this).GetDeviceSelector)(windows_core::Interface::as_raw(this), interfaceid, &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn FromIdAsync(sensorid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(sensorid: &windows_core::HSTRING) -> windows_core::Result> { Self::ICustomSensorStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(sensorid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/Devices/Sensors/mod.rs b/crates/libs/windows/src/Windows/Devices/Sensors/mod.rs index 8d396168bd..e24e1761e5 100644 --- a/crates/libs/windows/src/Windows/Devices/Sensors/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/Sensors/mod.rs @@ -122,7 +122,7 @@ impl Accelerometer { (windows_core::Interface::vtable(this).GetDefaultWithAccelerometerReadingType)(windows_core::Interface::as_raw(this), readingtype, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IAccelerometerStatics3(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -339,7 +339,7 @@ unsafe impl Sync for AccelerometerShakenEventArgs {} pub struct ActivitySensor(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(ActivitySensor, windows_core::IUnknown, windows_core::IInspectable); impl ActivitySensor { - pub fn GetCurrentReadingAsync(&self) -> windows_core::Result> { + pub fn GetCurrentReadingAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -395,7 +395,7 @@ impl ActivitySensor { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveReadingChanged)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn GetDefaultAsync() -> windows_core::Result> { + pub fn GetDefaultAsync() -> windows_core::Result> { Self::IActivitySensorStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetDefaultAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -407,19 +407,19 @@ impl ActivitySensor { (windows_core::Interface::vtable(this).GetDeviceSelector)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IActivitySensorStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetSystemHistoryAsync(fromtime: super::super::Foundation::DateTime) -> windows_core::Result>> { + pub fn GetSystemHistoryAsync(fromtime: super::super::Foundation::DateTime) -> windows_core::Result>> { Self::IActivitySensorStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetSystemHistoryAsync)(windows_core::Interface::as_raw(this), fromtime, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetSystemHistoryWithDurationAsync(fromtime: super::super::Foundation::DateTime, duration: super::super::Foundation::TimeSpan) -> windows_core::Result>> { + pub fn GetSystemHistoryWithDurationAsync(fromtime: super::super::Foundation::DateTime, duration: super::super::Foundation::TimeSpan) -> windows_core::Result>> { Self::IActivitySensorStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetSystemHistoryWithDurationAsync)(windows_core::Interface::as_raw(this), fromtime, duration, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -862,7 +862,7 @@ impl Barometer { (windows_core::Interface::vtable(this).GetDefault)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IBarometerStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -1096,7 +1096,7 @@ impl Compass { (windows_core::Interface::vtable(this).GetDeviceSelector)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::ICompassStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -1391,7 +1391,7 @@ impl Gyrometer { (windows_core::Interface::vtable(this).GetDeviceSelector)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IGyrometerStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -1669,7 +1669,7 @@ unsafe impl Sync for HingeAngleReading {} pub struct HingeAngleSensor(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(HingeAngleSensor, windows_core::IUnknown, windows_core::IInspectable); impl HingeAngleSensor { - pub fn GetCurrentReadingAsync(&self) -> windows_core::Result> { + pub fn GetCurrentReadingAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1721,19 +1721,19 @@ impl HingeAngleSensor { (windows_core::Interface::vtable(this).GetDeviceSelector)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn GetDefaultAsync() -> windows_core::Result> { + pub fn GetDefaultAsync() -> windows_core::Result> { Self::IHingeAngleSensorStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetDefaultAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetRelatedToAdjacentPanelsAsync(firstpanelid: &windows_core::HSTRING, secondpanelid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetRelatedToAdjacentPanelsAsync(firstpanelid: &windows_core::HSTRING, secondpanelid: &windows_core::HSTRING) -> windows_core::Result> { Self::IHingeAngleSensorStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetRelatedToAdjacentPanelsAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(firstpanelid), core::mem::transmute_copy(secondpanelid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IHingeAngleSensorStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -1972,13 +1972,13 @@ impl HumanPresenceSensor { (windows_core::Interface::vtable(this).GetDeviceSelector)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn FromIdAsync(sensorid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(sensorid: &windows_core::HSTRING) -> windows_core::Result> { Self::IHumanPresenceSensorStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(sensorid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetDefaultAsync() -> windows_core::Result> { + pub fn GetDefaultAsync() -> windows_core::Result> { Self::IHumanPresenceSensorStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetDefaultAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -2312,7 +2312,7 @@ impl HumanPresenceSettings { (windows_core::Interface::vtable(this).LockOptions)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetCurrentSettingsAsync() -> windows_core::Result> { + pub fn GetCurrentSettingsAsync() -> windows_core::Result> { Self::IHumanPresenceSettingsStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetCurrentSettingsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -2324,7 +2324,7 @@ impl HumanPresenceSettings { (windows_core::Interface::vtable(this).GetCurrentSettings)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn UpdateSettingsAsync(settings: P0) -> windows_core::Result + pub fn UpdateSettingsAsync(settings: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -2339,7 +2339,7 @@ impl HumanPresenceSettings { { Self::IHumanPresenceSettingsStatics(|this| unsafe { (windows_core::Interface::vtable(this).UpdateSettings)(windows_core::Interface::as_raw(this), settings.param().abi()).ok() }) } - pub fn GetSupportedFeaturesForSensorIdAsync(sensorid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetSupportedFeaturesForSensorIdAsync(sensorid: &windows_core::HSTRING) -> windows_core::Result> { Self::IHumanPresenceSettingsStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetSupportedFeaturesForSensorIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(sensorid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -4346,7 +4346,7 @@ impl Inclinometer { (windows_core::Interface::vtable(this).GetDeviceSelector)(windows_core::Interface::as_raw(this), readingtype, &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IInclinometerStatics4(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -4612,7 +4612,7 @@ impl LightSensor { (windows_core::Interface::vtable(this).GetDeviceSelector)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::ILightSensorStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -4880,7 +4880,7 @@ impl Magnetometer { (windows_core::Interface::vtable(this).GetDeviceSelector)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IMagnetometerStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -5190,7 +5190,7 @@ impl OrientationSensor { (windows_core::Interface::vtable(this).GetDeviceSelectorWithSensorReadingTypeAndSensorOptimizationGoal)(windows_core::Interface::as_raw(this), readingtype, optimizationgoal, &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IOrientationSensorStatics4(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -5368,13 +5368,13 @@ impl Pedometer { (windows_core::Interface::vtable(this).GetCurrentReadings)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IPedometerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetDefaultAsync() -> windows_core::Result> { + pub fn GetDefaultAsync() -> windows_core::Result> { Self::IPedometerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetDefaultAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -5386,13 +5386,13 @@ impl Pedometer { (windows_core::Interface::vtable(this).GetDeviceSelector)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn GetSystemHistoryAsync(fromtime: super::super::Foundation::DateTime) -> windows_core::Result>> { + pub fn GetSystemHistoryAsync(fromtime: super::super::Foundation::DateTime) -> windows_core::Result>> { Self::IPedometerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetSystemHistoryAsync)(windows_core::Interface::as_raw(this), fromtime, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetSystemHistoryWithDurationAsync(fromtime: super::super::Foundation::DateTime, duration: super::super::Foundation::TimeSpan) -> windows_core::Result>> { + pub fn GetSystemHistoryWithDurationAsync(fromtime: super::super::Foundation::DateTime, duration: super::super::Foundation::TimeSpan) -> windows_core::Result>> { Self::IPedometerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetSystemHistoryWithDurationAsync)(windows_core::Interface::as_raw(this), fromtime, duration, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -6042,7 +6042,7 @@ impl SimpleOrientationSensor { (windows_core::Interface::vtable(this).GetDeviceSelector)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::ISimpleOrientationSensorStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/Devices/SerialCommunication/mod.rs b/crates/libs/windows/src/Windows/Devices/SerialCommunication/mod.rs index 1cd727e498..23c6adca2a 100644 --- a/crates/libs/windows/src/Windows/Devices/SerialCommunication/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/SerialCommunication/mod.rs @@ -356,7 +356,7 @@ impl SerialDevice { (windows_core::Interface::vtable(this).GetDeviceSelectorFromUsbVidPid)(windows_core::Interface::as_raw(this), vendorid, productid, &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::ISerialDeviceStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/Devices/SmartCards/mod.rs b/crates/libs/windows/src/Windows/Devices/SmartCards/mod.rs index 6370309f1d..6b96589001 100644 --- a/crates/libs/windows/src/Windows/Devices/SmartCards/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/SmartCards/mod.rs @@ -851,7 +851,7 @@ impl SmartCard { (windows_core::Interface::vtable(this).Reader)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetStatusAsync(&self) -> windows_core::Result> { + pub fn GetStatusAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -859,14 +859,14 @@ impl SmartCard { } } #[cfg(feature = "Storage_Streams")] - pub fn GetAnswerToResetAsync(&self) -> windows_core::Result> { + pub fn GetAnswerToResetAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetAnswerToResetAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ConnectAsync(&self) -> windows_core::Result> { + pub fn ConnectAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1079,7 +1079,7 @@ impl SmartCardAppletIdGroupRegistration { (windows_core::Interface::vtable(this).AppletIdGroup)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestActivationPolicyChangeAsync(&self, policy: SmartCardAppletIdGroupActivationPolicy) -> windows_core::Result> { + pub fn RequestActivationPolicyChangeAsync(&self, policy: SmartCardAppletIdGroupActivationPolicy) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1093,7 +1093,7 @@ impl SmartCardAppletIdGroupRegistration { (windows_core::Interface::vtable(this).Id)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn SetAutomaticResponseApdusAsync(&self, apdus: P0) -> windows_core::Result + pub fn SetAutomaticResponseApdusAsync(&self, apdus: P0) -> windows_core::Result where P0: windows_core::Param>, { @@ -1111,7 +1111,7 @@ impl SmartCardAppletIdGroupRegistration { } } #[cfg(feature = "Foundation_Collections")] - pub fn SetPropertiesAsync(&self, props: P0) -> windows_core::Result + pub fn SetPropertiesAsync(&self, props: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -1314,7 +1314,7 @@ impl SmartCardChallengeContext { } } #[cfg(feature = "Storage_Streams")] - pub fn VerifyResponseAsync(&self, response: P0) -> windows_core::Result> + pub fn VerifyResponseAsync(&self, response: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1325,7 +1325,7 @@ impl SmartCardChallengeContext { } } #[cfg(feature = "Storage_Streams")] - pub fn ProvisionAsync(&self, response: P0, formatcard: bool) -> windows_core::Result + pub fn ProvisionAsync(&self, response: P0, formatcard: bool) -> windows_core::Result where P0: windows_core::Param, { @@ -1336,7 +1336,7 @@ impl SmartCardChallengeContext { } } #[cfg(feature = "Storage_Streams")] - pub fn ProvisionAsyncWithNewCardId(&self, response: P0, formatcard: bool, newcardid: windows_core::GUID) -> windows_core::Result + pub fn ProvisionAsyncWithNewCardId(&self, response: P0, formatcard: bool, newcardid: windows_core::GUID) -> windows_core::Result where P0: windows_core::Param, { @@ -1347,7 +1347,7 @@ impl SmartCardChallengeContext { } } #[cfg(feature = "Storage_Streams")] - pub fn ChangeAdministrativeKeyAsync(&self, response: P0, newadministrativekey: P1) -> windows_core::Result + pub fn ChangeAdministrativeKeyAsync(&self, response: P0, newadministrativekey: P1) -> windows_core::Result where P0: windows_core::Param, P1: windows_core::Param, @@ -1382,7 +1382,7 @@ impl SmartCardConnection { unsafe { (windows_core::Interface::vtable(this).Close)(windows_core::Interface::as_raw(this)).ok() } } #[cfg(feature = "Storage_Streams")] - pub fn TransmitAsync(&self, command: P0) -> windows_core::Result> + pub fn TransmitAsync(&self, command: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1465,14 +1465,14 @@ impl SmartCardCryptogramGenerator { (windows_core::Interface::vtable(this).SupportedSmartCardCryptogramStorageKeyCapabilities)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteCryptogramMaterialStorageKeyAsync(&self, storagekeyname: &windows_core::HSTRING) -> windows_core::Result> { + pub fn DeleteCryptogramMaterialStorageKeyAsync(&self, storagekeyname: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeleteCryptogramMaterialStorageKeyAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(storagekeyname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateCryptogramMaterialStorageKeyAsync(&self, promptingbehavior: SmartCardUnlockPromptingBehavior, storagekeyname: &windows_core::HSTRING, algorithm: SmartCardCryptogramStorageKeyAlgorithm, capabilities: SmartCardCryptogramStorageKeyCapabilities) -> windows_core::Result> { + pub fn CreateCryptogramMaterialStorageKeyAsync(&self, promptingbehavior: SmartCardUnlockPromptingBehavior, storagekeyname: &windows_core::HSTRING, algorithm: SmartCardCryptogramStorageKeyAlgorithm, capabilities: SmartCardCryptogramStorageKeyCapabilities) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1480,7 +1480,7 @@ impl SmartCardCryptogramGenerator { } } #[cfg(feature = "Security_Cryptography_Core")] - pub fn RequestCryptogramMaterialStorageKeyInfoAsync(&self, promptingbehavior: SmartCardUnlockPromptingBehavior, storagekeyname: &windows_core::HSTRING, format: super::super::Security::Cryptography::Core::CryptographicPublicKeyBlobType) -> windows_core::Result> { + pub fn RequestCryptogramMaterialStorageKeyInfoAsync(&self, promptingbehavior: SmartCardUnlockPromptingBehavior, storagekeyname: &windows_core::HSTRING, format: super::super::Security::Cryptography::Core::CryptographicPublicKeyBlobType) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1488,7 +1488,7 @@ impl SmartCardCryptogramGenerator { } } #[cfg(feature = "Storage_Streams")] - pub fn ImportCryptogramMaterialPackageAsync(&self, format: SmartCardCryptogramMaterialPackageFormat, storagekeyname: &windows_core::HSTRING, materialpackagename: &windows_core::HSTRING, cryptogrammaterialpackage: P3) -> windows_core::Result> + pub fn ImportCryptogramMaterialPackageAsync(&self, format: SmartCardCryptogramMaterialPackageFormat, storagekeyname: &windows_core::HSTRING, materialpackagename: &windows_core::HSTRING, cryptogrammaterialpackage: P3) -> windows_core::Result> where P3: windows_core::Param, { @@ -1499,7 +1499,7 @@ impl SmartCardCryptogramGenerator { } } #[cfg(feature = "Storage_Streams")] - pub fn TryProvePossessionOfCryptogramMaterialPackageAsync(&self, promptingbehavior: SmartCardUnlockPromptingBehavior, responseformat: SmartCardCryptogramMaterialPackageConfirmationResponseFormat, materialpackagename: &windows_core::HSTRING, materialname: &windows_core::HSTRING, challenge: P4) -> windows_core::Result> + pub fn TryProvePossessionOfCryptogramMaterialPackageAsync(&self, promptingbehavior: SmartCardUnlockPromptingBehavior, responseformat: SmartCardCryptogramMaterialPackageConfirmationResponseFormat, materialpackagename: &windows_core::HSTRING, materialname: &windows_core::HSTRING, challenge: P4) -> windows_core::Result> where P4: windows_core::Param, { @@ -1509,14 +1509,14 @@ impl SmartCardCryptogramGenerator { (windows_core::Interface::vtable(this).TryProvePossessionOfCryptogramMaterialPackageAsync)(windows_core::Interface::as_raw(this), promptingbehavior, responseformat, core::mem::transmute_copy(materialpackagename), core::mem::transmute_copy(materialname), challenge.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestUnlockCryptogramMaterialForUseAsync(&self, promptingbehavior: SmartCardUnlockPromptingBehavior) -> windows_core::Result> { + pub fn RequestUnlockCryptogramMaterialForUseAsync(&self, promptingbehavior: SmartCardUnlockPromptingBehavior) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestUnlockCryptogramMaterialForUseAsync)(windows_core::Interface::as_raw(this), promptingbehavior, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteCryptogramMaterialPackageAsync(&self, materialpackagename: &windows_core::HSTRING) -> windows_core::Result> { + pub fn DeleteCryptogramMaterialPackageAsync(&self, materialpackagename: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1524,7 +1524,7 @@ impl SmartCardCryptogramGenerator { } } #[cfg(feature = "Storage_Streams")] - pub fn ValidateRequestApduAsync(&self, promptingbehavior: SmartCardUnlockPromptingBehavior, apdutovalidate: P1, cryptogramplacementsteps: P2) -> windows_core::Result> + pub fn ValidateRequestApduAsync(&self, promptingbehavior: SmartCardUnlockPromptingBehavior, apdutovalidate: P1, cryptogramplacementsteps: P2) -> windows_core::Result> where P1: windows_core::Param, P2: windows_core::Param>, @@ -1535,35 +1535,35 @@ impl SmartCardCryptogramGenerator { (windows_core::Interface::vtable(this).ValidateRequestApduAsync)(windows_core::Interface::as_raw(this), promptingbehavior, apdutovalidate.param().abi(), cryptogramplacementsteps.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAllCryptogramStorageKeyCharacteristicsAsync(&self) -> windows_core::Result> { + pub fn GetAllCryptogramStorageKeyCharacteristicsAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetAllCryptogramStorageKeyCharacteristicsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAllCryptogramMaterialPackageCharacteristicsAsync(&self) -> windows_core::Result> { + pub fn GetAllCryptogramMaterialPackageCharacteristicsAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetAllCryptogramMaterialPackageCharacteristicsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAllCryptogramMaterialPackageCharacteristicsWithStorageKeyAsync(&self, storagekeyname: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetAllCryptogramMaterialPackageCharacteristicsWithStorageKeyAsync(&self, storagekeyname: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetAllCryptogramMaterialPackageCharacteristicsWithStorageKeyAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(storagekeyname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAllCryptogramMaterialCharacteristicsAsync(&self, promptingbehavior: SmartCardUnlockPromptingBehavior, materialpackagename: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetAllCryptogramMaterialCharacteristicsAsync(&self, promptingbehavior: SmartCardUnlockPromptingBehavior, materialpackagename: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetAllCryptogramMaterialCharacteristicsAsync)(windows_core::Interface::as_raw(this), promptingbehavior, core::mem::transmute_copy(materialpackagename), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetSmartCardCryptogramGeneratorAsync() -> windows_core::Result> { + pub fn GetSmartCardCryptogramGeneratorAsync() -> windows_core::Result> { Self::ISmartCardCryptogramGeneratorStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetSmartCardCryptogramGeneratorAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -2427,19 +2427,19 @@ impl SmartCardEmulator { (windows_core::Interface::vtable(this).IsHostCardEmulationSupported)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn GetDefaultAsync() -> windows_core::Result> { + pub fn GetDefaultAsync() -> windows_core::Result> { Self::ISmartCardEmulatorStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetDefaultAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetAppletIdGroupRegistrationsAsync() -> windows_core::Result>> { + pub fn GetAppletIdGroupRegistrationsAsync() -> windows_core::Result>> { Self::ISmartCardEmulatorStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetAppletIdGroupRegistrationsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RegisterAppletIdGroupAsync(appletidgroup: P0) -> windows_core::Result> + pub fn RegisterAppletIdGroupAsync(appletidgroup: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2448,7 +2448,7 @@ impl SmartCardEmulator { (windows_core::Interface::vtable(this).RegisterAppletIdGroupAsync)(windows_core::Interface::as_raw(this), appletidgroup.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn UnregisterAppletIdGroupAsync(registration: P0) -> windows_core::Result + pub fn UnregisterAppletIdGroupAsync(registration: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -2515,7 +2515,7 @@ impl SmartCardEmulatorApduReceivedEventArgs { } } #[cfg(feature = "Storage_Streams")] - pub fn TryRespondAsync(&self, responseapdu: P0) -> windows_core::Result> + pub fn TryRespondAsync(&self, responseapdu: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2540,7 +2540,7 @@ impl SmartCardEmulatorApduReceivedEventArgs { } } #[cfg(feature = "Storage_Streams")] - pub fn TryRespondWithStateAsync(&self, responseapdu: P0, nextstate: P1) -> windows_core::Result> + pub fn TryRespondWithStateAsync(&self, responseapdu: P0, nextstate: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param>, @@ -2552,7 +2552,7 @@ impl SmartCardEmulatorApduReceivedEventArgs { } } #[cfg(feature = "Storage_Streams")] - pub fn TryRespondWithCryptogramsAsync(&self, responsetemplate: P0, cryptogramplacementsteps: P1) -> windows_core::Result> + pub fn TryRespondWithCryptogramsAsync(&self, responsetemplate: P0, cryptogramplacementsteps: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param>, @@ -2564,7 +2564,7 @@ impl SmartCardEmulatorApduReceivedEventArgs { } } #[cfg(feature = "Storage_Streams")] - pub fn TryRespondWithCryptogramsAndStateAsync(&self, responsetemplate: P0, cryptogramplacementsteps: P1, nextstate: P2) -> windows_core::Result> + pub fn TryRespondWithCryptogramsAndStateAsync(&self, responsetemplate: P0, cryptogramplacementsteps: P1, nextstate: P2) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param>, @@ -2963,35 +2963,35 @@ impl SmartCardProvisioning { (windows_core::Interface::vtable(this).SmartCard)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetIdAsync(&self) -> windows_core::Result> { + pub fn GetIdAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetIdAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetNameAsync(&self) -> windows_core::Result> { + pub fn GetNameAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetNameAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetChallengeContextAsync(&self) -> windows_core::Result> { + pub fn GetChallengeContextAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetChallengeContextAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestPinChangeAsync(&self) -> windows_core::Result> { + pub fn RequestPinChangeAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestPinChangeAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestPinResetAsync(&self, handler: P0) -> windows_core::Result> + pub fn RequestPinResetAsync(&self, handler: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -3001,14 +3001,14 @@ impl SmartCardProvisioning { (windows_core::Interface::vtable(this).RequestPinResetAsync)(windows_core::Interface::as_raw(this), handler.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAuthorityKeyContainerNameAsync(&self) -> windows_core::Result> { + pub fn GetAuthorityKeyContainerNameAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetAuthorityKeyContainerNameAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FromSmartCardAsync(card: P0) -> windows_core::Result> + pub fn FromSmartCardAsync(card: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -3018,7 +3018,7 @@ impl SmartCardProvisioning { }) } #[cfg(feature = "Storage_Streams")] - pub fn RequestVirtualSmartCardCreationAsync(friendlyname: &windows_core::HSTRING, administrativekey: P1, pinpolicy: P2) -> windows_core::Result> + pub fn RequestVirtualSmartCardCreationAsync(friendlyname: &windows_core::HSTRING, administrativekey: P1, pinpolicy: P2) -> windows_core::Result> where P1: windows_core::Param, P2: windows_core::Param, @@ -3029,7 +3029,7 @@ impl SmartCardProvisioning { }) } #[cfg(feature = "Storage_Streams")] - pub fn RequestVirtualSmartCardCreationAsyncWithCardId(friendlyname: &windows_core::HSTRING, administrativekey: P1, pinpolicy: P2, cardid: windows_core::GUID) -> windows_core::Result> + pub fn RequestVirtualSmartCardCreationAsyncWithCardId(friendlyname: &windows_core::HSTRING, administrativekey: P1, pinpolicy: P2, cardid: windows_core::GUID) -> windows_core::Result> where P1: windows_core::Param, P2: windows_core::Param, @@ -3039,7 +3039,7 @@ impl SmartCardProvisioning { (windows_core::Interface::vtable(this).RequestVirtualSmartCardCreationAsyncWithCardId)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(friendlyname), administrativekey.param().abi(), pinpolicy.param().abi(), cardid, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RequestVirtualSmartCardDeletionAsync(card: P0) -> windows_core::Result> + pub fn RequestVirtualSmartCardDeletionAsync(card: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -3049,7 +3049,7 @@ impl SmartCardProvisioning { }) } #[cfg(feature = "Storage_Streams")] - pub fn RequestAttestedVirtualSmartCardCreationAsync(friendlyname: &windows_core::HSTRING, administrativekey: P1, pinpolicy: P2) -> windows_core::Result> + pub fn RequestAttestedVirtualSmartCardCreationAsync(friendlyname: &windows_core::HSTRING, administrativekey: P1, pinpolicy: P2) -> windows_core::Result> where P1: windows_core::Param, P2: windows_core::Param, @@ -3060,7 +3060,7 @@ impl SmartCardProvisioning { }) } #[cfg(feature = "Storage_Streams")] - pub fn RequestAttestedVirtualSmartCardCreationAsyncWithCardId(friendlyname: &windows_core::HSTRING, administrativekey: P1, pinpolicy: P2, cardid: windows_core::GUID) -> windows_core::Result> + pub fn RequestAttestedVirtualSmartCardCreationAsyncWithCardId(friendlyname: &windows_core::HSTRING, administrativekey: P1, pinpolicy: P2, cardid: windows_core::GUID) -> windows_core::Result> where P1: windows_core::Param, P2: windows_core::Param, @@ -3117,14 +3117,14 @@ impl SmartCardReader { (windows_core::Interface::vtable(this).Kind)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn GetStatusAsync(&self) -> windows_core::Result> { + pub fn GetStatusAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetStatusAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FindAllCardsAsync(&self) -> windows_core::Result>> { + pub fn FindAllCardsAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -3171,7 +3171,7 @@ impl SmartCardReader { (windows_core::Interface::vtable(this).GetDeviceSelectorWithKind)(windows_core::Interface::as_raw(this), kind, &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::ISmartCardReaderStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -3276,14 +3276,14 @@ impl SmartCardTriggerDetails { (windows_core::Interface::vtable(this).Emulator)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryLaunchCurrentAppAsync(&self, arguments: &windows_core::HSTRING) -> windows_core::Result> { + pub fn TryLaunchCurrentAppAsync(&self, arguments: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryLaunchCurrentAppAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(arguments), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryLaunchCurrentAppWithBehaviorAsync(&self, arguments: &windows_core::HSTRING, behavior: SmartCardLaunchBehavior) -> windows_core::Result> { + pub fn TryLaunchCurrentAppWithBehaviorAsync(&self, arguments: &windows_core::HSTRING, behavior: SmartCardLaunchBehavior) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Devices/Sms/mod.rs b/crates/libs/windows/src/Windows/Devices/Sms/mod.rs index 97eaab55f1..b231ac1ac3 100644 --- a/crates/libs/windows/src/Windows/Devices/Sms/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/Sms/mod.rs @@ -13,15 +13,15 @@ impl windows_core::RuntimeType for CellularClass { const SIGNATURE: windows_core::imp::ConstBuffer = windows_core::imp::ConstBuffer::from_slice(b"enum(Windows.Devices.Sms.CellularClass;i4)"); } #[cfg(feature = "deprecated")] -pub type DeleteSmsMessageOperation = super::super::Foundation::IAsyncAction; +pub type DeleteSmsMessageOperation = windows_async::IAsyncAction; #[cfg(feature = "deprecated")] -pub type DeleteSmsMessagesOperation = super::super::Foundation::IAsyncAction; +pub type DeleteSmsMessagesOperation = windows_async::IAsyncAction; #[cfg(feature = "deprecated")] -pub type GetSmsDeviceOperation = super::super::Foundation::IAsyncOperation; +pub type GetSmsDeviceOperation = windows_async::IAsyncOperation; #[cfg(feature = "deprecated")] -pub type GetSmsMessageOperation = super::super::Foundation::IAsyncOperation; +pub type GetSmsMessageOperation = windows_async::IAsyncOperation; #[cfg(feature = "deprecated")] -pub type GetSmsMessagesOperation = super::super::Foundation::IAsyncOperationWithProgress, i32>; +pub type GetSmsMessagesOperation = windows_async::IAsyncOperationWithProgress, i32>; windows_core::imp::define_interface!(ISmsAppMessage, ISmsAppMessage_Vtbl, 0xe8bb8494_d3a0_4a0a_86d7_291033a8cf54); impl windows_core::RuntimeType for ISmsAppMessage { const SIGNATURE: windows_core::imp::ConstBuffer = windows_core::imp::ConstBuffer::for_interface::(); @@ -1260,7 +1260,7 @@ pub struct ISmsWapMessage_Vtbl { pub Headers: unsafe extern "system" fn(*mut core::ffi::c_void, *mut *mut core::ffi::c_void) -> windows_core::HRESULT, } #[cfg(feature = "deprecated")] -pub type SendSmsMessageOperation = super::super::Foundation::IAsyncAction; +pub type SendSmsMessageOperation = windows_async::IAsyncAction; #[repr(transparent)] #[derive(Clone, Debug, Eq, PartialEq)] pub struct SmsAppMessage(windows_core::IUnknown); @@ -1778,19 +1778,19 @@ impl SmsDevice { (windows_core::Interface::vtable(this).GetDeviceSelector)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::ISmsDeviceStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetDefaultAsync() -> windows_core::Result> { + pub fn GetDefaultAsync() -> windows_core::Result> { Self::ISmsDeviceStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetDefaultAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn FromNetworkAccountIdAsync(networkaccountid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromNetworkAccountIdAsync(networkaccountid: &windows_core::HSTRING) -> windows_core::Result> { Self::ISmsDeviceStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromNetworkAccountIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(networkaccountid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -1879,7 +1879,7 @@ impl SmsDevice2 { (windows_core::Interface::vtable(this).CalculateLength)(windows_core::Interface::as_raw(this), message.param().abi(), &mut result__).map(|| result__) } } - pub fn SendMessageAndGetResultAsync(&self, message: P0) -> windows_core::Result> + pub fn SendMessageAndGetResultAsync(&self, message: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1950,28 +1950,28 @@ pub struct SmsDeviceMessageStore(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(SmsDeviceMessageStore, windows_core::IUnknown, windows_core::IInspectable); #[cfg(feature = "deprecated")] impl SmsDeviceMessageStore { - pub fn DeleteMessageAsync(&self, messageid: u32) -> windows_core::Result { + pub fn DeleteMessageAsync(&self, messageid: u32) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeleteMessageAsync)(windows_core::Interface::as_raw(this), messageid, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteMessagesAsync(&self, messagefilter: SmsMessageFilter) -> windows_core::Result { + pub fn DeleteMessagesAsync(&self, messagefilter: SmsMessageFilter) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeleteMessagesAsync)(windows_core::Interface::as_raw(this), messagefilter, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetMessageAsync(&self, messageid: u32) -> windows_core::Result> { + pub fn GetMessageAsync(&self, messageid: u32) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetMessageAsync)(windows_core::Interface::as_raw(this), messageid, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetMessagesAsync(&self, messagefilter: SmsMessageFilter) -> windows_core::Result, i32>> { + pub fn GetMessagesAsync(&self, messagefilter: SmsMessageFilter) -> windows_core::Result, i32>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Devices/Spi/Provider/mod.rs b/crates/libs/windows/src/Windows/Devices/Spi/Provider/mod.rs index 951411ee41..1f37ec7589 100644 --- a/crates/libs/windows/src/Windows/Devices/Spi/Provider/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/Spi/Provider/mod.rs @@ -212,7 +212,7 @@ impl windows_core::RuntimeType for ISpiProvider { } windows_core::imp::interface_hierarchy!(ISpiProvider, windows_core::IUnknown, windows_core::IInspectable); impl ISpiProvider { - pub fn GetControllersAsync(&self) -> windows_core::Result>> { + pub fn GetControllersAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -224,7 +224,7 @@ impl windows_core::RuntimeName for ISpiProvider { const NAME: &'static str = "Windows.Devices.Spi.Provider.ISpiProvider"; } pub trait ISpiProvider_Impl: windows_core::IUnknownImpl { - fn GetControllersAsync(&self) -> windows_core::Result>>; + fn GetControllersAsync(&self) -> windows_core::Result>>; } impl ISpiProvider_Vtbl { pub const fn new() -> Self { diff --git a/crates/libs/windows/src/Windows/Devices/Spi/mod.rs b/crates/libs/windows/src/Windows/Devices/Spi/mod.rs index 796bde9204..0565deef2d 100644 --- a/crates/libs/windows/src/Windows/Devices/Spi/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/Spi/mod.rs @@ -102,7 +102,7 @@ impl ISpiDeviceStatics { (windows_core::Interface::vtable(this).GetBusInfo)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(busid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FromIdAsync(&self, busid: &windows_core::HSTRING, settings: P1) -> windows_core::Result> + pub fn FromIdAsync(&self, busid: &windows_core::HSTRING, settings: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -120,7 +120,7 @@ pub trait ISpiDeviceStatics_Impl: windows_core::IUnknownImpl { fn GetDeviceSelector(&self) -> windows_core::Result; fn GetDeviceSelectorFromFriendlyName(&self, friendlyName: &windows_core::HSTRING) -> windows_core::Result; fn GetBusInfo(&self, busId: &windows_core::HSTRING) -> windows_core::Result; - fn FromIdAsync(&self, busId: &windows_core::HSTRING, settings: windows_core::Ref<'_, SpiConnectionSettings>) -> windows_core::Result>; + fn FromIdAsync(&self, busId: &windows_core::HSTRING, settings: windows_core::Ref<'_, SpiConnectionSettings>) -> windows_core::Result>; } impl ISpiDeviceStatics_Vtbl { pub const fn new() -> Self { @@ -340,14 +340,14 @@ impl SpiController { (windows_core::Interface::vtable(this).GetDevice)(windows_core::Interface::as_raw(this), settings.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetDefaultAsync() -> windows_core::Result> { + pub fn GetDefaultAsync() -> windows_core::Result> { Self::ISpiControllerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetDefaultAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "Devices_Spi_Provider")] - pub fn GetControllersAsync(provider: P0) -> windows_core::Result>> + pub fn GetControllersAsync(provider: P0) -> windows_core::Result>> where P0: windows_core::Param, { @@ -431,7 +431,7 @@ impl SpiDevice { (windows_core::Interface::vtable(this).GetBusInfo)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(busid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn FromIdAsync(busid: &windows_core::HSTRING, settings: P1) -> windows_core::Result> + pub fn FromIdAsync(busid: &windows_core::HSTRING, settings: P1) -> windows_core::Result> where P1: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Devices/Usb/mod.rs b/crates/libs/windows/src/Windows/Devices/Usb/mod.rs index 40c934e6c1..b0ce88e395 100644 --- a/crates/libs/windows/src/Windows/Devices/Usb/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/Usb/mod.rs @@ -438,7 +438,7 @@ impl UsbBulkInPipe { (windows_core::Interface::vtable(this).EndpointDescriptor)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ClearStallAsync(&self) -> windows_core::Result { + pub fn ClearStallAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -532,7 +532,7 @@ impl UsbBulkOutPipe { (windows_core::Interface::vtable(this).EndpointDescriptor)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ClearStallAsync(&self) -> windows_core::Result { + pub fn ClearStallAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -828,7 +828,7 @@ impl UsbDevice { unsafe { (windows_core::Interface::vtable(this).Close)(windows_core::Interface::as_raw(this)).ok() } } #[cfg(feature = "Storage_Streams")] - pub fn SendControlOutTransferAsync(&self, setuppacket: P0, buffer: P1) -> windows_core::Result> + pub fn SendControlOutTransferAsync(&self, setuppacket: P0, buffer: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -839,7 +839,7 @@ impl UsbDevice { (windows_core::Interface::vtable(this).SendControlOutTransferAsync)(windows_core::Interface::as_raw(this), setuppacket.param().abi(), buffer.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SendControlOutTransferAsyncNoBuffer(&self, setuppacket: P0) -> windows_core::Result> + pub fn SendControlOutTransferAsyncNoBuffer(&self, setuppacket: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -850,7 +850,7 @@ impl UsbDevice { } } #[cfg(feature = "Storage_Streams")] - pub fn SendControlInTransferAsync(&self, setuppacket: P0, buffer: P1) -> windows_core::Result> + pub fn SendControlInTransferAsync(&self, setuppacket: P0, buffer: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -862,7 +862,7 @@ impl UsbDevice { } } #[cfg(feature = "Storage_Streams")] - pub fn SendControlInTransferAsyncNoBuffer(&self, setuppacket: P0) -> windows_core::Result> + pub fn SendControlInTransferAsyncNoBuffer(&self, setuppacket: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -920,7 +920,7 @@ impl UsbDevice { (windows_core::Interface::vtable(this).GetDeviceClassSelector)(windows_core::Interface::as_raw(this), usbclass.param().abi(), &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IUsbDeviceStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -1429,7 +1429,7 @@ impl UsbInterfaceSetting { (windows_core::Interface::vtable(this).Selected)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn SelectSettingAsync(&self) -> windows_core::Result { + pub fn SelectSettingAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1547,7 +1547,7 @@ impl UsbInterruptInPipe { (windows_core::Interface::vtable(this).EndpointDescriptor)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ClearStallAsync(&self) -> windows_core::Result { + pub fn ClearStallAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1639,7 +1639,7 @@ impl UsbInterruptOutPipe { (windows_core::Interface::vtable(this).EndpointDescriptor)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ClearStallAsync(&self) -> windows_core::Result { + pub fn ClearStallAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Devices/WiFi/mod.rs b/crates/libs/windows/src/Windows/Devices/WiFi/mod.rs index db3d7f78f6..bc432dca7a 100644 --- a/crates/libs/windows/src/Windows/Devices/WiFi/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/WiFi/mod.rs @@ -197,7 +197,7 @@ impl WiFiAdapter { (windows_core::Interface::vtable(this).NetworkAdapter)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ScanAsync(&self) -> windows_core::Result { + pub fn ScanAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -225,7 +225,7 @@ impl WiFiAdapter { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveAvailableNetworksChanged)(windows_core::Interface::as_raw(this), eventcookie).ok() } } - pub fn ConnectAsync(&self, availablenetwork: P0, reconnectionkind: WiFiReconnectionKind) -> windows_core::Result> + pub fn ConnectAsync(&self, availablenetwork: P0, reconnectionkind: WiFiReconnectionKind) -> windows_core::Result> where P0: windows_core::Param, { @@ -236,7 +236,7 @@ impl WiFiAdapter { } } #[cfg(feature = "Security_Credentials")] - pub fn ConnectWithPasswordCredentialAsync(&self, availablenetwork: P0, reconnectionkind: WiFiReconnectionKind, passwordcredential: P2) -> windows_core::Result> + pub fn ConnectWithPasswordCredentialAsync(&self, availablenetwork: P0, reconnectionkind: WiFiReconnectionKind, passwordcredential: P2) -> windows_core::Result> where P0: windows_core::Param, P2: windows_core::Param, @@ -248,7 +248,7 @@ impl WiFiAdapter { } } #[cfg(feature = "Security_Credentials")] - pub fn ConnectWithPasswordCredentialAndSsidAsync(&self, availablenetwork: P0, reconnectionkind: WiFiReconnectionKind, passwordcredential: P2, ssid: &windows_core::HSTRING) -> windows_core::Result> + pub fn ConnectWithPasswordCredentialAndSsidAsync(&self, availablenetwork: P0, reconnectionkind: WiFiReconnectionKind, passwordcredential: P2, ssid: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, P2: windows_core::Param, @@ -263,7 +263,7 @@ impl WiFiAdapter { let this = self; unsafe { (windows_core::Interface::vtable(this).Disconnect)(windows_core::Interface::as_raw(this)).ok() } } - pub fn GetWpsConfigurationAsync(&self, availablenetwork: P0) -> windows_core::Result> + pub fn GetWpsConfigurationAsync(&self, availablenetwork: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -274,7 +274,7 @@ impl WiFiAdapter { } } #[cfg(feature = "Security_Credentials")] - pub fn ConnectWithPasswordCredentialAndSsidAndConnectionMethodAsync(&self, availablenetwork: P0, reconnectionkind: WiFiReconnectionKind, passwordcredential: P2, ssid: &windows_core::HSTRING, connectionmethod: WiFiConnectionMethod) -> windows_core::Result> + pub fn ConnectWithPasswordCredentialAndSsidAndConnectionMethodAsync(&self, availablenetwork: P0, reconnectionkind: WiFiReconnectionKind, passwordcredential: P2, ssid: &windows_core::HSTRING, connectionmethod: WiFiConnectionMethod) -> windows_core::Result> where P0: windows_core::Param, P2: windows_core::Param, @@ -285,7 +285,7 @@ impl WiFiAdapter { (windows_core::Interface::vtable(this).ConnectWithPasswordCredentialAndSsidAndConnectionMethodAsync)(windows_core::Interface::as_raw(this), availablenetwork.param().abi(), reconnectionkind, passwordcredential.param().abi(), core::mem::transmute_copy(ssid), connectionmethod, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FindAllAdaptersAsync() -> windows_core::Result>> { + pub fn FindAllAdaptersAsync() -> windows_core::Result>> { Self::IWiFiAdapterStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAllAdaptersAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -297,13 +297,13 @@ impl WiFiAdapter { (windows_core::Interface::vtable(this).GetDeviceSelector)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IWiFiAdapterStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RequestAccessAsync() -> windows_core::Result> { + pub fn RequestAccessAsync() -> windows_core::Result> { Self::IWiFiAdapterStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestAccessAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -601,7 +601,7 @@ impl WiFiOnDemandHotspotConnectTriggerDetails { let this = self; unsafe { (windows_core::Interface::vtable(this).ReportError)(windows_core::Interface::as_raw(this), status).ok() } } - pub fn ConnectAsync(&self) -> windows_core::Result> { + pub fn ConnectAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Devices/WiFiDirect/Services/mod.rs b/crates/libs/windows/src/Windows/Devices/WiFiDirect/Services/mod.rs index 8995ec9cb1..a0a34b6a04 100644 --- a/crates/libs/windows/src/Windows/Devices/WiFiDirect/Services/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/WiFiDirect/Services/mod.rs @@ -276,21 +276,21 @@ impl WiFiDirectService { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveSessionDeferred)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn GetProvisioningInfoAsync(&self, selectedconfigurationmethod: WiFiDirectServiceConfigurationMethod) -> windows_core::Result> { + pub fn GetProvisioningInfoAsync(&self, selectedconfigurationmethod: WiFiDirectServiceConfigurationMethod) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetProvisioningInfoAsync)(windows_core::Interface::as_raw(this), selectedconfigurationmethod, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ConnectAsync(&self) -> windows_core::Result> { + pub fn ConnectAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ConnectAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ConnectAsyncWithPin(&self, pin: &windows_core::HSTRING) -> windows_core::Result> { + pub fn ConnectAsyncWithPin(&self, pin: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -313,7 +313,7 @@ impl WiFiDirectService { (windows_core::Interface::vtable(this).GetSelectorWithFilter)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(servicename), serviceinfofilter.param().abi(), &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IWiFiDirectServiceStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -510,7 +510,7 @@ impl WiFiDirectServiceAdvertiser { unsafe { (windows_core::Interface::vtable(this).RemoveAdvertisementStatusChanged)(windows_core::Interface::as_raw(this), token).ok() } } #[cfg(feature = "Devices_Enumeration")] - pub fn ConnectAsync(&self, deviceinfo: P0) -> windows_core::Result> + pub fn ConnectAsync(&self, deviceinfo: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -521,7 +521,7 @@ impl WiFiDirectServiceAdvertiser { } } #[cfg(feature = "Devices_Enumeration")] - pub fn ConnectAsyncWithPin(&self, deviceinfo: P0, pin: &windows_core::HSTRING) -> windows_core::Result> + pub fn ConnectAsyncWithPin(&self, deviceinfo: P0, pin: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -785,7 +785,7 @@ impl WiFiDirectServiceSession { unsafe { (windows_core::Interface::vtable(this).RemoveSessionStatusChanged)(windows_core::Interface::as_raw(this), token).ok() } } #[cfg(feature = "Networking_Sockets")] - pub fn AddStreamSocketListenerAsync(&self, value: P0) -> windows_core::Result + pub fn AddStreamSocketListenerAsync(&self, value: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -796,7 +796,7 @@ impl WiFiDirectServiceSession { } } #[cfg(feature = "Networking_Sockets")] - pub fn AddDatagramSocketAsync(&self, value: P0) -> windows_core::Result + pub fn AddDatagramSocketAsync(&self, value: P0) -> windows_core::Result where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Devices/WiFiDirect/mod.rs b/crates/libs/windows/src/Windows/Devices/WiFiDirect/mod.rs index 34af38b91f..feba066bde 100644 --- a/crates/libs/windows/src/Windows/Devices/WiFiDirect/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/WiFiDirect/mod.rs @@ -651,7 +651,7 @@ impl WiFiDirectDevice { (windows_core::Interface::vtable(this).GetDeviceSelector)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IWiFiDirectDeviceStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -664,7 +664,7 @@ impl WiFiDirectDevice { }) } #[cfg(feature = "Devices_Enumeration")] - pub fn FromIdAsync2(deviceid: &windows_core::HSTRING, connectionparameters: P1) -> windows_core::Result> + pub fn FromIdAsync2(deviceid: &windows_core::HSTRING, connectionparameters: P1) -> windows_core::Result> where P1: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Embedded/DeviceLockdown/mod.rs b/crates/libs/windows/src/Windows/Embedded/DeviceLockdown/mod.rs index c01627c508..e66898d1d8 100644 --- a/crates/libs/windows/src/Windows/Embedded/DeviceLockdown/mod.rs +++ b/crates/libs/windows/src/Windows/Embedded/DeviceLockdown/mod.rs @@ -12,7 +12,7 @@ impl DeviceLockdownProfile { (windows_core::Interface::vtable(this).GetCurrentLockdownProfile)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) }) } - pub fn ApplyLockdownProfileAsync(profileid: windows_core::GUID) -> windows_core::Result { + pub fn ApplyLockdownProfileAsync(profileid: windows_core::GUID) -> windows_core::Result { Self::IDeviceLockdownProfileStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ApplyLockdownProfileAsync)(windows_core::Interface::as_raw(this), profileid, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/Foundation/Diagnostics/mod.rs b/crates/libs/windows/src/Windows/Foundation/Diagnostics/mod.rs index e3f838626a..8ec7d6fb39 100644 --- a/crates/libs/windows/src/Windows/Foundation/Diagnostics/mod.rs +++ b/crates/libs/windows/src/Windows/Foundation/Diagnostics/mod.rs @@ -3,7 +3,7 @@ impl AsyncCausalityTracer { pub fn TraceOperationCreation(tracelevel: CausalityTraceLevel, source: CausalitySource, platformid: windows_core::GUID, operationid: u64, operationname: &windows_core::HSTRING, relatedcontext: u64) -> windows_core::Result<()> { Self::IAsyncCausalityTracerStatics(|this| unsafe { (windows_core::Interface::vtable(this).TraceOperationCreation)(windows_core::Interface::as_raw(this), tracelevel, source, platformid, operationid, core::mem::transmute_copy(operationname), relatedcontext).ok() }) } - pub fn TraceOperationCompletion(tracelevel: CausalityTraceLevel, source: CausalitySource, platformid: windows_core::GUID, operationid: u64, status: super::AsyncStatus) -> windows_core::Result<()> { + pub fn TraceOperationCompletion(tracelevel: CausalityTraceLevel, source: CausalitySource, platformid: windows_core::GUID, operationid: u64, status: windows_async::AsyncStatus) -> windows_core::Result<()> { Self::IAsyncCausalityTracerStatics(|this| unsafe { (windows_core::Interface::vtable(this).TraceOperationCompletion)(windows_core::Interface::as_raw(this), tracelevel, source, platformid, operationid, status).ok() }) } pub fn TraceOperationRelation(tracelevel: CausalityTraceLevel, source: CausalitySource, platformid: windows_core::GUID, operationid: u64, relation: CausalityRelation) -> windows_core::Result<()> { @@ -119,7 +119,7 @@ impl ErrorDetails { (windows_core::Interface::vtable(this).HelpUri)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateFromHResultAsync(errorcode: i32) -> windows_core::Result> { + pub fn CreateFromHResultAsync(errorcode: i32) -> windows_core::Result> { Self::IErrorDetailsStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreateFromHResultAsync)(windows_core::Interface::as_raw(this), errorcode, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -230,7 +230,7 @@ impl FileLoggingSession { unsafe { (windows_core::Interface::vtable(this).RemoveLoggingChannel)(windows_core::Interface::as_raw(this), loggingchannel.param().abi()).ok() } } #[cfg(feature = "Storage_Streams")] - pub fn CloseAndSaveToFileAsync(&self) -> windows_core::Result> { + pub fn CloseAndSaveToFileAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -282,7 +282,7 @@ impl windows_core::RuntimeType for IAsyncCausalityTracerStatics { pub struct IAsyncCausalityTracerStatics_Vtbl { pub base__: windows_core::IInspectable_Vtbl, pub TraceOperationCreation: unsafe extern "system" fn(*mut core::ffi::c_void, CausalityTraceLevel, CausalitySource, windows_core::GUID, u64, *mut core::ffi::c_void, u64) -> windows_core::HRESULT, - pub TraceOperationCompletion: unsafe extern "system" fn(*mut core::ffi::c_void, CausalityTraceLevel, CausalitySource, windows_core::GUID, u64, super::AsyncStatus) -> windows_core::HRESULT, + pub TraceOperationCompletion: unsafe extern "system" fn(*mut core::ffi::c_void, CausalityTraceLevel, CausalitySource, windows_core::GUID, u64, windows_async::AsyncStatus) -> windows_core::HRESULT, pub TraceOperationRelation: unsafe extern "system" fn(*mut core::ffi::c_void, CausalityTraceLevel, CausalitySource, windows_core::GUID, u64, CausalityRelation) -> windows_core::HRESULT, pub TraceSynchronousWorkStart: unsafe extern "system" fn(*mut core::ffi::c_void, CausalityTraceLevel, CausalitySource, windows_core::GUID, u64, CausalitySynchronousWork) -> windows_core::HRESULT, pub TraceSynchronousWorkCompletion: unsafe extern "system" fn(*mut core::ffi::c_void, CausalityTraceLevel, CausalitySource, CausalitySynchronousWork) -> windows_core::HRESULT, @@ -406,7 +406,7 @@ impl IFileLoggingSession { unsafe { (windows_core::Interface::vtable(this).RemoveLoggingChannel)(windows_core::Interface::as_raw(this), loggingchannel.param().abi()).ok() } } #[cfg(feature = "Storage_Streams")] - pub fn CloseAndSaveToFileAsync(&self) -> windows_core::Result> { + pub fn CloseAndSaveToFileAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -442,7 +442,7 @@ pub trait IFileLoggingSession_Impl: super::IClosable_Impl { fn AddLoggingChannel(&self, loggingChannel: windows_core::Ref<'_, ILoggingChannel>) -> windows_core::Result<()>; fn AddLoggingChannelWithLevel(&self, loggingChannel: windows_core::Ref<'_, ILoggingChannel>, maxLevel: LoggingLevel) -> windows_core::Result<()>; fn RemoveLoggingChannel(&self, loggingChannel: windows_core::Ref<'_, ILoggingChannel>) -> windows_core::Result<()>; - fn CloseAndSaveToFileAsync(&self) -> windows_core::Result>; + fn CloseAndSaveToFileAsync(&self) -> windows_core::Result>; fn LogFileGenerated(&self, handler: windows_core::Ref<'_, super::TypedEventHandler>) -> windows_core::Result; fn RemoveLogFileGenerated(&self, token: i64) -> windows_core::Result<()>; } @@ -998,7 +998,7 @@ impl ILoggingSession { } } #[cfg(feature = "Storage_Streams")] - pub fn SaveToFileAsync(&self, folder: P0, filename: &windows_core::HSTRING) -> windows_core::Result> + pub fn SaveToFileAsync(&self, folder: P0, filename: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -1041,7 +1041,7 @@ impl windows_core::RuntimeName for ILoggingSession { #[cfg(feature = "Storage_Streams")] pub trait ILoggingSession_Impl: super::IClosable_Impl { fn Name(&self) -> windows_core::Result; - fn SaveToFileAsync(&self, folder: windows_core::Ref<'_, super::super::Storage::IStorageFolder>, fileName: &windows_core::HSTRING) -> windows_core::Result>; + fn SaveToFileAsync(&self, folder: windows_core::Ref<'_, super::super::Storage::IStorageFolder>, fileName: &windows_core::HSTRING) -> windows_core::Result>; fn AddLoggingChannel(&self, loggingChannel: windows_core::Ref<'_, ILoggingChannel>) -> windows_core::Result<()>; fn AddLoggingChannelWithLevel(&self, loggingChannel: windows_core::Ref<'_, ILoggingChannel>, maxLevel: LoggingLevel) -> windows_core::Result<()>; fn RemoveLoggingChannel(&self, loggingChannel: windows_core::Ref<'_, ILoggingChannel>) -> windows_core::Result<()>; @@ -2502,7 +2502,7 @@ impl LoggingSession { } } #[cfg(feature = "Storage_Streams")] - pub fn SaveToFileAsync(&self, folder: P0, filename: &windows_core::HSTRING) -> windows_core::Result> + pub fn SaveToFileAsync(&self, folder: P0, filename: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Foundation/mod.rs b/crates/libs/windows/src/Windows/Foundation/mod.rs index ddf3afef61..c7acf1ead5 100644 --- a/crates/libs/windows/src/Windows/Foundation/mod.rs +++ b/crates/libs/windows/src/Windows/Foundation/mod.rs @@ -6,218 +6,91 @@ pub mod Diagnostics; pub mod Metadata; #[cfg(feature = "Foundation_Numerics")] pub mod Numerics; -windows_core::imp::define_interface!(AsyncActionCompletedHandler, AsyncActionCompletedHandler_Vtbl, 0xa4ed5c81_76c9_40bd_8be6_b1d90fb20ae7); -impl windows_core::RuntimeType for AsyncActionCompletedHandler { - const SIGNATURE: windows_core::imp::ConstBuffer = windows_core::imp::ConstBuffer::for_interface::(); -} -impl AsyncActionCompletedHandler { - pub fn new, AsyncStatus) -> windows_core::Result<()> + Send + 'static>(invoke: F) -> Self { - let com = AsyncActionCompletedHandlerBox { vtable: &AsyncActionCompletedHandlerBox::::VTABLE, count: windows_core::imp::RefCount::new(1), invoke }; - unsafe { core::mem::transmute(windows_core::imp::Box::new(com)) } - } - pub fn Invoke(&self, asyncinfo: P0, asyncstatus: AsyncStatus) -> windows_core::Result<()> - where - P0: windows_core::Param, - { - let this = self; - unsafe { (windows_core::Interface::vtable(this).Invoke)(windows_core::Interface::as_raw(this), asyncinfo.param().abi(), asyncstatus).ok() } - } -} #[repr(C)] -pub struct AsyncActionCompletedHandler_Vtbl { - base__: windows_core::IUnknown_Vtbl, - Invoke: unsafe extern "system" fn(this: *mut core::ffi::c_void, asyncinfo: *mut core::ffi::c_void, asyncstatus: AsyncStatus) -> windows_core::HRESULT, +#[derive(Clone, Copy, Debug, Default, PartialEq)] +pub struct DateTime { + pub UniversalTime: i64, } -#[repr(C)] -struct AsyncActionCompletedHandlerBox, AsyncStatus) -> windows_core::Result<()> + Send + 'static> { - vtable: *const AsyncActionCompletedHandler_Vtbl, - invoke: F, - count: windows_core::imp::RefCount, +impl windows_core::TypeKind for DateTime { + type TypeKind = windows_core::CopyType; } -impl, AsyncStatus) -> windows_core::Result<()> + Send + 'static> AsyncActionCompletedHandlerBox { - const VTABLE: AsyncActionCompletedHandler_Vtbl = AsyncActionCompletedHandler_Vtbl { base__: windows_core::IUnknown_Vtbl { QueryInterface: Self::QueryInterface, AddRef: Self::AddRef, Release: Self::Release }, Invoke: Self::Invoke }; - unsafe extern "system" fn QueryInterface(this: *mut core::ffi::c_void, iid: *const windows_core::GUID, interface: *mut *mut core::ffi::c_void) -> windows_core::HRESULT { - unsafe { - let this = this as *mut *mut core::ffi::c_void as *mut Self; - if iid.is_null() || interface.is_null() { - return windows_core::HRESULT(-2147467261); - } - *interface = if *iid == ::IID || *iid == ::IID || *iid == ::IID { &mut (*this).vtable as *mut _ as _ } else { core::ptr::null_mut() }; - if (*interface).is_null() { - windows_core::HRESULT(-2147467262) - } else { - (*this).count.add_ref(); - windows_core::HRESULT(0) - } - } - } - unsafe extern "system" fn AddRef(this: *mut core::ffi::c_void) -> u32 { - unsafe { - let this = this as *mut *mut core::ffi::c_void as *mut Self; - (*this).count.add_ref() - } - } - unsafe extern "system" fn Release(this: *mut core::ffi::c_void) -> u32 { - unsafe { - let this = this as *mut *mut core::ffi::c_void as *mut Self; - let remaining = (*this).count.release(); - if remaining == 0 { - let _ = windows_core::imp::Box::from_raw(this); - } - remaining - } - } - unsafe extern "system" fn Invoke(this: *mut core::ffi::c_void, asyncinfo: *mut core::ffi::c_void, asyncstatus: AsyncStatus) -> windows_core::HRESULT { - unsafe { - let this = &mut *(this as *mut *mut core::ffi::c_void as *mut Self); - (this.invoke)(core::mem::transmute_copy(&asyncinfo), asyncstatus).into() - } - } +impl windows_core::RuntimeType for DateTime { + const SIGNATURE: windows_core::imp::ConstBuffer = windows_core::imp::ConstBuffer::from_slice(b"struct(Windows.Foundation.DateTime;i8)"); } #[repr(transparent)] #[derive(Clone, Debug, Eq, PartialEq)] -pub struct AsyncActionProgressHandler(windows_core::IUnknown, core::marker::PhantomData) -where - TProgress: windows_core::RuntimeType + 'static; -unsafe impl windows_core::Interface for AsyncActionProgressHandler { - type Vtable = AsyncActionProgressHandler_Vtbl; - const IID: windows_core::GUID = windows_core::GUID::from_signature(::SIGNATURE); -} -impl windows_core::RuntimeType for AsyncActionProgressHandler { - const SIGNATURE: windows_core::imp::ConstBuffer = windows_core::imp::ConstBuffer::new().push_slice(b"pinterface({6d844858-0cff-4590-ae89-95a5a5c8b4b8}").push_slice(b";").push_other(TProgress::SIGNATURE).push_slice(b")"); -} -impl AsyncActionProgressHandler { - pub fn new>, windows_core::Ref<'_, TProgress>) -> windows_core::Result<()> + Send + 'static>(invoke: F) -> Self { - let com = AsyncActionProgressHandlerBox { vtable: &AsyncActionProgressHandlerBox::::VTABLE, count: windows_core::imp::RefCount::new(1), invoke }; - unsafe { core::mem::transmute(windows_core::imp::Box::new(com)) } +pub struct Deferral(windows_core::IUnknown); +windows_core::imp::interface_hierarchy!(Deferral, windows_core::IUnknown, windows_core::IInspectable); +windows_core::imp::required_hierarchy!(Deferral, IClosable); +impl Deferral { + pub fn Close(&self) -> windows_core::Result<()> { + let this = &windows_core::Interface::cast::(self)?; + unsafe { (windows_core::Interface::vtable(this).Close)(windows_core::Interface::as_raw(this)).ok() } + } + pub fn Complete(&self) -> windows_core::Result<()> { + let this = self; + unsafe { (windows_core::Interface::vtable(this).Complete)(windows_core::Interface::as_raw(this)).ok() } } - pub fn Invoke(&self, asyncinfo: P0, progressinfo: P1) -> windows_core::Result<()> + pub fn Create(handler: P0) -> windows_core::Result where - P0: windows_core::Param>, - P1: windows_core::Param, + P0: windows_core::Param, { - let this = self; - unsafe { (windows_core::Interface::vtable(this).Invoke)(windows_core::Interface::as_raw(this), asyncinfo.param().abi(), progressinfo.param().abi()).ok() } + Self::IDeferralFactory(|this| unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(this).Create)(windows_core::Interface::as_raw(this), handler.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) + }) + } + fn IDeferralFactory windows_core::Result>(callback: F) -> windows_core::Result { + static SHARED: windows_core::imp::FactoryCache = windows_core::imp::FactoryCache::new(); + SHARED.call(callback) } } -#[repr(C)] -pub struct AsyncActionProgressHandler_Vtbl -where - TProgress: windows_core::RuntimeType + 'static, -{ - base__: windows_core::IUnknown_Vtbl, - Invoke: unsafe extern "system" fn(this: *mut core::ffi::c_void, asyncinfo: *mut core::ffi::c_void, progressinfo: windows_core::AbiType) -> windows_core::HRESULT, - TProgress: core::marker::PhantomData, -} -#[repr(C)] -struct AsyncActionProgressHandlerBox>, windows_core::Ref<'_, TProgress>) -> windows_core::Result<()> + Send + 'static> -where - TProgress: windows_core::RuntimeType + 'static, -{ - vtable: *const AsyncActionProgressHandler_Vtbl, - invoke: F, - count: windows_core::imp::RefCount, +impl windows_core::RuntimeType for Deferral { + const SIGNATURE: windows_core::imp::ConstBuffer = windows_core::imp::ConstBuffer::for_class::(); } -impl>, windows_core::Ref<'_, TProgress>) -> windows_core::Result<()> + Send + 'static> AsyncActionProgressHandlerBox { - const VTABLE: AsyncActionProgressHandler_Vtbl = AsyncActionProgressHandler_Vtbl:: { - base__: windows_core::IUnknown_Vtbl { QueryInterface: Self::QueryInterface, AddRef: Self::AddRef, Release: Self::Release }, - Invoke: Self::Invoke, - TProgress: core::marker::PhantomData::, - }; - unsafe extern "system" fn QueryInterface(this: *mut core::ffi::c_void, iid: *const windows_core::GUID, interface: *mut *mut core::ffi::c_void) -> windows_core::HRESULT { - unsafe { - let this = this as *mut *mut core::ffi::c_void as *mut Self; - if iid.is_null() || interface.is_null() { - return windows_core::HRESULT(-2147467261); - } - *interface = if *iid == as windows_core::Interface>::IID || *iid == ::IID || *iid == ::IID { &mut (*this).vtable as *mut _ as _ } else { core::ptr::null_mut() }; - if (*interface).is_null() { - windows_core::HRESULT(-2147467262) - } else { - (*this).count.add_ref(); - windows_core::HRESULT(0) - } - } - } - unsafe extern "system" fn AddRef(this: *mut core::ffi::c_void) -> u32 { - unsafe { - let this = this as *mut *mut core::ffi::c_void as *mut Self; - (*this).count.add_ref() - } - } - unsafe extern "system" fn Release(this: *mut core::ffi::c_void) -> u32 { - unsafe { - let this = this as *mut *mut core::ffi::c_void as *mut Self; - let remaining = (*this).count.release(); - if remaining == 0 { - let _ = windows_core::imp::Box::from_raw(this); - } - remaining - } - } - unsafe extern "system" fn Invoke(this: *mut core::ffi::c_void, asyncinfo: *mut core::ffi::c_void, progressinfo: windows_core::AbiType) -> windows_core::HRESULT { - unsafe { - let this = &mut *(this as *mut *mut core::ffi::c_void as *mut Self); - (this.invoke)(core::mem::transmute_copy(&asyncinfo), core::mem::transmute_copy(&progressinfo)).into() - } - } +unsafe impl windows_core::Interface for Deferral { + type Vtable = ::Vtable; + const IID: windows_core::GUID = ::IID; } -#[repr(transparent)] -#[derive(Clone, Debug, Eq, PartialEq)] -pub struct AsyncActionWithProgressCompletedHandler(windows_core::IUnknown, core::marker::PhantomData) -where - TProgress: windows_core::RuntimeType + 'static; -unsafe impl windows_core::Interface for AsyncActionWithProgressCompletedHandler { - type Vtable = AsyncActionWithProgressCompletedHandler_Vtbl; - const IID: windows_core::GUID = windows_core::GUID::from_signature(::SIGNATURE); +impl windows_core::RuntimeName for Deferral { + const NAME: &'static str = "Windows.Foundation.Deferral"; } -impl windows_core::RuntimeType for AsyncActionWithProgressCompletedHandler { - const SIGNATURE: windows_core::imp::ConstBuffer = windows_core::imp::ConstBuffer::new().push_slice(b"pinterface({9c029f91-cc84-44fd-ac26-0a6c4e555281}").push_slice(b";").push_other(TProgress::SIGNATURE).push_slice(b")"); +unsafe impl Send for Deferral {} +unsafe impl Sync for Deferral {} +windows_core::imp::define_interface!(DeferralCompletedHandler, DeferralCompletedHandler_Vtbl, 0xed32a372_f3c8_4faa_9cfb_470148da3888); +impl windows_core::RuntimeType for DeferralCompletedHandler { + const SIGNATURE: windows_core::imp::ConstBuffer = windows_core::imp::ConstBuffer::for_interface::(); } -impl AsyncActionWithProgressCompletedHandler { - pub fn new>, AsyncStatus) -> windows_core::Result<()> + Send + 'static>(invoke: F) -> Self { - let com = AsyncActionWithProgressCompletedHandlerBox { vtable: &AsyncActionWithProgressCompletedHandlerBox::::VTABLE, count: windows_core::imp::RefCount::new(1), invoke }; +impl DeferralCompletedHandler { + pub fn new windows_core::Result<()> + Send + 'static>(invoke: F) -> Self { + let com = DeferralCompletedHandlerBox { vtable: &DeferralCompletedHandlerBox::::VTABLE, count: windows_core::imp::RefCount::new(1), invoke }; unsafe { core::mem::transmute(windows_core::imp::Box::new(com)) } } - pub fn Invoke(&self, asyncinfo: P0, asyncstatus: AsyncStatus) -> windows_core::Result<()> - where - P0: windows_core::Param>, - { + pub fn Invoke(&self) -> windows_core::Result<()> { let this = self; - unsafe { (windows_core::Interface::vtable(this).Invoke)(windows_core::Interface::as_raw(this), asyncinfo.param().abi(), asyncstatus).ok() } + unsafe { (windows_core::Interface::vtable(this).Invoke)(windows_core::Interface::as_raw(this)).ok() } } } #[repr(C)] -pub struct AsyncActionWithProgressCompletedHandler_Vtbl -where - TProgress: windows_core::RuntimeType + 'static, -{ +pub struct DeferralCompletedHandler_Vtbl { base__: windows_core::IUnknown_Vtbl, - Invoke: unsafe extern "system" fn(this: *mut core::ffi::c_void, asyncinfo: *mut core::ffi::c_void, asyncstatus: AsyncStatus) -> windows_core::HRESULT, - TProgress: core::marker::PhantomData, + Invoke: unsafe extern "system" fn(this: *mut core::ffi::c_void) -> windows_core::HRESULT, } #[repr(C)] -struct AsyncActionWithProgressCompletedHandlerBox>, AsyncStatus) -> windows_core::Result<()> + Send + 'static> -where - TProgress: windows_core::RuntimeType + 'static, -{ - vtable: *const AsyncActionWithProgressCompletedHandler_Vtbl, +struct DeferralCompletedHandlerBox windows_core::Result<()> + Send + 'static> { + vtable: *const DeferralCompletedHandler_Vtbl, invoke: F, count: windows_core::imp::RefCount, } -impl>, AsyncStatus) -> windows_core::Result<()> + Send + 'static> AsyncActionWithProgressCompletedHandlerBox { - const VTABLE: AsyncActionWithProgressCompletedHandler_Vtbl = AsyncActionWithProgressCompletedHandler_Vtbl:: { - base__: windows_core::IUnknown_Vtbl { QueryInterface: Self::QueryInterface, AddRef: Self::AddRef, Release: Self::Release }, - Invoke: Self::Invoke, - TProgress: core::marker::PhantomData::, - }; +impl windows_core::Result<()> + Send + 'static> DeferralCompletedHandlerBox { + const VTABLE: DeferralCompletedHandler_Vtbl = DeferralCompletedHandler_Vtbl { base__: windows_core::IUnknown_Vtbl { QueryInterface: Self::QueryInterface, AddRef: Self::AddRef, Release: Self::Release }, Invoke: Self::Invoke }; unsafe extern "system" fn QueryInterface(this: *mut core::ffi::c_void, iid: *const windows_core::GUID, interface: *mut *mut core::ffi::c_void) -> windows_core::HRESULT { unsafe { let this = this as *mut *mut core::ffi::c_void as *mut Self; if iid.is_null() || interface.is_null() { return windows_core::HRESULT(-2147467261); } - *interface = if *iid == as windows_core::Interface>::IID || *iid == ::IID || *iid == ::IID { &mut (*this).vtable as *mut _ as _ } else { core::ptr::null_mut() }; + *interface = if *iid == ::IID || *iid == ::IID || *iid == ::IID { &mut (*this).vtable as *mut _ as _ } else { core::ptr::null_mut() }; if (*interface).is_null() { windows_core::HRESULT(-2147467262) } else { @@ -242,61 +115,62 @@ impl windows_core::HRESULT { + unsafe extern "system" fn Invoke(this: *mut core::ffi::c_void) -> windows_core::HRESULT { unsafe { let this = &mut *(this as *mut *mut core::ffi::c_void as *mut Self); - (this.invoke)(core::mem::transmute_copy(&asyncinfo), asyncstatus).into() + (this.invoke)().into() } } } #[repr(transparent)] #[derive(Clone, Debug, Eq, PartialEq)] -pub struct AsyncOperationCompletedHandler(windows_core::IUnknown, core::marker::PhantomData) +pub struct EventHandler(windows_core::IUnknown, core::marker::PhantomData) where - TResult: windows_core::RuntimeType + 'static; -unsafe impl windows_core::Interface for AsyncOperationCompletedHandler { - type Vtable = AsyncOperationCompletedHandler_Vtbl; + T: windows_core::RuntimeType + 'static; +unsafe impl windows_core::Interface for EventHandler { + type Vtable = EventHandler_Vtbl; const IID: windows_core::GUID = windows_core::GUID::from_signature(::SIGNATURE); } -impl windows_core::RuntimeType for AsyncOperationCompletedHandler { - const SIGNATURE: windows_core::imp::ConstBuffer = windows_core::imp::ConstBuffer::new().push_slice(b"pinterface({fcdcf02c-e5d8-4478-915a-4d90b74b83a5}").push_slice(b";").push_other(TResult::SIGNATURE).push_slice(b")"); +impl windows_core::RuntimeType for EventHandler { + const SIGNATURE: windows_core::imp::ConstBuffer = windows_core::imp::ConstBuffer::new().push_slice(b"pinterface({9de1c535-6ae1-11e0-84e1-18a905bcc53f}").push_slice(b";").push_other(T::SIGNATURE).push_slice(b")"); } -impl AsyncOperationCompletedHandler { - pub fn new>, AsyncStatus) -> windows_core::Result<()> + Send + 'static>(invoke: F) -> Self { - let com = AsyncOperationCompletedHandlerBox { vtable: &AsyncOperationCompletedHandlerBox::::VTABLE, count: windows_core::imp::RefCount::new(1), invoke }; +impl EventHandler { + pub fn new, windows_core::Ref<'_, T>) -> windows_core::Result<()> + Send + 'static>(invoke: F) -> Self { + let com = EventHandlerBox { vtable: &EventHandlerBox::::VTABLE, count: windows_core::imp::RefCount::new(1), invoke }; unsafe { core::mem::transmute(windows_core::imp::Box::new(com)) } } - pub fn Invoke(&self, asyncinfo: P0, asyncstatus: AsyncStatus) -> windows_core::Result<()> + pub fn Invoke(&self, sender: P0, args: P1) -> windows_core::Result<()> where - P0: windows_core::Param>, + P0: windows_core::Param, + P1: windows_core::Param, { let this = self; - unsafe { (windows_core::Interface::vtable(this).Invoke)(windows_core::Interface::as_raw(this), asyncinfo.param().abi(), asyncstatus).ok() } + unsafe { (windows_core::Interface::vtable(this).Invoke)(windows_core::Interface::as_raw(this), sender.param().abi(), args.param().abi()).ok() } } } #[repr(C)] -pub struct AsyncOperationCompletedHandler_Vtbl +pub struct EventHandler_Vtbl where - TResult: windows_core::RuntimeType + 'static, + T: windows_core::RuntimeType + 'static, { base__: windows_core::IUnknown_Vtbl, - Invoke: unsafe extern "system" fn(this: *mut core::ffi::c_void, asyncinfo: *mut core::ffi::c_void, asyncstatus: AsyncStatus) -> windows_core::HRESULT, - TResult: core::marker::PhantomData, + Invoke: unsafe extern "system" fn(this: *mut core::ffi::c_void, sender: *mut core::ffi::c_void, args: windows_core::AbiType) -> windows_core::HRESULT, + T: core::marker::PhantomData, } #[repr(C)] -struct AsyncOperationCompletedHandlerBox>, AsyncStatus) -> windows_core::Result<()> + Send + 'static> +struct EventHandlerBox, windows_core::Ref<'_, T>) -> windows_core::Result<()> + Send + 'static> where - TResult: windows_core::RuntimeType + 'static, + T: windows_core::RuntimeType + 'static, { - vtable: *const AsyncOperationCompletedHandler_Vtbl, + vtable: *const EventHandler_Vtbl, invoke: F, count: windows_core::imp::RefCount, } -impl>, AsyncStatus) -> windows_core::Result<()> + Send + 'static> AsyncOperationCompletedHandlerBox { - const VTABLE: AsyncOperationCompletedHandler_Vtbl = AsyncOperationCompletedHandler_Vtbl:: { +impl, windows_core::Ref<'_, T>) -> windows_core::Result<()> + Send + 'static> EventHandlerBox { + const VTABLE: EventHandler_Vtbl = EventHandler_Vtbl:: { base__: windows_core::IUnknown_Vtbl { QueryInterface: Self::QueryInterface, AddRef: Self::AddRef, Release: Self::Release }, Invoke: Self::Invoke, - TResult: core::marker::PhantomData::, + T: core::marker::PhantomData::, }; unsafe extern "system" fn QueryInterface(this: *mut core::ffi::c_void, iid: *const windows_core::GUID, interface: *mut *mut core::ffi::c_void) -> windows_core::HRESULT { unsafe { @@ -304,7 +178,7 @@ impl as windows_core::Interface>::IID || *iid == ::IID || *iid == ::IID { &mut (*this).vtable as *mut _ as _ } else { core::ptr::null_mut() }; + *interface = if *iid == as windows_core::Interface>::IID || *iid == ::IID || *iid == ::IID { &mut (*this).vtable as *mut _ as _ } else { core::ptr::null_mut() }; if (*interface).is_null() { windows_core::HRESULT(-2147467262) } else { @@ -329,1162 +203,40 @@ impl windows_core::HRESULT { + unsafe extern "system" fn Invoke(this: *mut core::ffi::c_void, sender: *mut core::ffi::c_void, args: windows_core::AbiType) -> windows_core::HRESULT { unsafe { let this = &mut *(this as *mut *mut core::ffi::c_void as *mut Self); - (this.invoke)(core::mem::transmute_copy(&asyncinfo), asyncstatus).into() + (this.invoke)(core::mem::transmute_copy(&sender), core::mem::transmute_copy(&args)).into() } } } -#[repr(transparent)] -#[derive(Clone, Debug, Eq, PartialEq)] -pub struct AsyncOperationProgressHandler(windows_core::IUnknown, core::marker::PhantomData, core::marker::PhantomData) -where - TResult: windows_core::RuntimeType + 'static, - TProgress: windows_core::RuntimeType + 'static; -unsafe impl windows_core::Interface for AsyncOperationProgressHandler { - type Vtable = AsyncOperationProgressHandler_Vtbl; - const IID: windows_core::GUID = windows_core::GUID::from_signature(::SIGNATURE); -} -impl windows_core::RuntimeType for AsyncOperationProgressHandler { - const SIGNATURE: windows_core::imp::ConstBuffer = windows_core::imp::ConstBuffer::new().push_slice(b"pinterface({55690902-0aab-421a-8778-f8ce5026d758}").push_slice(b";").push_other(TResult::SIGNATURE).push_slice(b";").push_other(TProgress::SIGNATURE).push_slice(b")"); -} -impl AsyncOperationProgressHandler { - pub fn new>, windows_core::Ref<'_, TProgress>) -> windows_core::Result<()> + Send + 'static>(invoke: F) -> Self { - let com = AsyncOperationProgressHandlerBox { vtable: &AsyncOperationProgressHandlerBox::::VTABLE, count: windows_core::imp::RefCount::new(1), invoke }; - unsafe { core::mem::transmute(windows_core::imp::Box::new(com)) } +pub struct GuidHelper; +impl GuidHelper { + pub fn CreateNewGuid() -> windows_core::Result { + Self::IGuidHelperStatics(|this| unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(this).CreateNewGuid)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) + }) } - pub fn Invoke(&self, asyncinfo: P0, progressinfo: P1) -> windows_core::Result<()> - where - P0: windows_core::Param>, - P1: windows_core::Param, - { - let this = self; - unsafe { (windows_core::Interface::vtable(this).Invoke)(windows_core::Interface::as_raw(this), asyncinfo.param().abi(), progressinfo.param().abi()).ok() } + pub fn Empty() -> windows_core::Result { + Self::IGuidHelperStatics(|this| unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(this).Empty)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) + }) + } + pub fn Equals(target: windows_core::GUID, value: windows_core::GUID) -> windows_core::Result { + Self::IGuidHelperStatics(|this| unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(this).Equals)(windows_core::Interface::as_raw(this), &target, &value, &mut result__).map(|| result__) + }) + } + fn IGuidHelperStatics windows_core::Result>(callback: F) -> windows_core::Result { + static SHARED: windows_core::imp::FactoryCache = windows_core::imp::FactoryCache::new(); + SHARED.call(callback) } } -#[repr(C)] -pub struct AsyncOperationProgressHandler_Vtbl -where - TResult: windows_core::RuntimeType + 'static, - TProgress: windows_core::RuntimeType + 'static, -{ - base__: windows_core::IUnknown_Vtbl, - Invoke: unsafe extern "system" fn(this: *mut core::ffi::c_void, asyncinfo: *mut core::ffi::c_void, progressinfo: windows_core::AbiType) -> windows_core::HRESULT, - TResult: core::marker::PhantomData, - TProgress: core::marker::PhantomData, -} -#[repr(C)] -struct AsyncOperationProgressHandlerBox>, windows_core::Ref<'_, TProgress>) -> windows_core::Result<()> + Send + 'static> -where - TResult: windows_core::RuntimeType + 'static, - TProgress: windows_core::RuntimeType + 'static, -{ - vtable: *const AsyncOperationProgressHandler_Vtbl, - invoke: F, - count: windows_core::imp::RefCount, -} -impl>, windows_core::Ref<'_, TProgress>) -> windows_core::Result<()> + Send + 'static> AsyncOperationProgressHandlerBox { - const VTABLE: AsyncOperationProgressHandler_Vtbl = AsyncOperationProgressHandler_Vtbl:: { - base__: windows_core::IUnknown_Vtbl { QueryInterface: Self::QueryInterface, AddRef: Self::AddRef, Release: Self::Release }, - Invoke: Self::Invoke, - TResult: core::marker::PhantomData::, - TProgress: core::marker::PhantomData::, - }; - unsafe extern "system" fn QueryInterface(this: *mut core::ffi::c_void, iid: *const windows_core::GUID, interface: *mut *mut core::ffi::c_void) -> windows_core::HRESULT { - unsafe { - let this = this as *mut *mut core::ffi::c_void as *mut Self; - if iid.is_null() || interface.is_null() { - return windows_core::HRESULT(-2147467261); - } - *interface = if *iid == as windows_core::Interface>::IID || *iid == ::IID || *iid == ::IID { &mut (*this).vtable as *mut _ as _ } else { core::ptr::null_mut() }; - if (*interface).is_null() { - windows_core::HRESULT(-2147467262) - } else { - (*this).count.add_ref(); - windows_core::HRESULT(0) - } - } - } - unsafe extern "system" fn AddRef(this: *mut core::ffi::c_void) -> u32 { - unsafe { - let this = this as *mut *mut core::ffi::c_void as *mut Self; - (*this).count.add_ref() - } - } - unsafe extern "system" fn Release(this: *mut core::ffi::c_void) -> u32 { - unsafe { - let this = this as *mut *mut core::ffi::c_void as *mut Self; - let remaining = (*this).count.release(); - if remaining == 0 { - let _ = windows_core::imp::Box::from_raw(this); - } - remaining - } - } - unsafe extern "system" fn Invoke(this: *mut core::ffi::c_void, asyncinfo: *mut core::ffi::c_void, progressinfo: windows_core::AbiType) -> windows_core::HRESULT { - unsafe { - let this = &mut *(this as *mut *mut core::ffi::c_void as *mut Self); - (this.invoke)(core::mem::transmute_copy(&asyncinfo), core::mem::transmute_copy(&progressinfo)).into() - } - } -} -#[repr(transparent)] -#[derive(Clone, Debug, Eq, PartialEq)] -pub struct AsyncOperationWithProgressCompletedHandler(windows_core::IUnknown, core::marker::PhantomData, core::marker::PhantomData) -where - TResult: windows_core::RuntimeType + 'static, - TProgress: windows_core::RuntimeType + 'static; -unsafe impl windows_core::Interface for AsyncOperationWithProgressCompletedHandler { - type Vtable = AsyncOperationWithProgressCompletedHandler_Vtbl; - const IID: windows_core::GUID = windows_core::GUID::from_signature(::SIGNATURE); -} -impl windows_core::RuntimeType for AsyncOperationWithProgressCompletedHandler { - const SIGNATURE: windows_core::imp::ConstBuffer = windows_core::imp::ConstBuffer::new().push_slice(b"pinterface({e85df41d-6aa7-46e3-a8e2-f009d840c627}").push_slice(b";").push_other(TResult::SIGNATURE).push_slice(b";").push_other(TProgress::SIGNATURE).push_slice(b")"); -} -impl AsyncOperationWithProgressCompletedHandler { - pub fn new>, AsyncStatus) -> windows_core::Result<()> + Send + 'static>(invoke: F) -> Self { - let com = AsyncOperationWithProgressCompletedHandlerBox { vtable: &AsyncOperationWithProgressCompletedHandlerBox::::VTABLE, count: windows_core::imp::RefCount::new(1), invoke }; - unsafe { core::mem::transmute(windows_core::imp::Box::new(com)) } - } - pub fn Invoke(&self, asyncinfo: P0, asyncstatus: AsyncStatus) -> windows_core::Result<()> - where - P0: windows_core::Param>, - { - let this = self; - unsafe { (windows_core::Interface::vtable(this).Invoke)(windows_core::Interface::as_raw(this), asyncinfo.param().abi(), asyncstatus).ok() } - } -} -#[repr(C)] -pub struct AsyncOperationWithProgressCompletedHandler_Vtbl -where - TResult: windows_core::RuntimeType + 'static, - TProgress: windows_core::RuntimeType + 'static, -{ - base__: windows_core::IUnknown_Vtbl, - Invoke: unsafe extern "system" fn(this: *mut core::ffi::c_void, asyncinfo: *mut core::ffi::c_void, asyncstatus: AsyncStatus) -> windows_core::HRESULT, - TResult: core::marker::PhantomData, - TProgress: core::marker::PhantomData, -} -#[repr(C)] -struct AsyncOperationWithProgressCompletedHandlerBox>, AsyncStatus) -> windows_core::Result<()> + Send + 'static> -where - TResult: windows_core::RuntimeType + 'static, - TProgress: windows_core::RuntimeType + 'static, -{ - vtable: *const AsyncOperationWithProgressCompletedHandler_Vtbl, - invoke: F, - count: windows_core::imp::RefCount, -} -impl>, AsyncStatus) -> windows_core::Result<()> + Send + 'static> AsyncOperationWithProgressCompletedHandlerBox { - const VTABLE: AsyncOperationWithProgressCompletedHandler_Vtbl = AsyncOperationWithProgressCompletedHandler_Vtbl:: { - base__: windows_core::IUnknown_Vtbl { QueryInterface: Self::QueryInterface, AddRef: Self::AddRef, Release: Self::Release }, - Invoke: Self::Invoke, - TResult: core::marker::PhantomData::, - TProgress: core::marker::PhantomData::, - }; - unsafe extern "system" fn QueryInterface(this: *mut core::ffi::c_void, iid: *const windows_core::GUID, interface: *mut *mut core::ffi::c_void) -> windows_core::HRESULT { - unsafe { - let this = this as *mut *mut core::ffi::c_void as *mut Self; - if iid.is_null() || interface.is_null() { - return windows_core::HRESULT(-2147467261); - } - *interface = if *iid == as windows_core::Interface>::IID || *iid == ::IID || *iid == ::IID { &mut (*this).vtable as *mut _ as _ } else { core::ptr::null_mut() }; - if (*interface).is_null() { - windows_core::HRESULT(-2147467262) - } else { - (*this).count.add_ref(); - windows_core::HRESULT(0) - } - } - } - unsafe extern "system" fn AddRef(this: *mut core::ffi::c_void) -> u32 { - unsafe { - let this = this as *mut *mut core::ffi::c_void as *mut Self; - (*this).count.add_ref() - } - } - unsafe extern "system" fn Release(this: *mut core::ffi::c_void) -> u32 { - unsafe { - let this = this as *mut *mut core::ffi::c_void as *mut Self; - let remaining = (*this).count.release(); - if remaining == 0 { - let _ = windows_core::imp::Box::from_raw(this); - } - remaining - } - } - unsafe extern "system" fn Invoke(this: *mut core::ffi::c_void, asyncinfo: *mut core::ffi::c_void, asyncstatus: AsyncStatus) -> windows_core::HRESULT { - unsafe { - let this = &mut *(this as *mut *mut core::ffi::c_void as *mut Self); - (this.invoke)(core::mem::transmute_copy(&asyncinfo), asyncstatus).into() - } - } -} -#[repr(transparent)] -#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)] -pub struct AsyncStatus(pub i32); -impl AsyncStatus { - pub const Canceled: Self = Self(2i32); - pub const Completed: Self = Self(1i32); - pub const Error: Self = Self(3i32); - pub const Started: Self = Self(0i32); -} -impl windows_core::TypeKind for AsyncStatus { - type TypeKind = windows_core::CopyType; -} -impl windows_core::RuntimeType for AsyncStatus { - const SIGNATURE: windows_core::imp::ConstBuffer = windows_core::imp::ConstBuffer::from_slice(b"enum(Windows.Foundation.AsyncStatus;i4)"); -} -#[repr(C)] -#[derive(Clone, Copy, Debug, Default, PartialEq)] -pub struct DateTime { - pub UniversalTime: i64, -} -impl windows_core::TypeKind for DateTime { - type TypeKind = windows_core::CopyType; -} -impl windows_core::RuntimeType for DateTime { - const SIGNATURE: windows_core::imp::ConstBuffer = windows_core::imp::ConstBuffer::from_slice(b"struct(Windows.Foundation.DateTime;i8)"); -} -#[repr(transparent)] -#[derive(Clone, Debug, Eq, PartialEq)] -pub struct Deferral(windows_core::IUnknown); -windows_core::imp::interface_hierarchy!(Deferral, windows_core::IUnknown, windows_core::IInspectable); -windows_core::imp::required_hierarchy!(Deferral, IClosable); -impl Deferral { - pub fn Close(&self) -> windows_core::Result<()> { - let this = &windows_core::Interface::cast::(self)?; - unsafe { (windows_core::Interface::vtable(this).Close)(windows_core::Interface::as_raw(this)).ok() } - } - pub fn Complete(&self) -> windows_core::Result<()> { - let this = self; - unsafe { (windows_core::Interface::vtable(this).Complete)(windows_core::Interface::as_raw(this)).ok() } - } - pub fn Create(handler: P0) -> windows_core::Result - where - P0: windows_core::Param, - { - Self::IDeferralFactory(|this| unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).Create)(windows_core::Interface::as_raw(this), handler.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) - }) - } - fn IDeferralFactory windows_core::Result>(callback: F) -> windows_core::Result { - static SHARED: windows_core::imp::FactoryCache = windows_core::imp::FactoryCache::new(); - SHARED.call(callback) - } -} -impl windows_core::RuntimeType for Deferral { - const SIGNATURE: windows_core::imp::ConstBuffer = windows_core::imp::ConstBuffer::for_class::(); -} -unsafe impl windows_core::Interface for Deferral { - type Vtable = ::Vtable; - const IID: windows_core::GUID = ::IID; -} -impl windows_core::RuntimeName for Deferral { - const NAME: &'static str = "Windows.Foundation.Deferral"; -} -unsafe impl Send for Deferral {} -unsafe impl Sync for Deferral {} -windows_core::imp::define_interface!(DeferralCompletedHandler, DeferralCompletedHandler_Vtbl, 0xed32a372_f3c8_4faa_9cfb_470148da3888); -impl windows_core::RuntimeType for DeferralCompletedHandler { - const SIGNATURE: windows_core::imp::ConstBuffer = windows_core::imp::ConstBuffer::for_interface::(); -} -impl DeferralCompletedHandler { - pub fn new windows_core::Result<()> + Send + 'static>(invoke: F) -> Self { - let com = DeferralCompletedHandlerBox { vtable: &DeferralCompletedHandlerBox::::VTABLE, count: windows_core::imp::RefCount::new(1), invoke }; - unsafe { core::mem::transmute(windows_core::imp::Box::new(com)) } - } - pub fn Invoke(&self) -> windows_core::Result<()> { - let this = self; - unsafe { (windows_core::Interface::vtable(this).Invoke)(windows_core::Interface::as_raw(this)).ok() } - } -} -#[repr(C)] -pub struct DeferralCompletedHandler_Vtbl { - base__: windows_core::IUnknown_Vtbl, - Invoke: unsafe extern "system" fn(this: *mut core::ffi::c_void) -> windows_core::HRESULT, -} -#[repr(C)] -struct DeferralCompletedHandlerBox windows_core::Result<()> + Send + 'static> { - vtable: *const DeferralCompletedHandler_Vtbl, - invoke: F, - count: windows_core::imp::RefCount, -} -impl windows_core::Result<()> + Send + 'static> DeferralCompletedHandlerBox { - const VTABLE: DeferralCompletedHandler_Vtbl = DeferralCompletedHandler_Vtbl { base__: windows_core::IUnknown_Vtbl { QueryInterface: Self::QueryInterface, AddRef: Self::AddRef, Release: Self::Release }, Invoke: Self::Invoke }; - unsafe extern "system" fn QueryInterface(this: *mut core::ffi::c_void, iid: *const windows_core::GUID, interface: *mut *mut core::ffi::c_void) -> windows_core::HRESULT { - unsafe { - let this = this as *mut *mut core::ffi::c_void as *mut Self; - if iid.is_null() || interface.is_null() { - return windows_core::HRESULT(-2147467261); - } - *interface = if *iid == ::IID || *iid == ::IID || *iid == ::IID { &mut (*this).vtable as *mut _ as _ } else { core::ptr::null_mut() }; - if (*interface).is_null() { - windows_core::HRESULT(-2147467262) - } else { - (*this).count.add_ref(); - windows_core::HRESULT(0) - } - } - } - unsafe extern "system" fn AddRef(this: *mut core::ffi::c_void) -> u32 { - unsafe { - let this = this as *mut *mut core::ffi::c_void as *mut Self; - (*this).count.add_ref() - } - } - unsafe extern "system" fn Release(this: *mut core::ffi::c_void) -> u32 { - unsafe { - let this = this as *mut *mut core::ffi::c_void as *mut Self; - let remaining = (*this).count.release(); - if remaining == 0 { - let _ = windows_core::imp::Box::from_raw(this); - } - remaining - } - } - unsafe extern "system" fn Invoke(this: *mut core::ffi::c_void) -> windows_core::HRESULT { - unsafe { - let this = &mut *(this as *mut *mut core::ffi::c_void as *mut Self); - (this.invoke)().into() - } - } -} -#[repr(transparent)] -#[derive(Clone, Debug, Eq, PartialEq)] -pub struct EventHandler(windows_core::IUnknown, core::marker::PhantomData) -where - T: windows_core::RuntimeType + 'static; -unsafe impl windows_core::Interface for EventHandler { - type Vtable = EventHandler_Vtbl; - const IID: windows_core::GUID = windows_core::GUID::from_signature(::SIGNATURE); -} -impl windows_core::RuntimeType for EventHandler { - const SIGNATURE: windows_core::imp::ConstBuffer = windows_core::imp::ConstBuffer::new().push_slice(b"pinterface({9de1c535-6ae1-11e0-84e1-18a905bcc53f}").push_slice(b";").push_other(T::SIGNATURE).push_slice(b")"); -} -impl EventHandler { - pub fn new, windows_core::Ref<'_, T>) -> windows_core::Result<()> + Send + 'static>(invoke: F) -> Self { - let com = EventHandlerBox { vtable: &EventHandlerBox::::VTABLE, count: windows_core::imp::RefCount::new(1), invoke }; - unsafe { core::mem::transmute(windows_core::imp::Box::new(com)) } - } - pub fn Invoke(&self, sender: P0, args: P1) -> windows_core::Result<()> - where - P0: windows_core::Param, - P1: windows_core::Param, - { - let this = self; - unsafe { (windows_core::Interface::vtable(this).Invoke)(windows_core::Interface::as_raw(this), sender.param().abi(), args.param().abi()).ok() } - } -} -#[repr(C)] -pub struct EventHandler_Vtbl -where - T: windows_core::RuntimeType + 'static, -{ - base__: windows_core::IUnknown_Vtbl, - Invoke: unsafe extern "system" fn(this: *mut core::ffi::c_void, sender: *mut core::ffi::c_void, args: windows_core::AbiType) -> windows_core::HRESULT, - T: core::marker::PhantomData, -} -#[repr(C)] -struct EventHandlerBox, windows_core::Ref<'_, T>) -> windows_core::Result<()> + Send + 'static> -where - T: windows_core::RuntimeType + 'static, -{ - vtable: *const EventHandler_Vtbl, - invoke: F, - count: windows_core::imp::RefCount, -} -impl, windows_core::Ref<'_, T>) -> windows_core::Result<()> + Send + 'static> EventHandlerBox { - const VTABLE: EventHandler_Vtbl = EventHandler_Vtbl:: { - base__: windows_core::IUnknown_Vtbl { QueryInterface: Self::QueryInterface, AddRef: Self::AddRef, Release: Self::Release }, - Invoke: Self::Invoke, - T: core::marker::PhantomData::, - }; - unsafe extern "system" fn QueryInterface(this: *mut core::ffi::c_void, iid: *const windows_core::GUID, interface: *mut *mut core::ffi::c_void) -> windows_core::HRESULT { - unsafe { - let this = this as *mut *mut core::ffi::c_void as *mut Self; - if iid.is_null() || interface.is_null() { - return windows_core::HRESULT(-2147467261); - } - *interface = if *iid == as windows_core::Interface>::IID || *iid == ::IID || *iid == ::IID { &mut (*this).vtable as *mut _ as _ } else { core::ptr::null_mut() }; - if (*interface).is_null() { - windows_core::HRESULT(-2147467262) - } else { - (*this).count.add_ref(); - windows_core::HRESULT(0) - } - } - } - unsafe extern "system" fn AddRef(this: *mut core::ffi::c_void) -> u32 { - unsafe { - let this = this as *mut *mut core::ffi::c_void as *mut Self; - (*this).count.add_ref() - } - } - unsafe extern "system" fn Release(this: *mut core::ffi::c_void) -> u32 { - unsafe { - let this = this as *mut *mut core::ffi::c_void as *mut Self; - let remaining = (*this).count.release(); - if remaining == 0 { - let _ = windows_core::imp::Box::from_raw(this); - } - remaining - } - } - unsafe extern "system" fn Invoke(this: *mut core::ffi::c_void, sender: *mut core::ffi::c_void, args: windows_core::AbiType) -> windows_core::HRESULT { - unsafe { - let this = &mut *(this as *mut *mut core::ffi::c_void as *mut Self); - (this.invoke)(core::mem::transmute_copy(&sender), core::mem::transmute_copy(&args)).into() - } - } -} -pub struct GuidHelper; -impl GuidHelper { - pub fn CreateNewGuid() -> windows_core::Result { - Self::IGuidHelperStatics(|this| unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).CreateNewGuid)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) - }) - } - pub fn Empty() -> windows_core::Result { - Self::IGuidHelperStatics(|this| unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).Empty)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) - }) - } - pub fn Equals(target: windows_core::GUID, value: windows_core::GUID) -> windows_core::Result { - Self::IGuidHelperStatics(|this| unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).Equals)(windows_core::Interface::as_raw(this), &target, &value, &mut result__).map(|| result__) - }) - } - fn IGuidHelperStatics windows_core::Result>(callback: F) -> windows_core::Result { - static SHARED: windows_core::imp::FactoryCache = windows_core::imp::FactoryCache::new(); - SHARED.call(callback) - } -} -impl windows_core::RuntimeName for GuidHelper { - const NAME: &'static str = "Windows.Foundation.GuidHelper"; -} -windows_core::imp::define_interface!(IAsyncAction, IAsyncAction_Vtbl, 0x5a648006_843a_4da9_865b_9d26e5dfad7b); -impl windows_core::RuntimeType for IAsyncAction { - const SIGNATURE: windows_core::imp::ConstBuffer = windows_core::imp::ConstBuffer::for_interface::(); -} -windows_core::imp::interface_hierarchy!(IAsyncAction, windows_core::IUnknown, windows_core::IInspectable); -windows_core::imp::required_hierarchy!(IAsyncAction, IAsyncInfo); -impl IAsyncAction { - pub fn SetCompleted(&self, handler: P0) -> windows_core::Result<()> - where - P0: windows_core::Param, - { - let this = self; - unsafe { (windows_core::Interface::vtable(this).SetCompleted)(windows_core::Interface::as_raw(this), handler.param().abi()).ok() } - } - pub fn Completed(&self) -> windows_core::Result { - let this = self; - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).Completed)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) - } - } - pub fn GetResults(&self) -> windows_core::Result<()> { - let this = self; - unsafe { (windows_core::Interface::vtable(this).GetResults)(windows_core::Interface::as_raw(this)).ok() } - } - pub fn Id(&self) -> windows_core::Result { - let this = &windows_core::Interface::cast::(self)?; - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).Id)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) - } - } - pub fn Status(&self) -> windows_core::Result { - let this = &windows_core::Interface::cast::(self)?; - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).Status)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) - } - } - pub fn ErrorCode(&self) -> windows_core::Result { - let this = &windows_core::Interface::cast::(self)?; - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).ErrorCode)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) - } - } - pub fn Cancel(&self) -> windows_core::Result<()> { - let this = &windows_core::Interface::cast::(self)?; - unsafe { (windows_core::Interface::vtable(this).Cancel)(windows_core::Interface::as_raw(this)).ok() } - } - pub fn Close(&self) -> windows_core::Result<()> { - let this = &windows_core::Interface::cast::(self)?; - unsafe { (windows_core::Interface::vtable(this).Close)(windows_core::Interface::as_raw(this)).ok() } - } -} -unsafe impl Send for IAsyncAction {} -unsafe impl Sync for IAsyncAction {} -impl windows_core::RuntimeName for IAsyncAction { - const NAME: &'static str = "Windows.Foundation.IAsyncAction"; -} -pub trait IAsyncAction_Impl: IAsyncInfo_Impl { - fn SetCompleted(&self, handler: windows_core::Ref<'_, AsyncActionCompletedHandler>) -> windows_core::Result<()>; - fn Completed(&self) -> windows_core::Result; - fn GetResults(&self) -> windows_core::Result<()>; -} -impl IAsyncAction_Vtbl { - pub const fn new() -> Self { - unsafe extern "system" fn SetCompleted(this: *mut core::ffi::c_void, handler: *mut core::ffi::c_void) -> windows_core::HRESULT { - unsafe { - let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - IAsyncAction_Impl::SetCompleted(this, core::mem::transmute_copy(&handler)).into() - } - } - unsafe extern "system" fn Completed(this: *mut core::ffi::c_void, result__: *mut *mut core::ffi::c_void) -> windows_core::HRESULT { - unsafe { - let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IAsyncAction_Impl::Completed(this) { - Ok(ok__) => { - result__.write(core::mem::transmute_copy(&ok__)); - core::mem::forget(ok__); - windows_core::HRESULT(0) - } - Err(err) => err.into(), - } - } - } - unsafe extern "system" fn GetResults(this: *mut core::ffi::c_void) -> windows_core::HRESULT { - unsafe { - let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - IAsyncAction_Impl::GetResults(this).into() - } - } - Self { - base__: windows_core::IInspectable_Vtbl::new::(), - SetCompleted: SetCompleted::, - Completed: Completed::, - GetResults: GetResults::, - } - } - pub fn matches(iid: &windows_core::GUID) -> bool { - iid == &::IID - } -} -#[repr(C)] -pub struct IAsyncAction_Vtbl { - pub base__: windows_core::IInspectable_Vtbl, - pub SetCompleted: unsafe extern "system" fn(*mut core::ffi::c_void, *mut core::ffi::c_void) -> windows_core::HRESULT, - pub Completed: unsafe extern "system" fn(*mut core::ffi::c_void, *mut *mut core::ffi::c_void) -> windows_core::HRESULT, - pub GetResults: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT, -} -#[repr(transparent)] -#[derive(Clone, Debug, Eq, PartialEq)] -pub struct IAsyncActionWithProgress(windows_core::IUnknown, core::marker::PhantomData) -where - TProgress: windows_core::RuntimeType + 'static; -impl windows_core::imp::CanInto for IAsyncActionWithProgress {} -impl windows_core::imp::CanInto for IAsyncActionWithProgress {} -unsafe impl windows_core::Interface for IAsyncActionWithProgress { - type Vtable = IAsyncActionWithProgress_Vtbl; - const IID: windows_core::GUID = windows_core::GUID::from_signature(::SIGNATURE); -} -impl windows_core::RuntimeType for IAsyncActionWithProgress { - const SIGNATURE: windows_core::imp::ConstBuffer = windows_core::imp::ConstBuffer::new().push_slice(b"pinterface({1f6db258-e803-48a1-9546-eb7353398884}").push_slice(b";").push_other(TProgress::SIGNATURE).push_slice(b")"); -} -impl windows_core::imp::CanInto for IAsyncActionWithProgress { - const QUERY: bool = true; -} -impl IAsyncActionWithProgress { - pub fn SetProgress(&self, handler: P0) -> windows_core::Result<()> - where - P0: windows_core::Param>, - { - let this = self; - unsafe { (windows_core::Interface::vtable(this).SetProgress)(windows_core::Interface::as_raw(this), handler.param().abi()).ok() } - } - pub fn Progress(&self) -> windows_core::Result> { - let this = self; - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).Progress)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) - } - } - pub fn SetCompleted(&self, handler: P0) -> windows_core::Result<()> - where - P0: windows_core::Param>, - { - let this = self; - unsafe { (windows_core::Interface::vtable(this).SetCompleted)(windows_core::Interface::as_raw(this), handler.param().abi()).ok() } - } - pub fn Completed(&self) -> windows_core::Result> { - let this = self; - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).Completed)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) - } - } - pub fn GetResults(&self) -> windows_core::Result<()> { - let this = self; - unsafe { (windows_core::Interface::vtable(this).GetResults)(windows_core::Interface::as_raw(this)).ok() } - } - pub fn Id(&self) -> windows_core::Result { - let this = &windows_core::Interface::cast::(self)?; - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).Id)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) - } - } - pub fn Status(&self) -> windows_core::Result { - let this = &windows_core::Interface::cast::(self)?; - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).Status)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) - } - } - pub fn ErrorCode(&self) -> windows_core::Result { - let this = &windows_core::Interface::cast::(self)?; - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).ErrorCode)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) - } - } - pub fn Cancel(&self) -> windows_core::Result<()> { - let this = &windows_core::Interface::cast::(self)?; - unsafe { (windows_core::Interface::vtable(this).Cancel)(windows_core::Interface::as_raw(this)).ok() } - } - pub fn Close(&self) -> windows_core::Result<()> { - let this = &windows_core::Interface::cast::(self)?; - unsafe { (windows_core::Interface::vtable(this).Close)(windows_core::Interface::as_raw(this)).ok() } - } -} -unsafe impl Send for IAsyncActionWithProgress {} -unsafe impl Sync for IAsyncActionWithProgress {} -impl windows_core::RuntimeName for IAsyncActionWithProgress { - const NAME: &'static str = "Windows.Foundation.IAsyncActionWithProgress"; -} -pub trait IAsyncActionWithProgress_Impl: IAsyncInfo_Impl -where - TProgress: windows_core::RuntimeType + 'static, -{ - fn SetProgress(&self, handler: windows_core::Ref<'_, AsyncActionProgressHandler>) -> windows_core::Result<()>; - fn Progress(&self) -> windows_core::Result>; - fn SetCompleted(&self, handler: windows_core::Ref<'_, AsyncActionWithProgressCompletedHandler>) -> windows_core::Result<()>; - fn Completed(&self) -> windows_core::Result>; - fn GetResults(&self) -> windows_core::Result<()>; -} -impl IAsyncActionWithProgress_Vtbl { - pub const fn new, const OFFSET: isize>() -> Self { - unsafe extern "system" fn SetProgress, const OFFSET: isize>(this: *mut core::ffi::c_void, handler: *mut core::ffi::c_void) -> windows_core::HRESULT { - unsafe { - let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - IAsyncActionWithProgress_Impl::SetProgress(this, core::mem::transmute_copy(&handler)).into() - } - } - unsafe extern "system" fn Progress, const OFFSET: isize>(this: *mut core::ffi::c_void, result__: *mut *mut core::ffi::c_void) -> windows_core::HRESULT { - unsafe { - let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IAsyncActionWithProgress_Impl::Progress(this) { - Ok(ok__) => { - result__.write(core::mem::transmute_copy(&ok__)); - core::mem::forget(ok__); - windows_core::HRESULT(0) - } - Err(err) => err.into(), - } - } - } - unsafe extern "system" fn SetCompleted, const OFFSET: isize>(this: *mut core::ffi::c_void, handler: *mut core::ffi::c_void) -> windows_core::HRESULT { - unsafe { - let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - IAsyncActionWithProgress_Impl::SetCompleted(this, core::mem::transmute_copy(&handler)).into() - } - } - unsafe extern "system" fn Completed, const OFFSET: isize>(this: *mut core::ffi::c_void, result__: *mut *mut core::ffi::c_void) -> windows_core::HRESULT { - unsafe { - let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IAsyncActionWithProgress_Impl::Completed(this) { - Ok(ok__) => { - result__.write(core::mem::transmute_copy(&ok__)); - core::mem::forget(ok__); - windows_core::HRESULT(0) - } - Err(err) => err.into(), - } - } - } - unsafe extern "system" fn GetResults, const OFFSET: isize>(this: *mut core::ffi::c_void) -> windows_core::HRESULT { - unsafe { - let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - IAsyncActionWithProgress_Impl::GetResults(this).into() - } - } - Self { - base__: windows_core::IInspectable_Vtbl::new::, OFFSET>(), - SetProgress: SetProgress::, - Progress: Progress::, - SetCompleted: SetCompleted::, - Completed: Completed::, - GetResults: GetResults::, - TProgress: core::marker::PhantomData::, - } - } - pub fn matches(iid: &windows_core::GUID) -> bool { - iid == & as windows_core::Interface>::IID - } -} -#[repr(C)] -pub struct IAsyncActionWithProgress_Vtbl -where - TProgress: windows_core::RuntimeType + 'static, -{ - pub base__: windows_core::IInspectable_Vtbl, - pub SetProgress: unsafe extern "system" fn(*mut core::ffi::c_void, *mut core::ffi::c_void) -> windows_core::HRESULT, - pub Progress: unsafe extern "system" fn(*mut core::ffi::c_void, *mut *mut core::ffi::c_void) -> windows_core::HRESULT, - pub SetCompleted: unsafe extern "system" fn(*mut core::ffi::c_void, *mut core::ffi::c_void) -> windows_core::HRESULT, - pub Completed: unsafe extern "system" fn(*mut core::ffi::c_void, *mut *mut core::ffi::c_void) -> windows_core::HRESULT, - pub GetResults: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT, - TProgress: core::marker::PhantomData, -} -windows_core::imp::define_interface!(IAsyncInfo, IAsyncInfo_Vtbl, 0x00000036_0000_0000_c000_000000000046); -impl windows_core::RuntimeType for IAsyncInfo { - const SIGNATURE: windows_core::imp::ConstBuffer = windows_core::imp::ConstBuffer::for_interface::(); -} -windows_core::imp::interface_hierarchy!(IAsyncInfo, windows_core::IUnknown, windows_core::IInspectable); -impl IAsyncInfo { - pub fn Id(&self) -> windows_core::Result { - let this = self; - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).Id)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) - } - } - pub fn Status(&self) -> windows_core::Result { - let this = self; - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).Status)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) - } - } - pub fn ErrorCode(&self) -> windows_core::Result { - let this = self; - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).ErrorCode)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) - } - } - pub fn Cancel(&self) -> windows_core::Result<()> { - let this = self; - unsafe { (windows_core::Interface::vtable(this).Cancel)(windows_core::Interface::as_raw(this)).ok() } - } - pub fn Close(&self) -> windows_core::Result<()> { - let this = self; - unsafe { (windows_core::Interface::vtable(this).Close)(windows_core::Interface::as_raw(this)).ok() } - } -} -impl windows_core::RuntimeName for IAsyncInfo { - const NAME: &'static str = "Windows.Foundation.IAsyncInfo"; -} -pub trait IAsyncInfo_Impl: windows_core::IUnknownImpl { - fn Id(&self) -> windows_core::Result; - fn Status(&self) -> windows_core::Result; - fn ErrorCode(&self) -> windows_core::Result; - fn Cancel(&self) -> windows_core::Result<()>; - fn Close(&self) -> windows_core::Result<()>; -} -impl IAsyncInfo_Vtbl { - pub const fn new() -> Self { - unsafe extern "system" fn Id(this: *mut core::ffi::c_void, result__: *mut u32) -> windows_core::HRESULT { - unsafe { - let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IAsyncInfo_Impl::Id(this) { - Ok(ok__) => { - result__.write(core::mem::transmute_copy(&ok__)); - windows_core::HRESULT(0) - } - Err(err) => err.into(), - } - } - } - unsafe extern "system" fn Status(this: *mut core::ffi::c_void, result__: *mut AsyncStatus) -> windows_core::HRESULT { - unsafe { - let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IAsyncInfo_Impl::Status(this) { - Ok(ok__) => { - result__.write(core::mem::transmute_copy(&ok__)); - windows_core::HRESULT(0) - } - Err(err) => err.into(), - } - } - } - unsafe extern "system" fn ErrorCode(this: *mut core::ffi::c_void, result__: *mut windows_core::HRESULT) -> windows_core::HRESULT { - unsafe { - let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IAsyncInfo_Impl::ErrorCode(this) { - Ok(ok__) => { - result__.write(core::mem::transmute_copy(&ok__)); - windows_core::HRESULT(0) - } - Err(err) => err.into(), - } - } - } - unsafe extern "system" fn Cancel(this: *mut core::ffi::c_void) -> windows_core::HRESULT { - unsafe { - let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - IAsyncInfo_Impl::Cancel(this).into() - } - } - unsafe extern "system" fn Close(this: *mut core::ffi::c_void) -> windows_core::HRESULT { - unsafe { - let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - IAsyncInfo_Impl::Close(this).into() - } - } - Self { - base__: windows_core::IInspectable_Vtbl::new::(), - Id: Id::, - Status: Status::, - ErrorCode: ErrorCode::, - Cancel: Cancel::, - Close: Close::, - } - } - pub fn matches(iid: &windows_core::GUID) -> bool { - iid == &::IID - } -} -#[repr(C)] -pub struct IAsyncInfo_Vtbl { - pub base__: windows_core::IInspectable_Vtbl, - pub Id: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, - pub Status: unsafe extern "system" fn(*mut core::ffi::c_void, *mut AsyncStatus) -> windows_core::HRESULT, - pub ErrorCode: unsafe extern "system" fn(*mut core::ffi::c_void, *mut windows_core::HRESULT) -> windows_core::HRESULT, - pub Cancel: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT, - pub Close: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT, -} -#[repr(transparent)] -#[derive(Clone, Debug, Eq, PartialEq)] -pub struct IAsyncOperation(windows_core::IUnknown, core::marker::PhantomData) -where - TResult: windows_core::RuntimeType + 'static; -impl windows_core::imp::CanInto for IAsyncOperation {} -impl windows_core::imp::CanInto for IAsyncOperation {} -unsafe impl windows_core::Interface for IAsyncOperation { - type Vtable = IAsyncOperation_Vtbl; - const IID: windows_core::GUID = windows_core::GUID::from_signature(::SIGNATURE); -} -impl windows_core::RuntimeType for IAsyncOperation { - const SIGNATURE: windows_core::imp::ConstBuffer = windows_core::imp::ConstBuffer::new().push_slice(b"pinterface({9fc2b0bb-e446-44e2-aa61-9cab8f636af2}").push_slice(b";").push_other(TResult::SIGNATURE).push_slice(b")"); -} -impl windows_core::imp::CanInto for IAsyncOperation { - const QUERY: bool = true; -} -impl IAsyncOperation { - pub fn SetCompleted(&self, handler: P0) -> windows_core::Result<()> - where - P0: windows_core::Param>, - { - let this = self; - unsafe { (windows_core::Interface::vtable(this).SetCompleted)(windows_core::Interface::as_raw(this), handler.param().abi()).ok() } - } - pub fn Completed(&self) -> windows_core::Result> { - let this = self; - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).Completed)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) - } - } - pub fn GetResults(&self) -> windows_core::Result { - let this = self; - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).GetResults)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) - } - } - pub fn Id(&self) -> windows_core::Result { - let this = &windows_core::Interface::cast::(self)?; - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).Id)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) - } - } - pub fn Status(&self) -> windows_core::Result { - let this = &windows_core::Interface::cast::(self)?; - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).Status)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) - } - } - pub fn ErrorCode(&self) -> windows_core::Result { - let this = &windows_core::Interface::cast::(self)?; - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).ErrorCode)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) - } - } - pub fn Cancel(&self) -> windows_core::Result<()> { - let this = &windows_core::Interface::cast::(self)?; - unsafe { (windows_core::Interface::vtable(this).Cancel)(windows_core::Interface::as_raw(this)).ok() } - } - pub fn Close(&self) -> windows_core::Result<()> { - let this = &windows_core::Interface::cast::(self)?; - unsafe { (windows_core::Interface::vtable(this).Close)(windows_core::Interface::as_raw(this)).ok() } - } -} -unsafe impl Send for IAsyncOperation {} -unsafe impl Sync for IAsyncOperation {} -impl windows_core::RuntimeName for IAsyncOperation { - const NAME: &'static str = "Windows.Foundation.IAsyncOperation"; -} -pub trait IAsyncOperation_Impl: IAsyncInfo_Impl -where - TResult: windows_core::RuntimeType + 'static, -{ - fn SetCompleted(&self, handler: windows_core::Ref<'_, AsyncOperationCompletedHandler>) -> windows_core::Result<()>; - fn Completed(&self) -> windows_core::Result>; - fn GetResults(&self) -> windows_core::Result; -} -impl IAsyncOperation_Vtbl { - pub const fn new, const OFFSET: isize>() -> Self { - unsafe extern "system" fn SetCompleted, const OFFSET: isize>(this: *mut core::ffi::c_void, handler: *mut core::ffi::c_void) -> windows_core::HRESULT { - unsafe { - let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - IAsyncOperation_Impl::SetCompleted(this, core::mem::transmute_copy(&handler)).into() - } - } - unsafe extern "system" fn Completed, const OFFSET: isize>(this: *mut core::ffi::c_void, result__: *mut *mut core::ffi::c_void) -> windows_core::HRESULT { - unsafe { - let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IAsyncOperation_Impl::Completed(this) { - Ok(ok__) => { - result__.write(core::mem::transmute_copy(&ok__)); - core::mem::forget(ok__); - windows_core::HRESULT(0) - } - Err(err) => err.into(), - } - } - } - unsafe extern "system" fn GetResults, const OFFSET: isize>(this: *mut core::ffi::c_void, result__: *mut windows_core::AbiType) -> windows_core::HRESULT { - unsafe { - let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IAsyncOperation_Impl::GetResults(this) { - Ok(ok__) => { - result__.write(core::mem::transmute_copy(&ok__)); - core::mem::forget(ok__); - windows_core::HRESULT(0) - } - Err(err) => err.into(), - } - } - } - Self { - base__: windows_core::IInspectable_Vtbl::new::, OFFSET>(), - SetCompleted: SetCompleted::, - Completed: Completed::, - GetResults: GetResults::, - TResult: core::marker::PhantomData::, - } - } - pub fn matches(iid: &windows_core::GUID) -> bool { - iid == & as windows_core::Interface>::IID - } -} -#[repr(C)] -pub struct IAsyncOperation_Vtbl -where - TResult: windows_core::RuntimeType + 'static, -{ - pub base__: windows_core::IInspectable_Vtbl, - pub SetCompleted: unsafe extern "system" fn(*mut core::ffi::c_void, *mut core::ffi::c_void) -> windows_core::HRESULT, - pub Completed: unsafe extern "system" fn(*mut core::ffi::c_void, *mut *mut core::ffi::c_void) -> windows_core::HRESULT, - pub GetResults: unsafe extern "system" fn(*mut core::ffi::c_void, *mut windows_core::AbiType) -> windows_core::HRESULT, - TResult: core::marker::PhantomData, -} -#[repr(transparent)] -#[derive(Clone, Debug, Eq, PartialEq)] -pub struct IAsyncOperationWithProgress(windows_core::IUnknown, core::marker::PhantomData, core::marker::PhantomData) -where - TResult: windows_core::RuntimeType + 'static, - TProgress: windows_core::RuntimeType + 'static; -impl windows_core::imp::CanInto for IAsyncOperationWithProgress {} -impl windows_core::imp::CanInto for IAsyncOperationWithProgress {} -unsafe impl windows_core::Interface for IAsyncOperationWithProgress { - type Vtable = IAsyncOperationWithProgress_Vtbl; - const IID: windows_core::GUID = windows_core::GUID::from_signature(::SIGNATURE); -} -impl windows_core::RuntimeType for IAsyncOperationWithProgress { - const SIGNATURE: windows_core::imp::ConstBuffer = windows_core::imp::ConstBuffer::new().push_slice(b"pinterface({b5d036d7-e297-498f-ba60-0289e76e23dd}").push_slice(b";").push_other(TResult::SIGNATURE).push_slice(b";").push_other(TProgress::SIGNATURE).push_slice(b")"); -} -impl windows_core::imp::CanInto for IAsyncOperationWithProgress { - const QUERY: bool = true; -} -impl IAsyncOperationWithProgress { - pub fn SetProgress(&self, handler: P0) -> windows_core::Result<()> - where - P0: windows_core::Param>, - { - let this = self; - unsafe { (windows_core::Interface::vtable(this).SetProgress)(windows_core::Interface::as_raw(this), handler.param().abi()).ok() } - } - pub fn Progress(&self) -> windows_core::Result> { - let this = self; - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).Progress)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) - } - } - pub fn SetCompleted(&self, handler: P0) -> windows_core::Result<()> - where - P0: windows_core::Param>, - { - let this = self; - unsafe { (windows_core::Interface::vtable(this).SetCompleted)(windows_core::Interface::as_raw(this), handler.param().abi()).ok() } - } - pub fn Completed(&self) -> windows_core::Result> { - let this = self; - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).Completed)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) - } - } - pub fn GetResults(&self) -> windows_core::Result { - let this = self; - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).GetResults)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) - } - } - pub fn Id(&self) -> windows_core::Result { - let this = &windows_core::Interface::cast::(self)?; - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).Id)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) - } - } - pub fn Status(&self) -> windows_core::Result { - let this = &windows_core::Interface::cast::(self)?; - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).Status)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) - } - } - pub fn ErrorCode(&self) -> windows_core::Result { - let this = &windows_core::Interface::cast::(self)?; - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).ErrorCode)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) - } - } - pub fn Cancel(&self) -> windows_core::Result<()> { - let this = &windows_core::Interface::cast::(self)?; - unsafe { (windows_core::Interface::vtable(this).Cancel)(windows_core::Interface::as_raw(this)).ok() } - } - pub fn Close(&self) -> windows_core::Result<()> { - let this = &windows_core::Interface::cast::(self)?; - unsafe { (windows_core::Interface::vtable(this).Close)(windows_core::Interface::as_raw(this)).ok() } - } -} -unsafe impl Send for IAsyncOperationWithProgress {} -unsafe impl Sync for IAsyncOperationWithProgress {} -impl windows_core::RuntimeName for IAsyncOperationWithProgress { - const NAME: &'static str = "Windows.Foundation.IAsyncOperationWithProgress"; -} -pub trait IAsyncOperationWithProgress_Impl: IAsyncInfo_Impl -where - TResult: windows_core::RuntimeType + 'static, - TProgress: windows_core::RuntimeType + 'static, -{ - fn SetProgress(&self, handler: windows_core::Ref<'_, AsyncOperationProgressHandler>) -> windows_core::Result<()>; - fn Progress(&self) -> windows_core::Result>; - fn SetCompleted(&self, handler: windows_core::Ref<'_, AsyncOperationWithProgressCompletedHandler>) -> windows_core::Result<()>; - fn Completed(&self) -> windows_core::Result>; - fn GetResults(&self) -> windows_core::Result; -} -impl IAsyncOperationWithProgress_Vtbl { - pub const fn new, const OFFSET: isize>() -> Self { - unsafe extern "system" fn SetProgress, const OFFSET: isize>(this: *mut core::ffi::c_void, handler: *mut core::ffi::c_void) -> windows_core::HRESULT { - unsafe { - let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - IAsyncOperationWithProgress_Impl::SetProgress(this, core::mem::transmute_copy(&handler)).into() - } - } - unsafe extern "system" fn Progress, const OFFSET: isize>(this: *mut core::ffi::c_void, result__: *mut *mut core::ffi::c_void) -> windows_core::HRESULT { - unsafe { - let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IAsyncOperationWithProgress_Impl::Progress(this) { - Ok(ok__) => { - result__.write(core::mem::transmute_copy(&ok__)); - core::mem::forget(ok__); - windows_core::HRESULT(0) - } - Err(err) => err.into(), - } - } - } - unsafe extern "system" fn SetCompleted, const OFFSET: isize>(this: *mut core::ffi::c_void, handler: *mut core::ffi::c_void) -> windows_core::HRESULT { - unsafe { - let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - IAsyncOperationWithProgress_Impl::SetCompleted(this, core::mem::transmute_copy(&handler)).into() - } - } - unsafe extern "system" fn Completed, const OFFSET: isize>(this: *mut core::ffi::c_void, result__: *mut *mut core::ffi::c_void) -> windows_core::HRESULT { - unsafe { - let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IAsyncOperationWithProgress_Impl::Completed(this) { - Ok(ok__) => { - result__.write(core::mem::transmute_copy(&ok__)); - core::mem::forget(ok__); - windows_core::HRESULT(0) - } - Err(err) => err.into(), - } - } - } - unsafe extern "system" fn GetResults, const OFFSET: isize>(this: *mut core::ffi::c_void, result__: *mut windows_core::AbiType) -> windows_core::HRESULT { - unsafe { - let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IAsyncOperationWithProgress_Impl::GetResults(this) { - Ok(ok__) => { - result__.write(core::mem::transmute_copy(&ok__)); - core::mem::forget(ok__); - windows_core::HRESULT(0) - } - Err(err) => err.into(), - } - } - } - Self { - base__: windows_core::IInspectable_Vtbl::new::, OFFSET>(), - SetProgress: SetProgress::, - Progress: Progress::, - SetCompleted: SetCompleted::, - Completed: Completed::, - GetResults: GetResults::, - TResult: core::marker::PhantomData::, - TProgress: core::marker::PhantomData::, - } - } - pub fn matches(iid: &windows_core::GUID) -> bool { - iid == & as windows_core::Interface>::IID - } -} -#[repr(C)] -pub struct IAsyncOperationWithProgress_Vtbl -where - TResult: windows_core::RuntimeType + 'static, - TProgress: windows_core::RuntimeType + 'static, -{ - pub base__: windows_core::IInspectable_Vtbl, - pub SetProgress: unsafe extern "system" fn(*mut core::ffi::c_void, *mut core::ffi::c_void) -> windows_core::HRESULT, - pub Progress: unsafe extern "system" fn(*mut core::ffi::c_void, *mut *mut core::ffi::c_void) -> windows_core::HRESULT, - pub SetCompleted: unsafe extern "system" fn(*mut core::ffi::c_void, *mut core::ffi::c_void) -> windows_core::HRESULT, - pub Completed: unsafe extern "system" fn(*mut core::ffi::c_void, *mut *mut core::ffi::c_void) -> windows_core::HRESULT, - pub GetResults: unsafe extern "system" fn(*mut core::ffi::c_void, *mut windows_core::AbiType) -> windows_core::HRESULT, - TResult: core::marker::PhantomData, - TProgress: core::marker::PhantomData, +impl windows_core::RuntimeName for GuidHelper { + const NAME: &'static str = "Windows.Foundation.GuidHelper"; } windows_core::imp::define_interface!(IClosable, IClosable_Vtbl, 0x30d5a829_7fa4_4026_83bb_d75bae4ea99e); impl windows_core::RuntimeType for IClosable { diff --git a/crates/libs/windows/src/Windows/Gaming/Input/Custom/mod.rs b/crates/libs/windows/src/Windows/Gaming/Input/Custom/mod.rs index a15eaae686..833964f701 100644 --- a/crates/libs/windows/src/Windows/Gaming/Input/Custom/mod.rs +++ b/crates/libs/windows/src/Windows/Gaming/Input/Custom/mod.rs @@ -169,7 +169,7 @@ impl GipGameControllerProvider { unsafe { (windows_core::Interface::vtable(this).SendReceiveMessage)(windows_core::Interface::as_raw(this), messageclass, messageid, requestmessagebuffer.len().try_into().unwrap(), requestmessagebuffer.as_ptr(), responsemessagebuffer.len().try_into().unwrap(), responsemessagebuffer.as_mut_ptr()).ok() } } #[cfg(feature = "Storage_Streams")] - pub fn UpdateFirmwareAsync(&self, firmwareimage: P0) -> windows_core::Result> + pub fn UpdateFirmwareAsync(&self, firmwareimage: P0) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Gaming/Input/ForceFeedback/mod.rs b/crates/libs/windows/src/Windows/Gaming/Input/ForceFeedback/mod.rs index e0af126777..5cbacb4ae8 100644 --- a/crates/libs/windows/src/Windows/Gaming/Input/ForceFeedback/mod.rs +++ b/crates/libs/windows/src/Windows/Gaming/Input/ForceFeedback/mod.rs @@ -251,7 +251,7 @@ impl ForceFeedbackMotor { (windows_core::Interface::vtable(this).SupportedAxes)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn LoadEffectAsync(&self, effect: P0) -> windows_core::Result> + pub fn LoadEffectAsync(&self, effect: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -273,28 +273,28 @@ impl ForceFeedbackMotor { let this = self; unsafe { (windows_core::Interface::vtable(this).StopAllEffects)(windows_core::Interface::as_raw(this)).ok() } } - pub fn TryDisableAsync(&self) -> windows_core::Result> { + pub fn TryDisableAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryDisableAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryEnableAsync(&self) -> windows_core::Result> { + pub fn TryEnableAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryEnableAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryResetAsync(&self) -> windows_core::Result> { + pub fn TryResetAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryResetAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryUnloadEffectAsync(&self, effect: P0) -> windows_core::Result> + pub fn TryUnloadEffectAsync(&self, effect: P0) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Gaming/Preview/GamesEnumeration/mod.rs b/crates/libs/windows/src/Windows/Gaming/Preview/GamesEnumeration/mod.rs index edd2bc243d..9cbe147b32 100644 --- a/crates/libs/windows/src/Windows/Gaming/Preview/GamesEnumeration/mod.rs +++ b/crates/libs/windows/src/Windows/Gaming/Preview/GamesEnumeration/mod.rs @@ -1,12 +1,12 @@ pub struct GameList; impl GameList { - pub fn FindAllAsync() -> windows_core::Result>> { + pub fn FindAllAsync() -> windows_core::Result>> { Self::IGameListStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAllAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn FindAllAsyncPackageFamilyName(packagefamilyname: &windows_core::HSTRING) -> windows_core::Result>> { + pub fn FindAllAsyncPackageFamilyName(packagefamilyname: &windows_core::HSTRING) -> windows_core::Result>> { Self::IGameListStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAllAsyncPackageFamilyName)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(packagefamilyname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -48,7 +48,7 @@ impl GameList { pub fn RemoveGameUpdated(token: i64) -> windows_core::Result<()> { Self::IGameListStatics(|this| unsafe { (windows_core::Interface::vtable(this).RemoveGameUpdated)(windows_core::Interface::as_raw(this), token).ok() }) } - pub fn MergeEntriesAsync(left: P0, right: P1) -> windows_core::Result> + pub fn MergeEntriesAsync(left: P0, right: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -58,7 +58,7 @@ impl GameList { (windows_core::Interface::vtable(this).MergeEntriesAsync)(windows_core::Interface::as_raw(this), left.param().abi(), right.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn UnmergeEntryAsync(mergedentry: P0) -> windows_core::Result>> + pub fn UnmergeEntryAsync(mergedentry: P0) -> windows_core::Result>> where P0: windows_core::Param, { @@ -174,7 +174,7 @@ impl GameListEntry { (windows_core::Interface::vtable(this).DisplayInfo)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn LaunchAsync(&self) -> windows_core::Result> { + pub fn LaunchAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -195,7 +195,7 @@ impl GameListEntry { (windows_core::Interface::vtable(this).Properties)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SetCategoryAsync(&self, value: GameListCategory) -> windows_core::Result { + pub fn SetCategoryAsync(&self, value: GameListCategory) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -225,7 +225,7 @@ impl GameListEntry { } } #[cfg(feature = "Storage_Streams")] - pub fn SetLauncherExecutableFileAsync(&self, executablefile: P0) -> windows_core::Result + pub fn SetLauncherExecutableFileAsync(&self, executablefile: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -236,7 +236,7 @@ impl GameListEntry { } } #[cfg(feature = "Storage_Streams")] - pub fn SetLauncherExecutableFileWithParamsAsync(&self, executablefile: P0, launchparams: &windows_core::HSTRING) -> windows_core::Result + pub fn SetLauncherExecutableFileWithParamsAsync(&self, executablefile: P0, launchparams: &windows_core::HSTRING) -> windows_core::Result where P0: windows_core::Param, { @@ -253,7 +253,7 @@ impl GameListEntry { (windows_core::Interface::vtable(this).TitleId)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn SetTitleIdAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result { + pub fn SetTitleIdAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -478,7 +478,7 @@ impl GameModeConfiguration { let this = self; unsafe { (windows_core::Interface::vtable(this).SetAffinitizeToExclusiveCpus)(windows_core::Interface::as_raw(this), value).ok() } } - pub fn SaveAsync(&self) -> windows_core::Result { + pub fn SaveAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -510,7 +510,7 @@ impl GameModeUserConfiguration { (windows_core::Interface::vtable(this).GamingRelatedProcessNames)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SaveAsync(&self) -> windows_core::Result { + pub fn SaveAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -554,7 +554,7 @@ impl IGameListEntry { (windows_core::Interface::vtable(this).DisplayInfo)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn LaunchAsync(&self) -> windows_core::Result> { + pub fn LaunchAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -575,7 +575,7 @@ impl IGameListEntry { (windows_core::Interface::vtable(this).Properties)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SetCategoryAsync(&self, value: GameListCategory) -> windows_core::Result { + pub fn SetCategoryAsync(&self, value: GameListCategory) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -590,10 +590,10 @@ impl windows_core::RuntimeName for IGameListEntry { #[cfg(feature = "ApplicationModel")] pub trait IGameListEntry_Impl: windows_core::IUnknownImpl { fn DisplayInfo(&self) -> windows_core::Result; - fn LaunchAsync(&self) -> windows_core::Result>; + fn LaunchAsync(&self) -> windows_core::Result>; fn Category(&self) -> windows_core::Result; fn Properties(&self) -> windows_core::Result>; - fn SetCategoryAsync(&self, value: GameListCategory) -> windows_core::Result; + fn SetCategoryAsync(&self, value: GameListCategory) -> windows_core::Result; } #[cfg(feature = "ApplicationModel")] impl IGameListEntry_Vtbl { diff --git a/crates/libs/windows/src/Windows/Gaming/XboxLive/Storage/mod.rs b/crates/libs/windows/src/Windows/Gaming/XboxLive/Storage/mod.rs index f1e4244eca..3854f86508 100644 --- a/crates/libs/windows/src/Windows/Gaming/XboxLive/Storage/mod.rs +++ b/crates/libs/windows/src/Windows/Gaming/XboxLive/Storage/mod.rs @@ -100,21 +100,21 @@ unsafe impl Sync for GameSaveBlobInfoGetResult {} pub struct GameSaveBlobInfoQuery(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(GameSaveBlobInfoQuery, windows_core::IUnknown, windows_core::IInspectable); impl GameSaveBlobInfoQuery { - pub fn GetBlobInfoAsync(&self) -> windows_core::Result> { + pub fn GetBlobInfoAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetBlobInfoAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetBlobInfoWithIndexAndMaxAsync(&self, startindex: u32, maxnumberofitems: u32) -> windows_core::Result> { + pub fn GetBlobInfoWithIndexAndMaxAsync(&self, startindex: u32, maxnumberofitems: u32) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetBlobInfoWithIndexAndMaxAsync)(windows_core::Interface::as_raw(this), startindex, maxnumberofitems, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetItemCountAsync(&self) -> windows_core::Result> { + pub fn GetItemCountAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -154,7 +154,7 @@ impl GameSaveContainer { } } #[cfg(feature = "Storage_Streams")] - pub fn SubmitUpdatesAsync(&self, blobstowrite: P0, blobstodelete: P1, displayname: &windows_core::HSTRING) -> windows_core::Result> + pub fn SubmitUpdatesAsync(&self, blobstowrite: P0, blobstodelete: P1, displayname: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param>, P1: windows_core::Param>, @@ -166,7 +166,7 @@ impl GameSaveContainer { } } #[cfg(feature = "Storage_Streams")] - pub fn ReadAsync(&self, blobstoread: P0) -> windows_core::Result> + pub fn ReadAsync(&self, blobstoread: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -176,7 +176,7 @@ impl GameSaveContainer { (windows_core::Interface::vtable(this).ReadAsync)(windows_core::Interface::as_raw(this), blobstoread.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAsync(&self, blobstoread: P0) -> windows_core::Result> + pub fn GetAsync(&self, blobstoread: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -187,7 +187,7 @@ impl GameSaveContainer { } } #[cfg(feature = "Foundation_Collections")] - pub fn SubmitPropertySetUpdatesAsync(&self, blobstowrite: P0, blobstodelete: P1, displayname: &windows_core::HSTRING) -> windows_core::Result> + pub fn SubmitPropertySetUpdatesAsync(&self, blobstowrite: P0, blobstodelete: P1, displayname: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param>, @@ -308,21 +308,21 @@ unsafe impl Sync for GameSaveContainerInfoGetResult {} pub struct GameSaveContainerInfoQuery(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(GameSaveContainerInfoQuery, windows_core::IUnknown, windows_core::IInspectable); impl GameSaveContainerInfoQuery { - pub fn GetContainerInfoAsync(&self) -> windows_core::Result> { + pub fn GetContainerInfoAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetContainerInfoAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetContainerInfoWithIndexAndMaxAsync(&self, startindex: u32, maxnumberofitems: u32) -> windows_core::Result> { + pub fn GetContainerInfoWithIndexAndMaxAsync(&self, startindex: u32, maxnumberofitems: u32) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetContainerInfoWithIndexAndMaxAsync)(windows_core::Interface::as_raw(this), startindex, maxnumberofitems, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetItemCountAsync(&self) -> windows_core::Result> { + pub fn GetItemCountAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -413,7 +413,7 @@ impl GameSaveProvider { (windows_core::Interface::vtable(this).CreateContainer)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(name), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteContainerAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { + pub fn DeleteContainerAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -434,7 +434,7 @@ impl GameSaveProvider { (windows_core::Interface::vtable(this).CreateContainerInfoQueryWithName)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(containernameprefix), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetRemainingBytesInQuotaAsync(&self) -> windows_core::Result> { + pub fn GetRemainingBytesInQuotaAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -449,7 +449,7 @@ impl GameSaveProvider { } } #[cfg(feature = "System")] - pub fn GetForUserAsync(user: P0, serviceconfigid: &windows_core::HSTRING) -> windows_core::Result> + pub fn GetForUserAsync(user: P0, serviceconfigid: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -459,7 +459,7 @@ impl GameSaveProvider { }) } #[cfg(feature = "System")] - pub fn GetSyncOnDemandForUserAsync(user: P0, serviceconfigid: &windows_core::HSTRING) -> windows_core::Result> + pub fn GetSyncOnDemandForUserAsync(user: P0, serviceconfigid: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Graphics/Capture/mod.rs b/crates/libs/windows/src/Windows/Graphics/Capture/mod.rs index d3f272baf1..39358133b4 100644 --- a/crates/libs/windows/src/Windows/Graphics/Capture/mod.rs +++ b/crates/libs/windows/src/Windows/Graphics/Capture/mod.rs @@ -158,7 +158,7 @@ unsafe impl Sync for Direct3D11CaptureFramePool {} pub struct GraphicsCaptureAccess; impl GraphicsCaptureAccess { #[cfg(feature = "Security_Authorization_AppCapabilityAccess")] - pub fn RequestAccessAsync(request: GraphicsCaptureAccessKind) -> windows_core::Result> { + pub fn RequestAccessAsync(request: GraphicsCaptureAccessKind) -> windows_core::Result> { Self::IGraphicsCaptureAccessStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestAccessAsync)(windows_core::Interface::as_raw(this), request, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -287,7 +287,7 @@ impl GraphicsCapturePicker { static SHARED: windows_core::imp::FactoryCache = windows_core::imp::FactoryCache::new(); SHARED.call(callback) } - pub fn PickSingleItemAsync(&self) -> windows_core::Result> { + pub fn PickSingleItemAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Graphics/Display/Core/mod.rs b/crates/libs/windows/src/Windows/Graphics/Display/Core/mod.rs index ab89dd0f41..895e7f4254 100644 --- a/crates/libs/windows/src/Windows/Graphics/Display/Core/mod.rs +++ b/crates/libs/windows/src/Windows/Graphics/Display/Core/mod.rs @@ -69,14 +69,14 @@ impl HdmiDisplayInformation { (windows_core::Interface::vtable(this).GetCurrentDisplayMode)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SetDefaultDisplayModeAsync(&self) -> windows_core::Result { + pub fn SetDefaultDisplayModeAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).SetDefaultDisplayModeAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestSetCurrentDisplayModeAsync(&self, mode: P0) -> windows_core::Result> + pub fn RequestSetCurrentDisplayModeAsync(&self, mode: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -86,7 +86,7 @@ impl HdmiDisplayInformation { (windows_core::Interface::vtable(this).RequestSetCurrentDisplayModeAsync)(windows_core::Interface::as_raw(this), mode.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestSetCurrentDisplayModeWithHdrAsync(&self, mode: P0, hdroption: HdmiDisplayHdrOption) -> windows_core::Result> + pub fn RequestSetCurrentDisplayModeWithHdrAsync(&self, mode: P0, hdroption: HdmiDisplayHdrOption) -> windows_core::Result> where P0: windows_core::Param, { @@ -96,7 +96,7 @@ impl HdmiDisplayInformation { (windows_core::Interface::vtable(this).RequestSetCurrentDisplayModeWithHdrAsync)(windows_core::Interface::as_raw(this), mode.param().abi(), hdroption, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestSetCurrentDisplayModeWithHdrAndMetadataAsync(&self, mode: P0, hdroption: HdmiDisplayHdrOption, hdrmetadata: HdmiDisplayHdr2086Metadata) -> windows_core::Result> + pub fn RequestSetCurrentDisplayModeWithHdrAndMetadataAsync(&self, mode: P0, hdroption: HdmiDisplayHdrOption, hdrmetadata: HdmiDisplayHdr2086Metadata) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Graphics/Display/mod.rs b/crates/libs/windows/src/Windows/Graphics/Display/mod.rs index 9737cf9f39..9d3d57d0ff 100644 --- a/crates/libs/windows/src/Windows/Graphics/Display/mod.rs +++ b/crates/libs/windows/src/Windows/Graphics/Display/mod.rs @@ -212,7 +212,7 @@ impl BrightnessOverride { (windows_core::Interface::vtable(this).GetForCurrentView)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn SaveForSystemAsync(value: P0) -> windows_core::Result> + pub fn SaveForSystemAsync(value: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -702,7 +702,7 @@ impl DisplayInformation { unsafe { (windows_core::Interface::vtable(this).RemoveStereoEnabledChanged)(windows_core::Interface::as_raw(this), token).ok() } } #[cfg(feature = "Storage_Streams")] - pub fn GetColorProfileAsync(&self) -> windows_core::Result> { + pub fn GetColorProfileAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -945,7 +945,7 @@ impl DisplayProperties { Self::IDisplayPropertiesStatics(|this| unsafe { (windows_core::Interface::vtable(this).RemoveStereoEnabledChanged)(windows_core::Interface::as_raw(this), token).ok() }) } #[cfg(feature = "Storage_Streams")] - pub fn GetColorProfileAsync() -> windows_core::Result> { + pub fn GetColorProfileAsync() -> windows_core::Result> { Self::IDisplayPropertiesStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetColorProfileAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/Graphics/Imaging/mod.rs b/crates/libs/windows/src/Windows/Graphics/Imaging/mod.rs index ff47ad331f..dda2091621 100644 --- a/crates/libs/windows/src/Windows/Graphics/Imaging/mod.rs +++ b/crates/libs/windows/src/Windows/Graphics/Imaging/mod.rs @@ -158,14 +158,14 @@ impl BitmapDecoder { } } #[cfg(feature = "Storage_Streams")] - pub fn GetPreviewAsync(&self) -> windows_core::Result> { + pub fn GetPreviewAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetPreviewAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetFrameAsync(&self, frameindex: u32) -> windows_core::Result> { + pub fn GetFrameAsync(&self, frameindex: u32) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -221,7 +221,7 @@ impl BitmapDecoder { }) } #[cfg(feature = "Storage_Streams")] - pub fn CreateAsync(stream: P0) -> windows_core::Result> + pub fn CreateAsync(stream: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -231,7 +231,7 @@ impl BitmapDecoder { }) } #[cfg(feature = "Storage_Streams")] - pub fn CreateWithIdAsync(decoderid: windows_core::GUID, stream: P1) -> windows_core::Result> + pub fn CreateWithIdAsync(decoderid: windows_core::GUID, stream: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -253,7 +253,7 @@ impl BitmapDecoder { }) } #[cfg(feature = "Storage_Streams")] - pub fn GetThumbnailAsync(&self) -> windows_core::Result> { + pub fn GetThumbnailAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -323,14 +323,14 @@ impl BitmapDecoder { (windows_core::Interface::vtable(this).OrientedPixelHeight)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn GetPixelDataAsync(&self) -> windows_core::Result> { + pub fn GetPixelDataAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetPixelDataAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetPixelDataTransformedAsync(&self, pixelformat: BitmapPixelFormat, alphamode: BitmapAlphaMode, transform: P2, exiforientationmode: ExifOrientationMode, colormanagementmode: ColorManagementMode) -> windows_core::Result> + pub fn GetPixelDataTransformedAsync(&self, pixelformat: BitmapPixelFormat, alphamode: BitmapAlphaMode, transform: P2, exiforientationmode: ExifOrientationMode, colormanagementmode: ColorManagementMode) -> windows_core::Result> where P2: windows_core::Param, { @@ -340,21 +340,21 @@ impl BitmapDecoder { (windows_core::Interface::vtable(this).GetPixelDataTransformedAsync)(windows_core::Interface::as_raw(this), pixelformat, alphamode, transform.param().abi(), exiforientationmode, colormanagementmode, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetSoftwareBitmapAsync(&self) -> windows_core::Result> { + pub fn GetSoftwareBitmapAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetSoftwareBitmapAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetSoftwareBitmapConvertedAsync(&self, pixelformat: BitmapPixelFormat, alphamode: BitmapAlphaMode) -> windows_core::Result> { + pub fn GetSoftwareBitmapConvertedAsync(&self, pixelformat: BitmapPixelFormat, alphamode: BitmapAlphaMode) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetSoftwareBitmapConvertedAsync)(windows_core::Interface::as_raw(this), pixelformat, alphamode, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetSoftwareBitmapTransformedAsync(&self, pixelformat: BitmapPixelFormat, alphamode: BitmapAlphaMode, transform: P2, exiforientationmode: ExifOrientationMode, colormanagementmode: ColorManagementMode) -> windows_core::Result> + pub fn GetSoftwareBitmapTransformedAsync(&self, pixelformat: BitmapPixelFormat, alphamode: BitmapAlphaMode, transform: P2, exiforientationmode: ExifOrientationMode, colormanagementmode: ColorManagementMode) -> windows_core::Result> where P2: windows_core::Param, { @@ -455,14 +455,14 @@ impl BitmapEncoder { let this = self; unsafe { (windows_core::Interface::vtable(this).SetPixelData)(windows_core::Interface::as_raw(this), pixelformat, alphamode, width, height, dpix, dpiy, pixels.len().try_into().unwrap(), pixels.as_ptr()).ok() } } - pub fn GoToNextFrameAsync(&self) -> windows_core::Result { + pub fn GoToNextFrameAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GoToNextFrameAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GoToNextFrameWithEncodingOptionsAsync(&self, encodingoptions: P0) -> windows_core::Result + pub fn GoToNextFrameWithEncodingOptionsAsync(&self, encodingoptions: P0) -> windows_core::Result where P0: windows_core::Param>>, { @@ -472,7 +472,7 @@ impl BitmapEncoder { (windows_core::Interface::vtable(this).GoToNextFrameWithEncodingOptionsAsync)(windows_core::Interface::as_raw(this), encodingoptions.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FlushAsync(&self) -> windows_core::Result { + pub fn FlushAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -522,7 +522,7 @@ impl BitmapEncoder { }) } #[cfg(feature = "Storage_Streams")] - pub fn CreateAsync(encoderid: windows_core::GUID, stream: P1) -> windows_core::Result> + pub fn CreateAsync(encoderid: windows_core::GUID, stream: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -532,7 +532,7 @@ impl BitmapEncoder { }) } #[cfg(feature = "Storage_Streams")] - pub fn CreateWithEncodingOptionsAsync(encoderid: windows_core::GUID, stream: P1, encodingoptions: P2) -> windows_core::Result> + pub fn CreateWithEncodingOptionsAsync(encoderid: windows_core::GUID, stream: P1, encodingoptions: P2) -> windows_core::Result> where P1: windows_core::Param, P2: windows_core::Param>>, @@ -543,7 +543,7 @@ impl BitmapEncoder { }) } #[cfg(feature = "Storage_Streams")] - pub fn CreateForTranscodingAsync(stream: P0, bitmapdecoder: P1) -> windows_core::Result> + pub fn CreateForTranscodingAsync(stream: P0, bitmapdecoder: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -553,7 +553,7 @@ impl BitmapEncoder { (windows_core::Interface::vtable(this).CreateForTranscodingAsync)(windows_core::Interface::as_raw(this), stream.param().abi(), bitmapdecoder.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn CreateForInPlacePropertyEncodingAsync(bitmapdecoder: P0) -> windows_core::Result> + pub fn CreateForInPlacePropertyEncodingAsync(bitmapdecoder: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -617,7 +617,7 @@ windows_core::imp::interface_hierarchy!(BitmapFrame, windows_core::IUnknown, win windows_core::imp::required_hierarchy!(BitmapFrame, IBitmapFrameWithSoftwareBitmap); impl BitmapFrame { #[cfg(feature = "Storage_Streams")] - pub fn GetThumbnailAsync(&self) -> windows_core::Result> { + pub fn GetThumbnailAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -687,14 +687,14 @@ impl BitmapFrame { (windows_core::Interface::vtable(this).OrientedPixelHeight)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn GetPixelDataAsync(&self) -> windows_core::Result> { + pub fn GetPixelDataAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetPixelDataAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetPixelDataTransformedAsync(&self, pixelformat: BitmapPixelFormat, alphamode: BitmapAlphaMode, transform: P2, exiforientationmode: ExifOrientationMode, colormanagementmode: ColorManagementMode) -> windows_core::Result> + pub fn GetPixelDataTransformedAsync(&self, pixelformat: BitmapPixelFormat, alphamode: BitmapAlphaMode, transform: P2, exiforientationmode: ExifOrientationMode, colormanagementmode: ColorManagementMode) -> windows_core::Result> where P2: windows_core::Param, { @@ -704,21 +704,21 @@ impl BitmapFrame { (windows_core::Interface::vtable(this).GetPixelDataTransformedAsync)(windows_core::Interface::as_raw(this), pixelformat, alphamode, transform.param().abi(), exiforientationmode, colormanagementmode, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetSoftwareBitmapAsync(&self) -> windows_core::Result> { + pub fn GetSoftwareBitmapAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetSoftwareBitmapAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetSoftwareBitmapConvertedAsync(&self, pixelformat: BitmapPixelFormat, alphamode: BitmapAlphaMode) -> windows_core::Result> { + pub fn GetSoftwareBitmapConvertedAsync(&self, pixelformat: BitmapPixelFormat, alphamode: BitmapAlphaMode) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetSoftwareBitmapConvertedAsync)(windows_core::Interface::as_raw(this), pixelformat, alphamode, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetSoftwareBitmapTransformedAsync(&self, pixelformat: BitmapPixelFormat, alphamode: BitmapAlphaMode, transform: P2, exiforientationmode: ExifOrientationMode, colormanagementmode: ColorManagementMode) -> windows_core::Result> + pub fn GetSoftwareBitmapTransformedAsync(&self, pixelformat: BitmapPixelFormat, alphamode: BitmapAlphaMode, transform: P2, exiforientationmode: ExifOrientationMode, colormanagementmode: ColorManagementMode) -> windows_core::Result> where P2: windows_core::Param, { @@ -796,7 +796,7 @@ pub struct BitmapProperties(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(BitmapProperties, windows_core::IUnknown, windows_core::IInspectable); windows_core::imp::required_hierarchy!(BitmapProperties, IBitmapPropertiesView); impl BitmapProperties { - pub fn SetPropertiesAsync(&self, propertiestoset: P0) -> windows_core::Result + pub fn SetPropertiesAsync(&self, propertiestoset: P0) -> windows_core::Result where P0: windows_core::Param>>, { @@ -806,7 +806,7 @@ impl BitmapProperties { (windows_core::Interface::vtable(this).SetPropertiesAsync)(windows_core::Interface::as_raw(this), propertiestoset.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetPropertiesAsync(&self, propertiestoretrieve: P0) -> windows_core::Result> + pub fn GetPropertiesAsync(&self, propertiestoretrieve: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -834,7 +834,7 @@ unsafe impl Sync for BitmapProperties {} pub struct BitmapPropertiesView(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(BitmapPropertiesView, windows_core::IUnknown, windows_core::IInspectable, IBitmapPropertiesView); impl BitmapPropertiesView { - pub fn GetPropertiesAsync(&self, propertiestoretrieve: P0) -> windows_core::Result> + pub fn GetPropertiesAsync(&self, propertiestoretrieve: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -1286,7 +1286,7 @@ impl windows_core::RuntimeType for IBitmapFrame { windows_core::imp::interface_hierarchy!(IBitmapFrame, windows_core::IUnknown, windows_core::IInspectable); impl IBitmapFrame { #[cfg(feature = "Storage_Streams")] - pub fn GetThumbnailAsync(&self) -> windows_core::Result> { + pub fn GetThumbnailAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1356,14 +1356,14 @@ impl IBitmapFrame { (windows_core::Interface::vtable(this).OrientedPixelHeight)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn GetPixelDataAsync(&self) -> windows_core::Result> { + pub fn GetPixelDataAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetPixelDataAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetPixelDataTransformedAsync(&self, pixelformat: BitmapPixelFormat, alphamode: BitmapAlphaMode, transform: P2, exiforientationmode: ExifOrientationMode, colormanagementmode: ColorManagementMode) -> windows_core::Result> + pub fn GetPixelDataTransformedAsync(&self, pixelformat: BitmapPixelFormat, alphamode: BitmapAlphaMode, transform: P2, exiforientationmode: ExifOrientationMode, colormanagementmode: ColorManagementMode) -> windows_core::Result> where P2: windows_core::Param, { @@ -1380,7 +1380,7 @@ impl windows_core::RuntimeName for IBitmapFrame { } #[cfg(feature = "Storage_Streams")] pub trait IBitmapFrame_Impl: windows_core::IUnknownImpl { - fn GetThumbnailAsync(&self) -> windows_core::Result>; + fn GetThumbnailAsync(&self) -> windows_core::Result>; fn BitmapProperties(&self) -> windows_core::Result; fn BitmapPixelFormat(&self) -> windows_core::Result; fn BitmapAlphaMode(&self) -> windows_core::Result; @@ -1390,8 +1390,8 @@ pub trait IBitmapFrame_Impl: windows_core::IUnknownImpl { fn PixelHeight(&self) -> windows_core::Result; fn OrientedPixelWidth(&self) -> windows_core::Result; fn OrientedPixelHeight(&self) -> windows_core::Result; - fn GetPixelDataAsync(&self) -> windows_core::Result>; - fn GetPixelDataTransformedAsync(&self, pixelFormat: BitmapPixelFormat, alphaMode: BitmapAlphaMode, transform: windows_core::Ref<'_, BitmapTransform>, exifOrientationMode: ExifOrientationMode, colorManagementMode: ColorManagementMode) -> windows_core::Result>; + fn GetPixelDataAsync(&self) -> windows_core::Result>; + fn GetPixelDataTransformedAsync(&self, pixelFormat: BitmapPixelFormat, alphaMode: BitmapAlphaMode, transform: windows_core::Ref<'_, BitmapTransform>, exifOrientationMode: ExifOrientationMode, colorManagementMode: ColorManagementMode) -> windows_core::Result>; } #[cfg(feature = "Storage_Streams")] impl IBitmapFrame_Vtbl { @@ -1590,21 +1590,21 @@ impl windows_core::RuntimeType for IBitmapFrameWithSoftwareBitmap { windows_core::imp::interface_hierarchy!(IBitmapFrameWithSoftwareBitmap, windows_core::IUnknown, windows_core::IInspectable); windows_core::imp::required_hierarchy!(IBitmapFrameWithSoftwareBitmap, IBitmapFrame); impl IBitmapFrameWithSoftwareBitmap { - pub fn GetSoftwareBitmapAsync(&self) -> windows_core::Result> { + pub fn GetSoftwareBitmapAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetSoftwareBitmapAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetSoftwareBitmapConvertedAsync(&self, pixelformat: BitmapPixelFormat, alphamode: BitmapAlphaMode) -> windows_core::Result> { + pub fn GetSoftwareBitmapConvertedAsync(&self, pixelformat: BitmapPixelFormat, alphamode: BitmapAlphaMode) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetSoftwareBitmapConvertedAsync)(windows_core::Interface::as_raw(this), pixelformat, alphamode, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetSoftwareBitmapTransformedAsync(&self, pixelformat: BitmapPixelFormat, alphamode: BitmapAlphaMode, transform: P2, exiforientationmode: ExifOrientationMode, colormanagementmode: ColorManagementMode) -> windows_core::Result> + pub fn GetSoftwareBitmapTransformedAsync(&self, pixelformat: BitmapPixelFormat, alphamode: BitmapAlphaMode, transform: P2, exiforientationmode: ExifOrientationMode, colormanagementmode: ColorManagementMode) -> windows_core::Result> where P2: windows_core::Param, { @@ -1615,7 +1615,7 @@ impl IBitmapFrameWithSoftwareBitmap { } } #[cfg(feature = "Storage_Streams")] - pub fn GetThumbnailAsync(&self) -> windows_core::Result> { + pub fn GetThumbnailAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1685,14 +1685,14 @@ impl IBitmapFrameWithSoftwareBitmap { (windows_core::Interface::vtable(this).OrientedPixelHeight)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn GetPixelDataAsync(&self) -> windows_core::Result> { + pub fn GetPixelDataAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetPixelDataAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetPixelDataTransformedAsync(&self, pixelformat: BitmapPixelFormat, alphamode: BitmapAlphaMode, transform: P2, exiforientationmode: ExifOrientationMode, colormanagementmode: ColorManagementMode) -> windows_core::Result> + pub fn GetPixelDataTransformedAsync(&self, pixelformat: BitmapPixelFormat, alphamode: BitmapAlphaMode, transform: P2, exiforientationmode: ExifOrientationMode, colormanagementmode: ColorManagementMode) -> windows_core::Result> where P2: windows_core::Param, { @@ -1709,9 +1709,9 @@ impl windows_core::RuntimeName for IBitmapFrameWithSoftwareBitmap { } #[cfg(feature = "Storage_Streams")] pub trait IBitmapFrameWithSoftwareBitmap_Impl: IBitmapFrame_Impl { - fn GetSoftwareBitmapAsync(&self) -> windows_core::Result>; - fn GetSoftwareBitmapConvertedAsync(&self, pixelFormat: BitmapPixelFormat, alphaMode: BitmapAlphaMode) -> windows_core::Result>; - fn GetSoftwareBitmapTransformedAsync(&self, pixelFormat: BitmapPixelFormat, alphaMode: BitmapAlphaMode, transform: windows_core::Ref<'_, BitmapTransform>, exifOrientationMode: ExifOrientationMode, colorManagementMode: ColorManagementMode) -> windows_core::Result>; + fn GetSoftwareBitmapAsync(&self) -> windows_core::Result>; + fn GetSoftwareBitmapConvertedAsync(&self, pixelFormat: BitmapPixelFormat, alphaMode: BitmapAlphaMode) -> windows_core::Result>; + fn GetSoftwareBitmapTransformedAsync(&self, pixelFormat: BitmapPixelFormat, alphaMode: BitmapAlphaMode, transform: windows_core::Ref<'_, BitmapTransform>, exifOrientationMode: ExifOrientationMode, colorManagementMode: ColorManagementMode) -> windows_core::Result>; } #[cfg(feature = "Storage_Streams")] impl IBitmapFrameWithSoftwareBitmap_Vtbl { @@ -1788,7 +1788,7 @@ impl windows_core::RuntimeType for IBitmapPropertiesView { } windows_core::imp::interface_hierarchy!(IBitmapPropertiesView, windows_core::IUnknown, windows_core::IInspectable); impl IBitmapPropertiesView { - pub fn GetPropertiesAsync(&self, propertiestoretrieve: P0) -> windows_core::Result> + pub fn GetPropertiesAsync(&self, propertiestoretrieve: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -1803,7 +1803,7 @@ impl windows_core::RuntimeName for IBitmapPropertiesView { const NAME: &'static str = "Windows.Graphics.Imaging.IBitmapPropertiesView"; } pub trait IBitmapPropertiesView_Impl: windows_core::IUnknownImpl { - fn GetPropertiesAsync(&self, propertiesToRetrieve: windows_core::Ref<'_, windows_collections::IIterable>) -> windows_core::Result>; + fn GetPropertiesAsync(&self, propertiesToRetrieve: windows_core::Ref<'_, windows_collections::IIterable>) -> windows_core::Result>; } impl IBitmapPropertiesView_Vtbl { pub const fn new() -> Self { @@ -1968,7 +1968,7 @@ impl ImageStream { (windows_core::Interface::vtable(this).ContentType)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn ReadAsync(&self, buffer: P0, count: u32, options: super::super::Storage::Streams::InputStreamOptions) -> windows_core::Result> + pub fn ReadAsync(&self, buffer: P0, count: u32, options: super::super::Storage::Streams::InputStreamOptions) -> windows_core::Result> where P0: windows_core::Param, { @@ -1978,7 +1978,7 @@ impl ImageStream { (windows_core::Interface::vtable(this).ReadAsync)(windows_core::Interface::as_raw(this), buffer.param().abi(), count, options, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn WriteAsync(&self, buffer: P0) -> windows_core::Result> + pub fn WriteAsync(&self, buffer: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1988,7 +1988,7 @@ impl ImageStream { (windows_core::Interface::vtable(this).WriteAsync)(windows_core::Interface::as_raw(this), buffer.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FlushAsync(&self) -> windows_core::Result> { + pub fn FlushAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -2292,7 +2292,7 @@ impl SoftwareBitmap { }) } #[cfg(feature = "Graphics_DirectX_Direct3D11")] - pub fn CreateCopyFromSurfaceAsync(surface: P0) -> windows_core::Result> + pub fn CreateCopyFromSurfaceAsync(surface: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2302,7 +2302,7 @@ impl SoftwareBitmap { }) } #[cfg(feature = "Graphics_DirectX_Direct3D11")] - pub fn CreateCopyWithAlphaFromSurfaceAsync(surface: P0, alpha: BitmapAlphaMode) -> windows_core::Result> + pub fn CreateCopyWithAlphaFromSurfaceAsync(surface: P0, alpha: BitmapAlphaMode) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Graphics/Printing/PrintTicket/mod.rs b/crates/libs/windows/src/Windows/Graphics/Printing/PrintTicket/mod.rs index 204ddff109..2369c1a23f 100644 --- a/crates/libs/windows/src/Windows/Graphics/Printing/PrintTicket/mod.rs +++ b/crates/libs/windows/src/Windows/Graphics/Printing/PrintTicket/mod.rs @@ -832,14 +832,14 @@ impl WorkflowPrintTicket { (windows_core::Interface::vtable(this).GetFeature)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(name), core::mem::transmute_copy(xmlnamespace), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn NotifyXmlChangedAsync(&self) -> windows_core::Result { + pub fn NotifyXmlChangedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).NotifyXmlChangedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ValidateAsync(&self) -> windows_core::Result> { + pub fn ValidateAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Graphics/Printing/Workflow/mod.rs b/crates/libs/windows/src/Windows/Graphics/Printing/Workflow/mod.rs index e2d8ff9f13..288030a936 100644 --- a/crates/libs/windows/src/Windows/Graphics/Printing/Workflow/mod.rs +++ b/crates/libs/windows/src/Windows/Graphics/Printing/Workflow/mod.rs @@ -680,7 +680,7 @@ pub struct PrintWorkflowBackgroundSetupRequestedEventArgs(windows_core::IUnknown windows_core::imp::interface_hierarchy!(PrintWorkflowBackgroundSetupRequestedEventArgs, windows_core::IUnknown, windows_core::IInspectable); impl PrintWorkflowBackgroundSetupRequestedEventArgs { #[cfg(feature = "Graphics_Printing_PrintTicket")] - pub fn GetUserPrintTicketAsync(&self) -> windows_core::Result> { + pub fn GetUserPrintTicketAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -824,7 +824,7 @@ pub struct PrintWorkflowForegroundSetupRequestedEventArgs(windows_core::IUnknown windows_core::imp::interface_hierarchy!(PrintWorkflowForegroundSetupRequestedEventArgs, windows_core::IUnknown, windows_core::IInspectable); impl PrintWorkflowForegroundSetupRequestedEventArgs { #[cfg(feature = "Graphics_Printing_PrintTicket")] - pub fn GetUserPrintTicketAsync(&self) -> windows_core::Result> { + pub fn GetUserPrintTicketAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1370,7 +1370,7 @@ pub struct PrintWorkflowPdlConverter(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(PrintWorkflowPdlConverter, windows_core::IUnknown, windows_core::IInspectable); impl PrintWorkflowPdlConverter { #[cfg(all(feature = "Graphics_Printing_PrintTicket", feature = "Storage_Streams"))] - pub fn ConvertPdlAsync(&self, printticket: P0, inputstream: P1, outputstream: P2) -> windows_core::Result + pub fn ConvertPdlAsync(&self, printticket: P0, inputstream: P1, outputstream: P2) -> windows_core::Result where P0: windows_core::Param, P1: windows_core::Param, @@ -1383,7 +1383,7 @@ impl PrintWorkflowPdlConverter { } } #[cfg(all(feature = "Graphics_Printing_PrintTicket", feature = "Storage_Streams"))] - pub fn ConvertPdlAsync2(&self, printticket: P0, inputstream: P1, outputstream: P2, hostbasedprocessingoperations: PdlConversionHostBasedProcessingOperations) -> windows_core::Result + pub fn ConvertPdlAsync2(&self, printticket: P0, inputstream: P1, outputstream: P2, hostbasedprocessingoperations: PdlConversionHostBasedProcessingOperations) -> windows_core::Result where P0: windows_core::Param, P1: windows_core::Param, @@ -1588,7 +1588,7 @@ impl PrintWorkflowPdlSourceContent { } } #[cfg(feature = "Storage_Streams")] - pub fn GetContentFileAsync(&self) -> windows_core::Result> { + pub fn GetContentFileAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1778,7 +1778,7 @@ pub struct PrintWorkflowSourceContent(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(PrintWorkflowSourceContent, windows_core::IUnknown, windows_core::IInspectable); impl PrintWorkflowSourceContent { #[cfg(feature = "Graphics_Printing_PrintTicket")] - pub fn GetJobPrintTicketAsync(&self) -> windows_core::Result> { + pub fn GetJobPrintTicketAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2105,7 +2105,7 @@ impl PrintWorkflowUILauncher { (windows_core::Interface::vtable(this).IsUILaunchEnabled)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn LaunchAndCompleteUIAsync(&self) -> windows_core::Result> { + pub fn LaunchAndCompleteUIAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2167,7 +2167,7 @@ impl PrintWorkflowVirtualPrinterDataAvailableEventArgs { } } #[cfg(feature = "Storage_Streams")] - pub fn GetTargetFileAsync(&self) -> windows_core::Result> { + pub fn GetTargetFileAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Graphics/Printing/mod.rs b/crates/libs/windows/src/Windows/Graphics/Printing/mod.rs index fe61bfa894..ad13589353 100644 --- a/crates/libs/windows/src/Windows/Graphics/Printing/mod.rs +++ b/crates/libs/windows/src/Windows/Graphics/Printing/mod.rs @@ -973,7 +973,7 @@ impl PrintManager { (windows_core::Interface::vtable(this).GetForCurrentView)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn ShowPrintUIAsync() -> windows_core::Result> { + pub fn ShowPrintUIAsync() -> windows_core::Result> { Self::IPrintManagerStatic(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ShowPrintUIAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/Graphics/Printing3D/mod.rs b/crates/libs/windows/src/Windows/Graphics/Printing3D/mod.rs index b682e51170..0f740b8a82 100644 --- a/crates/libs/windows/src/Windows/Graphics/Printing3D/mod.rs +++ b/crates/libs/windows/src/Windows/Graphics/Printing3D/mod.rs @@ -546,7 +546,7 @@ impl Print3DManager { (windows_core::Interface::vtable(this).GetForCurrentView)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn ShowPrintUIAsync() -> windows_core::Result> { + pub fn ShowPrintUIAsync() -> windows_core::Result> { Self::IPrint3DManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ShowPrintUIAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -886,7 +886,7 @@ impl Printing3D3MFPackage { SHARED.call(callback) } #[cfg(feature = "Storage_Streams")] - pub fn SaveAsync(&self) -> windows_core::Result> { + pub fn SaveAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -947,7 +947,7 @@ impl Printing3D3MFPackage { } } #[cfg(feature = "Storage_Streams")] - pub fn LoadModelFromPackageAsync(&self, value: P0) -> windows_core::Result> + pub fn LoadModelFromPackageAsync(&self, value: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -957,7 +957,7 @@ impl Printing3D3MFPackage { (windows_core::Interface::vtable(this).LoadModelFromPackageAsync)(windows_core::Interface::as_raw(this), value.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SaveModelToPackageAsync(&self, value: P0) -> windows_core::Result + pub fn SaveModelToPackageAsync(&self, value: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -979,7 +979,7 @@ impl Printing3D3MFPackage { unsafe { (windows_core::Interface::vtable(this).SetCompression)(windows_core::Interface::as_raw(this), value).ok() } } #[cfg(feature = "Storage_Streams")] - pub fn LoadAsync(value: P0) -> windows_core::Result> + pub fn LoadAsync(value: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1732,7 +1732,7 @@ impl Printing3DMesh { (windows_core::Interface::vtable(this).BufferSet)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn VerifyAsync(&self, value: Printing3DMeshVerificationMode) -> windows_core::Result> { + pub fn VerifyAsync(&self, value: Printing3DMeshVerificationMode) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1901,7 +1901,7 @@ impl Printing3DModel { (windows_core::Interface::vtable(this).Metadata)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RepairAsync(&self) -> windows_core::Result { + pub fn RepairAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1915,28 +1915,28 @@ impl Printing3DModel { (windows_core::Interface::vtable(this).Clone)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryPartialRepairAsync(&self) -> windows_core::Result> { + pub fn TryPartialRepairAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryPartialRepairAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryPartialRepairWithTimeAsync(&self, maxwaittime: super::super::Foundation::TimeSpan) -> windows_core::Result> { + pub fn TryPartialRepairWithTimeAsync(&self, maxwaittime: super::super::Foundation::TimeSpan) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryPartialRepairWithTimeAsync)(windows_core::Interface::as_raw(this), maxwaittime, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryReduceFacesAsync(&self) -> windows_core::Result> { + pub fn TryReduceFacesAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryReduceFacesAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryReduceFacesWithOptionsAsync(&self, printing3dfacereductionoptions: P0) -> windows_core::Result> + pub fn TryReduceFacesWithOptionsAsync(&self, printing3dfacereductionoptions: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1946,7 +1946,7 @@ impl Printing3DModel { (windows_core::Interface::vtable(this).TryReduceFacesWithOptionsAsync)(windows_core::Interface::as_raw(this), printing3dfacereductionoptions.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryReduceFacesWithOptionsAndTimeAsync(&self, printing3dfacereductionoptions: P0, maxwait: super::super::Foundation::TimeSpan) -> windows_core::Result> + pub fn TryReduceFacesWithOptionsAndTimeAsync(&self, printing3dfacereductionoptions: P0, maxwait: super::super::Foundation::TimeSpan) -> windows_core::Result> where P0: windows_core::Param, { @@ -1956,7 +1956,7 @@ impl Printing3DModel { (windows_core::Interface::vtable(this).TryReduceFacesWithOptionsAndTimeAsync)(windows_core::Interface::as_raw(this), printing3dfacereductionoptions.param().abi(), maxwait, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RepairWithProgressAsync(&self) -> windows_core::Result> { + pub fn RepairWithProgressAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Management/Deployment/mod.rs b/crates/libs/windows/src/Windows/Management/Deployment/mod.rs index 2ce6cebfea..1d35fff1f5 100644 --- a/crates/libs/windows/src/Windows/Management/Deployment/mod.rs +++ b/crates/libs/windows/src/Windows/Management/Deployment/mod.rs @@ -1619,7 +1619,7 @@ impl PackageManager { static SHARED: windows_core::imp::FactoryCache = windows_core::imp::FactoryCache::new(); SHARED.call(callback) } - pub fn AddPackageAsync(&self, packageuri: P0, dependencypackageuris: P1, deploymentoptions: DeploymentOptions) -> windows_core::Result> + pub fn AddPackageAsync(&self, packageuri: P0, dependencypackageuris: P1, deploymentoptions: DeploymentOptions) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param>, @@ -1630,7 +1630,7 @@ impl PackageManager { (windows_core::Interface::vtable(this).AddPackageAsync)(windows_core::Interface::as_raw(this), packageuri.param().abi(), dependencypackageuris.param().abi(), deploymentoptions, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn UpdatePackageAsync(&self, packageuri: P0, dependencypackageuris: P1, deploymentoptions: DeploymentOptions) -> windows_core::Result> + pub fn UpdatePackageAsync(&self, packageuri: P0, dependencypackageuris: P1, deploymentoptions: DeploymentOptions) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param>, @@ -1641,14 +1641,14 @@ impl PackageManager { (windows_core::Interface::vtable(this).UpdatePackageAsync)(windows_core::Interface::as_raw(this), packageuri.param().abi(), dependencypackageuris.param().abi(), deploymentoptions, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RemovePackageAsync(&self, packagefullname: &windows_core::HSTRING) -> windows_core::Result> { + pub fn RemovePackageAsync(&self, packagefullname: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RemovePackageAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(packagefullname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StagePackageAsync(&self, packageuri: P0, dependencypackageuris: P1) -> windows_core::Result> + pub fn StagePackageAsync(&self, packageuri: P0, dependencypackageuris: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param>, @@ -1659,7 +1659,7 @@ impl PackageManager { (windows_core::Interface::vtable(this).StagePackageAsync)(windows_core::Interface::as_raw(this), packageuri.param().abi(), dependencypackageuris.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RegisterPackageAsync(&self, manifesturi: P0, dependencypackageuris: P1, deploymentoptions: DeploymentOptions) -> windows_core::Result> + pub fn RegisterPackageAsync(&self, manifesturi: P0, dependencypackageuris: P1, deploymentoptions: DeploymentOptions) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param>, @@ -1721,7 +1721,7 @@ impl PackageManager { (windows_core::Interface::vtable(this).FindPackageByPackageFullName)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(packagefullname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CleanupPackageForUserAsync(&self, packagename: &windows_core::HSTRING, usersecurityid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CleanupPackageForUserAsync(&self, packagename: &windows_core::HSTRING, usersecurityid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1752,7 +1752,7 @@ impl PackageManager { (windows_core::Interface::vtable(this).FindPackageByUserSecurityIdPackageFullName)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(usersecurityid), core::mem::transmute_copy(packagefullname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ProvisionPackageForAllUsersWithOptionsAsync(&self, mainpackagefamilyname: &windows_core::HSTRING, options: P1) -> windows_core::Result> + pub fn ProvisionPackageForAllUsersWithOptionsAsync(&self, mainpackagefamilyname: &windows_core::HSTRING, options: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -1762,7 +1762,7 @@ impl PackageManager { (windows_core::Interface::vtable(this).ProvisionPackageForAllUsersWithOptionsAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(mainpackagefamilyname), options.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RemovePackageByUriAsync(&self, packageuri: P0, options: P1) -> windows_core::Result> + pub fn RemovePackageByUriAsync(&self, packageuri: P0, options: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -1807,14 +1807,14 @@ impl PackageManager { (windows_core::Interface::vtable(this).IsPackageRemovalPendingByUriForUser)(windows_core::Interface::as_raw(this), packageuri.param().abi(), core::mem::transmute_copy(usersecurityid), &mut result__).map(|| result__) } } - pub fn RemovePackageWithOptionsAsync(&self, packagefullname: &windows_core::HSTRING, removaloptions: RemovalOptions) -> windows_core::Result> { + pub fn RemovePackageWithOptionsAsync(&self, packagefullname: &windows_core::HSTRING, removaloptions: RemovalOptions) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RemovePackageWithOptionsAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(packagefullname), removaloptions, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StagePackageWithOptionsAsync(&self, packageuri: P0, dependencypackageuris: P1, deploymentoptions: DeploymentOptions) -> windows_core::Result> + pub fn StagePackageWithOptionsAsync(&self, packageuri: P0, dependencypackageuris: P1, deploymentoptions: DeploymentOptions) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param>, @@ -1825,7 +1825,7 @@ impl PackageManager { (windows_core::Interface::vtable(this).StagePackageWithOptionsAsync)(windows_core::Interface::as_raw(this), packageuri.param().abi(), dependencypackageuris.param().abi(), deploymentoptions, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RegisterPackageByFullNameAsync(&self, mainpackagefullname: &windows_core::HSTRING, dependencypackagefullnames: P1, deploymentoptions: DeploymentOptions) -> windows_core::Result> + pub fn RegisterPackageByFullNameAsync(&self, mainpackagefullname: &windows_core::HSTRING, dependencypackagefullnames: P1, deploymentoptions: DeploymentOptions) -> windows_core::Result> where P1: windows_core::Param>, { @@ -1883,21 +1883,21 @@ impl PackageManager { (windows_core::Interface::vtable(this).FindPackagesByUserSecurityIdPackageFamilyNameWithPackageTypes)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(usersecurityid), core::mem::transmute_copy(packagefamilyname), packagetypes, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StageUserDataAsync(&self, packagefullname: &windows_core::HSTRING) -> windows_core::Result> { + pub fn StageUserDataAsync(&self, packagefullname: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).StageUserDataAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(packagefullname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn AddPackageVolumeAsync(&self, packagestorepath: &windows_core::HSTRING) -> windows_core::Result> { + pub fn AddPackageVolumeAsync(&self, packagestorepath: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).AddPackageVolumeAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(packagestorepath), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn AddPackageToVolumeAsync(&self, packageuri: P0, dependencypackageuris: P1, deploymentoptions: DeploymentOptions, targetvolume: P3) -> windows_core::Result> + pub fn AddPackageToVolumeAsync(&self, packageuri: P0, dependencypackageuris: P1, deploymentoptions: DeploymentOptions, targetvolume: P3) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param>, @@ -1913,7 +1913,7 @@ impl PackageManager { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).ClearPackageStatus)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(packagefullname), status).ok() } } - pub fn RegisterPackageWithAppDataVolumeAsync(&self, manifesturi: P0, dependencypackageuris: P1, deploymentoptions: DeploymentOptions, appdatavolume: P3) -> windows_core::Result> + pub fn RegisterPackageWithAppDataVolumeAsync(&self, manifesturi: P0, dependencypackageuris: P1, deploymentoptions: DeploymentOptions, appdatavolume: P3) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param>, @@ -1946,7 +1946,7 @@ impl PackageManager { (windows_core::Interface::vtable(this).GetDefaultPackageVolume)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn MovePackageToVolumeAsync(&self, packagefullname: &windows_core::HSTRING, deploymentoptions: DeploymentOptions, targetvolume: P2) -> windows_core::Result> + pub fn MovePackageToVolumeAsync(&self, packagefullname: &windows_core::HSTRING, deploymentoptions: DeploymentOptions, targetvolume: P2) -> windows_core::Result> where P2: windows_core::Param, { @@ -1956,7 +1956,7 @@ impl PackageManager { (windows_core::Interface::vtable(this).MovePackageToVolumeAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(packagefullname), deploymentoptions, targetvolume.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RemovePackageVolumeAsync(&self, volume: P0) -> windows_core::Result> + pub fn RemovePackageVolumeAsync(&self, volume: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1977,7 +1977,7 @@ impl PackageManager { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).SetPackageStatus)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(packagefullname), status).ok() } } - pub fn SetPackageVolumeOfflineAsync(&self, packagevolume: P0) -> windows_core::Result> + pub fn SetPackageVolumeOfflineAsync(&self, packagevolume: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1987,7 +1987,7 @@ impl PackageManager { (windows_core::Interface::vtable(this).SetPackageVolumeOfflineAsync)(windows_core::Interface::as_raw(this), packagevolume.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SetPackageVolumeOnlineAsync(&self, packagevolume: P0) -> windows_core::Result> + pub fn SetPackageVolumeOnlineAsync(&self, packagevolume: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1997,7 +1997,7 @@ impl PackageManager { (windows_core::Interface::vtable(this).SetPackageVolumeOnlineAsync)(windows_core::Interface::as_raw(this), packagevolume.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StagePackageToVolumeAsync(&self, packageuri: P0, dependencypackageuris: P1, deploymentoptions: DeploymentOptions, targetvolume: P3) -> windows_core::Result> + pub fn StagePackageToVolumeAsync(&self, packageuri: P0, dependencypackageuris: P1, deploymentoptions: DeploymentOptions, targetvolume: P3) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param>, @@ -2009,21 +2009,21 @@ impl PackageManager { (windows_core::Interface::vtable(this).StagePackageToVolumeAsync)(windows_core::Interface::as_raw(this), packageuri.param().abi(), dependencypackageuris.param().abi(), deploymentoptions, targetvolume.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StageUserDataWithOptionsAsync(&self, packagefullname: &windows_core::HSTRING, deploymentoptions: DeploymentOptions) -> windows_core::Result> { + pub fn StageUserDataWithOptionsAsync(&self, packagefullname: &windows_core::HSTRING, deploymentoptions: DeploymentOptions) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).StageUserDataWithOptionsAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(packagefullname), deploymentoptions, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetPackageVolumesAsync(&self) -> windows_core::Result>> { + pub fn GetPackageVolumesAsync(&self) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetPackageVolumesAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn AddPackageToVolumeAndOptionalPackagesAsync(&self, packageuri: P0, dependencypackageuris: P1, deploymentoptions: DeploymentOptions, targetvolume: P3, optionalpackagefamilynames: P4, externalpackageuris: P5) -> windows_core::Result> + pub fn AddPackageToVolumeAndOptionalPackagesAsync(&self, packageuri: P0, dependencypackageuris: P1, deploymentoptions: DeploymentOptions, targetvolume: P3, optionalpackagefamilynames: P4, externalpackageuris: P5) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param>, @@ -2037,7 +2037,7 @@ impl PackageManager { (windows_core::Interface::vtable(this).AddPackageToVolumeAndOptionalPackagesAsync)(windows_core::Interface::as_raw(this), packageuri.param().abi(), dependencypackageuris.param().abi(), deploymentoptions, targetvolume.param().abi(), optionalpackagefamilynames.param().abi(), externalpackageuris.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StagePackageToVolumeAndOptionalPackagesAsync(&self, packageuri: P0, dependencypackageuris: P1, deploymentoptions: DeploymentOptions, targetvolume: P3, optionalpackagefamilynames: P4, externalpackageuris: P5) -> windows_core::Result> + pub fn StagePackageToVolumeAndOptionalPackagesAsync(&self, packageuri: P0, dependencypackageuris: P1, deploymentoptions: DeploymentOptions, targetvolume: P3, optionalpackagefamilynames: P4, externalpackageuris: P5) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param>, @@ -2051,7 +2051,7 @@ impl PackageManager { (windows_core::Interface::vtable(this).StagePackageToVolumeAndOptionalPackagesAsync)(windows_core::Interface::as_raw(this), packageuri.param().abi(), dependencypackageuris.param().abi(), deploymentoptions, targetvolume.param().abi(), optionalpackagefamilynames.param().abi(), externalpackageuris.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RegisterPackageByFamilyNameAndOptionalPackagesAsync(&self, mainpackagefamilyname: &windows_core::HSTRING, dependencypackagefamilynames: P1, deploymentoptions: DeploymentOptions, appdatavolume: P3, optionalpackagefamilynames: P4) -> windows_core::Result> + pub fn RegisterPackageByFamilyNameAndOptionalPackagesAsync(&self, mainpackagefamilyname: &windows_core::HSTRING, dependencypackagefamilynames: P1, deploymentoptions: DeploymentOptions, appdatavolume: P3, optionalpackagefamilynames: P4) -> windows_core::Result> where P1: windows_core::Param>, P3: windows_core::Param, @@ -2070,14 +2070,14 @@ impl PackageManager { (windows_core::Interface::vtable(this).DebugSettings)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ProvisionPackageForAllUsersAsync(&self, packagefamilyname: &windows_core::HSTRING) -> windows_core::Result> { + pub fn ProvisionPackageForAllUsersAsync(&self, packagefamilyname: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ProvisionPackageForAllUsersAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(packagefamilyname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn AddPackageByAppInstallerFileAsync(&self, appinstallerfileuri: P0, options: AddPackageByAppInstallerOptions, targetvolume: P2) -> windows_core::Result> + pub fn AddPackageByAppInstallerFileAsync(&self, appinstallerfileuri: P0, options: AddPackageByAppInstallerOptions, targetvolume: P2) -> windows_core::Result> where P0: windows_core::Param, P2: windows_core::Param, @@ -2088,7 +2088,7 @@ impl PackageManager { (windows_core::Interface::vtable(this).AddPackageByAppInstallerFileAsync)(windows_core::Interface::as_raw(this), appinstallerfileuri.param().abi(), options, targetvolume.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestAddPackageByAppInstallerFileAsync(&self, appinstallerfileuri: P0, options: AddPackageByAppInstallerOptions, targetvolume: P2) -> windows_core::Result> + pub fn RequestAddPackageByAppInstallerFileAsync(&self, appinstallerfileuri: P0, options: AddPackageByAppInstallerOptions, targetvolume: P2) -> windows_core::Result> where P0: windows_core::Param, P2: windows_core::Param, @@ -2099,7 +2099,7 @@ impl PackageManager { (windows_core::Interface::vtable(this).RequestAddPackageByAppInstallerFileAsync)(windows_core::Interface::as_raw(this), appinstallerfileuri.param().abi(), options, targetvolume.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn AddPackageToVolumeAndRelatedSetAsync(&self, packageuri: P0, dependencypackageuris: P1, options: DeploymentOptions, targetvolume: P3, optionalpackagefamilynames: P4, packageuristoinstall: P5, relatedpackageuris: P6) -> windows_core::Result> + pub fn AddPackageToVolumeAndRelatedSetAsync(&self, packageuri: P0, dependencypackageuris: P1, options: DeploymentOptions, targetvolume: P3, optionalpackagefamilynames: P4, packageuristoinstall: P5, relatedpackageuris: P6) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param>, @@ -2114,7 +2114,7 @@ impl PackageManager { (windows_core::Interface::vtable(this).AddPackageToVolumeAndRelatedSetAsync)(windows_core::Interface::as_raw(this), packageuri.param().abi(), dependencypackageuris.param().abi(), options, targetvolume.param().abi(), optionalpackagefamilynames.param().abi(), packageuristoinstall.param().abi(), relatedpackageuris.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StagePackageToVolumeAndRelatedSetAsync(&self, packageuri: P0, dependencypackageuris: P1, options: DeploymentOptions, targetvolume: P3, optionalpackagefamilynames: P4, packageuristoinstall: P5, relatedpackageuris: P6) -> windows_core::Result> + pub fn StagePackageToVolumeAndRelatedSetAsync(&self, packageuri: P0, dependencypackageuris: P1, options: DeploymentOptions, targetvolume: P3, optionalpackagefamilynames: P4, packageuristoinstall: P5, relatedpackageuris: P6) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param>, @@ -2129,7 +2129,7 @@ impl PackageManager { (windows_core::Interface::vtable(this).StagePackageToVolumeAndRelatedSetAsync)(windows_core::Interface::as_raw(this), packageuri.param().abi(), dependencypackageuris.param().abi(), options, targetvolume.param().abi(), optionalpackagefamilynames.param().abi(), packageuristoinstall.param().abi(), relatedpackageuris.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestAddPackageAsync(&self, packageuri: P0, dependencypackageuris: P1, deploymentoptions: DeploymentOptions, targetvolume: P3, optionalpackagefamilynames: P4, relatedpackageuris: P5) -> windows_core::Result> + pub fn RequestAddPackageAsync(&self, packageuri: P0, dependencypackageuris: P1, deploymentoptions: DeploymentOptions, targetvolume: P3, optionalpackagefamilynames: P4, relatedpackageuris: P5) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param>, @@ -2143,7 +2143,7 @@ impl PackageManager { (windows_core::Interface::vtable(this).RequestAddPackageAsync)(windows_core::Interface::as_raw(this), packageuri.param().abi(), dependencypackageuris.param().abi(), deploymentoptions, targetvolume.param().abi(), optionalpackagefamilynames.param().abi(), relatedpackageuris.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestAddPackageAndRelatedSetAsync(&self, packageuri: P0, dependencypackageuris: P1, deploymentoptions: DeploymentOptions, targetvolume: P3, optionalpackagefamilynames: P4, relatedpackageuris: P5, packageuristoinstall: P6) -> windows_core::Result> + pub fn RequestAddPackageAndRelatedSetAsync(&self, packageuri: P0, dependencypackageuris: P1, deploymentoptions: DeploymentOptions, targetvolume: P3, optionalpackagefamilynames: P4, relatedpackageuris: P5, packageuristoinstall: P6) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param>, @@ -2158,7 +2158,7 @@ impl PackageManager { (windows_core::Interface::vtable(this).RequestAddPackageAndRelatedSetAsync)(windows_core::Interface::as_raw(this), packageuri.param().abi(), dependencypackageuris.param().abi(), deploymentoptions, targetvolume.param().abi(), optionalpackagefamilynames.param().abi(), relatedpackageuris.param().abi(), packageuristoinstall.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeprovisionPackageForAllUsersAsync(&self, packagefamilyname: &windows_core::HSTRING) -> windows_core::Result> { + pub fn DeprovisionPackageForAllUsersAsync(&self, packagefamilyname: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -2173,7 +2173,7 @@ impl PackageManager { (windows_core::Interface::vtable(this).FindProvisionedPackages)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn AddPackageByUriAsync(&self, packageuri: P0, options: P1) -> windows_core::Result> + pub fn AddPackageByUriAsync(&self, packageuri: P0, options: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -2184,7 +2184,7 @@ impl PackageManager { (windows_core::Interface::vtable(this).AddPackageByUriAsync)(windows_core::Interface::as_raw(this), packageuri.param().abi(), options.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StagePackageByUriAsync(&self, packageuri: P0, options: P1) -> windows_core::Result> + pub fn StagePackageByUriAsync(&self, packageuri: P0, options: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -2195,7 +2195,7 @@ impl PackageManager { (windows_core::Interface::vtable(this).StagePackageByUriAsync)(windows_core::Interface::as_raw(this), packageuri.param().abi(), options.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RegisterPackageByUriAsync(&self, manifesturi: P0, options: P1) -> windows_core::Result> + pub fn RegisterPackageByUriAsync(&self, manifesturi: P0, options: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -2206,7 +2206,7 @@ impl PackageManager { (windows_core::Interface::vtable(this).RegisterPackageByUriAsync)(windows_core::Interface::as_raw(this), manifesturi.param().abi(), options.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RegisterPackagesByFullNameAsync(&self, packagefullnames: P0, options: P1) -> windows_core::Result> + pub fn RegisterPackagesByFullNameAsync(&self, packagefullnames: P0, options: P1) -> windows_core::Result> where P0: windows_core::Param>, P1: windows_core::Param, @@ -2247,7 +2247,7 @@ pub struct PackageManagerDebugSettings(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(PackageManagerDebugSettings, windows_core::IUnknown, windows_core::IInspectable); impl PackageManagerDebugSettings { #[cfg(feature = "ApplicationModel")] - pub fn SetContentGroupStateAsync(&self, package: P0, contentgroupname: &windows_core::HSTRING, state: super::super::ApplicationModel::PackageContentGroupState) -> windows_core::Result + pub fn SetContentGroupStateAsync(&self, package: P0, contentgroupname: &windows_core::HSTRING, state: super::super::ApplicationModel::PackageContentGroupState) -> windows_core::Result where P0: windows_core::Param, { @@ -2258,7 +2258,7 @@ impl PackageManagerDebugSettings { } } #[cfg(feature = "ApplicationModel")] - pub fn SetContentGroupStateWithPercentageAsync(&self, package: P0, contentgroupname: &windows_core::HSTRING, state: super::super::ApplicationModel::PackageContentGroupState, completionpercentage: f64) -> windows_core::Result + pub fn SetContentGroupStateWithPercentageAsync(&self, package: P0, contentgroupname: &windows_core::HSTRING, state: super::super::ApplicationModel::PackageContentGroupState, completionpercentage: f64) -> windows_core::Result where P0: windows_core::Param, { @@ -2615,7 +2615,7 @@ impl PackageVolume { (windows_core::Interface::vtable(this).IsAppxInstallSupported)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn GetAvailableSpaceAsync(&self) -> windows_core::Result> { + pub fn GetAvailableSpaceAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Management/Setup/mod.rs b/crates/libs/windows/src/Windows/Management/Setup/mod.rs index 3775239fde..2c57c1a254 100644 --- a/crates/libs/windows/src/Windows/Management/Setup/mod.rs +++ b/crates/libs/windows/src/Windows/Management/Setup/mod.rs @@ -734,7 +734,7 @@ impl MachineProvisioningProgressReporter { let this = self; unsafe { (windows_core::Interface::vtable(this).ReportProgress)(windows_core::Interface::as_raw(this), updatereport.param().abi()).ok() } } - pub fn GetDevicePreparationExecutionContextAsync(&self) -> windows_core::Result> { + pub fn GetDevicePreparationExecutionContextAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Management/Update/mod.rs b/crates/libs/windows/src/Windows/Management/Update/mod.rs index f008a3a6bb..ce1aaf0306 100644 --- a/crates/libs/windows/src/Windows/Management/Update/mod.rs +++ b/crates/libs/windows/src/Windows/Management/Update/mod.rs @@ -302,7 +302,7 @@ impl PreviewBuildsManager { (windows_core::Interface::vtable(this).GetCurrentState)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SyncAsync(&self) -> windows_core::Result> { + pub fn SyncAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1254,7 +1254,7 @@ impl WindowsUpdateManager { (windows_core::Interface::vtable(this).GetMostRecentCompletedUpdates)(windows_core::Interface::as_raw(this), count, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetMostRecentCompletedUpdatesAsync(&self, count: i32) -> windows_core::Result>> { + pub fn GetMostRecentCompletedUpdatesAsync(&self, count: i32) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Management/mod.rs b/crates/libs/windows/src/Windows/Management/mod.rs index 33ce710836..88fcc26a1a 100644 --- a/crates/libs/windows/src/Windows/Management/mod.rs +++ b/crates/libs/windows/src/Windows/Management/mod.rs @@ -219,7 +219,7 @@ impl MdmSession { (windows_core::Interface::vtable(this).State)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn AttachAsync(&self) -> windows_core::Result { + pub fn AttachAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -230,14 +230,14 @@ impl MdmSession { let this = self; unsafe { (windows_core::Interface::vtable(this).Delete)(windows_core::Interface::as_raw(this)).ok() } } - pub fn StartAsync(&self) -> windows_core::Result { + pub fn StartAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).StartAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StartWithAlertsAsync(&self, alerts: P0) -> windows_core::Result + pub fn StartWithAlertsAsync(&self, alerts: P0) -> windows_core::Result where P0: windows_core::Param>, { diff --git a/crates/libs/windows/src/Windows/Media/AppRecording/mod.rs b/crates/libs/windows/src/Windows/Media/AppRecording/mod.rs index 6ed7ed0dea..a9fea381f5 100644 --- a/crates/libs/windows/src/Windows/Media/AppRecording/mod.rs +++ b/crates/libs/windows/src/Windows/Media/AppRecording/mod.rs @@ -11,7 +11,7 @@ impl AppRecordingManager { } } #[cfg(feature = "Storage_Streams")] - pub fn StartRecordingToFileAsync(&self, file: P0) -> windows_core::Result> + pub fn StartRecordingToFileAsync(&self, file: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -22,7 +22,7 @@ impl AppRecordingManager { } } #[cfg(feature = "Storage_Streams")] - pub fn RecordTimeSpanToFileAsync(&self, starttime: super::super::Foundation::DateTime, duration: super::super::Foundation::TimeSpan, file: P2) -> windows_core::Result> + pub fn RecordTimeSpanToFileAsync(&self, starttime: super::super::Foundation::DateTime, duration: super::super::Foundation::TimeSpan, file: P2) -> windows_core::Result> where P2: windows_core::Param, { @@ -40,7 +40,7 @@ impl AppRecordingManager { } } #[cfg(feature = "Storage_Search")] - pub fn SaveScreenshotToFilesAsync(&self, folder: P0, filenameprefix: &windows_core::HSTRING, option: AppRecordingSaveScreenshotOption, requestedformats: P3) -> windows_core::Result> + pub fn SaveScreenshotToFilesAsync(&self, folder: P0, filenameprefix: &windows_core::HSTRING, option: AppRecordingSaveScreenshotOption, requestedformats: P3) -> windows_core::Result> where P0: windows_core::Param, P3: windows_core::Param>, diff --git a/crates/libs/windows/src/Windows/Media/Audio/mod.rs b/crates/libs/windows/src/Windows/Media/Audio/mod.rs index 9238e41ac0..6316a4474c 100644 --- a/crates/libs/windows/src/Windows/Media/Audio/mod.rs +++ b/crates/libs/windows/src/Windows/Media/Audio/mod.rs @@ -596,7 +596,7 @@ impl AudioFileOutputNode { } } #[cfg(feature = "Media_Transcoding")] - pub fn FinalizeAsync(&self) -> windows_core::Result> { + pub fn FinalizeAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1013,7 +1013,7 @@ impl AudioGraph { } } #[cfg(feature = "Media_Capture")] - pub fn CreateDeviceInputNodeAsync(&self, category: super::Capture::MediaCategory) -> windows_core::Result> { + pub fn CreateDeviceInputNodeAsync(&self, category: super::Capture::MediaCategory) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1021,7 +1021,7 @@ impl AudioGraph { } } #[cfg(all(feature = "Media_Capture", feature = "Media_MediaProperties"))] - pub fn CreateDeviceInputNodeWithFormatAsync(&self, category: super::Capture::MediaCategory, encodingproperties: P1) -> windows_core::Result> + pub fn CreateDeviceInputNodeWithFormatAsync(&self, category: super::Capture::MediaCategory, encodingproperties: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -1032,7 +1032,7 @@ impl AudioGraph { } } #[cfg(all(feature = "Devices_Enumeration", feature = "Media_Capture", feature = "Media_MediaProperties"))] - pub fn CreateDeviceInputNodeWithFormatOnDeviceAsync(&self, category: super::Capture::MediaCategory, encodingproperties: P1, device: P2) -> windows_core::Result> + pub fn CreateDeviceInputNodeWithFormatOnDeviceAsync(&self, category: super::Capture::MediaCategory, encodingproperties: P1, device: P2) -> windows_core::Result> where P1: windows_core::Param, P2: windows_core::Param, @@ -1061,7 +1061,7 @@ impl AudioGraph { (windows_core::Interface::vtable(this).CreateFrameOutputNodeWithFormat)(windows_core::Interface::as_raw(this), encodingproperties.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateDeviceOutputNodeAsync(&self) -> windows_core::Result> { + pub fn CreateDeviceOutputNodeAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1069,7 +1069,7 @@ impl AudioGraph { } } #[cfg(feature = "Storage_Streams")] - pub fn CreateFileInputNodeAsync(&self, file: P0) -> windows_core::Result> + pub fn CreateFileInputNodeAsync(&self, file: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1080,7 +1080,7 @@ impl AudioGraph { } } #[cfg(feature = "Storage_Streams")] - pub fn CreateFileOutputNodeAsync(&self, file: P0) -> windows_core::Result> + pub fn CreateFileOutputNodeAsync(&self, file: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1091,7 +1091,7 @@ impl AudioGraph { } } #[cfg(all(feature = "Media_MediaProperties", feature = "Storage_Streams"))] - pub fn CreateFileOutputNodeWithFileProfileAsync(&self, file: P0, fileencodingprofile: P1) -> windows_core::Result> + pub fn CreateFileOutputNodeWithFileProfileAsync(&self, file: P0, fileencodingprofile: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -1231,7 +1231,7 @@ impl AudioGraph { } } #[cfg(all(feature = "Devices_Enumeration", feature = "Media_Capture", feature = "Media_MediaProperties"))] - pub fn CreateDeviceInputNodeWithFormatAndEmitterOnDeviceAsync(&self, category: super::Capture::MediaCategory, encodingproperties: P1, device: P2, emitter: P3) -> windows_core::Result> + pub fn CreateDeviceInputNodeWithFormatAndEmitterOnDeviceAsync(&self, category: super::Capture::MediaCategory, encodingproperties: P1, device: P2, emitter: P3) -> windows_core::Result> where P1: windows_core::Param, P2: windows_core::Param, @@ -1244,7 +1244,7 @@ impl AudioGraph { } } #[cfg(feature = "Storage_Streams")] - pub fn CreateFileInputNodeWithEmitterAsync(&self, file: P0, emitter: P1) -> windows_core::Result> + pub fn CreateFileInputNodeWithEmitterAsync(&self, file: P0, emitter: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -1275,7 +1275,7 @@ impl AudioGraph { } } #[cfg(all(feature = "Media_Core", feature = "Media_Playback"))] - pub fn CreateMediaSourceAudioInputNodeAsync(&self, mediasource: P0) -> windows_core::Result> + pub fn CreateMediaSourceAudioInputNodeAsync(&self, mediasource: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1286,7 +1286,7 @@ impl AudioGraph { } } #[cfg(all(feature = "Media_Core", feature = "Media_Playback"))] - pub fn CreateMediaSourceAudioInputNodeWithEmitterAsync(&self, mediasource: P0, emitter: P1) -> windows_core::Result> + pub fn CreateMediaSourceAudioInputNodeWithEmitterAsync(&self, mediasource: P0, emitter: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -1297,7 +1297,7 @@ impl AudioGraph { (windows_core::Interface::vtable(this).CreateMediaSourceAudioInputNodeWithEmitterAsync)(windows_core::Interface::as_raw(this), mediasource.param().abi(), emitter.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateAsync(settings: P0) -> windows_core::Result> + pub fn CreateAsync(settings: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2029,7 +2029,7 @@ impl AudioPlaybackConnection { let this = self; unsafe { (windows_core::Interface::vtable(this).Start)(windows_core::Interface::as_raw(this)).ok() } } - pub fn StartAsync(&self) -> windows_core::Result { + pub fn StartAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2057,7 +2057,7 @@ impl AudioPlaybackConnection { (windows_core::Interface::vtable(this).Open)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn OpenAsync(&self) -> windows_core::Result> { + pub fn OpenAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -5200,7 +5200,7 @@ impl SpatialAudioDeviceConfiguration { (windows_core::Interface::vtable(this).DefaultSpatialAudioFormat)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn SetDefaultSpatialAudioFormatAsync(&self, subtype: &windows_core::HSTRING) -> windows_core::Result> { + pub fn SetDefaultSpatialAudioFormatAsync(&self, subtype: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -5249,14 +5249,14 @@ unsafe impl Sync for SpatialAudioDeviceConfiguration {} pub struct SpatialAudioFormatConfiguration(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(SpatialAudioFormatConfiguration, windows_core::IUnknown, windows_core::IInspectable); impl SpatialAudioFormatConfiguration { - pub fn ReportLicenseChangedAsync(&self, subtype: &windows_core::HSTRING) -> windows_core::Result { + pub fn ReportLicenseChangedAsync(&self, subtype: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportLicenseChangedAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(subtype), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportConfigurationChangedAsync(&self, subtype: &windows_core::HSTRING) -> windows_core::Result { + pub fn ReportConfigurationChangedAsync(&self, subtype: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Media/Capture/Core/mod.rs b/crates/libs/windows/src/Windows/Media/Capture/Core/mod.rs index 8846fb5679..104f737191 100644 --- a/crates/libs/windows/src/Windows/Media/Capture/Core/mod.rs +++ b/crates/libs/windows/src/Windows/Media/Capture/Core/mod.rs @@ -89,21 +89,21 @@ unsafe impl Sync for VariablePhotoCapturedEventArgs {} pub struct VariablePhotoSequenceCapture(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(VariablePhotoSequenceCapture, windows_core::IUnknown, windows_core::IInspectable); impl VariablePhotoSequenceCapture { - pub fn StartAsync(&self) -> windows_core::Result { + pub fn StartAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).StartAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StopAsync(&self) -> windows_core::Result { + pub fn StopAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).StopAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FinishAsync(&self) -> windows_core::Result { + pub fn FinishAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -138,7 +138,7 @@ impl VariablePhotoSequenceCapture { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveStopped)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn UpdateSettingsAsync(&self) -> windows_core::Result { + pub fn UpdateSettingsAsync(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Media/Capture/Frames/mod.rs b/crates/libs/windows/src/Windows/Media/Capture/Frames/mod.rs index 528b3bf027..6a90f15656 100644 --- a/crates/libs/windows/src/Windows/Media/Capture/Frames/mod.rs +++ b/crates/libs/windows/src/Windows/Media/Capture/Frames/mod.rs @@ -693,14 +693,14 @@ impl MediaFrameReader { (windows_core::Interface::vtable(this).TryAcquireLatestFrame)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StartAsync(&self) -> windows_core::Result> { + pub fn StartAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).StartAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StopAsync(&self) -> windows_core::Result { + pub fn StopAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -880,7 +880,7 @@ impl MediaFrameSource { (windows_core::Interface::vtable(this).CurrentFormat)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SetFormatAsync(&self, format: P0) -> windows_core::Result + pub fn SetFormatAsync(&self, format: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -933,14 +933,14 @@ unsafe impl Sync for MediaFrameSource {} pub struct MediaFrameSourceController(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(MediaFrameSourceController, windows_core::IUnknown, windows_core::IInspectable); impl MediaFrameSourceController { - pub fn GetPropertyAsync(&self, propertyid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetPropertyAsync(&self, propertyid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetPropertyAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(propertyid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SetPropertyAsync(&self, propertyid: &windows_core::HSTRING, propertyvalue: P1) -> windows_core::Result> + pub fn SetPropertyAsync(&self, propertyid: &windows_core::HSTRING, propertyvalue: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -958,7 +958,7 @@ impl MediaFrameSourceController { (windows_core::Interface::vtable(this).VideoDeviceController)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetPropertyByExtendedIdAsync(&self, extendedpropertyid: &[u8], maxpropertyvaluesize: P1) -> windows_core::Result> + pub fn GetPropertyByExtendedIdAsync(&self, extendedpropertyid: &[u8], maxpropertyvaluesize: P1) -> windows_core::Result> where P1: windows_core::Param>, { @@ -968,7 +968,7 @@ impl MediaFrameSourceController { (windows_core::Interface::vtable(this).GetPropertyByExtendedIdAsync)(windows_core::Interface::as_raw(this), extendedpropertyid.len().try_into().unwrap(), extendedpropertyid.as_ptr(), maxpropertyvaluesize.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SetPropertyByExtendedIdAsync(&self, extendedpropertyid: &[u8], propertyvalue: &[u8]) -> windows_core::Result> { + pub fn SetPropertyByExtendedIdAsync(&self, extendedpropertyid: &[u8], propertyvalue: &[u8]) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1071,13 +1071,13 @@ impl MediaFrameSourceGroup { (windows_core::Interface::vtable(this).SourceInfos)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FindAllAsync() -> windows_core::Result>> { + pub fn FindAllAsync() -> windows_core::Result>> { Self::IMediaFrameSourceGroupStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAllAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn FromIdAsync(id: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(id: &windows_core::HSTRING) -> windows_core::Result> { Self::IMediaFrameSourceGroupStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(id), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -1290,14 +1290,14 @@ impl MultiSourceMediaFrameReader { (windows_core::Interface::vtable(this).TryAcquireLatestFrame)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StartAsync(&self) -> windows_core::Result> { + pub fn StartAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).StartAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StopAsync(&self) -> windows_core::Result { + pub fn StopAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Media/Capture/mod.rs b/crates/libs/windows/src/Windows/Media/Capture/mod.rs index f5dadc97aa..ed82f55778 100644 --- a/crates/libs/windows/src/Windows/Media/Capture/mod.rs +++ b/crates/libs/windows/src/Windows/Media/Capture/mod.rs @@ -55,14 +55,14 @@ unsafe impl Sync for AdvancedCapturedPhoto {} pub struct AdvancedPhotoCapture(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(AdvancedPhotoCapture, windows_core::IUnknown, windows_core::IInspectable); impl AdvancedPhotoCapture { - pub fn CaptureAsync(&self) -> windows_core::Result> { + pub fn CaptureAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CaptureAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CaptureWithContextAsync(&self, context: P0) -> windows_core::Result> + pub fn CaptureWithContextAsync(&self, context: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -100,7 +100,7 @@ impl AdvancedPhotoCapture { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveAllPhotosCaptured)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn FinishAsync(&self) -> windows_core::Result { + pub fn FinishAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1428,7 +1428,7 @@ impl AppBroadcastServices { (windows_core::Interface::vtable(this).CanCapture)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn EnterBroadcastModeAsync(&self, plugin: P0) -> windows_core::Result> + pub fn EnterBroadcastModeAsync(&self, plugin: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2245,7 +2245,7 @@ impl AppCapture { (windows_core::Interface::vtable(this).GetForCurrentView)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn SetAllowedAsync(allowed: bool) -> windows_core::Result { + pub fn SetAllowedAsync(allowed: bool) -> windows_core::Result { Self::IAppCaptureStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).SetAllowedAsync)(windows_core::Interface::as_raw(this), allowed, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -3392,7 +3392,7 @@ impl CameraCaptureUI { } } #[cfg(feature = "Storage_Streams")] - pub fn CaptureFileAsync(&self, mode: CameraCaptureUIMode) -> windows_core::Result> { + pub fn CaptureFileAsync(&self, mode: CameraCaptureUIMode) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -3692,7 +3692,7 @@ impl CapturedFrame { (windows_core::Interface::vtable(this).ContentType)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn ReadAsync(&self, buffer: P0, count: u32, options: super::super::Storage::Streams::InputStreamOptions) -> windows_core::Result> + pub fn ReadAsync(&self, buffer: P0, count: u32, options: super::super::Storage::Streams::InputStreamOptions) -> windows_core::Result> where P0: windows_core::Param, { @@ -3702,7 +3702,7 @@ impl CapturedFrame { (windows_core::Interface::vtable(this).ReadAsync)(windows_core::Interface::as_raw(this), buffer.param().abi(), count, options, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn WriteAsync(&self, buffer: P0) -> windows_core::Result> + pub fn WriteAsync(&self, buffer: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -3712,7 +3712,7 @@ impl CapturedFrame { (windows_core::Interface::vtable(this).WriteAsync)(windows_core::Interface::as_raw(this), buffer.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FlushAsync(&self) -> windows_core::Result> { + pub fn FlushAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -6122,21 +6122,21 @@ impl windows_core::RuntimeType for KnownVideoProfile { pub struct LowLagMediaRecording(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(LowLagMediaRecording, windows_core::IUnknown, windows_core::IInspectable); impl LowLagMediaRecording { - pub fn StartAsync(&self) -> windows_core::Result { + pub fn StartAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).StartAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StopAsync(&self) -> windows_core::Result { + pub fn StopAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).StopAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FinishAsync(&self) -> windows_core::Result { + pub fn FinishAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -6144,14 +6144,14 @@ impl LowLagMediaRecording { } } #[cfg(feature = "Media_Devices")] - pub fn PauseAsync(&self, behavior: super::Devices::MediaCapturePauseBehavior) -> windows_core::Result { + pub fn PauseAsync(&self, behavior: super::Devices::MediaCapturePauseBehavior) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).PauseAsync)(windows_core::Interface::as_raw(this), behavior, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ResumeAsync(&self) -> windows_core::Result { + pub fn ResumeAsync(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -6159,14 +6159,14 @@ impl LowLagMediaRecording { } } #[cfg(feature = "Media_Devices")] - pub fn PauseWithResultAsync(&self, behavior: super::Devices::MediaCapturePauseBehavior) -> windows_core::Result> { + pub fn PauseWithResultAsync(&self, behavior: super::Devices::MediaCapturePauseBehavior) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).PauseWithResultAsync)(windows_core::Interface::as_raw(this), behavior, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StopWithResultAsync(&self) -> windows_core::Result> { + pub fn StopWithResultAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -6189,14 +6189,14 @@ impl windows_core::RuntimeName for LowLagMediaRecording { pub struct LowLagPhotoCapture(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(LowLagPhotoCapture, windows_core::IUnknown, windows_core::IInspectable); impl LowLagPhotoCapture { - pub fn CaptureAsync(&self) -> windows_core::Result> { + pub fn CaptureAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CaptureAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FinishAsync(&self) -> windows_core::Result { + pub fn FinishAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -6219,21 +6219,21 @@ impl windows_core::RuntimeName for LowLagPhotoCapture { pub struct LowLagPhotoSequenceCapture(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(LowLagPhotoSequenceCapture, windows_core::IUnknown, windows_core::IInspectable); impl LowLagPhotoSequenceCapture { - pub fn StartAsync(&self) -> windows_core::Result { + pub fn StartAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).StartAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StopAsync(&self) -> windows_core::Result { + pub fn StopAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).StopAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FinishAsync(&self) -> windows_core::Result { + pub fn FinishAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -6282,14 +6282,14 @@ impl MediaCapture { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).Close)(windows_core::Interface::as_raw(this)).ok() } } - pub fn InitializeAsync(&self) -> windows_core::Result { + pub fn InitializeAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).InitializeAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn InitializeWithSettingsAsync(&self, mediacaptureinitializationsettings: P0) -> windows_core::Result + pub fn InitializeWithSettingsAsync(&self, mediacaptureinitializationsettings: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -6300,7 +6300,7 @@ impl MediaCapture { } } #[cfg(all(feature = "Media_MediaProperties", feature = "Storage_Streams"))] - pub fn StartRecordToStorageFileAsync(&self, encodingprofile: P0, file: P1) -> windows_core::Result + pub fn StartRecordToStorageFileAsync(&self, encodingprofile: P0, file: P1) -> windows_core::Result where P0: windows_core::Param, P1: windows_core::Param, @@ -6312,7 +6312,7 @@ impl MediaCapture { } } #[cfg(all(feature = "Media_MediaProperties", feature = "Storage_Streams"))] - pub fn StartRecordToStreamAsync(&self, encodingprofile: P0, stream: P1) -> windows_core::Result + pub fn StartRecordToStreamAsync(&self, encodingprofile: P0, stream: P1) -> windows_core::Result where P0: windows_core::Param, P1: windows_core::Param, @@ -6324,7 +6324,7 @@ impl MediaCapture { } } #[cfg(feature = "Media_MediaProperties")] - pub fn StartRecordToCustomSinkAsync(&self, encodingprofile: P0, custommediasink: P1) -> windows_core::Result + pub fn StartRecordToCustomSinkAsync(&self, encodingprofile: P0, custommediasink: P1) -> windows_core::Result where P0: windows_core::Param, P1: windows_core::Param, @@ -6336,7 +6336,7 @@ impl MediaCapture { } } #[cfg(all(feature = "Foundation_Collections", feature = "Media_MediaProperties"))] - pub fn StartRecordToCustomSinkIdAsync(&self, encodingprofile: P0, customsinkactivationid: &windows_core::HSTRING, customsinksettings: P2) -> windows_core::Result + pub fn StartRecordToCustomSinkIdAsync(&self, encodingprofile: P0, customsinkactivationid: &windows_core::HSTRING, customsinksettings: P2) -> windows_core::Result where P0: windows_core::Param, P2: windows_core::Param, @@ -6347,7 +6347,7 @@ impl MediaCapture { (windows_core::Interface::vtable(this).StartRecordToCustomSinkIdAsync)(windows_core::Interface::as_raw(this), encodingprofile.param().abi(), core::mem::transmute_copy(customsinkactivationid), customsinksettings.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StopRecordAsync(&self) -> windows_core::Result { + pub fn StopRecordAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -6355,7 +6355,7 @@ impl MediaCapture { } } #[cfg(all(feature = "Media_MediaProperties", feature = "Storage_Streams"))] - pub fn CapturePhotoToStorageFileAsync(&self, r#type: P0, file: P1) -> windows_core::Result + pub fn CapturePhotoToStorageFileAsync(&self, r#type: P0, file: P1) -> windows_core::Result where P0: windows_core::Param, P1: windows_core::Param, @@ -6367,7 +6367,7 @@ impl MediaCapture { } } #[cfg(all(feature = "Media_MediaProperties", feature = "Storage_Streams"))] - pub fn CapturePhotoToStreamAsync(&self, r#type: P0, stream: P1) -> windows_core::Result + pub fn CapturePhotoToStreamAsync(&self, r#type: P0, stream: P1) -> windows_core::Result where P0: windows_core::Param, P1: windows_core::Param, @@ -6379,7 +6379,7 @@ impl MediaCapture { } } #[cfg(all(feature = "Foundation_Collections", feature = "deprecated"))] - pub fn AddEffectAsync(&self, mediastreamtype: MediaStreamType, effectactivationid: &windows_core::HSTRING, effectsettings: P2) -> windows_core::Result + pub fn AddEffectAsync(&self, mediastreamtype: MediaStreamType, effectactivationid: &windows_core::HSTRING, effectsettings: P2) -> windows_core::Result where P2: windows_core::Param, { @@ -6389,7 +6389,7 @@ impl MediaCapture { (windows_core::Interface::vtable(this).AddEffectAsync)(windows_core::Interface::as_raw(this), mediastreamtype, core::mem::transmute_copy(effectactivationid), effectsettings.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ClearEffectsAsync(&self, mediastreamtype: MediaStreamType) -> windows_core::Result { + pub fn ClearEffectsAsync(&self, mediastreamtype: MediaStreamType) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -6495,7 +6495,7 @@ impl MediaCapture { } } #[cfg(all(feature = "Media_MediaProperties", feature = "Storage_Streams"))] - pub fn PrepareLowLagRecordToStorageFileAsync(&self, encodingprofile: P0, file: P1) -> windows_core::Result> + pub fn PrepareLowLagRecordToStorageFileAsync(&self, encodingprofile: P0, file: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -6507,7 +6507,7 @@ impl MediaCapture { } } #[cfg(all(feature = "Media_MediaProperties", feature = "Storage_Streams"))] - pub fn PrepareLowLagRecordToStreamAsync(&self, encodingprofile: P0, stream: P1) -> windows_core::Result> + pub fn PrepareLowLagRecordToStreamAsync(&self, encodingprofile: P0, stream: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -6519,7 +6519,7 @@ impl MediaCapture { } } #[cfg(feature = "Media_MediaProperties")] - pub fn PrepareLowLagRecordToCustomSinkAsync(&self, encodingprofile: P0, custommediasink: P1) -> windows_core::Result> + pub fn PrepareLowLagRecordToCustomSinkAsync(&self, encodingprofile: P0, custommediasink: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -6531,7 +6531,7 @@ impl MediaCapture { } } #[cfg(all(feature = "Foundation_Collections", feature = "Media_MediaProperties"))] - pub fn PrepareLowLagRecordToCustomSinkIdAsync(&self, encodingprofile: P0, customsinkactivationid: &windows_core::HSTRING, customsinksettings: P2) -> windows_core::Result> + pub fn PrepareLowLagRecordToCustomSinkIdAsync(&self, encodingprofile: P0, customsinkactivationid: &windows_core::HSTRING, customsinksettings: P2) -> windows_core::Result> where P0: windows_core::Param, P2: windows_core::Param, @@ -6543,7 +6543,7 @@ impl MediaCapture { } } #[cfg(feature = "Media_MediaProperties")] - pub fn PrepareLowLagPhotoCaptureAsync(&self, r#type: P0) -> windows_core::Result> + pub fn PrepareLowLagPhotoCaptureAsync(&self, r#type: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -6554,7 +6554,7 @@ impl MediaCapture { } } #[cfg(feature = "Media_MediaProperties")] - pub fn PrepareLowLagPhotoSequenceCaptureAsync(&self, r#type: P0) -> windows_core::Result> + pub fn PrepareLowLagPhotoSequenceCaptureAsync(&self, r#type: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -6565,7 +6565,7 @@ impl MediaCapture { } } #[cfg(feature = "Media_MediaProperties")] - pub fn SetEncodingPropertiesAsync(&self, mediastreamtype: MediaStreamType, mediaencodingproperties: P1, encoderproperties: P2) -> windows_core::Result + pub fn SetEncodingPropertiesAsync(&self, mediastreamtype: MediaStreamType, mediaencodingproperties: P1, encoderproperties: P2) -> windows_core::Result where P1: windows_core::Param, P2: windows_core::Param, @@ -6577,7 +6577,7 @@ impl MediaCapture { } } #[cfg(all(feature = "Media_Capture_Core", feature = "Media_MediaProperties"))] - pub fn PrepareVariablePhotoSequenceCaptureAsync(&self, r#type: P0) -> windows_core::Result> + pub fn PrepareVariablePhotoSequenceCaptureAsync(&self, r#type: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -6616,7 +6616,7 @@ impl MediaCapture { unsafe { (windows_core::Interface::vtable(this).RemovePhotoConfirmationCaptured)(windows_core::Interface::as_raw(this), token).ok() } } #[cfg(feature = "Media_Effects")] - pub fn AddAudioEffectAsync(&self, definition: P0) -> windows_core::Result> + pub fn AddAudioEffectAsync(&self, definition: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -6627,7 +6627,7 @@ impl MediaCapture { } } #[cfg(feature = "Media_Effects")] - pub fn AddVideoEffectAsync(&self, definition: P0, mediastreamtype: MediaStreamType) -> windows_core::Result> + pub fn AddVideoEffectAsync(&self, definition: P0, mediastreamtype: MediaStreamType) -> windows_core::Result> where P0: windows_core::Param, { @@ -6638,14 +6638,14 @@ impl MediaCapture { } } #[cfg(feature = "Media_Devices")] - pub fn PauseRecordAsync(&self, behavior: super::Devices::MediaCapturePauseBehavior) -> windows_core::Result { + pub fn PauseRecordAsync(&self, behavior: super::Devices::MediaCapturePauseBehavior) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).PauseRecordAsync)(windows_core::Interface::as_raw(this), behavior, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ResumeRecordAsync(&self) -> windows_core::Result { + pub fn ResumeRecordAsync(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -6674,14 +6674,14 @@ impl MediaCapture { (windows_core::Interface::vtable(this).CameraStreamState)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn GetPreviewFrameAsync(&self) -> windows_core::Result> { + pub fn GetPreviewFrameAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetPreviewFrameAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetPreviewFrameCopyAsync(&self, destination: P0) -> windows_core::Result> + pub fn GetPreviewFrameCopyAsync(&self, destination: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -6713,7 +6713,7 @@ impl MediaCapture { } } #[cfg(feature = "Media_MediaProperties")] - pub fn PrepareAdvancedPhotoCaptureAsync(&self, encodingproperties: P0) -> windows_core::Result> + pub fn PrepareAdvancedPhotoCaptureAsync(&self, encodingproperties: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -6723,7 +6723,7 @@ impl MediaCapture { (windows_core::Interface::vtable(this).PrepareAdvancedPhotoCaptureAsync)(windows_core::Interface::as_raw(this), encodingproperties.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RemoveEffectAsync(&self, effect: P0) -> windows_core::Result + pub fn RemoveEffectAsync(&self, effect: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -6734,14 +6734,14 @@ impl MediaCapture { } } #[cfg(feature = "Media_Devices")] - pub fn PauseRecordWithResultAsync(&self, behavior: super::Devices::MediaCapturePauseBehavior) -> windows_core::Result> { + pub fn PauseRecordWithResultAsync(&self, behavior: super::Devices::MediaCapturePauseBehavior) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).PauseRecordWithResultAsync)(windows_core::Interface::as_raw(this), behavior, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StopRecordWithResultAsync(&self) -> windows_core::Result> { + pub fn StopRecordWithResultAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -6757,7 +6757,7 @@ impl MediaCapture { } } #[cfg(feature = "Media_Capture_Frames")] - pub fn CreateFrameReaderAsync(&self, inputsource: P0) -> windows_core::Result> + pub fn CreateFrameReaderAsync(&self, inputsource: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -6768,7 +6768,7 @@ impl MediaCapture { } } #[cfg(feature = "Media_Capture_Frames")] - pub fn CreateFrameReaderWithSubtypeAsync(&self, inputsource: P0, outputsubtype: &windows_core::HSTRING) -> windows_core::Result> + pub fn CreateFrameReaderWithSubtypeAsync(&self, inputsource: P0, outputsubtype: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -6779,7 +6779,7 @@ impl MediaCapture { } } #[cfg(all(feature = "Graphics_Imaging", feature = "Media_Capture_Frames"))] - pub fn CreateFrameReaderWithSubtypeAndSizeAsync(&self, inputsource: P0, outputsubtype: &windows_core::HSTRING, outputsize: super::super::Graphics::Imaging::BitmapSize) -> windows_core::Result> + pub fn CreateFrameReaderWithSubtypeAndSizeAsync(&self, inputsource: P0, outputsubtype: &windows_core::HSTRING, outputsize: super::super::Graphics::Imaging::BitmapSize) -> windows_core::Result> where P0: windows_core::Param, { @@ -6804,7 +6804,7 @@ impl MediaCapture { unsafe { (windows_core::Interface::vtable(this).RemoveCaptureDeviceExclusiveControlStatusChanged)(windows_core::Interface::as_raw(this), token).ok() } } #[cfg(feature = "Media_Capture_Frames")] - pub fn CreateMultiSourceFrameReaderAsync(&self, inputsources: P0) -> windows_core::Result> + pub fn CreateMultiSourceFrameReaderAsync(&self, inputsources: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -6849,7 +6849,7 @@ impl MediaCapture { (windows_core::Interface::vtable(this).FindKnownVideoProfiles)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(videodeviceid), name, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn StartPreviewAsync(&self) -> windows_core::Result { + pub fn StartPreviewAsync(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -6857,7 +6857,7 @@ impl MediaCapture { } } #[cfg(feature = "Media_MediaProperties")] - pub fn StartPreviewToCustomSinkAsync(&self, encodingprofile: P0, custommediasink: P1) -> windows_core::Result + pub fn StartPreviewToCustomSinkAsync(&self, encodingprofile: P0, custommediasink: P1) -> windows_core::Result where P0: windows_core::Param, P1: windows_core::Param, @@ -6869,7 +6869,7 @@ impl MediaCapture { } } #[cfg(all(feature = "Foundation_Collections", feature = "Media_MediaProperties"))] - pub fn StartPreviewToCustomSinkIdAsync(&self, encodingprofile: P0, customsinkactivationid: &windows_core::HSTRING, customsinksettings: P2) -> windows_core::Result + pub fn StartPreviewToCustomSinkIdAsync(&self, encodingprofile: P0, customsinkactivationid: &windows_core::HSTRING, customsinksettings: P2) -> windows_core::Result where P0: windows_core::Param, P2: windows_core::Param, @@ -6880,7 +6880,7 @@ impl MediaCapture { (windows_core::Interface::vtable(this).StartPreviewToCustomSinkIdAsync)(windows_core::Interface::as_raw(this), encodingprofile.param().abi(), core::mem::transmute_copy(customsinkactivationid), customsinksettings.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StopPreviewAsync(&self) -> windows_core::Result { + pub fn StopPreviewAsync(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Media/Casting/mod.rs b/crates/libs/windows/src/Windows/Media/Casting/mod.rs index d9762560e1..62060ea1f4 100644 --- a/crates/libs/windows/src/Windows/Media/Casting/mod.rs +++ b/crates/libs/windows/src/Windows/Media/Casting/mod.rs @@ -60,7 +60,7 @@ impl CastingConnection { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveErrorOccurred)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn RequestStartCastingAsync(&self, value: P0) -> windows_core::Result> + pub fn RequestStartCastingAsync(&self, value: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -70,7 +70,7 @@ impl CastingConnection { (windows_core::Interface::vtable(this).RequestStartCastingAsync)(windows_core::Interface::as_raw(this), value.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DisconnectAsync(&self) -> windows_core::Result> { + pub fn DisconnectAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -187,7 +187,7 @@ impl CastingDevice { (windows_core::Interface::vtable(this).Icon)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetSupportedCastingPlaybackTypesAsync(&self) -> windows_core::Result> { + pub fn GetSupportedCastingPlaybackTypesAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -207,7 +207,7 @@ impl CastingDevice { (windows_core::Interface::vtable(this).GetDeviceSelector)(windows_core::Interface::as_raw(this), r#type, &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn GetDeviceSelectorFromCastingSourceAsync(castingsource: P0) -> windows_core::Result> + pub fn GetDeviceSelectorFromCastingSourceAsync(castingsource: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -216,14 +216,14 @@ impl CastingDevice { (windows_core::Interface::vtable(this).GetDeviceSelectorFromCastingSourceAsync)(windows_core::Interface::as_raw(this), castingsource.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn FromIdAsync(value: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(value: &windows_core::HSTRING) -> windows_core::Result> { Self::ICastingDeviceStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(value), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "Devices_Enumeration")] - pub fn DeviceInfoSupportsCastingAsync(device: P0) -> windows_core::Result> + pub fn DeviceInfoSupportsCastingAsync(device: P0) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Media/ContentRestrictions/mod.rs b/crates/libs/windows/src/Windows/Media/ContentRestrictions/mod.rs index 3ac6e87bb8..0007f3f60b 100644 --- a/crates/libs/windows/src/Windows/Media/ContentRestrictions/mod.rs +++ b/crates/libs/windows/src/Windows/Media/ContentRestrictions/mod.rs @@ -238,14 +238,14 @@ impl RatedContentRestrictions { static SHARED: windows_core::imp::FactoryCache = windows_core::imp::FactoryCache::new(); SHARED.call(callback) } - pub fn GetBrowsePolicyAsync(&self) -> windows_core::Result> { + pub fn GetBrowsePolicyAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetBrowsePolicyAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetRestrictionLevelAsync(&self, ratedcontentdescription: P0) -> windows_core::Result> + pub fn GetRestrictionLevelAsync(&self, ratedcontentdescription: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -255,7 +255,7 @@ impl RatedContentRestrictions { (windows_core::Interface::vtable(this).GetRestrictionLevelAsync)(windows_core::Interface::as_raw(this), ratedcontentdescription.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestContentAccessAsync(&self, ratedcontentdescription: P0) -> windows_core::Result> + pub fn RequestContentAccessAsync(&self, ratedcontentdescription: P0) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Media/Control/mod.rs b/crates/libs/windows/src/Windows/Media/Control/mod.rs index 2abf0771b3..70d77ecca0 100644 --- a/crates/libs/windows/src/Windows/Media/Control/mod.rs +++ b/crates/libs/windows/src/Windows/Media/Control/mod.rs @@ -27,7 +27,7 @@ impl GlobalSystemMediaTransportControlsSession { (windows_core::Interface::vtable(this).SourceAppUserModelId)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn TryGetMediaPropertiesAsync(&self) -> windows_core::Result> { + pub fn TryGetMediaPropertiesAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -48,105 +48,105 @@ impl GlobalSystemMediaTransportControlsSession { (windows_core::Interface::vtable(this).GetPlaybackInfo)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryPlayAsync(&self) -> windows_core::Result> { + pub fn TryPlayAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryPlayAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryPauseAsync(&self) -> windows_core::Result> { + pub fn TryPauseAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryPauseAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryStopAsync(&self) -> windows_core::Result> { + pub fn TryStopAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryStopAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryRecordAsync(&self) -> windows_core::Result> { + pub fn TryRecordAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryRecordAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryFastForwardAsync(&self) -> windows_core::Result> { + pub fn TryFastForwardAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryFastForwardAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryRewindAsync(&self) -> windows_core::Result> { + pub fn TryRewindAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryRewindAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TrySkipNextAsync(&self) -> windows_core::Result> { + pub fn TrySkipNextAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TrySkipNextAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TrySkipPreviousAsync(&self) -> windows_core::Result> { + pub fn TrySkipPreviousAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TrySkipPreviousAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryChangeChannelUpAsync(&self) -> windows_core::Result> { + pub fn TryChangeChannelUpAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryChangeChannelUpAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryChangeChannelDownAsync(&self) -> windows_core::Result> { + pub fn TryChangeChannelDownAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryChangeChannelDownAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryTogglePlayPauseAsync(&self) -> windows_core::Result> { + pub fn TryTogglePlayPauseAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryTogglePlayPauseAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryChangeAutoRepeatModeAsync(&self, requestedautorepeatmode: super::MediaPlaybackAutoRepeatMode) -> windows_core::Result> { + pub fn TryChangeAutoRepeatModeAsync(&self, requestedautorepeatmode: super::MediaPlaybackAutoRepeatMode) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryChangeAutoRepeatModeAsync)(windows_core::Interface::as_raw(this), requestedautorepeatmode, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryChangePlaybackRateAsync(&self, requestedplaybackrate: f64) -> windows_core::Result> { + pub fn TryChangePlaybackRateAsync(&self, requestedplaybackrate: f64) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryChangePlaybackRateAsync)(windows_core::Interface::as_raw(this), requestedplaybackrate, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryChangeShuffleActiveAsync(&self, requestedshufflestate: bool) -> windows_core::Result> { + pub fn TryChangeShuffleActiveAsync(&self, requestedshufflestate: bool) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryChangeShuffleActiveAsync)(windows_core::Interface::as_raw(this), requestedshufflestate, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryChangePlaybackPositionAsync(&self, requestedplaybackposition: i64) -> windows_core::Result> { + pub fn TryChangePlaybackPositionAsync(&self, requestedplaybackposition: i64) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -255,7 +255,7 @@ impl GlobalSystemMediaTransportControlsSessionManager { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveSessionsChanged)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn RequestAsync() -> windows_core::Result> { + pub fn RequestAsync() -> windows_core::Result> { Self::IGlobalSystemMediaTransportControlsSessionManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/Media/Core/mod.rs b/crates/libs/windows/src/Windows/Media/Core/mod.rs index c9308871ce..d1a567437e 100644 --- a/crates/libs/windows/src/Windows/Media/Core/mod.rs +++ b/crates/libs/windows/src/Windows/Media/Core/mod.rs @@ -471,7 +471,7 @@ impl CodecQuery { static SHARED: windows_core::imp::FactoryCache = windows_core::imp::FactoryCache::new(); SHARED.call(callback) } - pub fn FindAllAsync(&self, kind: CodecKind, category: CodecCategory, subtype: &windows_core::HSTRING) -> windows_core::Result>> { + pub fn FindAllAsync(&self, kind: CodecKind, category: CodecCategory, subtype: &windows_core::HSTRING) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -3513,7 +3513,7 @@ impl LowLightFusion { }) } #[cfg(feature = "Graphics_Imaging")] - pub fn FuseAsync(frameset: P0) -> windows_core::Result> + pub fn FuseAsync(frameset: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -3872,7 +3872,7 @@ impl MediaSource { (windows_core::Interface::vtable(this).Uri)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn OpenAsync(&self) -> windows_core::Result { + pub fn OpenAsync(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -4296,7 +4296,7 @@ impl MediaStreamSample { }) } #[cfg(feature = "Storage_Streams")] - pub fn CreateFromStreamAsync(stream: P0, count: u32, timestamp: super::super::Foundation::TimeSpan) -> windows_core::Result> + pub fn CreateFromStreamAsync(stream: P0, count: u32, timestamp: super::super::Foundation::TimeSpan) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Media/Devices/mod.rs b/crates/libs/windows/src/Windows/Media/Devices/mod.rs index 81f92cec89..f2b257155c 100644 --- a/crates/libs/windows/src/Windows/Media/Devices/mod.rs +++ b/crates/libs/windows/src/Windows/Media/Devices/mod.rs @@ -150,7 +150,7 @@ impl AudioDeviceController { } } #[cfg(all(feature = "Media_Capture", feature = "Media_MediaProperties"))] - pub fn SetMediaStreamPropertiesAsync(&self, mediastreamtype: super::Capture::MediaStreamType, mediaencodingproperties: P1) -> windows_core::Result + pub fn SetMediaStreamPropertiesAsync(&self, mediastreamtype: super::Capture::MediaStreamType, mediaencodingproperties: P1) -> windows_core::Result where P1: windows_core::Param, { @@ -212,7 +212,7 @@ impl AudioDeviceModule { } } #[cfg(feature = "Storage_Streams")] - pub fn SendCommandAsync(&self, command: P0) -> windows_core::Result> + pub fn SendCommandAsync(&self, command: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1157,7 +1157,7 @@ impl ExposureCompensationControl { (windows_core::Interface::vtable(this).Value)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn SetValueAsync(&self, value: f32) -> windows_core::Result { + pub fn SetValueAsync(&self, value: f32) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1194,7 +1194,7 @@ impl ExposureControl { (windows_core::Interface::vtable(this).Auto)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn SetAutoAsync(&self, value: bool) -> windows_core::Result { + pub fn SetAutoAsync(&self, value: bool) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1229,7 +1229,7 @@ impl ExposureControl { (windows_core::Interface::vtable(this).Value)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn SetValueAsync(&self, shutterduration: super::super::Foundation::TimeSpan) -> windows_core::Result { + pub fn SetValueAsync(&self, shutterduration: super::super::Foundation::TimeSpan) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1408,14 +1408,14 @@ impl FocusControl { (windows_core::Interface::vtable(this).Preset)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn SetPresetAsync(&self, preset: FocusPreset) -> windows_core::Result { + pub fn SetPresetAsync(&self, preset: FocusPreset) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).SetPresetAsync)(windows_core::Interface::as_raw(this), preset, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SetPresetWithCompletionOptionAsync(&self, preset: FocusPreset, completebeforefocus: bool) -> windows_core::Result { + pub fn SetPresetWithCompletionOptionAsync(&self, preset: FocusPreset, completebeforefocus: bool) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1450,14 +1450,14 @@ impl FocusControl { (windows_core::Interface::vtable(this).Value)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn SetValueAsync(&self, focus: u32) -> windows_core::Result { + pub fn SetValueAsync(&self, focus: u32) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).SetValueAsync)(windows_core::Interface::as_raw(this), focus, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FocusAsync(&self) -> windows_core::Result { + pub fn FocusAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1513,14 +1513,14 @@ impl FocusControl { (windows_core::Interface::vtable(this).FocusState)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn UnlockAsync(&self) -> windows_core::Result { + pub fn UnlockAsync(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).UnlockAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn LockAsync(&self) -> windows_core::Result { + pub fn LockAsync(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -2465,7 +2465,7 @@ impl IMediaDeviceController { } } #[cfg(all(feature = "Media_Capture", feature = "Media_MediaProperties"))] - pub fn SetMediaStreamPropertiesAsync(&self, mediastreamtype: super::Capture::MediaStreamType, mediaencodingproperties: P1) -> windows_core::Result + pub fn SetMediaStreamPropertiesAsync(&self, mediastreamtype: super::Capture::MediaStreamType, mediaencodingproperties: P1) -> windows_core::Result where P1: windows_core::Param, { @@ -2484,7 +2484,7 @@ impl windows_core::RuntimeName for IMediaDeviceController { pub trait IMediaDeviceController_Impl: windows_core::IUnknownImpl { fn GetAvailableMediaStreamProperties(&self, mediaStreamType: super::Capture::MediaStreamType) -> windows_core::Result>; fn GetMediaStreamProperties(&self, mediaStreamType: super::Capture::MediaStreamType) -> windows_core::Result; - fn SetMediaStreamPropertiesAsync(&self, mediaStreamType: super::Capture::MediaStreamType, mediaEncodingProperties: windows_core::Ref<'_, super::MediaProperties::IMediaEncodingProperties>) -> windows_core::Result; + fn SetMediaStreamPropertiesAsync(&self, mediaStreamType: super::Capture::MediaStreamType, mediaEncodingProperties: windows_core::Ref<'_, super::MediaProperties::IMediaEncodingProperties>) -> windows_core::Result; } #[cfg(all(feature = "Media_Capture", feature = "Media_MediaProperties"))] impl IMediaDeviceController_Vtbl { @@ -2932,7 +2932,7 @@ impl IsoSpeedControl { } } #[cfg(feature = "deprecated")] - pub fn SetPresetAsync(&self, preset: IsoSpeedPreset) -> windows_core::Result { + pub fn SetPresetAsync(&self, preset: IsoSpeedPreset) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2967,7 +2967,7 @@ impl IsoSpeedControl { (windows_core::Interface::vtable(this).Value)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn SetValueAsync(&self, isospeed: u32) -> windows_core::Result { + pub fn SetValueAsync(&self, isospeed: u32) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -2981,7 +2981,7 @@ impl IsoSpeedControl { (windows_core::Interface::vtable(this).Auto)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn SetAutoAsync(&self) -> windows_core::Result { + pub fn SetAutoAsync(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -3938,7 +3938,7 @@ impl RegionsOfInterestControl { (windows_core::Interface::vtable(this).MaxRegions)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn SetRegionsAsync(&self, regions: P0) -> windows_core::Result + pub fn SetRegionsAsync(&self, regions: P0) -> windows_core::Result where P0: windows_core::Param>, { @@ -3948,7 +3948,7 @@ impl RegionsOfInterestControl { (windows_core::Interface::vtable(this).SetRegionsAsync)(windows_core::Interface::as_raw(this), regions.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SetRegionsWithLockAsync(&self, regions: P0, lockvalues: bool) -> windows_core::Result + pub fn SetRegionsWithLockAsync(&self, regions: P0, lockvalues: bool) -> windows_core::Result where P0: windows_core::Param>, { @@ -3958,7 +3958,7 @@ impl RegionsOfInterestControl { (windows_core::Interface::vtable(this).SetRegionsWithLockAsync)(windows_core::Interface::as_raw(this), regions.param().abi(), lockvalues, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ClearRegionsAsync(&self) -> windows_core::Result { + pub fn ClearRegionsAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -4016,7 +4016,7 @@ impl SceneModeControl { (windows_core::Interface::vtable(this).Value)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn SetValueAsync(&self, scenemode: CaptureSceneMode) -> windows_core::Result { + pub fn SetValueAsync(&self, scenemode: CaptureSceneMode) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -4399,7 +4399,7 @@ impl VideoDeviceController { } } #[cfg(all(feature = "Media_Capture", feature = "Media_MediaProperties"))] - pub fn SetMediaStreamPropertiesAsync(&self, mediastreamtype: super::Capture::MediaStreamType, mediaencodingproperties: P1) -> windows_core::Result + pub fn SetMediaStreamPropertiesAsync(&self, mediastreamtype: super::Capture::MediaStreamType, mediaencodingproperties: P1) -> windows_core::Result where P1: windows_core::Param, { @@ -4656,7 +4656,7 @@ impl WhiteBalanceControl { (windows_core::Interface::vtable(this).Preset)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn SetPresetAsync(&self, preset: ColorTemperaturePreset) -> windows_core::Result { + pub fn SetPresetAsync(&self, preset: ColorTemperaturePreset) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -4691,7 +4691,7 @@ impl WhiteBalanceControl { (windows_core::Interface::vtable(this).Value)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn SetValueAsync(&self, temperature: u32) -> windows_core::Result { + pub fn SetValueAsync(&self, temperature: u32) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Media/DialProtocol/mod.rs b/crates/libs/windows/src/Windows/Media/DialProtocol/mod.rs index 8c352baa3c..e87828b680 100644 --- a/crates/libs/windows/src/Windows/Media/DialProtocol/mod.rs +++ b/crates/libs/windows/src/Windows/Media/DialProtocol/mod.rs @@ -10,21 +10,21 @@ impl DialApp { (windows_core::Interface::vtable(this).AppName)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn RequestLaunchAsync(&self, appargument: &windows_core::HSTRING) -> windows_core::Result> { + pub fn RequestLaunchAsync(&self, appargument: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestLaunchAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(appargument), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StopAsync(&self) -> windows_core::Result> { + pub fn StopAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).StopAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAppStateAsync(&self) -> windows_core::Result> { + pub fn GetAppStateAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -161,14 +161,14 @@ impl DialDevice { (windows_core::Interface::vtable(this).GetDeviceSelector)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(appname), &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn FromIdAsync(value: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(value: &windows_core::HSTRING) -> windows_core::Result> { Self::IDialDeviceStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(value), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "Devices_Enumeration")] - pub fn DeviceInfoSupportsDialAsync(device: P0) -> windows_core::Result> + pub fn DeviceInfoSupportsDialAsync(device: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -289,7 +289,7 @@ impl DialDevicePicker { let this = self; unsafe { (windows_core::Interface::vtable(this).ShowWithPlacement)(windows_core::Interface::as_raw(this), selection, preferredplacement).ok() } } - pub fn PickSingleDialDeviceAsync(&self, selection: super::super::Foundation::Rect) -> windows_core::Result> { + pub fn PickSingleDialDeviceAsync(&self, selection: super::super::Foundation::Rect) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -297,7 +297,7 @@ impl DialDevicePicker { } } #[cfg(feature = "UI_Popups")] - pub fn PickSingleDialDeviceAsyncWithPlacement(&self, selection: super::super::Foundation::Rect, preferredplacement: super::super::UI::Popups::Placement) -> windows_core::Result> { + pub fn PickSingleDialDeviceAsyncWithPlacement(&self, selection: super::super::Foundation::Rect, preferredplacement: super::super::UI::Popups::Placement) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -408,14 +408,14 @@ unsafe impl Sync for DialDisconnectButtonClickedEventArgs {} pub struct DialReceiverApp(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(DialReceiverApp, windows_core::IUnknown, windows_core::IInspectable); impl DialReceiverApp { - pub fn GetAdditionalDataAsync(&self) -> windows_core::Result>> { + pub fn GetAdditionalDataAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetAdditionalDataAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SetAdditionalDataAsync(&self, additionaldata: P0) -> windows_core::Result + pub fn SetAdditionalDataAsync(&self, additionaldata: P0) -> windows_core::Result where P0: windows_core::Param>>, { @@ -425,7 +425,7 @@ impl DialReceiverApp { (windows_core::Interface::vtable(this).SetAdditionalDataAsync)(windows_core::Interface::as_raw(this), additionaldata.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetUniqueDeviceNameAsync(&self) -> windows_core::Result> { + pub fn GetUniqueDeviceNameAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Media/Editing/mod.rs b/crates/libs/windows/src/Windows/Media/Editing/mod.rs index c8bd60f426..fd54d74466 100644 --- a/crates/libs/windows/src/Windows/Media/Editing/mod.rs +++ b/crates/libs/windows/src/Windows/Media/Editing/mod.rs @@ -101,7 +101,7 @@ impl BackgroundAudioTrack { }) } #[cfg(feature = "Storage_Streams")] - pub fn CreateFromFileAsync(file: P0) -> windows_core::Result> + pub fn CreateFromFileAsync(file: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -531,7 +531,7 @@ impl MediaClip { }) } #[cfg(feature = "Storage_Streams")] - pub fn CreateFromFileAsync(file: P0) -> windows_core::Result> + pub fn CreateFromFileAsync(file: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -541,7 +541,7 @@ impl MediaClip { }) } #[cfg(feature = "Storage_Streams")] - pub fn CreateFromImageFileAsync(file: P0, originalduration: super::super::Foundation::TimeSpan) -> windows_core::Result> + pub fn CreateFromImageFileAsync(file: P0, originalduration: super::super::Foundation::TimeSpan) -> windows_core::Result> where P0: windows_core::Param, { @@ -629,7 +629,7 @@ impl MediaComposition { } } #[cfg(feature = "Storage_Streams")] - pub fn SaveAsync(&self, file: P0) -> windows_core::Result + pub fn SaveAsync(&self, file: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -640,7 +640,7 @@ impl MediaComposition { } } #[cfg(all(feature = "Graphics_Imaging", feature = "Storage_Streams"))] - pub fn GetThumbnailAsync(&self, timefromstart: super::super::Foundation::TimeSpan, scaledwidth: i32, scaledheight: i32, frameprecision: VideoFramePrecision) -> windows_core::Result> { + pub fn GetThumbnailAsync(&self, timefromstart: super::super::Foundation::TimeSpan, scaledwidth: i32, scaledheight: i32, frameprecision: VideoFramePrecision) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -648,7 +648,7 @@ impl MediaComposition { } } #[cfg(all(feature = "Graphics_Imaging", feature = "Storage_Streams"))] - pub fn GetThumbnailsAsync(&self, timesfromstart: P0, scaledwidth: i32, scaledheight: i32, frameprecision: VideoFramePrecision) -> windows_core::Result>> + pub fn GetThumbnailsAsync(&self, timesfromstart: P0, scaledwidth: i32, scaledheight: i32, frameprecision: VideoFramePrecision) -> windows_core::Result>> where P0: windows_core::Param>, { @@ -659,7 +659,7 @@ impl MediaComposition { } } #[cfg(all(feature = "Media_Transcoding", feature = "Storage_Streams"))] - pub fn RenderToFileAsync(&self, destination: P0) -> windows_core::Result> + pub fn RenderToFileAsync(&self, destination: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -670,7 +670,7 @@ impl MediaComposition { } } #[cfg(all(feature = "Media_Transcoding", feature = "Storage_Streams"))] - pub fn RenderToFileWithTrimmingPreferenceAsync(&self, destination: P0, trimmingpreference: MediaTrimmingPreference) -> windows_core::Result> + pub fn RenderToFileWithTrimmingPreferenceAsync(&self, destination: P0, trimmingpreference: MediaTrimmingPreference) -> windows_core::Result> where P0: windows_core::Param, { @@ -681,7 +681,7 @@ impl MediaComposition { } } #[cfg(all(feature = "Media_MediaProperties", feature = "Media_Transcoding", feature = "Storage_Streams"))] - pub fn RenderToFileWithProfileAsync(&self, destination: P0, trimmingpreference: MediaTrimmingPreference, encodingprofile: P2) -> windows_core::Result> + pub fn RenderToFileWithProfileAsync(&self, destination: P0, trimmingpreference: MediaTrimmingPreference, encodingprofile: P2) -> windows_core::Result> where P0: windows_core::Param, P2: windows_core::Param, @@ -735,7 +735,7 @@ impl MediaComposition { } } #[cfg(feature = "Storage_Streams")] - pub fn LoadAsync(file: P0) -> windows_core::Result> + pub fn LoadAsync(file: P0) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Media/FaceAnalysis/mod.rs b/crates/libs/windows/src/Windows/Media/FaceAnalysis/mod.rs index 136b469c86..f159cdc01b 100644 --- a/crates/libs/windows/src/Windows/Media/FaceAnalysis/mod.rs +++ b/crates/libs/windows/src/Windows/Media/FaceAnalysis/mod.rs @@ -30,7 +30,7 @@ pub struct FaceDetector(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(FaceDetector, windows_core::IUnknown, windows_core::IInspectable); impl FaceDetector { #[cfg(feature = "Graphics_Imaging")] - pub fn DetectFacesAsync(&self, image: P0) -> windows_core::Result>> + pub fn DetectFacesAsync(&self, image: P0) -> windows_core::Result>> where P0: windows_core::Param, { @@ -41,7 +41,7 @@ impl FaceDetector { } } #[cfg(feature = "Graphics_Imaging")] - pub fn DetectFacesWithSearchAreaAsync(&self, image: P0, searcharea: super::super::Graphics::Imaging::BitmapBounds) -> windows_core::Result>> + pub fn DetectFacesWithSearchAreaAsync(&self, image: P0, searcharea: super::super::Graphics::Imaging::BitmapBounds) -> windows_core::Result>> where P0: windows_core::Param, { @@ -77,7 +77,7 @@ impl FaceDetector { let this = self; unsafe { (windows_core::Interface::vtable(this).SetMaxDetectableFaceSize)(windows_core::Interface::as_raw(this), value).ok() } } - pub fn CreateAsync() -> windows_core::Result> { + pub fn CreateAsync() -> windows_core::Result> { Self::IFaceDetectorStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreateAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -125,7 +125,7 @@ unsafe impl Sync for FaceDetector {} pub struct FaceTracker(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(FaceTracker, windows_core::IUnknown, windows_core::IInspectable); impl FaceTracker { - pub fn ProcessNextFrameAsync(&self, videoframe: P0) -> windows_core::Result>> + pub fn ProcessNextFrameAsync(&self, videoframe: P0) -> windows_core::Result>> where P0: windows_core::Param, { @@ -161,7 +161,7 @@ impl FaceTracker { let this = self; unsafe { (windows_core::Interface::vtable(this).SetMaxDetectableFaceSize)(windows_core::Interface::as_raw(this), value).ok() } } - pub fn CreateAsync() -> windows_core::Result> { + pub fn CreateAsync() -> windows_core::Result> { Self::IFaceTrackerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreateAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/Media/Import/mod.rs b/crates/libs/windows/src/Windows/Media/Import/mod.rs index cf44f0aad6..d37adcd9a5 100644 --- a/crates/libs/windows/src/Windows/Media/Import/mod.rs +++ b/crates/libs/windows/src/Windows/Media/Import/mod.rs @@ -555,7 +555,7 @@ impl PhotoImportFindItemsResult { let this = self; unsafe { (windows_core::Interface::vtable(this).SelectNone)(windows_core::Interface::as_raw(this)).ok() } } - pub fn SelectNewAsync(&self) -> windows_core::Result { + pub fn SelectNewAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -657,7 +657,7 @@ impl PhotoImportFindItemsResult { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveSelectionChanged)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn ImportItemsAsync(&self) -> windows_core::Result> { + pub fn ImportItemsAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -791,7 +791,7 @@ impl PhotoImportImportItemsResult { (windows_core::Interface::vtable(this).TotalSizeInBytes)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn DeleteImportedItemsFromSourceAsync(&self) -> windows_core::Result> { + pub fn DeleteImportedItemsFromSourceAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -981,13 +981,13 @@ impl windows_core::RuntimeType for PhotoImportItemSelectionMode { } pub struct PhotoImportManager; impl PhotoImportManager { - pub fn IsSupportedAsync() -> windows_core::Result> { + pub fn IsSupportedAsync() -> windows_core::Result> { Self::IPhotoImportManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).IsSupportedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn FindAllSourcesAsync() -> windows_core::Result>> { + pub fn FindAllSourcesAsync() -> windows_core::Result>> { Self::IPhotoImportManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAllSourcesAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -1026,21 +1026,21 @@ impl PhotoImportOperation { (windows_core::Interface::vtable(this).Session)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ContinueFindingItemsAsync(&self) -> windows_core::Result> { + pub fn ContinueFindingItemsAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ContinueFindingItemsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ContinueImportingItemsAsync(&self) -> windows_core::Result> { + pub fn ContinueImportingItemsAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ContinueImportingItemsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ContinueDeletingImportedItemsFromSourceAsync(&self) -> windows_core::Result> { + pub fn ContinueDeletingImportedItemsFromSourceAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1187,7 +1187,7 @@ impl PhotoImportSession { (windows_core::Interface::vtable(this).DestinationFileNamePrefix)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn FindItemsAsync(&self, contenttypefilter: PhotoImportContentTypeFilter, itemselectionmode: PhotoImportItemSelectionMode) -> windows_core::Result> { + pub fn FindItemsAsync(&self, contenttypefilter: PhotoImportContentTypeFilter, itemselectionmode: PhotoImportItemSelectionMode) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1393,14 +1393,14 @@ impl PhotoImportSource { (windows_core::Interface::vtable(this).CreateImportSession)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FromIdAsync(sourceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(sourceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IPhotoImportSourceStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(sourceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "Storage")] - pub fn FromFolderAsync(sourcerootfolder: P0) -> windows_core::Result> + pub fn FromFolderAsync(sourcerootfolder: P0) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Media/MediaProperties/mod.rs b/crates/libs/windows/src/Windows/Media/MediaProperties/mod.rs index 786501b674..d7a408ebba 100644 --- a/crates/libs/windows/src/Windows/Media/MediaProperties/mod.rs +++ b/crates/libs/windows/src/Windows/Media/MediaProperties/mod.rs @@ -1463,7 +1463,7 @@ impl MediaEncodingProfile { }) } #[cfg(feature = "Storage_Streams")] - pub fn CreateFromFileAsync(file: P0) -> windows_core::Result> + pub fn CreateFromFileAsync(file: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1473,7 +1473,7 @@ impl MediaEncodingProfile { }) } #[cfg(feature = "Storage_Streams")] - pub fn CreateFromStreamAsync(stream: P0) -> windows_core::Result> + pub fn CreateFromStreamAsync(stream: P0) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Media/Miracast/mod.rs b/crates/libs/windows/src/Windows/Media/Miracast/mod.rs index 78be92b1ae..5c395d4c73 100644 --- a/crates/libs/windows/src/Windows/Media/Miracast/mod.rs +++ b/crates/libs/windows/src/Windows/Media/Miracast/mod.rs @@ -305,7 +305,7 @@ impl MiracastReceiver { (windows_core::Interface::vtable(this).GetCurrentSettings)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetCurrentSettingsAsync(&self) -> windows_core::Result> { + pub fn GetCurrentSettingsAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -322,7 +322,7 @@ impl MiracastReceiver { (windows_core::Interface::vtable(this).DisconnectAllAndApplySettings)(windows_core::Interface::as_raw(this), settings.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DisconnectAllAndApplySettingsAsync(&self, settings: P0) -> windows_core::Result> + pub fn DisconnectAllAndApplySettingsAsync(&self, settings: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -339,7 +339,7 @@ impl MiracastReceiver { (windows_core::Interface::vtable(this).GetStatus)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetStatusAsync(&self) -> windows_core::Result> { + pub fn GetStatusAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -372,7 +372,7 @@ impl MiracastReceiver { } } #[cfg(feature = "ApplicationModel_Core")] - pub fn CreateSessionAsync(&self, view: P0) -> windows_core::Result> + pub fn CreateSessionAsync(&self, view: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -494,7 +494,7 @@ impl MiracastReceiverConnection { let this = self; unsafe { (windows_core::Interface::vtable(this).Pause)(windows_core::Interface::as_raw(this)).ok() } } - pub fn PauseAsync(&self) -> windows_core::Result { + pub fn PauseAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -505,7 +505,7 @@ impl MiracastReceiverConnection { let this = self; unsafe { (windows_core::Interface::vtable(this).Resume)(windows_core::Interface::as_raw(this)).ok() } } - pub fn ResumeAsync(&self) -> windows_core::Result { + pub fn ResumeAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1070,7 +1070,7 @@ impl MiracastReceiverSession { (windows_core::Interface::vtable(this).Start)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StartAsync(&self) -> windows_core::Result> { + pub fn StartAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1275,7 +1275,7 @@ impl MiracastReceiverStreamControl { (windows_core::Interface::vtable(this).GetVideoStreamSettings)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetVideoStreamSettingsAsync(&self) -> windows_core::Result> { + pub fn GetVideoStreamSettingsAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1289,7 +1289,7 @@ impl MiracastReceiverStreamControl { let this = self; unsafe { (windows_core::Interface::vtable(this).SuggestVideoStreamSettings)(windows_core::Interface::as_raw(this), settings.param().abi()).ok() } } - pub fn SuggestVideoStreamSettingsAsync(&self, settings: P0) -> windows_core::Result + pub fn SuggestVideoStreamSettingsAsync(&self, settings: P0) -> windows_core::Result where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Media/Ocr/mod.rs b/crates/libs/windows/src/Windows/Media/Ocr/mod.rs index 9594ec142f..9ed71f8128 100644 --- a/crates/libs/windows/src/Windows/Media/Ocr/mod.rs +++ b/crates/libs/windows/src/Windows/Media/Ocr/mod.rs @@ -73,7 +73,7 @@ pub struct OcrEngine(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(OcrEngine, windows_core::IUnknown, windows_core::IInspectable); impl OcrEngine { #[cfg(feature = "Graphics_Imaging")] - pub fn RecognizeAsync(&self, bitmap: P0) -> windows_core::Result> + pub fn RecognizeAsync(&self, bitmap: P0) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Media/PlayTo/mod.rs b/crates/libs/windows/src/Windows/Media/PlayTo/mod.rs index 21f3119224..36689e794c 100644 --- a/crates/libs/windows/src/Windows/Media/PlayTo/mod.rs +++ b/crates/libs/windows/src/Windows/Media/PlayTo/mod.rs @@ -870,14 +870,14 @@ impl PlayToReceiver { (windows_core::Interface::vtable(this).Properties)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StartAsync(&self) -> windows_core::Result { + pub fn StartAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).StartAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StopAsync(&self) -> windows_core::Result { + pub fn StopAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Media/Playlists/mod.rs b/crates/libs/windows/src/Windows/Media/Playlists/mod.rs index 1282e74967..2857ce2be2 100644 --- a/crates/libs/windows/src/Windows/Media/Playlists/mod.rs +++ b/crates/libs/windows/src/Windows/Media/Playlists/mod.rs @@ -51,7 +51,7 @@ impl Playlist { (windows_core::Interface::vtable(this).Files)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SaveAsync(&self) -> windows_core::Result { + pub fn SaveAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -59,7 +59,7 @@ impl Playlist { } } #[cfg(feature = "Storage_Streams")] - pub fn SaveAsAsync(&self, savelocation: P0, desiredname: &windows_core::HSTRING, option: super::super::Storage::NameCollisionOption) -> windows_core::Result> + pub fn SaveAsAsync(&self, savelocation: P0, desiredname: &windows_core::HSTRING, option: super::super::Storage::NameCollisionOption) -> windows_core::Result> where P0: windows_core::Param, { @@ -70,7 +70,7 @@ impl Playlist { } } #[cfg(feature = "Storage_Streams")] - pub fn SaveAsWithFormatAsync(&self, savelocation: P0, desiredname: &windows_core::HSTRING, option: super::super::Storage::NameCollisionOption, playlistformat: PlaylistFormat) -> windows_core::Result> + pub fn SaveAsWithFormatAsync(&self, savelocation: P0, desiredname: &windows_core::HSTRING, option: super::super::Storage::NameCollisionOption, playlistformat: PlaylistFormat) -> windows_core::Result> where P0: windows_core::Param, { @@ -81,7 +81,7 @@ impl Playlist { } } #[cfg(feature = "Storage_Streams")] - pub fn LoadAsync(file: P0) -> windows_core::Result> + pub fn LoadAsync(file: P0) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Media/Protection/PlayReady/mod.rs b/crates/libs/windows/src/Windows/Media/Protection/PlayReady/mod.rs index 01cfe4150e..4d179c86b0 100644 --- a/crates/libs/windows/src/Windows/Media/Protection/PlayReady/mod.rs +++ b/crates/libs/windows/src/Windows/Media/Protection/PlayReady/mod.rs @@ -792,28 +792,28 @@ impl windows_core::RuntimeType for INDMessenger { windows_core::imp::interface_hierarchy!(INDMessenger, windows_core::IUnknown, windows_core::IInspectable); #[cfg(feature = "deprecated")] impl INDMessenger { - pub fn SendRegistrationRequestAsync(&self, sessionidbytes: &[u8], challengedatabytes: &[u8]) -> windows_core::Result> { + pub fn SendRegistrationRequestAsync(&self, sessionidbytes: &[u8], challengedatabytes: &[u8]) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).SendRegistrationRequestAsync)(windows_core::Interface::as_raw(this), sessionidbytes.len().try_into().unwrap(), sessionidbytes.as_ptr(), challengedatabytes.len().try_into().unwrap(), challengedatabytes.as_ptr(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SendProximityDetectionStartAsync(&self, pdtype: NDProximityDetectionType, transmitterchannelbytes: &[u8], sessionidbytes: &[u8], challengedatabytes: &[u8]) -> windows_core::Result> { + pub fn SendProximityDetectionStartAsync(&self, pdtype: NDProximityDetectionType, transmitterchannelbytes: &[u8], sessionidbytes: &[u8], challengedatabytes: &[u8]) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).SendProximityDetectionStartAsync)(windows_core::Interface::as_raw(this), pdtype, transmitterchannelbytes.len().try_into().unwrap(), transmitterchannelbytes.as_ptr(), sessionidbytes.len().try_into().unwrap(), sessionidbytes.as_ptr(), challengedatabytes.len().try_into().unwrap(), challengedatabytes.as_ptr(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SendProximityDetectionResponseAsync(&self, pdtype: NDProximityDetectionType, transmitterchannelbytes: &[u8], sessionidbytes: &[u8], responsedatabytes: &[u8]) -> windows_core::Result> { + pub fn SendProximityDetectionResponseAsync(&self, pdtype: NDProximityDetectionType, transmitterchannelbytes: &[u8], sessionidbytes: &[u8], responsedatabytes: &[u8]) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).SendProximityDetectionResponseAsync)(windows_core::Interface::as_raw(this), pdtype, transmitterchannelbytes.len().try_into().unwrap(), transmitterchannelbytes.as_ptr(), sessionidbytes.len().try_into().unwrap(), sessionidbytes.as_ptr(), responsedatabytes.len().try_into().unwrap(), responsedatabytes.as_ptr(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SendLicenseFetchRequestAsync(&self, sessionidbytes: &[u8], challengedatabytes: &[u8]) -> windows_core::Result> { + pub fn SendLicenseFetchRequestAsync(&self, sessionidbytes: &[u8], challengedatabytes: &[u8]) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -827,10 +827,10 @@ impl windows_core::RuntimeName for INDMessenger { } #[cfg(feature = "deprecated")] pub trait INDMessenger_Impl: windows_core::IUnknownImpl { - fn SendRegistrationRequestAsync(&self, sessionIDBytes: &[u8], challengeDataBytes: &[u8]) -> windows_core::Result>; - fn SendProximityDetectionStartAsync(&self, pdType: NDProximityDetectionType, transmitterChannelBytes: &[u8], sessionIDBytes: &[u8], challengeDataBytes: &[u8]) -> windows_core::Result>; - fn SendProximityDetectionResponseAsync(&self, pdType: NDProximityDetectionType, transmitterChannelBytes: &[u8], sessionIDBytes: &[u8], responseDataBytes: &[u8]) -> windows_core::Result>; - fn SendLicenseFetchRequestAsync(&self, sessionIDBytes: &[u8], challengeDataBytes: &[u8]) -> windows_core::Result>; + fn SendRegistrationRequestAsync(&self, sessionIDBytes: &[u8], challengeDataBytes: &[u8]) -> windows_core::Result>; + fn SendProximityDetectionStartAsync(&self, pdType: NDProximityDetectionType, transmitterChannelBytes: &[u8], sessionIDBytes: &[u8], challengeDataBytes: &[u8]) -> windows_core::Result>; + fn SendProximityDetectionResponseAsync(&self, pdType: NDProximityDetectionType, transmitterChannelBytes: &[u8], sessionIDBytes: &[u8], responseDataBytes: &[u8]) -> windows_core::Result>; + fn SendLicenseFetchRequestAsync(&self, sessionIDBytes: &[u8], challengeDataBytes: &[u8]) -> windows_core::Result>; } #[cfg(feature = "deprecated")] impl INDMessenger_Vtbl { @@ -2307,7 +2307,7 @@ impl IPlayReadyLicenseAcquisitionServiceRequest { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).SetChallengeCustomData)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(value)).ok() } } - pub fn BeginServiceRequest(&self) -> windows_core::Result { + pub fn BeginServiceRequest(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -2699,7 +2699,7 @@ impl IPlayReadySecureStopServiceRequest { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).SetChallengeCustomData)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(value)).ok() } } - pub fn BeginServiceRequest(&self) -> windows_core::Result { + pub fn BeginServiceRequest(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -2873,7 +2873,7 @@ impl IPlayReadyServiceRequest { let this = self; unsafe { (windows_core::Interface::vtable(this).SetChallengeCustomData)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(value)).ok() } } - pub fn BeginServiceRequest(&self) -> windows_core::Result { + pub fn BeginServiceRequest(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2925,7 +2925,7 @@ pub trait IPlayReadyServiceRequest_Impl: super::IMediaProtectionServiceRequest_I fn ResponseCustomData(&self) -> windows_core::Result; fn ChallengeCustomData(&self) -> windows_core::Result; fn SetChallengeCustomData(&self, value: &windows_core::HSTRING) -> windows_core::Result<()>; - fn BeginServiceRequest(&self) -> windows_core::Result; + fn BeginServiceRequest(&self) -> windows_core::Result; fn NextServiceRequest(&self) -> windows_core::Result; fn GenerateManualEnablingChallenge(&self) -> windows_core::Result; fn ProcessManualEnablingResponse(&self, responseBytes: &[u8]) -> windows_core::Result; @@ -3277,7 +3277,7 @@ impl NDClient { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveClosedCaptionDataReceived)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn StartAsync(&self, contenturl: P0, startasyncoptions: u32, registrationcustomdata: P2, licensefetchdescriptor: P3) -> windows_core::Result> + pub fn StartAsync(&self, contenturl: P0, startasyncoptions: u32, registrationcustomdata: P2, licensefetchdescriptor: P3) -> windows_core::Result> where P0: windows_core::Param, P2: windows_core::Param, @@ -3289,7 +3289,7 @@ impl NDClient { (windows_core::Interface::vtable(this).StartAsync)(windows_core::Interface::as_raw(this), contenturl.param().abi(), startasyncoptions, registrationcustomdata.param().abi(), licensefetchdescriptor.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn LicenseFetchAsync(&self, licensefetchdescriptor: P0) -> windows_core::Result> + pub fn LicenseFetchAsync(&self, licensefetchdescriptor: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -3299,7 +3299,7 @@ impl NDClient { (windows_core::Interface::vtable(this).LicenseFetchAsync)(windows_core::Interface::as_raw(this), licensefetchdescriptor.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReRegistrationAsync(&self, registrationcustomdata: P0) -> windows_core::Result + pub fn ReRegistrationAsync(&self, registrationcustomdata: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -3684,28 +3684,28 @@ pub struct NDTCPMessenger(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(NDTCPMessenger, windows_core::IUnknown, windows_core::IInspectable, INDMessenger); #[cfg(feature = "deprecated")] impl NDTCPMessenger { - pub fn SendRegistrationRequestAsync(&self, sessionidbytes: &[u8], challengedatabytes: &[u8]) -> windows_core::Result> { + pub fn SendRegistrationRequestAsync(&self, sessionidbytes: &[u8], challengedatabytes: &[u8]) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).SendRegistrationRequestAsync)(windows_core::Interface::as_raw(this), sessionidbytes.len().try_into().unwrap(), sessionidbytes.as_ptr(), challengedatabytes.len().try_into().unwrap(), challengedatabytes.as_ptr(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SendProximityDetectionStartAsync(&self, pdtype: NDProximityDetectionType, transmitterchannelbytes: &[u8], sessionidbytes: &[u8], challengedatabytes: &[u8]) -> windows_core::Result> { + pub fn SendProximityDetectionStartAsync(&self, pdtype: NDProximityDetectionType, transmitterchannelbytes: &[u8], sessionidbytes: &[u8], challengedatabytes: &[u8]) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).SendProximityDetectionStartAsync)(windows_core::Interface::as_raw(this), pdtype, transmitterchannelbytes.len().try_into().unwrap(), transmitterchannelbytes.as_ptr(), sessionidbytes.len().try_into().unwrap(), sessionidbytes.as_ptr(), challengedatabytes.len().try_into().unwrap(), challengedatabytes.as_ptr(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SendProximityDetectionResponseAsync(&self, pdtype: NDProximityDetectionType, transmitterchannelbytes: &[u8], sessionidbytes: &[u8], responsedatabytes: &[u8]) -> windows_core::Result> { + pub fn SendProximityDetectionResponseAsync(&self, pdtype: NDProximityDetectionType, transmitterchannelbytes: &[u8], sessionidbytes: &[u8], responsedatabytes: &[u8]) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).SendProximityDetectionResponseAsync)(windows_core::Interface::as_raw(this), pdtype, transmitterchannelbytes.len().try_into().unwrap(), transmitterchannelbytes.as_ptr(), sessionidbytes.len().try_into().unwrap(), sessionidbytes.as_ptr(), responsedatabytes.len().try_into().unwrap(), responsedatabytes.as_ptr(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SendLicenseFetchRequestAsync(&self, sessionidbytes: &[u8], challengedatabytes: &[u8]) -> windows_core::Result> { + pub fn SendLicenseFetchRequestAsync(&self, sessionidbytes: &[u8], challengedatabytes: &[u8]) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -4146,7 +4146,7 @@ impl PlayReadyDomainJoinServiceRequest { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).SetChallengeCustomData)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(value)).ok() } } - pub fn BeginServiceRequest(&self) -> windows_core::Result { + pub fn BeginServiceRequest(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -4266,7 +4266,7 @@ impl PlayReadyDomainLeaveServiceRequest { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).SetChallengeCustomData)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(value)).ok() } } - pub fn BeginServiceRequest(&self) -> windows_core::Result { + pub fn BeginServiceRequest(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -4442,7 +4442,7 @@ impl PlayReadyIndividualizationServiceRequest { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).SetChallengeCustomData)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(value)).ok() } } - pub fn BeginServiceRequest(&self) -> windows_core::Result { + pub fn BeginServiceRequest(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -4675,7 +4675,7 @@ impl PlayReadyLicenseAcquisitionServiceRequest { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).SetChallengeCustomData)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(value)).ok() } } - pub fn BeginServiceRequest(&self) -> windows_core::Result { + pub fn BeginServiceRequest(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -4817,7 +4817,7 @@ impl windows_core::RuntimeName for PlayReadyLicenseIterator { } pub struct PlayReadyLicenseManagement; impl PlayReadyLicenseManagement { - pub fn DeleteLicenses(contentheader: P0) -> windows_core::Result + pub fn DeleteLicenses(contentheader: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -4959,7 +4959,7 @@ impl PlayReadyMeteringReportServiceRequest { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).SetChallengeCustomData)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(value)).ok() } } - pub fn BeginServiceRequest(&self) -> windows_core::Result { + pub fn BeginServiceRequest(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -5057,7 +5057,7 @@ impl PlayReadyRevocationServiceRequest { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).SetChallengeCustomData)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(value)).ok() } } - pub fn BeginServiceRequest(&self) -> windows_core::Result { + pub fn BeginServiceRequest(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -5286,7 +5286,7 @@ impl PlayReadySecureStopServiceRequest { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).SetChallengeCustomData)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(value)).ok() } } - pub fn BeginServiceRequest(&self) -> windows_core::Result { + pub fn BeginServiceRequest(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Media/Protection/mod.rs b/crates/libs/windows/src/Windows/Media/Protection/mod.rs index 57d08f018d..e896b3b0f5 100644 --- a/crates/libs/windows/src/Windows/Media/Protection/mod.rs +++ b/crates/libs/windows/src/Windows/Media/Protection/mod.rs @@ -103,7 +103,7 @@ impl, windows_core::Ref<' } pub struct ComponentRenewal; impl ComponentRenewal { - pub fn RenewSystemComponentsAsync(information: P0) -> windows_core::Result> + pub fn RenewSystemComponentsAsync(information: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -182,7 +182,7 @@ impl HdcpSession { (windows_core::Interface::vtable(this).GetEffectiveProtection)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SetDesiredMinProtectionAsync(&self, protection: HdcpProtection) -> windows_core::Result> { + pub fn SetDesiredMinProtectionAsync(&self, protection: HdcpProtection) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Media/SpeechRecognition/mod.rs b/crates/libs/windows/src/Windows/Media/SpeechRecognition/mod.rs index 13d0f98cd3..9440646076 100644 --- a/crates/libs/windows/src/Windows/Media/SpeechRecognition/mod.rs +++ b/crates/libs/windows/src/Windows/Media/SpeechRecognition/mod.rs @@ -557,35 +557,35 @@ impl SpeechContinuousRecognitionSession { let this = self; unsafe { (windows_core::Interface::vtable(this).SetAutoStopSilenceTimeout)(windows_core::Interface::as_raw(this), value).ok() } } - pub fn StartAsync(&self) -> windows_core::Result { + pub fn StartAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).StartAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StartWithModeAsync(&self, mode: SpeechContinuousRecognitionMode) -> windows_core::Result { + pub fn StartWithModeAsync(&self, mode: SpeechContinuousRecognitionMode) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).StartWithModeAsync)(windows_core::Interface::as_raw(this), mode, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StopAsync(&self) -> windows_core::Result { + pub fn StopAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).StopAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CancelAsync(&self) -> windows_core::Result { + pub fn CancelAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CancelAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn PauseAsync(&self) -> windows_core::Result { + pub fn PauseAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1321,21 +1321,21 @@ impl SpeechRecognizer { (windows_core::Interface::vtable(this).UIOptions)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CompileConstraintsAsync(&self) -> windows_core::Result> { + pub fn CompileConstraintsAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CompileConstraintsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RecognizeAsync(&self) -> windows_core::Result> { + pub fn RecognizeAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RecognizeAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RecognizeWithUIAsync(&self) -> windows_core::Result> { + pub fn RecognizeWithUIAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1384,7 +1384,7 @@ impl SpeechRecognizer { (windows_core::Interface::vtable(this).State)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn StopRecognitionAsync(&self) -> windows_core::Result { + pub fn StopRecognitionAsync(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1437,7 +1437,7 @@ impl SpeechRecognizer { }) } #[cfg(feature = "Globalization")] - pub fn TrySetSystemSpeechLanguageAsync(speechlanguage: P0) -> windows_core::Result> + pub fn TrySetSystemSpeechLanguageAsync(speechlanguage: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1630,7 +1630,7 @@ unsafe impl Sync for SpeechRecognizerUIOptions {} pub struct VoiceCommandManager; impl VoiceCommandManager { #[cfg(feature = "Storage_Streams")] - pub fn InstallCommandSetsFromStorageFileAsync(file: P0) -> windows_core::Result + pub fn InstallCommandSetsFromStorageFileAsync(file: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -1672,7 +1672,7 @@ impl VoiceCommandSet { (windows_core::Interface::vtable(this).Name)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn SetPhraseListAsync(&self, phraselistname: &windows_core::HSTRING, phraselist: P1) -> windows_core::Result + pub fn SetPhraseListAsync(&self, phraselistname: &windows_core::HSTRING, phraselist: P1) -> windows_core::Result where P1: windows_core::Param>, { diff --git a/crates/libs/windows/src/Windows/Media/SpeechSynthesis/mod.rs b/crates/libs/windows/src/Windows/Media/SpeechSynthesis/mod.rs index 58090155ae..aa0a269540 100644 --- a/crates/libs/windows/src/Windows/Media/SpeechSynthesis/mod.rs +++ b/crates/libs/windows/src/Windows/Media/SpeechSynthesis/mod.rs @@ -154,7 +154,7 @@ impl SpeechSynthesisStream { (windows_core::Interface::vtable(this).ContentType)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn ReadAsync(&self, buffer: P0, count: u32, options: super::super::Storage::Streams::InputStreamOptions) -> windows_core::Result> + pub fn ReadAsync(&self, buffer: P0, count: u32, options: super::super::Storage::Streams::InputStreamOptions) -> windows_core::Result> where P0: windows_core::Param, { @@ -164,7 +164,7 @@ impl SpeechSynthesisStream { (windows_core::Interface::vtable(this).ReadAsync)(windows_core::Interface::as_raw(this), buffer.param().abi(), count, options, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn WriteAsync(&self, buffer: P0) -> windows_core::Result> + pub fn WriteAsync(&self, buffer: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -174,7 +174,7 @@ impl SpeechSynthesisStream { (windows_core::Interface::vtable(this).WriteAsync)(windows_core::Interface::as_raw(this), buffer.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FlushAsync(&self) -> windows_core::Result> { + pub fn FlushAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -299,7 +299,7 @@ impl SpeechSynthesizer { (windows_core::Interface::vtable(this).DefaultVoice)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn TrySetDefaultVoiceAsync(voice: P0) -> windows_core::Result> + pub fn TrySetDefaultVoiceAsync(voice: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -309,7 +309,7 @@ impl SpeechSynthesizer { }) } #[cfg(all(feature = "Media_Core", feature = "Storage_Streams"))] - pub fn SynthesizeTextToStreamAsync(&self, text: &windows_core::HSTRING) -> windows_core::Result> { + pub fn SynthesizeTextToStreamAsync(&self, text: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -317,7 +317,7 @@ impl SpeechSynthesizer { } } #[cfg(all(feature = "Media_Core", feature = "Storage_Streams"))] - pub fn SynthesizeSsmlToStreamAsync(&self, ssml: &windows_core::HSTRING) -> windows_core::Result> { + pub fn SynthesizeSsmlToStreamAsync(&self, ssml: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Media/Streaming/Adaptive/mod.rs b/crates/libs/windows/src/Windows/Media/Streaming/Adaptive/mod.rs index 517a2e85be..399f5286a8 100644 --- a/crates/libs/windows/src/Windows/Media/Streaming/Adaptive/mod.rs +++ b/crates/libs/windows/src/Windows/Media/Streaming/Adaptive/mod.rs @@ -236,7 +236,7 @@ impl AdaptiveMediaSource { (windows_core::Interface::vtable(this).IsContentTypeSupported)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(contenttype), &mut result__).map(|| result__) }) } - pub fn CreateFromUriAsync(uri: P0) -> windows_core::Result> + pub fn CreateFromUriAsync(uri: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -246,7 +246,7 @@ impl AdaptiveMediaSource { }) } #[cfg(feature = "Web_Http")] - pub fn CreateFromUriWithDownloaderAsync(uri: P0, httpclient: P1) -> windows_core::Result> + pub fn CreateFromUriWithDownloaderAsync(uri: P0, httpclient: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -257,7 +257,7 @@ impl AdaptiveMediaSource { }) } #[cfg(feature = "Storage_Streams")] - pub fn CreateFromStreamAsync(stream: P0, uri: P1, contenttype: &windows_core::HSTRING) -> windows_core::Result> + pub fn CreateFromStreamAsync(stream: P0, uri: P1, contenttype: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -268,7 +268,7 @@ impl AdaptiveMediaSource { }) } #[cfg(all(feature = "Storage_Streams", feature = "Web_Http"))] - pub fn CreateFromStreamWithDownloaderAsync(stream: P0, uri: P1, contenttype: &windows_core::HSTRING, httpclient: P3) -> windows_core::Result> + pub fn CreateFromStreamWithDownloaderAsync(stream: P0, uri: P1, contenttype: &windows_core::HSTRING, httpclient: P3) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, diff --git a/crates/libs/windows/src/Windows/Media/Transcoding/mod.rs b/crates/libs/windows/src/Windows/Media/Transcoding/mod.rs index 50e07b66a8..103fc2260e 100644 --- a/crates/libs/windows/src/Windows/Media/Transcoding/mod.rs +++ b/crates/libs/windows/src/Windows/Media/Transcoding/mod.rs @@ -143,7 +143,7 @@ impl MediaTranscoder { unsafe { (windows_core::Interface::vtable(this).ClearEffects)(windows_core::Interface::as_raw(this)).ok() } } #[cfg(all(feature = "Media_MediaProperties", feature = "Storage_Streams"))] - pub fn PrepareFileTranscodeAsync(&self, source: P0, destination: P1, profile: P2) -> windows_core::Result> + pub fn PrepareFileTranscodeAsync(&self, source: P0, destination: P1, profile: P2) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -156,7 +156,7 @@ impl MediaTranscoder { } } #[cfg(all(feature = "Media_MediaProperties", feature = "Storage_Streams"))] - pub fn PrepareStreamTranscodeAsync(&self, source: P0, destination: P1, profile: P2) -> windows_core::Result> + pub fn PrepareStreamTranscodeAsync(&self, source: P0, destination: P1, profile: P2) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -169,7 +169,7 @@ impl MediaTranscoder { } } #[cfg(all(feature = "Media_Core", feature = "Media_MediaProperties", feature = "Storage_Streams"))] - pub fn PrepareMediaStreamSourceTranscodeAsync(&self, source: P0, destination: P1, profile: P2) -> windows_core::Result> + pub fn PrepareMediaStreamSourceTranscodeAsync(&self, source: P0, destination: P1, profile: P2) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -237,7 +237,7 @@ impl PrepareTranscodeResult { (windows_core::Interface::vtable(this).FailureReason)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn TranscodeAsync(&self) -> windows_core::Result> { + pub fn TranscodeAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Media/mod.rs b/crates/libs/windows/src/Windows/Media/mod.rs index eeaabd817f..9ad990cc4e 100644 --- a/crates/libs/windows/src/Windows/Media/mod.rs +++ b/crates/libs/windows/src/Windows/Media/mod.rs @@ -2442,7 +2442,7 @@ impl SystemMediaTransportControlsDisplayUpdater { } } #[cfg(feature = "Storage_Streams")] - pub fn CopyFromFileAsync(&self, r#type: MediaPlaybackType, source: P1) -> windows_core::Result> + pub fn CopyFromFileAsync(&self, r#type: MediaPlaybackType, source: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -2746,7 +2746,7 @@ impl VideoFrame { (windows_core::Interface::vtable(this).SoftwareBitmap)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CopyToAsync(&self, frame: P0) -> windows_core::Result + pub fn CopyToAsync(&self, frame: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -2765,7 +2765,7 @@ impl VideoFrame { } } #[cfg(feature = "Graphics_Imaging")] - pub fn CopyToWithBoundsAsync(&self, frame: P0, sourcebounds: P1, destinationbounds: P2) -> windows_core::Result + pub fn CopyToWithBoundsAsync(&self, frame: P0, sourcebounds: P1, destinationbounds: P2) -> windows_core::Result where P0: windows_core::Param, P1: windows_core::Param>, diff --git a/crates/libs/windows/src/Windows/Networking/BackgroundTransfer/mod.rs b/crates/libs/windows/src/Windows/Networking/BackgroundTransfer/mod.rs index 08b39eca2a..51e5021d70 100644 --- a/crates/libs/windows/src/Windows/Networking/BackgroundTransfer/mod.rs +++ b/crates/libs/windows/src/Windows/Networking/BackgroundTransfer/mod.rs @@ -52,7 +52,7 @@ impl BackgroundDownloader { } } #[cfg(feature = "Storage_Streams")] - pub fn CreateDownloadAsync(&self, uri: P0, resultfile: P1, requestbodystream: P2) -> windows_core::Result> + pub fn CreateDownloadAsync(&self, uri: P0, resultfile: P1, requestbodystream: P2) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -158,20 +158,20 @@ impl BackgroundDownloader { (windows_core::Interface::vtable(this).CreateWithCompletionGroup)(windows_core::Interface::as_raw(this), completiongroup.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetCurrentDownloadsAsync() -> windows_core::Result>> { + pub fn GetCurrentDownloadsAsync() -> windows_core::Result>> { Self::IBackgroundDownloaderStaticMethods(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetCurrentDownloadsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "deprecated")] - pub fn GetCurrentDownloadsForGroupAsync(group: &windows_core::HSTRING) -> windows_core::Result>> { + pub fn GetCurrentDownloadsForGroupAsync(group: &windows_core::HSTRING) -> windows_core::Result>> { Self::IBackgroundDownloaderStaticMethods(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetCurrentDownloadsForGroupAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(group), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetCurrentDownloadsForTransferGroupAsync(group: P0) -> windows_core::Result>> + pub fn GetCurrentDownloadsForTransferGroupAsync(group: P0) -> windows_core::Result>> where P0: windows_core::Param, { @@ -181,7 +181,7 @@ impl BackgroundDownloader { }) } #[cfg(feature = "deprecated")] - pub fn RequestUnconstrainedDownloadsAsync(operations: P0) -> windows_core::Result> + pub fn RequestUnconstrainedDownloadsAsync(operations: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -715,7 +715,7 @@ impl BackgroundUploader { } } #[cfg(feature = "Storage_Streams")] - pub fn CreateUploadFromStreamAsync(&self, uri: P0, sourcestream: P1) -> windows_core::Result> + pub fn CreateUploadFromStreamAsync(&self, uri: P0, sourcestream: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -726,7 +726,7 @@ impl BackgroundUploader { (windows_core::Interface::vtable(this).CreateUploadFromStreamAsync)(windows_core::Interface::as_raw(this), uri.param().abi(), sourcestream.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateUploadWithFormDataAndAutoBoundaryAsync(&self, uri: P0, parts: P1) -> windows_core::Result> + pub fn CreateUploadWithFormDataAndAutoBoundaryAsync(&self, uri: P0, parts: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param>, @@ -737,7 +737,7 @@ impl BackgroundUploader { (windows_core::Interface::vtable(this).CreateUploadWithFormDataAndAutoBoundaryAsync)(windows_core::Interface::as_raw(this), uri.param().abi(), parts.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateUploadWithSubTypeAsync(&self, uri: P0, parts: P1, subtype: &windows_core::HSTRING) -> windows_core::Result> + pub fn CreateUploadWithSubTypeAsync(&self, uri: P0, parts: P1, subtype: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param>, @@ -748,7 +748,7 @@ impl BackgroundUploader { (windows_core::Interface::vtable(this).CreateUploadWithSubTypeAsync)(windows_core::Interface::as_raw(this), uri.param().abi(), parts.param().abi(), core::mem::transmute_copy(subtype), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateUploadWithSubTypeAndBoundaryAsync(&self, uri: P0, parts: P1, subtype: &windows_core::HSTRING, boundary: &windows_core::HSTRING) -> windows_core::Result> + pub fn CreateUploadWithSubTypeAndBoundaryAsync(&self, uri: P0, parts: P1, subtype: &windows_core::HSTRING, boundary: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param>, @@ -853,20 +853,20 @@ impl BackgroundUploader { (windows_core::Interface::vtable(this).CreateWithCompletionGroup)(windows_core::Interface::as_raw(this), completiongroup.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetCurrentUploadsAsync() -> windows_core::Result>> { + pub fn GetCurrentUploadsAsync() -> windows_core::Result>> { Self::IBackgroundUploaderStaticMethods(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetCurrentUploadsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "deprecated")] - pub fn GetCurrentUploadsForGroupAsync(group: &windows_core::HSTRING) -> windows_core::Result>> { + pub fn GetCurrentUploadsForGroupAsync(group: &windows_core::HSTRING) -> windows_core::Result>> { Self::IBackgroundUploaderStaticMethods(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetCurrentUploadsForGroupAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(group), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetCurrentUploadsForTransferGroupAsync(group: P0) -> windows_core::Result>> + pub fn GetCurrentUploadsForTransferGroupAsync(group: P0) -> windows_core::Result>> where P0: windows_core::Param, { @@ -876,7 +876,7 @@ impl BackgroundUploader { }) } #[cfg(feature = "deprecated")] - pub fn RequestUnconstrainedUploadsAsync(operations: P0) -> windows_core::Result> + pub fn RequestUnconstrainedUploadsAsync(operations: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -1040,14 +1040,14 @@ impl DownloadOperation { (windows_core::Interface::vtable(this).Progress)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn StartAsync(&self) -> windows_core::Result> { + pub fn StartAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).StartAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn AttachAsync(&self) -> windows_core::Result> { + pub fn AttachAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2382,14 +2382,14 @@ impl UploadOperation { (windows_core::Interface::vtable(this).Progress)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn StartAsync(&self) -> windows_core::Result> { + pub fn StartAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).StartAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn AttachAsync(&self) -> windows_core::Result> { + pub fn AttachAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Networking/Connectivity/mod.rs b/crates/libs/windows/src/Windows/Networking/Connectivity/mod.rs index 77af67f118..53c91786e7 100644 --- a/crates/libs/windows/src/Windows/Networking/Connectivity/mod.rs +++ b/crates/libs/windows/src/Windows/Networking/Connectivity/mod.rs @@ -341,28 +341,28 @@ impl ConnectionProfile { (windows_core::Interface::vtable(this).GetDomainConnectivityLevel)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn GetNetworkUsageAsync(&self, starttime: super::super::Foundation::DateTime, endtime: super::super::Foundation::DateTime, granularity: DataUsageGranularity, states: NetworkUsageStates) -> windows_core::Result>> { + pub fn GetNetworkUsageAsync(&self, starttime: super::super::Foundation::DateTime, endtime: super::super::Foundation::DateTime, granularity: DataUsageGranularity, states: NetworkUsageStates) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetNetworkUsageAsync)(windows_core::Interface::as_raw(this), starttime, endtime, granularity, states, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetConnectivityIntervalsAsync(&self, starttime: super::super::Foundation::DateTime, endtime: super::super::Foundation::DateTime, states: NetworkUsageStates) -> windows_core::Result>> { + pub fn GetConnectivityIntervalsAsync(&self, starttime: super::super::Foundation::DateTime, endtime: super::super::Foundation::DateTime, states: NetworkUsageStates) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetConnectivityIntervalsAsync)(windows_core::Interface::as_raw(this), starttime, endtime, states, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAttributedNetworkUsageAsync(&self, starttime: super::super::Foundation::DateTime, endtime: super::super::Foundation::DateTime, states: NetworkUsageStates) -> windows_core::Result>> { + pub fn GetAttributedNetworkUsageAsync(&self, starttime: super::super::Foundation::DateTime, endtime: super::super::Foundation::DateTime, states: NetworkUsageStates) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetAttributedNetworkUsageAsync)(windows_core::Interface::as_raw(this), starttime, endtime, states, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetProviderNetworkUsageAsync(&self, starttime: super::super::Foundation::DateTime, endtime: super::super::Foundation::DateTime, states: NetworkUsageStates) -> windows_core::Result>> { + pub fn GetProviderNetworkUsageAsync(&self, starttime: super::super::Foundation::DateTime, endtime: super::super::Foundation::DateTime, states: NetworkUsageStates) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -376,7 +376,7 @@ impl ConnectionProfile { (windows_core::Interface::vtable(this).CanDelete)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn TryDeleteAsync(&self) -> windows_core::Result> { + pub fn TryDeleteAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -629,7 +629,7 @@ unsafe impl Send for ConnectivityInterval {} unsafe impl Sync for ConnectivityInterval {} pub struct ConnectivityManager; impl ConnectivityManager { - pub fn AcquireConnectionAsync(cellularapncontext: P0) -> windows_core::Result> + pub fn AcquireConnectionAsync(cellularapncontext: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1430,7 +1430,7 @@ impl NetworkAdapter { (windows_core::Interface::vtable(this).NetworkAdapterId)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn GetConnectedProfileAsync(&self) -> windows_core::Result> { + pub fn GetConnectedProfileAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1555,7 +1555,7 @@ impl NetworkInformation { (windows_core::Interface::vtable(this).GetHostNames)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetProxyConfigurationAsync(uri: P0) -> windows_core::Result> + pub fn GetProxyConfigurationAsync(uri: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1585,7 +1585,7 @@ impl NetworkInformation { pub fn RemoveNetworkStatusChanged(eventcookie: i64) -> windows_core::Result<()> { Self::INetworkInformationStatics(|this| unsafe { (windows_core::Interface::vtable(this).RemoveNetworkStatusChanged)(windows_core::Interface::as_raw(this), eventcookie).ok() }) } - pub fn FindConnectionProfilesAsync(pprofilefilter: P0) -> windows_core::Result>> + pub fn FindConnectionProfilesAsync(pprofilefilter: P0) -> windows_core::Result>> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Networking/NetworkOperators/mod.rs b/crates/libs/windows/src/Windows/Networking/NetworkOperators/mod.rs index 2e0a711c06..553130be89 100644 --- a/crates/libs/windows/src/Windows/Networking/NetworkOperators/mod.rs +++ b/crates/libs/windows/src/Windows/Networking/NetworkOperators/mod.rs @@ -113,21 +113,21 @@ impl ESim { (windows_core::Interface::vtable(this).GetProfiles)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteProfileAsync(&self, profileid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn DeleteProfileAsync(&self, profileid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeleteProfileAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(profileid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DownloadProfileMetadataAsync(&self, activationcode: &windows_core::HSTRING) -> windows_core::Result> { + pub fn DownloadProfileMetadataAsync(&self, activationcode: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DownloadProfileMetadataAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(activationcode), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ResetAsync(&self) -> windows_core::Result> { + pub fn ResetAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -162,14 +162,14 @@ impl ESim { (windows_core::Interface::vtable(this).DiscoverWithServerAddressAndMatchingId)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(serveraddress), core::mem::transmute_copy(matchingid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DiscoverAsync(&self) -> windows_core::Result> { + pub fn DiscoverAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DiscoverAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DiscoverWithServerAddressAndMatchingIdAsync(&self, serveraddress: &windows_core::HSTRING, matchingid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn DiscoverWithServerAddressAndMatchingIdAsync(&self, serveraddress: &windows_core::HSTRING, matchingid: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -545,21 +545,21 @@ impl ESimProfile { (windows_core::Interface::vtable(this).State)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn DisableAsync(&self) -> windows_core::Result> { + pub fn DisableAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DisableAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn EnableAsync(&self) -> windows_core::Result> { + pub fn EnableAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).EnableAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SetNicknameAsync(&self, newnickname: &windows_core::HSTRING) -> windows_core::Result> { + pub fn SetNicknameAsync(&self, newnickname: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -660,28 +660,28 @@ impl ESimProfileMetadata { (windows_core::Interface::vtable(this).State)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn DenyInstallAsync(&self) -> windows_core::Result> { + pub fn DenyInstallAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DenyInstallAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ConfirmInstallAsync(&self) -> windows_core::Result> { + pub fn ConfirmInstallAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ConfirmInstallAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ConfirmInstallWithConfirmationCodeAsync(&self, confirmationcode: &windows_core::HSTRING) -> windows_core::Result> { + pub fn ConfirmInstallWithConfirmationCodeAsync(&self, confirmationcode: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ConfirmInstallWithConfirmationCodeAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(confirmationcode), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn PostponeInstallAsync(&self) -> windows_core::Result> { + pub fn PostponeInstallAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1006,7 +1006,7 @@ impl windows_core::RuntimeType for ESimWatcherStatus { } pub struct FdnAccessManager; impl FdnAccessManager { - pub fn RequestUnlockAsync(contactlistid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn RequestUnlockAsync(contactlistid: &windows_core::HSTRING) -> windows_core::Result> { Self::IFdnAccessManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestUnlockAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(contactlistid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -1078,7 +1078,7 @@ impl HotspotAuthenticationContext { let this = self; unsafe { (windows_core::Interface::vtable(this).TriggerAttentionRequired)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(packagerelativeapplicationid), core::mem::transmute_copy(applicationparameters)).ok() } } - pub fn IssueCredentialsAsync(&self, username: &windows_core::HSTRING, password: &windows_core::HSTRING, extraparameters: &windows_core::HSTRING, markasmanualconnectonfailure: bool) -> windows_core::Result> { + pub fn IssueCredentialsAsync(&self, username: &windows_core::HSTRING, password: &windows_core::HSTRING, extraparameters: &windows_core::HSTRING, markasmanualconnectonfailure: bool) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -3963,7 +3963,7 @@ pub struct MobileBroadbandDeviceServiceCommandSession(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(MobileBroadbandDeviceServiceCommandSession, windows_core::IUnknown, windows_core::IInspectable); impl MobileBroadbandDeviceServiceCommandSession { #[cfg(feature = "Storage_Streams")] - pub fn SendQueryCommandAsync(&self, commandid: u32, data: P1) -> windows_core::Result> + pub fn SendQueryCommandAsync(&self, commandid: u32, data: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -3974,7 +3974,7 @@ impl MobileBroadbandDeviceServiceCommandSession { } } #[cfg(feature = "Storage_Streams")] - pub fn SendSetCommandAsync(&self, commandid: u32, data: P1) -> windows_core::Result> + pub fn SendSetCommandAsync(&self, commandid: u32, data: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -4047,7 +4047,7 @@ pub struct MobileBroadbandDeviceServiceDataSession(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(MobileBroadbandDeviceServiceDataSession, windows_core::IUnknown, windows_core::IInspectable); impl MobileBroadbandDeviceServiceDataSession { #[cfg(feature = "Storage_Streams")] - pub fn WriteDataAsync(&self, value: P0) -> windows_core::Result + pub fn WriteDataAsync(&self, value: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -4243,14 +4243,14 @@ impl MobileBroadbandModem { (windows_core::Interface::vtable(this).IsResetSupported)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn ResetAsync(&self) -> windows_core::Result { + pub fn ResetAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ResetAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetCurrentConfigurationAsync(&self) -> windows_core::Result> { + pub fn GetCurrentConfigurationAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -4264,21 +4264,21 @@ impl MobileBroadbandModem { (windows_core::Interface::vtable(this).CurrentNetwork)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetIsPassthroughEnabledAsync(&self) -> windows_core::Result> { + pub fn GetIsPassthroughEnabledAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetIsPassthroughEnabledAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SetIsPassthroughEnabledAsync(&self, value: bool) -> windows_core::Result> { + pub fn SetIsPassthroughEnabledAsync(&self, value: bool) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).SetIsPassthroughEnabledAsync)(windows_core::Interface::as_raw(this), value, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryGetPcoAsync(&self) -> windows_core::Result> { + pub fn TryGetPcoAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -4306,14 +4306,14 @@ impl MobileBroadbandModem { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).RemoveIsInEmergencyCallModeChanged)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn SetIsPassthroughEnabledWithSlotIndexAsync(&self, value: bool, slotindex: i32) -> windows_core::Result> { + pub fn SetIsPassthroughEnabledWithSlotIndexAsync(&self, value: bool, slotindex: i32) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).SetIsPassthroughEnabledWithSlotIndexAsync)(windows_core::Interface::as_raw(this), value, slotindex, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetIsPassthroughEnabledWithSlotIndexAsync(&self, slotindex: i32) -> windows_core::Result> { + pub fn GetIsPassthroughEnabledWithSlotIndexAsync(&self, slotindex: i32) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -4433,14 +4433,14 @@ impl MobileBroadbandModemIsolation { let this = self; unsafe { (windows_core::Interface::vtable(this).AddAllowedHostRange)(windows_core::Interface::as_raw(this), first.param().abi(), last.param().abi()).ok() } } - pub fn ApplyConfigurationAsync(&self) -> windows_core::Result { + pub fn ApplyConfigurationAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ApplyConfigurationAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ClearConfigurationAsync(&self) -> windows_core::Result { + pub fn ClearConfigurationAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -4558,7 +4558,7 @@ impl MobileBroadbandNetwork { let this = self; unsafe { (windows_core::Interface::vtable(this).ShowConnectionUI)(windows_core::Interface::as_raw(this)).ok() } } - pub fn GetVoiceCallSupportAsync(&self) -> windows_core::Result> { + pub fn GetVoiceCallSupportAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -4572,7 +4572,7 @@ impl MobileBroadbandNetwork { (windows_core::Interface::vtable(this).RegistrationUiccApps)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetCellsInfoAsync(&self) -> windows_core::Result> { + pub fn GetCellsInfoAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -4766,35 +4766,35 @@ impl MobileBroadbandPin { (windows_core::Interface::vtable(this).AttemptsRemaining)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn EnableAsync(&self, currentpin: &windows_core::HSTRING) -> windows_core::Result> { + pub fn EnableAsync(&self, currentpin: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).EnableAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(currentpin), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DisableAsync(&self, currentpin: &windows_core::HSTRING) -> windows_core::Result> { + pub fn DisableAsync(&self, currentpin: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DisableAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(currentpin), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn EnterAsync(&self, currentpin: &windows_core::HSTRING) -> windows_core::Result> { + pub fn EnterAsync(&self, currentpin: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).EnterAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(currentpin), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ChangeAsync(&self, currentpin: &windows_core::HSTRING, newpin: &windows_core::HSTRING) -> windows_core::Result> { + pub fn ChangeAsync(&self, currentpin: &windows_core::HSTRING, newpin: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ChangeAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(currentpin), core::mem::transmute_copy(newpin), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn UnblockAsync(&self, pinunblockkey: &windows_core::HSTRING, newpin: &windows_core::HSTRING) -> windows_core::Result> { + pub fn UnblockAsync(&self, pinunblockkey: &windows_core::HSTRING, newpin: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -5117,21 +5117,21 @@ impl MobileBroadbandSarManager { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveTransmissionStateChanged)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn EnableBackoffAsync(&self) -> windows_core::Result { + pub fn EnableBackoffAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).EnableBackoffAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DisableBackoffAsync(&self) -> windows_core::Result { + pub fn DisableBackoffAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DisableBackoffAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SetConfigurationAsync(&self, antennas: P0) -> windows_core::Result + pub fn SetConfigurationAsync(&self, antennas: P0) -> windows_core::Result where P0: windows_core::Param>, { @@ -5141,21 +5141,21 @@ impl MobileBroadbandSarManager { (windows_core::Interface::vtable(this).SetConfigurationAsync)(windows_core::Interface::as_raw(this), antennas.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RevertSarToHardwareControlAsync(&self) -> windows_core::Result { + pub fn RevertSarToHardwareControlAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RevertSarToHardwareControlAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SetTransmissionStateChangedHysteresisAsync(&self, timerperiod: super::super::Foundation::TimeSpan) -> windows_core::Result { + pub fn SetTransmissionStateChangedHysteresisAsync(&self, timerperiod: super::super::Foundation::TimeSpan) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).SetTransmissionStateChangedHysteresisAsync)(windows_core::Interface::as_raw(this), timerperiod, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetIsTransmittingAsync(&self) -> windows_core::Result> { + pub fn GetIsTransmittingAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -5273,7 +5273,7 @@ impl MobileBroadbandSlotManager { (windows_core::Interface::vtable(this).SetCurrentSlot)(windows_core::Interface::as_raw(this), slotindex, &mut result__).map(|| result__) } } - pub fn SetCurrentSlotAsync(&self, slotindex: i32) -> windows_core::Result> { + pub fn SetCurrentSlotAsync(&self, slotindex: i32) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -5379,7 +5379,7 @@ impl MobileBroadbandUicc { (windows_core::Interface::vtable(this).SimIccId)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn GetUiccAppsAsync(&self) -> windows_core::Result> { + pub fn GetUiccAppsAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -5419,7 +5419,7 @@ impl MobileBroadbandUiccApp { (windows_core::Interface::vtable(this).Kind)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn GetRecordDetailsAsync(&self, uiccfilepath: P0) -> windows_core::Result> + pub fn GetRecordDetailsAsync(&self, uiccfilepath: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -5429,7 +5429,7 @@ impl MobileBroadbandUiccApp { (windows_core::Interface::vtable(this).GetRecordDetailsAsync)(windows_core::Interface::as_raw(this), uiccfilepath.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReadRecordAsync(&self, uiccfilepath: P0, recordindex: i32) -> windows_core::Result> + pub fn ReadRecordAsync(&self, uiccfilepath: P0, recordindex: i32) -> windows_core::Result> where P0: windows_core::Param>, { @@ -5778,7 +5778,7 @@ impl NetworkOperatorTetheringAccessPointConfiguration { (windows_core::Interface::vtable(this).IsBandSupported)(windows_core::Interface::as_raw(this), band, &mut result__).map(|| result__) } } - pub fn IsBandSupportedAsync(&self, band: TetheringWiFiBand) -> windows_core::Result> { + pub fn IsBandSupportedAsync(&self, band: TetheringWiFiBand) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -5803,7 +5803,7 @@ impl NetworkOperatorTetheringAccessPointConfiguration { (windows_core::Interface::vtable(this).IsAuthenticationKindSupported)(windows_core::Interface::as_raw(this), authenticationkind, &mut result__).map(|| result__) } } - pub fn IsAuthenticationKindSupportedAsync(&self, authenticationkind: TetheringWiFiAuthenticationKind) -> windows_core::Result> { + pub fn IsAuthenticationKindSupportedAsync(&self, authenticationkind: TetheringWiFiAuthenticationKind) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -5906,7 +5906,7 @@ impl NetworkOperatorTetheringManager { (windows_core::Interface::vtable(this).GetCurrentAccessPointConfiguration)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ConfigureAccessPointAsync(&self, configuration: P0) -> windows_core::Result + pub fn ConfigureAccessPointAsync(&self, configuration: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -5916,21 +5916,21 @@ impl NetworkOperatorTetheringManager { (windows_core::Interface::vtable(this).ConfigureAccessPointAsync)(windows_core::Interface::as_raw(this), configuration.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StartTetheringAsync(&self) -> windows_core::Result> { + pub fn StartTetheringAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).StartTetheringAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StopTetheringAsync(&self) -> windows_core::Result> { + pub fn StopTetheringAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).StopTetheringAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StartTetheringAsync2(&self, configuration: P0) -> windows_core::Result> + pub fn StartTetheringAsync2(&self, configuration: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -5992,7 +5992,7 @@ impl NetworkOperatorTetheringManager { pub fn EnableNoConnectionsTimeout() -> windows_core::Result<()> { Self::INetworkOperatorTetheringManagerStatics4(|this| unsafe { (windows_core::Interface::vtable(this).EnableNoConnectionsTimeout)(windows_core::Interface::as_raw(this)).ok() }) } - pub fn EnableNoConnectionsTimeoutAsync() -> windows_core::Result { + pub fn EnableNoConnectionsTimeoutAsync() -> windows_core::Result { Self::INetworkOperatorTetheringManagerStatics4(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).EnableNoConnectionsTimeoutAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -6001,7 +6001,7 @@ impl NetworkOperatorTetheringManager { pub fn DisableNoConnectionsTimeout() -> windows_core::Result<()> { Self::INetworkOperatorTetheringManagerStatics4(|this| unsafe { (windows_core::Interface::vtable(this).DisableNoConnectionsTimeout)(windows_core::Interface::as_raw(this)).ok() }) } - pub fn DisableNoConnectionsTimeoutAsync() -> windows_core::Result { + pub fn DisableNoConnectionsTimeoutAsync() -> windows_core::Result { Self::INetworkOperatorTetheringManagerStatics4(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DisableNoConnectionsTimeoutAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -6105,7 +6105,7 @@ impl NetworkOperatorTetheringSessionAccessPointConfiguration { (windows_core::Interface::vtable(this).IsBandSupported)(windows_core::Interface::as_raw(this), band, &mut result__).map(|| result__) } } - pub fn IsBandSupportedAsync(&self, band: TetheringWiFiBand) -> windows_core::Result> { + pub fn IsBandSupportedAsync(&self, band: TetheringWiFiBand) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -6130,7 +6130,7 @@ impl NetworkOperatorTetheringSessionAccessPointConfiguration { (windows_core::Interface::vtable(this).IsAuthenticationKindSupported)(windows_core::Interface::as_raw(this), authenticationkind, &mut result__).map(|| result__) } } - pub fn IsAuthenticationKindSupportedAsync(&self, authenticationkind: TetheringWiFiAuthenticationKind) -> windows_core::Result> { + pub fn IsAuthenticationKindSupportedAsync(&self, authenticationkind: TetheringWiFiAuthenticationKind) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -6282,7 +6282,7 @@ impl ProvisioningAgent { static SHARED: windows_core::imp::FactoryCache = windows_core::imp::FactoryCache::new(); SHARED.call(callback) } - pub fn ProvisionFromXmlDocumentAsync(&self, provisioningxmldocument: &windows_core::HSTRING) -> windows_core::Result> { + pub fn ProvisionFromXmlDocumentAsync(&self, provisioningxmldocument: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -6613,7 +6613,7 @@ impl windows_core::RuntimeType for UssdResultCode { pub struct UssdSession(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(UssdSession, windows_core::IUnknown, windows_core::IInspectable); impl UssdSession { - pub fn SendMessageAndGetReplyAsync(&self, message: P0) -> windows_core::Result> + pub fn SendMessageAndGetReplyAsync(&self, message: P0) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Networking/Proximity/mod.rs b/crates/libs/windows/src/Windows/Networking/Proximity/mod.rs index d357ff6b9d..ff2f9882ae 100644 --- a/crates/libs/windows/src/Windows/Networking/Proximity/mod.rs +++ b/crates/libs/windows/src/Windows/Networking/Proximity/mod.rs @@ -607,14 +607,14 @@ impl PeerFinder { pub fn RemoveConnectionRequested(cookie: i64) -> windows_core::Result<()> { Self::IPeerFinderStatics(|this| unsafe { (windows_core::Interface::vtable(this).RemoveConnectionRequested)(windows_core::Interface::as_raw(this), cookie).ok() }) } - pub fn FindAllPeersAsync() -> windows_core::Result>> { + pub fn FindAllPeersAsync() -> windows_core::Result>> { Self::IPeerFinderStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAllPeersAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "Networking_Sockets")] - pub fn ConnectAsync(peerinformation: P0) -> windows_core::Result> + pub fn ConnectAsync(peerinformation: P0) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Networking/PushNotifications/mod.rs b/crates/libs/windows/src/Windows/Networking/PushNotifications/mod.rs index c794579c6e..e25a74a10d 100644 --- a/crates/libs/windows/src/Windows/Networking/PushNotifications/mod.rs +++ b/crates/libs/windows/src/Windows/Networking/PushNotifications/mod.rs @@ -199,19 +199,19 @@ unsafe impl Send for PushNotificationChannel {} unsafe impl Sync for PushNotificationChannel {} pub struct PushNotificationChannelManager; impl PushNotificationChannelManager { - pub fn CreatePushNotificationChannelForApplicationAsync() -> windows_core::Result> { + pub fn CreatePushNotificationChannelForApplicationAsync() -> windows_core::Result> { Self::IPushNotificationChannelManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreatePushNotificationChannelForApplicationAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn CreatePushNotificationChannelForApplicationAsyncWithId(applicationid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CreatePushNotificationChannelForApplicationAsyncWithId(applicationid: &windows_core::HSTRING) -> windows_core::Result> { Self::IPushNotificationChannelManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreatePushNotificationChannelForApplicationAsyncWithId)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(applicationid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn CreatePushNotificationChannelForSecondaryTileAsync(tileid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CreatePushNotificationChannelForSecondaryTileAsync(tileid: &windows_core::HSTRING) -> windows_core::Result> { Self::IPushNotificationChannelManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreatePushNotificationChannelForSecondaryTileAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(tileid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -270,21 +270,21 @@ impl windows_core::RuntimeName for PushNotificationChannelManager { pub struct PushNotificationChannelManagerForUser(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(PushNotificationChannelManagerForUser, windows_core::IUnknown, windows_core::IInspectable); impl PushNotificationChannelManagerForUser { - pub fn CreatePushNotificationChannelForApplicationAsync(&self) -> windows_core::Result> { + pub fn CreatePushNotificationChannelForApplicationAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreatePushNotificationChannelForApplicationAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreatePushNotificationChannelForApplicationAsyncWithId(&self, applicationid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CreatePushNotificationChannelForApplicationAsyncWithId(&self, applicationid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreatePushNotificationChannelForApplicationAsyncWithId)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(applicationid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreatePushNotificationChannelForSecondaryTileAsync(&self, tileid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CreatePushNotificationChannelForSecondaryTileAsync(&self, tileid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -300,7 +300,7 @@ impl PushNotificationChannelManagerForUser { } } #[cfg(feature = "Storage_Streams")] - pub fn CreateRawPushNotificationChannelWithAlternateKeyForApplicationAsync(&self, appserverkey: P0, channelid: &windows_core::HSTRING) -> windows_core::Result> + pub fn CreateRawPushNotificationChannelWithAlternateKeyForApplicationAsync(&self, appserverkey: P0, channelid: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -311,7 +311,7 @@ impl PushNotificationChannelManagerForUser { } } #[cfg(feature = "Storage_Streams")] - pub fn CreateRawPushNotificationChannelWithAlternateKeyForApplicationAsyncWithId(&self, appserverkey: P0, channelid: &windows_core::HSTRING, appid: &windows_core::HSTRING) -> windows_core::Result> + pub fn CreateRawPushNotificationChannelWithAlternateKeyForApplicationAsyncWithId(&self, appserverkey: P0, channelid: &windows_core::HSTRING, appid: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Networking/ServiceDiscovery/Dnssd/mod.rs b/crates/libs/windows/src/Windows/Networking/ServiceDiscovery/Dnssd/mod.rs index a67b6605d0..d2520a28b7 100644 --- a/crates/libs/windows/src/Windows/Networking/ServiceDiscovery/Dnssd/mod.rs +++ b/crates/libs/windows/src/Windows/Networking/ServiceDiscovery/Dnssd/mod.rs @@ -139,7 +139,7 @@ impl DnssdServiceInstance { } } #[cfg(feature = "Networking_Sockets")] - pub fn RegisterStreamSocketListenerAsync(&self, socket: P0) -> windows_core::Result> + pub fn RegisterStreamSocketListenerAsync(&self, socket: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -150,7 +150,7 @@ impl DnssdServiceInstance { } } #[cfg(all(feature = "Networking_Connectivity", feature = "Networking_Sockets"))] - pub fn RegisterStreamSocketListenerAsync2(&self, socket: P0, adapter: P1) -> windows_core::Result> + pub fn RegisterStreamSocketListenerAsync2(&self, socket: P0, adapter: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -162,7 +162,7 @@ impl DnssdServiceInstance { } } #[cfg(feature = "Networking_Sockets")] - pub fn RegisterDatagramSocketAsync(&self, socket: P0) -> windows_core::Result> + pub fn RegisterDatagramSocketAsync(&self, socket: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -173,7 +173,7 @@ impl DnssdServiceInstance { } } #[cfg(all(feature = "Networking_Connectivity", feature = "Networking_Sockets"))] - pub fn RegisterDatagramSocketAsync2(&self, socket: P0, adapter: P1) -> windows_core::Result> + pub fn RegisterDatagramSocketAsync2(&self, socket: P0, adapter: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, diff --git a/crates/libs/windows/src/Windows/Networking/Sockets/mod.rs b/crates/libs/windows/src/Windows/Networking/Sockets/mod.rs index b1586c2759..75e39176b4 100644 --- a/crates/libs/windows/src/Windows/Networking/Sockets/mod.rs +++ b/crates/libs/windows/src/Windows/Networking/Sockets/mod.rs @@ -215,7 +215,7 @@ impl DatagramSocket { (windows_core::Interface::vtable(this).OutputStream)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ConnectAsync(&self, remotehostname: P0, remoteservicename: &windows_core::HSTRING) -> windows_core::Result + pub fn ConnectAsync(&self, remotehostname: P0, remoteservicename: &windows_core::HSTRING) -> windows_core::Result where P0: windows_core::Param, { @@ -225,7 +225,7 @@ impl DatagramSocket { (windows_core::Interface::vtable(this).ConnectAsync)(windows_core::Interface::as_raw(this), remotehostname.param().abi(), core::mem::transmute_copy(remoteservicename), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ConnectWithEndpointPairAsync(&self, endpointpair: P0) -> windows_core::Result + pub fn ConnectWithEndpointPairAsync(&self, endpointpair: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -235,14 +235,14 @@ impl DatagramSocket { (windows_core::Interface::vtable(this).ConnectWithEndpointPairAsync)(windows_core::Interface::as_raw(this), endpointpair.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn BindServiceNameAsync(&self, localservicename: &windows_core::HSTRING) -> windows_core::Result { + pub fn BindServiceNameAsync(&self, localservicename: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).BindServiceNameAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(localservicename), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn BindEndpointAsync(&self, localhostname: P0, localservicename: &windows_core::HSTRING) -> windows_core::Result + pub fn BindEndpointAsync(&self, localhostname: P0, localservicename: &windows_core::HSTRING) -> windows_core::Result where P0: windows_core::Param, { @@ -260,7 +260,7 @@ impl DatagramSocket { unsafe { (windows_core::Interface::vtable(this).JoinMulticastGroup)(windows_core::Interface::as_raw(this), host.param().abi()).ok() } } #[cfg(feature = "Storage_Streams")] - pub fn GetOutputStreamAsync(&self, remotehostname: P0, remoteservicename: &windows_core::HSTRING) -> windows_core::Result> + pub fn GetOutputStreamAsync(&self, remotehostname: P0, remoteservicename: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -271,7 +271,7 @@ impl DatagramSocket { } } #[cfg(feature = "Storage_Streams")] - pub fn GetOutputStreamWithEndpointPairAsync(&self, endpointpair: P0) -> windows_core::Result> + pub fn GetOutputStreamWithEndpointPairAsync(&self, endpointpair: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -296,7 +296,7 @@ impl DatagramSocket { unsafe { (windows_core::Interface::vtable(this).RemoveMessageReceived)(windows_core::Interface::as_raw(this), eventcookie).ok() } } #[cfg(feature = "Networking_Connectivity")] - pub fn BindServiceNameAndAdapterAsync(&self, localservicename: &windows_core::HSTRING, adapter: P1) -> windows_core::Result + pub fn BindServiceNameAndAdapterAsync(&self, localservicename: &windows_core::HSTRING, adapter: P1) -> windows_core::Result where P1: windows_core::Param, { @@ -306,7 +306,7 @@ impl DatagramSocket { (windows_core::Interface::vtable(this).BindServiceNameAndAdapterAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(localservicename), adapter.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CancelIOAsync(&self) -> windows_core::Result { + pub fn CancelIOAsync(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -339,7 +339,7 @@ impl DatagramSocket { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).TransferOwnershipWithContextAndKeepAliveTime)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(socketid), data.param().abi(), keepalivetime).ok() } } - pub fn GetEndpointPairsAsync(remotehostname: P0, remoteservicename: &windows_core::HSTRING) -> windows_core::Result>> + pub fn GetEndpointPairsAsync(remotehostname: P0, remoteservicename: &windows_core::HSTRING) -> windows_core::Result>> where P0: windows_core::Param, { @@ -348,7 +348,7 @@ impl DatagramSocket { (windows_core::Interface::vtable(this).GetEndpointPairsAsync)(windows_core::Interface::as_raw(this), remotehostname.param().abi(), core::mem::transmute_copy(remoteservicename), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetEndpointPairsWithSortOptionsAsync(remotehostname: P0, remoteservicename: &windows_core::HSTRING, sortoptions: super::HostNameSortOptions) -> windows_core::Result>> + pub fn GetEndpointPairsWithSortOptionsAsync(remotehostname: P0, remoteservicename: &windows_core::HSTRING, sortoptions: super::HostNameSortOptions) -> windows_core::Result>> where P0: windows_core::Param, { @@ -1409,7 +1409,7 @@ impl IWebSocket { (windows_core::Interface::vtable(this).OutputStream)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ConnectAsync(&self, uri: P0) -> windows_core::Result + pub fn ConnectAsync(&self, uri: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -1453,7 +1453,7 @@ impl windows_core::RuntimeName for IWebSocket { #[cfg(feature = "Storage_Streams")] pub trait IWebSocket_Impl: super::super::Foundation::IClosable_Impl { fn OutputStream(&self) -> windows_core::Result; - fn ConnectAsync(&self, uri: windows_core::Ref<'_, super::super::Foundation::Uri>) -> windows_core::Result; + fn ConnectAsync(&self, uri: windows_core::Ref<'_, super::super::Foundation::Uri>) -> windows_core::Result; fn SetRequestHeader(&self, headerName: &windows_core::HSTRING, headerValue: &windows_core::HSTRING) -> windows_core::Result<()>; fn Closed(&self, eventHandler: windows_core::Ref<'_, super::super::Foundation::TypedEventHandler>) -> windows_core::Result; fn RemoveClosed(&self, eventCookie: i64) -> windows_core::Result<()>; @@ -2186,7 +2186,7 @@ impl MessageWebSocket { unsafe { (windows_core::Interface::vtable(this).RemoveServerCustomValidationRequested)(windows_core::Interface::as_raw(this), eventcookie).ok() } } #[cfg(feature = "Storage_Streams")] - pub fn SendNonfinalFrameAsync(&self, data: P0) -> windows_core::Result> + pub fn SendNonfinalFrameAsync(&self, data: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2197,7 +2197,7 @@ impl MessageWebSocket { } } #[cfg(feature = "Storage_Streams")] - pub fn SendFinalFrameAsync(&self, data: P0) -> windows_core::Result> + pub fn SendFinalFrameAsync(&self, data: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2215,7 +2215,7 @@ impl MessageWebSocket { (windows_core::Interface::vtable(this).OutputStream)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ConnectAsync(&self, uri: P0) -> windows_core::Result + pub fn ConnectAsync(&self, uri: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -3158,7 +3158,7 @@ impl StreamSocket { (windows_core::Interface::vtable(this).OutputStream)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ConnectWithEndpointPairAsync(&self, endpointpair: P0) -> windows_core::Result + pub fn ConnectWithEndpointPairAsync(&self, endpointpair: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -3168,7 +3168,7 @@ impl StreamSocket { (windows_core::Interface::vtable(this).ConnectWithEndpointPairAsync)(windows_core::Interface::as_raw(this), endpointpair.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ConnectAsync(&self, remotehostname: P0, remoteservicename: &windows_core::HSTRING) -> windows_core::Result + pub fn ConnectAsync(&self, remotehostname: P0, remoteservicename: &windows_core::HSTRING) -> windows_core::Result where P0: windows_core::Param, { @@ -3178,7 +3178,7 @@ impl StreamSocket { (windows_core::Interface::vtable(this).ConnectAsync)(windows_core::Interface::as_raw(this), remotehostname.param().abi(), core::mem::transmute_copy(remoteservicename), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ConnectWithEndpointPairAndProtectionLevelAsync(&self, endpointpair: P0, protectionlevel: SocketProtectionLevel) -> windows_core::Result + pub fn ConnectWithEndpointPairAndProtectionLevelAsync(&self, endpointpair: P0, protectionlevel: SocketProtectionLevel) -> windows_core::Result where P0: windows_core::Param, { @@ -3188,7 +3188,7 @@ impl StreamSocket { (windows_core::Interface::vtable(this).ConnectWithEndpointPairAndProtectionLevelAsync)(windows_core::Interface::as_raw(this), endpointpair.param().abi(), protectionlevel, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ConnectWithProtectionLevelAsync(&self, remotehostname: P0, remoteservicename: &windows_core::HSTRING, protectionlevel: SocketProtectionLevel) -> windows_core::Result + pub fn ConnectWithProtectionLevelAsync(&self, remotehostname: P0, remoteservicename: &windows_core::HSTRING, protectionlevel: SocketProtectionLevel) -> windows_core::Result where P0: windows_core::Param, { @@ -3198,7 +3198,7 @@ impl StreamSocket { (windows_core::Interface::vtable(this).ConnectWithProtectionLevelAsync)(windows_core::Interface::as_raw(this), remotehostname.param().abi(), core::mem::transmute_copy(remoteservicename), protectionlevel, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn UpgradeToSslAsync(&self, protectionlevel: SocketProtectionLevel, validationhostname: P1) -> windows_core::Result + pub fn UpgradeToSslAsync(&self, protectionlevel: SocketProtectionLevel, validationhostname: P1) -> windows_core::Result where P1: windows_core::Param, { @@ -3209,7 +3209,7 @@ impl StreamSocket { } } #[cfg(feature = "Networking_Connectivity")] - pub fn ConnectWithProtectionLevelAndAdapterAsync(&self, remotehostname: P0, remoteservicename: &windows_core::HSTRING, protectionlevel: SocketProtectionLevel, adapter: P3) -> windows_core::Result + pub fn ConnectWithProtectionLevelAndAdapterAsync(&self, remotehostname: P0, remoteservicename: &windows_core::HSTRING, protectionlevel: SocketProtectionLevel, adapter: P3) -> windows_core::Result where P0: windows_core::Param, P3: windows_core::Param, @@ -3220,7 +3220,7 @@ impl StreamSocket { (windows_core::Interface::vtable(this).ConnectWithProtectionLevelAndAdapterAsync)(windows_core::Interface::as_raw(this), remotehostname.param().abi(), core::mem::transmute_copy(remoteservicename), protectionlevel, adapter.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CancelIOAsync(&self) -> windows_core::Result { + pub fn CancelIOAsync(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -3253,7 +3253,7 @@ impl StreamSocket { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).TransferOwnershipWithContextAndKeepAliveTime)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(socketid), data.param().abi(), keepalivetime).ok() } } - pub fn GetEndpointPairsAsync(remotehostname: P0, remoteservicename: &windows_core::HSTRING) -> windows_core::Result>> + pub fn GetEndpointPairsAsync(remotehostname: P0, remoteservicename: &windows_core::HSTRING) -> windows_core::Result>> where P0: windows_core::Param, { @@ -3262,7 +3262,7 @@ impl StreamSocket { (windows_core::Interface::vtable(this).GetEndpointPairsAsync)(windows_core::Interface::as_raw(this), remotehostname.param().abi(), core::mem::transmute_copy(remoteservicename), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetEndpointPairsWithSortOptionsAsync(remotehostname: P0, remoteservicename: &windows_core::HSTRING, sortoptions: super::HostNameSortOptions) -> windows_core::Result>> + pub fn GetEndpointPairsWithSortOptionsAsync(remotehostname: P0, remoteservicename: &windows_core::HSTRING, sortoptions: super::HostNameSortOptions) -> windows_core::Result>> where P0: windows_core::Param, { @@ -3558,14 +3558,14 @@ impl StreamSocketListener { (windows_core::Interface::vtable(this).Information)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn BindServiceNameAsync(&self, localservicename: &windows_core::HSTRING) -> windows_core::Result { + pub fn BindServiceNameAsync(&self, localservicename: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).BindServiceNameAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(localservicename), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn BindEndpointAsync(&self, localhostname: P0, localservicename: &windows_core::HSTRING) -> windows_core::Result + pub fn BindEndpointAsync(&self, localhostname: P0, localservicename: &windows_core::HSTRING) -> windows_core::Result where P0: windows_core::Param, { @@ -3589,7 +3589,7 @@ impl StreamSocketListener { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveConnectionReceived)(windows_core::Interface::as_raw(this), eventcookie).ok() } } - pub fn BindServiceNameWithProtectionLevelAsync(&self, localservicename: &windows_core::HSTRING, protectionlevel: SocketProtectionLevel) -> windows_core::Result { + pub fn BindServiceNameWithProtectionLevelAsync(&self, localservicename: &windows_core::HSTRING, protectionlevel: SocketProtectionLevel) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -3597,7 +3597,7 @@ impl StreamSocketListener { } } #[cfg(feature = "Networking_Connectivity")] - pub fn BindServiceNameWithProtectionLevelAndAdapterAsync(&self, localservicename: &windows_core::HSTRING, protectionlevel: SocketProtectionLevel, adapter: P2) -> windows_core::Result + pub fn BindServiceNameWithProtectionLevelAndAdapterAsync(&self, localservicename: &windows_core::HSTRING, protectionlevel: SocketProtectionLevel, adapter: P2) -> windows_core::Result where P2: windows_core::Param, { @@ -3607,7 +3607,7 @@ impl StreamSocketListener { (windows_core::Interface::vtable(this).BindServiceNameWithProtectionLevelAndAdapterAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(localservicename), protectionlevel, adapter.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CancelIOAsync(&self) -> windows_core::Result { + pub fn CancelIOAsync(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -3830,7 +3830,7 @@ impl StreamWebSocket { (windows_core::Interface::vtable(this).OutputStream)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ConnectAsync(&self, uri: P0) -> windows_core::Result + pub fn ConnectAsync(&self, uri: P0) -> windows_core::Result where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Networking/Vpn/mod.rs b/crates/libs/windows/src/Windows/Networking/Vpn/mod.rs index f68526098a..0283f27d52 100644 --- a/crates/libs/windows/src/Windows/Networking/Vpn/mod.rs +++ b/crates/libs/windows/src/Windows/Networking/Vpn/mod.rs @@ -1895,7 +1895,7 @@ impl VpnChannel { (windows_core::Interface::vtable(this).GetVpnReceivePacketBuffer)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestCustomPromptAsync(&self, custompromptelement: P0) -> windows_core::Result + pub fn RequestCustomPromptAsync(&self, custompromptelement: P0) -> windows_core::Result where P0: windows_core::Param>, { @@ -1906,7 +1906,7 @@ impl VpnChannel { } } #[cfg(feature = "Security_Cryptography_Certificates")] - pub fn RequestCredentialsWithCertificateAsync(&self, credtype: VpnCredentialType, credoptions: u32, certificate: P2) -> windows_core::Result> + pub fn RequestCredentialsWithCertificateAsync(&self, credtype: VpnCredentialType, credoptions: u32, certificate: P2) -> windows_core::Result> where P2: windows_core::Param, { @@ -1916,14 +1916,14 @@ impl VpnChannel { (windows_core::Interface::vtable(this).RequestCredentialsWithCertificateAsync)(windows_core::Interface::as_raw(this), credtype, credoptions, certificate.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestCredentialsWithOptionsAsync(&self, credtype: VpnCredentialType, credoptions: u32) -> windows_core::Result> { + pub fn RequestCredentialsWithOptionsAsync(&self, credtype: VpnCredentialType, credoptions: u32) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestCredentialsWithOptionsAsync)(windows_core::Interface::as_raw(this), credtype, credoptions, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestCredentialsSimpleAsync(&self, credtype: VpnCredentialType) -> windows_core::Result> { + pub fn RequestCredentialsSimpleAsync(&self, credtype: VpnCredentialType) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -3285,14 +3285,14 @@ impl VpnManagementAgent { static SHARED: windows_core::imp::FactoryCache = windows_core::imp::FactoryCache::new(); SHARED.call(callback) } - pub fn AddProfileFromXmlAsync(&self, xml: &windows_core::HSTRING) -> windows_core::Result> { + pub fn AddProfileFromXmlAsync(&self, xml: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).AddProfileFromXmlAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(xml), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn AddProfileFromObjectAsync(&self, profile: P0) -> windows_core::Result> + pub fn AddProfileFromObjectAsync(&self, profile: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -3302,14 +3302,14 @@ impl VpnManagementAgent { (windows_core::Interface::vtable(this).AddProfileFromObjectAsync)(windows_core::Interface::as_raw(this), profile.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn UpdateProfileFromXmlAsync(&self, xml: &windows_core::HSTRING) -> windows_core::Result> { + pub fn UpdateProfileFromXmlAsync(&self, xml: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).UpdateProfileFromXmlAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(xml), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn UpdateProfileFromObjectAsync(&self, profile: P0) -> windows_core::Result> + pub fn UpdateProfileFromObjectAsync(&self, profile: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -3319,14 +3319,14 @@ impl VpnManagementAgent { (windows_core::Interface::vtable(this).UpdateProfileFromObjectAsync)(windows_core::Interface::as_raw(this), profile.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetProfilesAsync(&self) -> windows_core::Result>> { + pub fn GetProfilesAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetProfilesAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteProfileAsync(&self, profile: P0) -> windows_core::Result> + pub fn DeleteProfileAsync(&self, profile: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -3336,7 +3336,7 @@ impl VpnManagementAgent { (windows_core::Interface::vtable(this).DeleteProfileAsync)(windows_core::Interface::as_raw(this), profile.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ConnectProfileAsync(&self, profile: P0) -> windows_core::Result> + pub fn ConnectProfileAsync(&self, profile: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -3347,7 +3347,7 @@ impl VpnManagementAgent { } } #[cfg(feature = "Security_Credentials")] - pub fn ConnectProfileWithPasswordCredentialAsync(&self, profile: P0, passwordcredential: P1) -> windows_core::Result> + pub fn ConnectProfileWithPasswordCredentialAsync(&self, profile: P0, passwordcredential: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -3358,7 +3358,7 @@ impl VpnManagementAgent { (windows_core::Interface::vtable(this).ConnectProfileWithPasswordCredentialAsync)(windows_core::Interface::as_raw(this), profile.param().abi(), passwordcredential.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DisconnectProfileAsync(&self, profile: P0) -> windows_core::Result> + pub fn DisconnectProfileAsync(&self, profile: P0) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Networking/XboxLive/mod.rs b/crates/libs/windows/src/Windows/Networking/XboxLive/mod.rs index b1c57ebf2a..4a833e1969 100644 --- a/crates/libs/windows/src/Windows/Networking/XboxLive/mod.rs +++ b/crates/libs/windows/src/Windows/Networking/XboxLive/mod.rs @@ -340,7 +340,7 @@ impl XboxLiveEndpointPair { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveStateChanged)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn DeleteAsync(&self) -> windows_core::Result { + pub fn DeleteAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -618,7 +618,7 @@ impl XboxLiveEndpointPairTemplate { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveInboundEndpointPairCreated)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn CreateEndpointPairDefaultAsync(&self, deviceaddress: P0) -> windows_core::Result> + pub fn CreateEndpointPairDefaultAsync(&self, deviceaddress: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -628,7 +628,7 @@ impl XboxLiveEndpointPairTemplate { (windows_core::Interface::vtable(this).CreateEndpointPairDefaultAsync)(windows_core::Interface::as_raw(this), deviceaddress.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateEndpointPairWithBehaviorsAsync(&self, deviceaddress: P0, behaviors: XboxLiveEndpointPairCreationBehaviors) -> windows_core::Result> + pub fn CreateEndpointPairWithBehaviorsAsync(&self, deviceaddress: P0, behaviors: XboxLiveEndpointPairCreationBehaviors) -> windows_core::Result> where P0: windows_core::Param, { @@ -638,7 +638,7 @@ impl XboxLiveEndpointPairTemplate { (windows_core::Interface::vtable(this).CreateEndpointPairWithBehaviorsAsync)(windows_core::Interface::as_raw(this), deviceaddress.param().abi(), behaviors, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateEndpointPairForPortsDefaultAsync(&self, deviceaddress: P0, initiatorport: &windows_core::HSTRING, acceptorport: &windows_core::HSTRING) -> windows_core::Result> + pub fn CreateEndpointPairForPortsDefaultAsync(&self, deviceaddress: P0, initiatorport: &windows_core::HSTRING, acceptorport: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -648,7 +648,7 @@ impl XboxLiveEndpointPairTemplate { (windows_core::Interface::vtable(this).CreateEndpointPairForPortsDefaultAsync)(windows_core::Interface::as_raw(this), deviceaddress.param().abi(), core::mem::transmute_copy(initiatorport), core::mem::transmute_copy(acceptorport), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateEndpointPairForPortsWithBehaviorsAsync(&self, deviceaddress: P0, initiatorport: &windows_core::HSTRING, acceptorport: &windows_core::HSTRING, behaviors: XboxLiveEndpointPairCreationBehaviors) -> windows_core::Result> + pub fn CreateEndpointPairForPortsWithBehaviorsAsync(&self, deviceaddress: P0, initiatorport: &windows_core::HSTRING, acceptorport: &windows_core::HSTRING, behaviors: XboxLiveEndpointPairCreationBehaviors) -> windows_core::Result> where P0: windows_core::Param, { @@ -787,7 +787,7 @@ impl XboxLiveQualityOfServiceMeasurement { static SHARED: windows_core::imp::FactoryCache = windows_core::imp::FactoryCache::new(); SHARED.call(callback) } - pub fn MeasureAsync(&self) -> windows_core::Result { + pub fn MeasureAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Perception/People/mod.rs b/crates/libs/windows/src/Windows/Perception/People/mod.rs index 5f165e3360..a70c1754d1 100644 --- a/crates/libs/windows/src/Windows/Perception/People/mod.rs +++ b/crates/libs/windows/src/Windows/Perception/People/mod.rs @@ -32,7 +32,7 @@ impl EyesPose { }) } #[cfg(feature = "UI_Input")] - pub fn RequestAccessAsync() -> windows_core::Result> { + pub fn RequestAccessAsync() -> windows_core::Result> { Self::IEyesPoseStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestAccessAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/Perception/Spatial/Surfaces/mod.rs b/crates/libs/windows/src/Windows/Perception/Spatial/Surfaces/mod.rs index fe1588823e..c4037e53cb 100644 --- a/crates/libs/windows/src/Windows/Perception/Spatial/Surfaces/mod.rs +++ b/crates/libs/windows/src/Windows/Perception/Spatial/Surfaces/mod.rs @@ -161,14 +161,14 @@ impl SpatialSurfaceInfo { (windows_core::Interface::vtable(this).TryGetBounds)(windows_core::Interface::as_raw(this), coordinatesystem.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryComputeLatestMeshAsync(&self, maxtrianglespercubicmeter: f64) -> windows_core::Result> { + pub fn TryComputeLatestMeshAsync(&self, maxtrianglespercubicmeter: f64) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryComputeLatestMeshAsync)(windows_core::Interface::as_raw(this), maxtrianglespercubicmeter, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryComputeLatestMeshWithOptionsAsync(&self, maxtrianglespercubicmeter: f64, options: P1) -> windows_core::Result> + pub fn TryComputeLatestMeshWithOptionsAsync(&self, maxtrianglespercubicmeter: f64, options: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -446,7 +446,7 @@ impl SpatialSurfaceObserver { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveObservedSurfacesChanged)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn RequestAccessAsync() -> windows_core::Result> { + pub fn RequestAccessAsync() -> windows_core::Result> { Self::ISpatialSurfaceObserverStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestAccessAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/Perception/Spatial/mod.rs b/crates/libs/windows/src/Windows/Perception/Spatial/mod.rs index cea807653a..a20c620902 100644 --- a/crates/libs/windows/src/Windows/Perception/Spatial/mod.rs +++ b/crates/libs/windows/src/Windows/Perception/Spatial/mod.rs @@ -536,7 +536,7 @@ unsafe impl Sync for SpatialAnchorExportSufficiency {} pub struct SpatialAnchorExporter(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(SpatialAnchorExporter, windows_core::IUnknown, windows_core::IInspectable); impl SpatialAnchorExporter { - pub fn GetAnchorExportSufficiencyAsync(&self, anchor: P0, purpose: SpatialAnchorExportPurpose) -> windows_core::Result> + pub fn GetAnchorExportSufficiencyAsync(&self, anchor: P0, purpose: SpatialAnchorExportPurpose) -> windows_core::Result> where P0: windows_core::Param, { @@ -547,7 +547,7 @@ impl SpatialAnchorExporter { } } #[cfg(feature = "Storage_Streams")] - pub fn TryExportAnchorAsync(&self, anchor: P0, purpose: SpatialAnchorExportPurpose, stream: P2) -> windows_core::Result> + pub fn TryExportAnchorAsync(&self, anchor: P0, purpose: SpatialAnchorExportPurpose, stream: P2) -> windows_core::Result> where P0: windows_core::Param, P2: windows_core::Param, @@ -564,7 +564,7 @@ impl SpatialAnchorExporter { (windows_core::Interface::vtable(this).GetDefault)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RequestAccessAsync() -> windows_core::Result> { + pub fn RequestAccessAsync() -> windows_core::Result> { Self::ISpatialAnchorExporterStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestAccessAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -589,7 +589,7 @@ unsafe impl Send for SpatialAnchorExporter {} unsafe impl Sync for SpatialAnchorExporter {} pub struct SpatialAnchorManager; impl SpatialAnchorManager { - pub fn RequestStoreAsync() -> windows_core::Result> { + pub fn RequestStoreAsync() -> windows_core::Result> { Self::ISpatialAnchorManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestStoreAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -676,7 +676,7 @@ pub struct SpatialAnchorTransferManager; #[cfg(feature = "deprecated")] impl SpatialAnchorTransferManager { #[cfg(feature = "Storage_Streams")] - pub fn TryImportAnchorsAsync(stream: P0) -> windows_core::Result>> + pub fn TryImportAnchorsAsync(stream: P0) -> windows_core::Result>> where P0: windows_core::Param, { @@ -686,7 +686,7 @@ impl SpatialAnchorTransferManager { }) } #[cfg(feature = "Storage_Streams")] - pub fn TryExportAnchorsAsync(anchors: P0, stream: P1) -> windows_core::Result> + pub fn TryExportAnchorsAsync(anchors: P0, stream: P1) -> windows_core::Result> where P0: windows_core::Param>>, P1: windows_core::Param, @@ -696,7 +696,7 @@ impl SpatialAnchorTransferManager { (windows_core::Interface::vtable(this).TryExportAnchorsAsync)(windows_core::Interface::as_raw(this), anchors.param().abi(), stream.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RequestAccessAsync() -> windows_core::Result> { + pub fn RequestAccessAsync() -> windows_core::Result> { Self::ISpatialAnchorTransferManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestAccessAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -971,7 +971,7 @@ unsafe impl Sync for SpatialEntityRemovedEventArgs {} pub struct SpatialEntityStore(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(SpatialEntityStore, windows_core::IUnknown, windows_core::IInspectable); impl SpatialEntityStore { - pub fn SaveAsync(&self, entity: P0) -> windows_core::Result + pub fn SaveAsync(&self, entity: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -981,7 +981,7 @@ impl SpatialEntityStore { (windows_core::Interface::vtable(this).SaveAsync)(windows_core::Interface::as_raw(this), entity.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RemoveAsync(&self, entity: P0) -> windows_core::Result + pub fn RemoveAsync(&self, entity: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -1601,7 +1601,7 @@ impl SpatialStageFrameOfReference { pub fn RemoveCurrentChanged(cookie: i64) -> windows_core::Result<()> { Self::ISpatialStageFrameOfReferenceStatics(|this| unsafe { (windows_core::Interface::vtable(this).RemoveCurrentChanged)(windows_core::Interface::as_raw(this), cookie).ok() }) } - pub fn RequestNewStageAsync() -> windows_core::Result> { + pub fn RequestNewStageAsync() -> windows_core::Result> { Self::ISpatialStageFrameOfReferenceStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestNewStageAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/Phone/Management/Deployment/mod.rs b/crates/libs/windows/src/Windows/Phone/Management/Deployment/mod.rs index f43c38c851..479c705371 100644 --- a/crates/libs/windows/src/Windows/Phone/Management/Deployment/mod.rs +++ b/crates/libs/windows/src/Windows/Phone/Management/Deployment/mod.rs @@ -72,19 +72,19 @@ impl EnterpriseEnrollmentManager { (windows_core::Interface::vtable(this).CurrentEnterprise)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn ValidateEnterprisesAsync() -> windows_core::Result { + pub fn ValidateEnterprisesAsync() -> windows_core::Result { Self::IEnterpriseEnrollmentManager(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ValidateEnterprisesAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RequestEnrollmentAsync(enrollmenttoken: &windows_core::HSTRING) -> windows_core::Result> { + pub fn RequestEnrollmentAsync(enrollmenttoken: &windows_core::HSTRING) -> windows_core::Result> { Self::IEnterpriseEnrollmentManager(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestEnrollmentAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(enrollmenttoken), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RequestUnenrollmentAsync(enterprise: P0) -> windows_core::Result> + pub fn RequestUnenrollmentAsync(enterprise: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -260,7 +260,7 @@ pub struct IPackageInstallResult2_Vtbl { } pub struct InstallationManager; impl InstallationManager { - pub fn AddPackageAsync(title: &windows_core::HSTRING, sourcelocation: P1) -> windows_core::Result> + pub fn AddPackageAsync(title: &windows_core::HSTRING, sourcelocation: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -269,7 +269,7 @@ impl InstallationManager { (windows_core::Interface::vtable(this).AddPackageAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(title), sourcelocation.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn AddPackagePreloadedAsync(title: &windows_core::HSTRING, sourcelocation: P1, instanceid: &windows_core::HSTRING, offerid: &windows_core::HSTRING, license: P4) -> windows_core::Result> + pub fn AddPackagePreloadedAsync(title: &windows_core::HSTRING, sourcelocation: P1, instanceid: &windows_core::HSTRING, offerid: &windows_core::HSTRING, license: P4) -> windows_core::Result> where P1: windows_core::Param, P4: windows_core::Param, @@ -279,7 +279,7 @@ impl InstallationManager { (windows_core::Interface::vtable(this).AddPackagePreloadedAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(title), sourcelocation.param().abi(), core::mem::transmute_copy(instanceid), core::mem::transmute_copy(offerid), license.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetPendingPackageInstalls() -> windows_core::Result>> { + pub fn GetPendingPackageInstalls() -> windows_core::Result>> { Self::IInstallationManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetPendingPackageInstalls)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -300,14 +300,14 @@ impl InstallationManager { }) } #[cfg(feature = "Management_Deployment")] - pub fn RemovePackageAsync(packagefullname: &windows_core::HSTRING, removaloptions: super::super::super::Management::Deployment::RemovalOptions) -> windows_core::Result> { + pub fn RemovePackageAsync(packagefullname: &windows_core::HSTRING, removaloptions: super::super::super::Management::Deployment::RemovalOptions) -> windows_core::Result> { Self::IInstallationManagerStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RemovePackageAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(packagefullname), removaloptions, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "Management_Deployment")] - pub fn RegisterPackageAsync(manifesturi: P0, dependencypackageuris: P1, deploymentoptions: super::super::super::Management::Deployment::DeploymentOptions) -> windows_core::Result> + pub fn RegisterPackageAsync(manifesturi: P0, dependencypackageuris: P1, deploymentoptions: super::super::super::Management::Deployment::DeploymentOptions) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param>, diff --git a/crates/libs/windows/src/Windows/Phone/PersonalInformation/Provisioning/mod.rs b/crates/libs/windows/src/Windows/Phone/PersonalInformation/Provisioning/mod.rs index 7dd85452bd..26fab355f9 100644 --- a/crates/libs/windows/src/Windows/Phone/PersonalInformation/Provisioning/mod.rs +++ b/crates/libs/windows/src/Windows/Phone/PersonalInformation/Provisioning/mod.rs @@ -1,6 +1,6 @@ pub struct ContactPartnerProvisioningManager; impl ContactPartnerProvisioningManager { - pub fn AssociateNetworkAccountAsync(store: P0, networkname: &windows_core::HSTRING, networkaccountid: &windows_core::HSTRING) -> windows_core::Result + pub fn AssociateNetworkAccountAsync(store: P0, networkname: &windows_core::HSTRING, networkaccountid: &windows_core::HSTRING) -> windows_core::Result where P0: windows_core::Param, { @@ -10,7 +10,7 @@ impl ContactPartnerProvisioningManager { }) } #[cfg(feature = "Storage_Streams")] - pub fn ImportVcardToSystemAsync(stream: P0) -> windows_core::Result + pub fn ImportVcardToSystemAsync(stream: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -19,7 +19,7 @@ impl ContactPartnerProvisioningManager { (windows_core::Interface::vtable(this).ImportVcardToSystemAsync)(windows_core::Interface::as_raw(this), stream.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn AssociateSocialNetworkAccountAsync(store: P0, networkname: &windows_core::HSTRING, networkaccountid: &windows_core::HSTRING) -> windows_core::Result + pub fn AssociateSocialNetworkAccountAsync(store: P0, networkname: &windows_core::HSTRING, networkaccountid: &windows_core::HSTRING) -> windows_core::Result where P0: windows_core::Param, { @@ -74,7 +74,7 @@ pub struct IMessagePartnerProvisioningManagerStatics_Vtbl { } pub struct MessagePartnerProvisioningManager; impl MessagePartnerProvisioningManager { - pub fn ImportSmsToSystemAsync(incoming: bool, read: bool, body: &windows_core::HSTRING, sender: &windows_core::HSTRING, recipients: P4, deliverytime: super::super::super::Foundation::DateTime) -> windows_core::Result + pub fn ImportSmsToSystemAsync(incoming: bool, read: bool, body: &windows_core::HSTRING, sender: &windows_core::HSTRING, recipients: P4, deliverytime: super::super::super::Foundation::DateTime) -> windows_core::Result where P4: windows_core::Param>, { @@ -83,7 +83,7 @@ impl MessagePartnerProvisioningManager { (windows_core::Interface::vtable(this).ImportSmsToSystemAsync)(windows_core::Interface::as_raw(this), incoming, read, core::mem::transmute_copy(body), core::mem::transmute_copy(sender), recipients.param().abi(), deliverytime, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn ImportMmsToSystemAsync(incoming: bool, read: bool, subject: &windows_core::HSTRING, sender: &windows_core::HSTRING, recipients: P4, deliverytime: super::super::super::Foundation::DateTime, attachments: P6) -> windows_core::Result + pub fn ImportMmsToSystemAsync(incoming: bool, read: bool, subject: &windows_core::HSTRING, sender: &windows_core::HSTRING, recipients: P4, deliverytime: super::super::super::Foundation::DateTime, attachments: P6) -> windows_core::Result where P4: windows_core::Param>, P6: windows_core::Param>>, diff --git a/crates/libs/windows/src/Windows/Phone/PersonalInformation/mod.rs b/crates/libs/windows/src/Windows/Phone/PersonalInformation/mod.rs index 77c5b9684a..4aa7104dff 100644 --- a/crates/libs/windows/src/Windows/Phone/PersonalInformation/mod.rs +++ b/crates/libs/windows/src/Windows/Phone/PersonalInformation/mod.rs @@ -208,7 +208,7 @@ impl ContactInformation { unsafe { (windows_core::Interface::vtable(this).SetHonorificSuffix)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(value)).ok() } } #[cfg(feature = "Storage_Streams")] - pub fn GetDisplayPictureAsync(&self) -> windows_core::Result> { + pub fn GetDisplayPictureAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -216,7 +216,7 @@ impl ContactInformation { } } #[cfg(feature = "Storage_Streams")] - pub fn SetDisplayPictureAsync(&self, stream: P0) -> windows_core::Result + pub fn SetDisplayPictureAsync(&self, stream: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -234,7 +234,7 @@ impl ContactInformation { (windows_core::Interface::vtable(this).DisplayPicture)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetPropertiesAsync(&self) -> windows_core::Result>> { + pub fn GetPropertiesAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -242,7 +242,7 @@ impl ContactInformation { } } #[cfg(feature = "Storage_Streams")] - pub fn ToVcardAsync(&self) -> windows_core::Result> { + pub fn ToVcardAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -250,7 +250,7 @@ impl ContactInformation { } } #[cfg(feature = "Storage_Streams")] - pub fn ToVcardWithOptionsAsync(&self, format: VCardFormat) -> windows_core::Result> { + pub fn ToVcardWithOptionsAsync(&self, format: VCardFormat) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -258,7 +258,7 @@ impl ContactInformation { } } #[cfg(feature = "Storage_Streams")] - pub fn ParseVcardAsync(vcard: P0) -> windows_core::Result> + pub fn ParseVcardAsync(vcard: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -332,21 +332,21 @@ unsafe impl Sync for ContactQueryOptions {} pub struct ContactQueryResult(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(ContactQueryResult, windows_core::IUnknown, windows_core::IInspectable); impl ContactQueryResult { - pub fn GetContactCountAsync(&self) -> windows_core::Result> { + pub fn GetContactCountAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetContactCountAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetContactsAsync(&self) -> windows_core::Result>> { + pub fn GetContactsAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetContactsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetContactsAsyncInRange(&self, startindex: u32, maxnumberofitems: u32) -> windows_core::Result>> { + pub fn GetContactsAsyncInRange(&self, startindex: u32, maxnumberofitems: u32) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -392,21 +392,21 @@ impl windows_core::RuntimeType for ContactQueryResultOrdering { pub struct ContactStore(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(ContactStore, windows_core::IUnknown, windows_core::IInspectable); impl ContactStore { - pub fn FindContactByRemoteIdAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FindContactByRemoteIdAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindContactByRemoteIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(id), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FindContactByIdAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FindContactByIdAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindContactByIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(id), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteContactAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result { + pub fn DeleteContactAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -430,7 +430,7 @@ impl ContactStore { (windows_core::Interface::vtable(this).CreateContactQueryWithOptions)(windows_core::Interface::as_raw(this), options.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAsync(&self) -> windows_core::Result { + pub fn DeleteAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -444,21 +444,21 @@ impl ContactStore { (windows_core::Interface::vtable(this).RevisionNumber)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn GetChangesAsync(&self, baserevisionnumber: u64) -> windows_core::Result>> { + pub fn GetChangesAsync(&self, baserevisionnumber: u64) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetChangesAsync)(windows_core::Interface::as_raw(this), baserevisionnumber, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn LoadExtendedPropertiesAsync(&self) -> windows_core::Result>> { + pub fn LoadExtendedPropertiesAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).LoadExtendedPropertiesAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SaveExtendedPropertiesAsync(&self, data: P0) -> windows_core::Result + pub fn SaveExtendedPropertiesAsync(&self, data: P0) -> windows_core::Result where P0: windows_core::Param>, { @@ -468,20 +468,20 @@ impl ContactStore { (windows_core::Interface::vtable(this).SaveExtendedPropertiesAsync)(windows_core::Interface::as_raw(this), data.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateMeContactAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CreateMeContactAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreateMeContactAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(id), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateOrOpenAsync() -> windows_core::Result> { + pub fn CreateOrOpenAsync() -> windows_core::Result> { Self::IContactStoreStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreateOrOpenAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn CreateOrOpenWithOptionsAsync(access: ContactStoreSystemAccessMode, sharing: ContactStoreApplicationAccessMode) -> windows_core::Result> { + pub fn CreateOrOpenWithOptionsAsync(access: ContactStoreSystemAccessMode, sharing: ContactStoreApplicationAccessMode) -> windows_core::Result> { Self::IContactStoreStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreateOrOpenWithOptionsAsync)(windows_core::Interface::as_raw(this), access, sharing, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -622,7 +622,7 @@ impl IContactInformation { unsafe { (windows_core::Interface::vtable(this).SetHonorificSuffix)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(value)).ok() } } #[cfg(feature = "Storage_Streams")] - pub fn GetDisplayPictureAsync(&self) -> windows_core::Result> { + pub fn GetDisplayPictureAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -630,7 +630,7 @@ impl IContactInformation { } } #[cfg(feature = "Storage_Streams")] - pub fn SetDisplayPictureAsync(&self, stream: P0) -> windows_core::Result + pub fn SetDisplayPictureAsync(&self, stream: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -648,7 +648,7 @@ impl IContactInformation { (windows_core::Interface::vtable(this).DisplayPicture)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetPropertiesAsync(&self) -> windows_core::Result>> { + pub fn GetPropertiesAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -656,7 +656,7 @@ impl IContactInformation { } } #[cfg(feature = "Storage_Streams")] - pub fn ToVcardAsync(&self) -> windows_core::Result> { + pub fn ToVcardAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -664,7 +664,7 @@ impl IContactInformation { } } #[cfg(feature = "Storage_Streams")] - pub fn ToVcardWithOptionsAsync(&self, format: VCardFormat) -> windows_core::Result> { + pub fn ToVcardWithOptionsAsync(&self, format: VCardFormat) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -688,12 +688,12 @@ pub trait IContactInformation_Impl: windows_core::IUnknownImpl { fn SetHonorificPrefix(&self, value: &windows_core::HSTRING) -> windows_core::Result<()>; fn HonorificSuffix(&self) -> windows_core::Result; fn SetHonorificSuffix(&self, value: &windows_core::HSTRING) -> windows_core::Result<()>; - fn GetDisplayPictureAsync(&self) -> windows_core::Result>; - fn SetDisplayPictureAsync(&self, stream: windows_core::Ref<'_, super::super::Storage::Streams::IInputStream>) -> windows_core::Result; + fn GetDisplayPictureAsync(&self) -> windows_core::Result>; + fn SetDisplayPictureAsync(&self, stream: windows_core::Ref<'_, super::super::Storage::Streams::IInputStream>) -> windows_core::Result; fn DisplayPicture(&self) -> windows_core::Result; - fn GetPropertiesAsync(&self) -> windows_core::Result>>; - fn ToVcardAsync(&self) -> windows_core::Result>; - fn ToVcardWithOptionsAsync(&self, format: VCardFormat) -> windows_core::Result>; + fn GetPropertiesAsync(&self) -> windows_core::Result>>; + fn ToVcardAsync(&self) -> windows_core::Result>; + fn ToVcardWithOptionsAsync(&self, format: VCardFormat) -> windows_core::Result>; } #[cfg(feature = "Storage_Streams")] impl IContactInformation_Vtbl { @@ -1413,7 +1413,7 @@ impl StoredContact { unsafe { (windows_core::Interface::vtable(this).SetHonorificSuffix)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(value)).ok() } } #[cfg(feature = "Storage_Streams")] - pub fn GetDisplayPictureAsync(&self) -> windows_core::Result> { + pub fn GetDisplayPictureAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1421,7 +1421,7 @@ impl StoredContact { } } #[cfg(feature = "Storage_Streams")] - pub fn SetDisplayPictureAsync(&self, stream: P0) -> windows_core::Result + pub fn SetDisplayPictureAsync(&self, stream: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -1439,7 +1439,7 @@ impl StoredContact { (windows_core::Interface::vtable(this).DisplayPicture)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetPropertiesAsync(&self) -> windows_core::Result>> { + pub fn GetPropertiesAsync(&self) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1447,7 +1447,7 @@ impl StoredContact { } } #[cfg(feature = "Storage_Streams")] - pub fn ToVcardAsync(&self) -> windows_core::Result> { + pub fn ToVcardAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1455,7 +1455,7 @@ impl StoredContact { } } #[cfg(feature = "Storage_Streams")] - pub fn ToVcardWithOptionsAsync(&self, format: VCardFormat) -> windows_core::Result> { + pub fn ToVcardWithOptionsAsync(&self, format: VCardFormat) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1498,21 +1498,21 @@ impl StoredContact { let this = self; unsafe { (windows_core::Interface::vtable(this).SetRemoteId)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(value)).ok() } } - pub fn GetExtendedPropertiesAsync(&self) -> windows_core::Result>> { + pub fn GetExtendedPropertiesAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetExtendedPropertiesAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SaveAsync(&self) -> windows_core::Result { + pub fn SaveAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).SaveAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReplaceExistingContactAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result { + pub fn ReplaceExistingContactAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Phone/StartScreen/mod.rs b/crates/libs/windows/src/Windows/Phone/StartScreen/mod.rs index 83c93a9457..ea997b4aa7 100644 --- a/crates/libs/windows/src/Windows/Phone/StartScreen/mod.rs +++ b/crates/libs/windows/src/Windows/Phone/StartScreen/mod.rs @@ -28,21 +28,21 @@ impl DualSimTile { (windows_core::Interface::vtable(this).IsPinnedToStart)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn CreateAsync(&self) -> windows_core::Result> { + pub fn CreateAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreateAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn UpdateAsync(&self) -> windows_core::Result> { + pub fn UpdateAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).UpdateAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAsync(&self) -> windows_core::Result> { + pub fn DeleteAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -55,7 +55,7 @@ impl DualSimTile { (windows_core::Interface::vtable(this).GetTileForSim2)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn UpdateDisplayNameForSim1Async(name: &windows_core::HSTRING) -> windows_core::Result> { + pub fn UpdateDisplayNameForSim1Async(name: &windows_core::HSTRING) -> windows_core::Result> { Self::IDualSimTileStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).UpdateDisplayNameForSim1Async)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(name), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/Phone/System/UserProfile/GameServices/Core/mod.rs b/crates/libs/windows/src/Windows/Phone/System/UserProfile/GameServices/Core/mod.rs index 7f3ccccafc..73034d5510 100644 --- a/crates/libs/windows/src/Windows/Phone/System/UserProfile/GameServices/Core/mod.rs +++ b/crates/libs/windows/src/Windows/Phone/System/UserProfile/GameServices/Core/mod.rs @@ -6,19 +6,19 @@ impl GameService { (windows_core::Interface::vtable(this).ServiceUri)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetGamerProfileAsync() -> windows_core::Result> { + pub fn GetGamerProfileAsync() -> windows_core::Result> { Self::IGameService(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetGamerProfileAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetInstalledGameItemsAsync() -> windows_core::Result> { + pub fn GetInstalledGameItemsAsync() -> windows_core::Result> { Self::IGameService(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetInstalledGameItemsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetPartnerTokenAsync(audienceuri: P0) -> windows_core::Result> + pub fn GetPartnerTokenAsync(audienceuri: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -27,7 +27,7 @@ impl GameService { (windows_core::Interface::vtable(this).GetPartnerTokenAsync)(windows_core::Interface::as_raw(this), audienceuri.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetPrivilegesAsync() -> windows_core::Result> { + pub fn GetPrivilegesAsync() -> windows_core::Result> { Self::IGameService(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetPrivilegesAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -90,7 +90,7 @@ impl windows_core::RuntimeType for GameServiceGameOutcome { pub struct GameServicePropertyCollection(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(GameServicePropertyCollection, windows_core::IUnknown, windows_core::IInspectable); impl GameServicePropertyCollection { - pub fn GetPropertyAsync(&self, propertyname: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetPropertyAsync(&self, propertyname: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Security/Authentication/Identity/Core/mod.rs b/crates/libs/windows/src/Windows/Security/Authentication/Identity/Core/mod.rs index 1e0a562d67..8a575adf2c 100644 --- a/crates/libs/windows/src/Windows/Security/Authentication/Identity/Core/mod.rs +++ b/crates/libs/windows/src/Windows/Security/Authentication/Identity/Core/mod.rs @@ -78,35 +78,35 @@ pub struct IMicrosoftAccountMultiFactorUnregisteredAccountsAndSessionInfo_Vtbl { pub struct MicrosoftAccountMultiFactorAuthenticationManager(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(MicrosoftAccountMultiFactorAuthenticationManager, windows_core::IUnknown, windows_core::IInspectable); impl MicrosoftAccountMultiFactorAuthenticationManager { - pub fn GetOneTimePassCodeAsync(&self, useraccountid: &windows_core::HSTRING, codelength: u32) -> windows_core::Result> { + pub fn GetOneTimePassCodeAsync(&self, useraccountid: &windows_core::HSTRING, codelength: u32) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetOneTimePassCodeAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(useraccountid), codelength, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn AddDeviceAsync(&self, useraccountid: &windows_core::HSTRING, authenticationtoken: &windows_core::HSTRING, wnschannelid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn AddDeviceAsync(&self, useraccountid: &windows_core::HSTRING, authenticationtoken: &windows_core::HSTRING, wnschannelid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).AddDeviceAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(useraccountid), core::mem::transmute_copy(authenticationtoken), core::mem::transmute_copy(wnschannelid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RemoveDeviceAsync(&self, useraccountid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn RemoveDeviceAsync(&self, useraccountid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RemoveDeviceAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(useraccountid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn UpdateWnsChannelAsync(&self, useraccountid: &windows_core::HSTRING, channeluri: &windows_core::HSTRING) -> windows_core::Result> { + pub fn UpdateWnsChannelAsync(&self, useraccountid: &windows_core::HSTRING, channeluri: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).UpdateWnsChannelAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(useraccountid), core::mem::transmute_copy(channeluri), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetSessionsAsync(&self, useraccountidlist: P0) -> windows_core::Result> + pub fn GetSessionsAsync(&self, useraccountidlist: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -116,7 +116,7 @@ impl MicrosoftAccountMultiFactorAuthenticationManager { (windows_core::Interface::vtable(this).GetSessionsAsync)(windows_core::Interface::as_raw(this), useraccountidlist.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetSessionsAndUnregisteredAccountsAsync(&self, useraccountidlist: P0) -> windows_core::Result> + pub fn GetSessionsAndUnregisteredAccountsAsync(&self, useraccountidlist: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -126,7 +126,7 @@ impl MicrosoftAccountMultiFactorAuthenticationManager { (windows_core::Interface::vtable(this).GetSessionsAndUnregisteredAccountsAsync)(windows_core::Interface::as_raw(this), useraccountidlist.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ApproveSessionUsingAuthSessionInfoAsync(&self, sessionauthentictionstatus: MicrosoftAccountMultiFactorSessionAuthenticationStatus, authenticationsessioninfo: P1) -> windows_core::Result> + pub fn ApproveSessionUsingAuthSessionInfoAsync(&self, sessionauthentictionstatus: MicrosoftAccountMultiFactorSessionAuthenticationStatus, authenticationsessioninfo: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -136,14 +136,14 @@ impl MicrosoftAccountMultiFactorAuthenticationManager { (windows_core::Interface::vtable(this).ApproveSessionUsingAuthSessionInfoAsync)(windows_core::Interface::as_raw(this), sessionauthentictionstatus, authenticationsessioninfo.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ApproveSessionAsync(&self, sessionauthentictionstatus: MicrosoftAccountMultiFactorSessionAuthenticationStatus, useraccountid: &windows_core::HSTRING, sessionid: &windows_core::HSTRING, sessionauthenticationtype: MicrosoftAccountMultiFactorAuthenticationType) -> windows_core::Result> { + pub fn ApproveSessionAsync(&self, sessionauthentictionstatus: MicrosoftAccountMultiFactorSessionAuthenticationStatus, useraccountid: &windows_core::HSTRING, sessionid: &windows_core::HSTRING, sessionauthenticationtype: MicrosoftAccountMultiFactorAuthenticationType) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ApproveSessionAsync)(windows_core::Interface::as_raw(this), sessionauthentictionstatus, core::mem::transmute_copy(useraccountid), core::mem::transmute_copy(sessionid), sessionauthenticationtype, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DenySessionUsingAuthSessionInfoAsync(&self, authenticationsessioninfo: P0) -> windows_core::Result> + pub fn DenySessionUsingAuthSessionInfoAsync(&self, authenticationsessioninfo: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -153,7 +153,7 @@ impl MicrosoftAccountMultiFactorAuthenticationManager { (windows_core::Interface::vtable(this).DenySessionUsingAuthSessionInfoAsync)(windows_core::Interface::as_raw(this), authenticationsessioninfo.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DenySessionAsync(&self, useraccountid: &windows_core::HSTRING, sessionid: &windows_core::HSTRING, sessionauthenticationtype: MicrosoftAccountMultiFactorAuthenticationType) -> windows_core::Result> { + pub fn DenySessionAsync(&self, useraccountid: &windows_core::HSTRING, sessionid: &windows_core::HSTRING, sessionauthenticationtype: MicrosoftAccountMultiFactorAuthenticationType) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Security/Authentication/Identity/mod.rs b/crates/libs/windows/src/Windows/Security/Authentication/Identity/mod.rs index 25a2b91b47..df28dffad7 100644 --- a/crates/libs/windows/src/Windows/Security/Authentication/Identity/mod.rs +++ b/crates/libs/windows/src/Windows/Security/Authentication/Identity/mod.rs @@ -58,7 +58,7 @@ unsafe impl Sync for EnterpriseKeyCredentialRegistrationInfo {} pub struct EnterpriseKeyCredentialRegistrationManager(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(EnterpriseKeyCredentialRegistrationManager, windows_core::IUnknown, windows_core::IInspectable); impl EnterpriseKeyCredentialRegistrationManager { - pub fn GetRegistrationsAsync(&self) -> windows_core::Result>> { + pub fn GetRegistrationsAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Security/Authentication/OnlineId/mod.rs b/crates/libs/windows/src/Windows/Security/Authentication/OnlineId/mod.rs index 1457a70d55..7cf68082ec 100644 --- a/crates/libs/windows/src/Windows/Security/Authentication/OnlineId/mod.rs +++ b/crates/libs/windows/src/Windows/Security/Authentication/OnlineId/mod.rs @@ -318,7 +318,7 @@ impl windows_core::RuntimeName for OnlineIdSystemAuthenticator { pub struct OnlineIdSystemAuthenticatorForUser(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(OnlineIdSystemAuthenticatorForUser, windows_core::IUnknown, windows_core::IInspectable); impl OnlineIdSystemAuthenticatorForUser { - pub fn GetTicketAsync(&self, request: P0) -> windows_core::Result> + pub fn GetTicketAsync(&self, request: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -445,8 +445,8 @@ impl windows_core::TypeKind for OnlineIdSystemTicketStatus { impl windows_core::RuntimeType for OnlineIdSystemTicketStatus { const SIGNATURE: windows_core::imp::ConstBuffer = windows_core::imp::ConstBuffer::from_slice(b"enum(Windows.Security.Authentication.OnlineId.OnlineIdSystemTicketStatus;i4)"); } -pub type SignOutUserOperation = super::super::super::Foundation::IAsyncAction; -pub type UserAuthenticationOperation = super::super::super::Foundation::IAsyncOperation; +pub type SignOutUserOperation = windows_async::IAsyncAction; +pub type UserAuthenticationOperation = windows_async::IAsyncOperation; #[repr(transparent)] #[derive(Clone, Debug, Eq, PartialEq)] pub struct UserIdentity(windows_core::IUnknown); diff --git a/crates/libs/windows/src/Windows/Security/Authentication/Web/Core/mod.rs b/crates/libs/windows/src/Windows/Security/Authentication/Web/Core/mod.rs index 8fecbf879d..683a06ea55 100644 --- a/crates/libs/windows/src/Windows/Security/Authentication/Web/Core/mod.rs +++ b/crates/libs/windows/src/Windows/Security/Authentication/Web/Core/mod.rs @@ -590,7 +590,7 @@ impl windows_core::RuntimeType for WebAuthenticationAddAccountStatus { } pub struct WebAuthenticationCoreManager; impl WebAuthenticationCoreManager { - pub fn GetTokenSilentlyAsync(request: P0) -> windows_core::Result> + pub fn GetTokenSilentlyAsync(request: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -600,7 +600,7 @@ impl WebAuthenticationCoreManager { }) } #[cfg(feature = "Security_Credentials")] - pub fn GetTokenSilentlyWithWebAccountAsync(request: P0, webaccount: P1) -> windows_core::Result> + pub fn GetTokenSilentlyWithWebAccountAsync(request: P0, webaccount: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -610,7 +610,7 @@ impl WebAuthenticationCoreManager { (windows_core::Interface::vtable(this).GetTokenSilentlyWithWebAccountAsync)(windows_core::Interface::as_raw(this), request.param().abi(), webaccount.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RequestTokenAsync(request: P0) -> windows_core::Result> + pub fn RequestTokenAsync(request: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -620,7 +620,7 @@ impl WebAuthenticationCoreManager { }) } #[cfg(feature = "Security_Credentials")] - pub fn RequestTokenWithWebAccountAsync(request: P0, webaccount: P1) -> windows_core::Result> + pub fn RequestTokenWithWebAccountAsync(request: P0, webaccount: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -631,7 +631,7 @@ impl WebAuthenticationCoreManager { }) } #[cfg(feature = "Security_Credentials")] - pub fn FindAccountAsync(provider: P0, webaccountid: &windows_core::HSTRING) -> windows_core::Result> + pub fn FindAccountAsync(provider: P0, webaccountid: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -641,21 +641,21 @@ impl WebAuthenticationCoreManager { }) } #[cfg(feature = "Security_Credentials")] - pub fn FindAccountProviderAsync(webaccountproviderid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FindAccountProviderAsync(webaccountproviderid: &windows_core::HSTRING) -> windows_core::Result> { Self::IWebAuthenticationCoreManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAccountProviderAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(webaccountproviderid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "Security_Credentials")] - pub fn FindAccountProviderWithAuthorityAsync(webaccountproviderid: &windows_core::HSTRING, authority: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FindAccountProviderWithAuthorityAsync(webaccountproviderid: &windows_core::HSTRING, authority: &windows_core::HSTRING) -> windows_core::Result> { Self::IWebAuthenticationCoreManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAccountProviderWithAuthorityAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(webaccountproviderid), core::mem::transmute_copy(authority), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(all(feature = "Security_Credentials", feature = "System"))] - pub fn FindAccountProviderWithAuthorityForUserAsync(webaccountproviderid: &windows_core::HSTRING, authority: &windows_core::HSTRING, user: P2) -> windows_core::Result> + pub fn FindAccountProviderWithAuthorityForUserAsync(webaccountproviderid: &windows_core::HSTRING, authority: &windows_core::HSTRING, user: P2) -> windows_core::Result> where P2: windows_core::Param, { @@ -675,7 +675,7 @@ impl WebAuthenticationCoreManager { }) } #[cfg(feature = "Security_Credentials")] - pub fn FindAllAccountsAsync(provider: P0) -> windows_core::Result> + pub fn FindAllAccountsAsync(provider: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -685,7 +685,7 @@ impl WebAuthenticationCoreManager { }) } #[cfg(feature = "Security_Credentials")] - pub fn FindAllAccountsWithClientIdAsync(provider: P0, clientid: &windows_core::HSTRING) -> windows_core::Result> + pub fn FindAllAccountsWithClientIdAsync(provider: P0, clientid: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -695,21 +695,21 @@ impl WebAuthenticationCoreManager { }) } #[cfg(feature = "Security_Credentials")] - pub fn FindSystemAccountProviderAsync(webaccountproviderid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FindSystemAccountProviderAsync(webaccountproviderid: &windows_core::HSTRING) -> windows_core::Result> { Self::IWebAuthenticationCoreManagerStatics4(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindSystemAccountProviderAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(webaccountproviderid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "Security_Credentials")] - pub fn FindSystemAccountProviderWithAuthorityAsync(webaccountproviderid: &windows_core::HSTRING, authority: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FindSystemAccountProviderWithAuthorityAsync(webaccountproviderid: &windows_core::HSTRING, authority: &windows_core::HSTRING) -> windows_core::Result> { Self::IWebAuthenticationCoreManagerStatics4(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindSystemAccountProviderWithAuthorityAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(webaccountproviderid), core::mem::transmute_copy(authority), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(all(feature = "Security_Credentials", feature = "System"))] - pub fn FindSystemAccountProviderWithAuthorityForUserAsync(webaccountproviderid: &windows_core::HSTRING, authority: &windows_core::HSTRING, user: P2) -> windows_core::Result> + pub fn FindSystemAccountProviderWithAuthorityForUserAsync(webaccountproviderid: &windows_core::HSTRING, authority: &windows_core::HSTRING, user: P2) -> windows_core::Result> where P2: windows_core::Param, { @@ -718,7 +718,7 @@ impl WebAuthenticationCoreManager { (windows_core::Interface::vtable(this).FindSystemAccountProviderWithAuthorityForUserAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(webaccountproviderid), core::mem::transmute_copy(authority), user.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn AddAccountWithTransferTokenAsync(request: P0) -> windows_core::Result> + pub fn AddAccountWithTransferTokenAsync(request: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1034,7 +1034,7 @@ impl WebTokenRequestResult { (windows_core::Interface::vtable(this).ResponseError)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn InvalidateCacheAsync(&self) -> windows_core::Result { + pub fn InvalidateCacheAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Security/Authentication/Web/Provider/mod.rs b/crates/libs/windows/src/Windows/Security/Authentication/Web/Provider/mod.rs index cfa494db79..c88a42d135 100644 --- a/crates/libs/windows/src/Windows/Security/Authentication/Web/Provider/mod.rs +++ b/crates/libs/windows/src/Windows/Security/Authentication/Web/Provider/mod.rs @@ -826,7 +826,7 @@ impl windows_core::RuntimeType for WebAccountClientViewType { pub struct WebAccountManager; impl WebAccountManager { #[cfg(feature = "Security_Credentials")] - pub fn UpdateWebAccountPropertiesAsync(webaccount: P0, webaccountusername: &windows_core::HSTRING, additionalproperties: P2) -> windows_core::Result + pub fn UpdateWebAccountPropertiesAsync(webaccount: P0, webaccountusername: &windows_core::HSTRING, additionalproperties: P2) -> windows_core::Result where P0: windows_core::Param, P2: windows_core::Param>, @@ -837,7 +837,7 @@ impl WebAccountManager { }) } #[cfg(feature = "Security_Credentials")] - pub fn AddWebAccountAsync(webaccountid: &windows_core::HSTRING, webaccountusername: &windows_core::HSTRING, props: P2) -> windows_core::Result> + pub fn AddWebAccountAsync(webaccountid: &windows_core::HSTRING, webaccountusername: &windows_core::HSTRING, props: P2) -> windows_core::Result> where P2: windows_core::Param>, { @@ -847,7 +847,7 @@ impl WebAccountManager { }) } #[cfg(feature = "Security_Credentials")] - pub fn DeleteWebAccountAsync(webaccount: P0) -> windows_core::Result + pub fn DeleteWebAccountAsync(webaccount: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -857,14 +857,14 @@ impl WebAccountManager { }) } #[cfg(feature = "Security_Credentials")] - pub fn FindAllProviderWebAccountsAsync() -> windows_core::Result>> { + pub fn FindAllProviderWebAccountsAsync() -> windows_core::Result>> { Self::IWebAccountManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAllProviderWebAccountsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "Web_Http")] - pub fn PushCookiesAsync(uri: P0, cookies: P1) -> windows_core::Result + pub fn PushCookiesAsync(uri: P0, cookies: P1) -> windows_core::Result where P0: windows_core::Param, P1: windows_core::Param>, @@ -875,7 +875,7 @@ impl WebAccountManager { }) } #[cfg(feature = "Security_Credentials")] - pub fn SetViewAsync(webaccount: P0, view: P1) -> windows_core::Result + pub fn SetViewAsync(webaccount: P0, view: P1) -> windows_core::Result where P0: windows_core::Param, P1: windows_core::Param, @@ -886,7 +886,7 @@ impl WebAccountManager { }) } #[cfg(feature = "Security_Credentials")] - pub fn ClearViewAsync(webaccount: P0, applicationcallbackuri: P1) -> windows_core::Result + pub fn ClearViewAsync(webaccount: P0, applicationcallbackuri: P1) -> windows_core::Result where P0: windows_core::Param, P1: windows_core::Param, @@ -897,7 +897,7 @@ impl WebAccountManager { }) } #[cfg(feature = "Security_Credentials")] - pub fn GetViewsAsync(webaccount: P0) -> windows_core::Result>> + pub fn GetViewsAsync(webaccount: P0) -> windows_core::Result>> where P0: windows_core::Param, { @@ -907,7 +907,7 @@ impl WebAccountManager { }) } #[cfg(all(feature = "Security_Credentials", feature = "Storage_Streams"))] - pub fn SetWebAccountPictureAsync(webaccount: P0, webaccountpicture: P1) -> windows_core::Result + pub fn SetWebAccountPictureAsync(webaccount: P0, webaccountpicture: P1) -> windows_core::Result where P0: windows_core::Param, P1: windows_core::Param, @@ -918,7 +918,7 @@ impl WebAccountManager { }) } #[cfg(feature = "Security_Credentials")] - pub fn ClearWebAccountPictureAsync(webaccount: P0) -> windows_core::Result + pub fn ClearWebAccountPictureAsync(webaccount: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -927,14 +927,14 @@ impl WebAccountManager { (windows_core::Interface::vtable(this).ClearWebAccountPictureAsync)(windows_core::Interface::as_raw(this), webaccount.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn PullCookiesAsync(uristring: &windows_core::HSTRING, callerpfn: &windows_core::HSTRING) -> windows_core::Result { + pub fn PullCookiesAsync(uristring: &windows_core::HSTRING, callerpfn: &windows_core::HSTRING) -> windows_core::Result { Self::IWebAccountManagerStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).PullCookiesAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(uristring), core::mem::transmute_copy(callerpfn), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(all(feature = "Security_Credentials", feature = "System"))] - pub fn FindAllProviderWebAccountsForUserAsync(user: P0) -> windows_core::Result>> + pub fn FindAllProviderWebAccountsForUserAsync(user: P0) -> windows_core::Result>> where P0: windows_core::Param, { @@ -944,7 +944,7 @@ impl WebAccountManager { }) } #[cfg(all(feature = "Security_Credentials", feature = "System"))] - pub fn AddWebAccountForUserAsync(user: P0, webaccountid: &windows_core::HSTRING, webaccountusername: &windows_core::HSTRING, props: P3) -> windows_core::Result> + pub fn AddWebAccountForUserAsync(user: P0, webaccountid: &windows_core::HSTRING, webaccountusername: &windows_core::HSTRING, props: P3) -> windows_core::Result> where P0: windows_core::Param, P3: windows_core::Param>, @@ -955,7 +955,7 @@ impl WebAccountManager { }) } #[cfg(all(feature = "Security_Credentials", feature = "System"))] - pub fn AddWebAccountWithScopeForUserAsync(user: P0, webaccountid: &windows_core::HSTRING, webaccountusername: &windows_core::HSTRING, props: P3, scope: WebAccountScope) -> windows_core::Result> + pub fn AddWebAccountWithScopeForUserAsync(user: P0, webaccountid: &windows_core::HSTRING, webaccountusername: &windows_core::HSTRING, props: P3, scope: WebAccountScope) -> windows_core::Result> where P0: windows_core::Param, P3: windows_core::Param>, @@ -966,7 +966,7 @@ impl WebAccountManager { }) } #[cfg(all(feature = "Security_Credentials", feature = "System"))] - pub fn AddWebAccountWithScopeAndMapForUserAsync(user: P0, webaccountid: &windows_core::HSTRING, webaccountusername: &windows_core::HSTRING, props: P3, scope: WebAccountScope, peruserwebaccountid: &windows_core::HSTRING) -> windows_core::Result> + pub fn AddWebAccountWithScopeAndMapForUserAsync(user: P0, webaccountid: &windows_core::HSTRING, webaccountusername: &windows_core::HSTRING, props: P3, scope: WebAccountScope, peruserwebaccountid: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, P3: windows_core::Param>, @@ -976,14 +976,14 @@ impl WebAccountManager { (windows_core::Interface::vtable(this).AddWebAccountWithScopeAndMapForUserAsync)(windows_core::Interface::as_raw(this), user.param().abi(), core::mem::transmute_copy(webaccountid), core::mem::transmute_copy(webaccountusername), props.param().abi(), scope, core::mem::transmute_copy(peruserwebaccountid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn InvalidateAppCacheForAllAccountsAsync() -> windows_core::Result { + pub fn InvalidateAppCacheForAllAccountsAsync() -> windows_core::Result { Self::IWebAccountManagerStatics4(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).InvalidateAppCacheForAllAccountsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "Security_Credentials")] - pub fn InvalidateAppCacheForAccountAsync(webaccount: P0) -> windows_core::Result + pub fn InvalidateAppCacheForAccountAsync(webaccount: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -993,7 +993,7 @@ impl WebAccountManager { }) } #[cfg(feature = "Security_Credentials")] - pub fn AddWebAccountWithScopeAndMapAsync(webaccountid: &windows_core::HSTRING, webaccountusername: &windows_core::HSTRING, props: P2, scope: WebAccountScope, peruserwebaccountid: &windows_core::HSTRING) -> windows_core::Result> + pub fn AddWebAccountWithScopeAndMapAsync(webaccountid: &windows_core::HSTRING, webaccountusername: &windows_core::HSTRING, props: P2, scope: WebAccountScope, peruserwebaccountid: &windows_core::HSTRING) -> windows_core::Result> where P2: windows_core::Param>, { @@ -1003,7 +1003,7 @@ impl WebAccountManager { }) } #[cfg(feature = "Security_Credentials")] - pub fn SetPerAppToPerUserAccountAsync(perappaccount: P0, peruserwebaccountid: &windows_core::HSTRING) -> windows_core::Result + pub fn SetPerAppToPerUserAccountAsync(perappaccount: P0, peruserwebaccountid: &windows_core::HSTRING) -> windows_core::Result where P0: windows_core::Param, { @@ -1013,7 +1013,7 @@ impl WebAccountManager { }) } #[cfg(feature = "Security_Credentials")] - pub fn GetPerUserFromPerAppAccountAsync(perappaccount: P0) -> windows_core::Result> + pub fn GetPerUserFromPerAppAccountAsync(perappaccount: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1023,7 +1023,7 @@ impl WebAccountManager { }) } #[cfg(feature = "Security_Credentials")] - pub fn ClearPerUserFromPerAppAccountAsync(perappaccount: P0) -> windows_core::Result + pub fn ClearPerUserFromPerAppAccountAsync(perappaccount: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -1033,7 +1033,7 @@ impl WebAccountManager { }) } #[cfg(feature = "Security_Credentials")] - pub fn AddWebAccountWithScopeAsync(webaccountid: &windows_core::HSTRING, webaccountusername: &windows_core::HSTRING, props: P2, scope: WebAccountScope) -> windows_core::Result> + pub fn AddWebAccountWithScopeAsync(webaccountid: &windows_core::HSTRING, webaccountusername: &windows_core::HSTRING, props: P2, scope: WebAccountScope) -> windows_core::Result> where P2: windows_core::Param>, { @@ -1043,7 +1043,7 @@ impl WebAccountManager { }) } #[cfg(feature = "Security_Credentials")] - pub fn SetScopeAsync(webaccount: P0, scope: WebAccountScope) -> windows_core::Result + pub fn SetScopeAsync(webaccount: P0, scope: WebAccountScope) -> windows_core::Result where P0: windows_core::Param, { @@ -1627,7 +1627,7 @@ impl WebProviderTokenRequest { } } #[cfg(feature = "Security_Cryptography_Core")] - pub fn GetApplicationTokenBindingKeyAsync(&self, keytype: super::TokenBindingKeyType, target: P1) -> windows_core::Result> + pub fn GetApplicationTokenBindingKeyAsync(&self, keytype: super::TokenBindingKeyType, target: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -1638,7 +1638,7 @@ impl WebProviderTokenRequest { } } #[cfg(feature = "Storage_Streams")] - pub fn GetApplicationTokenBindingKeyIdAsync(&self, keytype: super::TokenBindingKeyType, target: P1) -> windows_core::Result> + pub fn GetApplicationTokenBindingKeyIdAsync(&self, keytype: super::TokenBindingKeyType, target: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -1662,7 +1662,7 @@ impl WebProviderTokenRequest { (windows_core::Interface::vtable(this).ApplicationProcessName)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn CheckApplicationForCapabilityAsync(&self, capabilityname: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CheckApplicationForCapabilityAsync(&self, capabilityname: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Security/Authentication/Web/mod.rs b/crates/libs/windows/src/Windows/Security/Authentication/Web/mod.rs index 0e691103ae..22e4e671c2 100644 --- a/crates/libs/windows/src/Windows/Security/Authentication/Web/mod.rs +++ b/crates/libs/windows/src/Windows/Security/Authentication/Web/mod.rs @@ -56,7 +56,7 @@ impl windows_core::RuntimeType for TokenBindingKeyType { } pub struct WebAuthenticationBroker; impl WebAuthenticationBroker { - pub fn AuthenticateWithCallbackUriAsync(options: WebAuthenticationOptions, requesturi: P1, callbackuri: P2) -> windows_core::Result> + pub fn AuthenticateWithCallbackUriAsync(options: WebAuthenticationOptions, requesturi: P1, callbackuri: P2) -> windows_core::Result> where P1: windows_core::Param, P2: windows_core::Param, @@ -66,7 +66,7 @@ impl WebAuthenticationBroker { (windows_core::Interface::vtable(this).AuthenticateWithCallbackUriAsync)(windows_core::Interface::as_raw(this), options, requesturi.param().abi(), callbackuri.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn AuthenticateWithoutCallbackUriAsync(options: WebAuthenticationOptions, requesturi: P1) -> windows_core::Result> + pub fn AuthenticateWithoutCallbackUriAsync(options: WebAuthenticationOptions, requesturi: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -103,7 +103,7 @@ impl WebAuthenticationBroker { { Self::IWebAuthenticationBrokerStatics2(|this| unsafe { (windows_core::Interface::vtable(this).AuthenticateWithCallbackUriContinuationDataAndOptionsAndContinue)(windows_core::Interface::as_raw(this), requesturi.param().abi(), callbackuri.param().abi(), continuationdata.param().abi(), options).ok() }) } - pub fn AuthenticateSilentlyAsync(requesturi: P0) -> windows_core::Result> + pub fn AuthenticateSilentlyAsync(requesturi: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -112,7 +112,7 @@ impl WebAuthenticationBroker { (windows_core::Interface::vtable(this).AuthenticateSilentlyAsync)(windows_core::Interface::as_raw(this), requesturi.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn AuthenticateSilentlyWithOptionsAsync(requesturi: P0, options: WebAuthenticationOptions) -> windows_core::Result> + pub fn AuthenticateSilentlyWithOptionsAsync(requesturi: P0, options: WebAuthenticationOptions) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Security/Authorization/AppCapabilityAccess/mod.rs b/crates/libs/windows/src/Windows/Security/Authorization/AppCapabilityAccess/mod.rs index 6fcf164cef..53509fb9ed 100644 --- a/crates/libs/windows/src/Windows/Security/Authorization/AppCapabilityAccess/mod.rs +++ b/crates/libs/windows/src/Windows/Security/Authorization/AppCapabilityAccess/mod.rs @@ -18,7 +18,7 @@ impl AppCapability { (windows_core::Interface::vtable(this).User)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestAccessAsync(&self) -> windows_core::Result> { + pub fn RequestAccessAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -57,7 +57,7 @@ impl AppCapability { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).SetDisplayMessage)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(value)).ok() } } - pub fn RequestAccessForCapabilitiesAsync(capabilitynames: P0) -> windows_core::Result>> + pub fn RequestAccessForCapabilitiesAsync(capabilitynames: P0) -> windows_core::Result>> where P0: windows_core::Param>, { @@ -67,7 +67,7 @@ impl AppCapability { }) } #[cfg(feature = "System")] - pub fn RequestAccessForCapabilitiesForUserAsync(user: P0, capabilitynames: P1) -> windows_core::Result>> + pub fn RequestAccessForCapabilitiesForUserAsync(user: P0, capabilitynames: P1) -> windows_core::Result>> where P0: windows_core::Param, P1: windows_core::Param>, diff --git a/crates/libs/windows/src/Windows/Security/Credentials/UI/mod.rs b/crates/libs/windows/src/Windows/Security/Credentials/UI/mod.rs index 90cb387f00..4dbf54dcbe 100644 --- a/crates/libs/windows/src/Windows/Security/Credentials/UI/mod.rs +++ b/crates/libs/windows/src/Windows/Security/Credentials/UI/mod.rs @@ -18,7 +18,7 @@ impl windows_core::RuntimeType for AuthenticationProtocol { } pub struct CredentialPicker; impl CredentialPicker { - pub fn PickWithOptionsAsync(options: P0) -> windows_core::Result> + pub fn PickWithOptionsAsync(options: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -27,13 +27,13 @@ impl CredentialPicker { (windows_core::Interface::vtable(this).PickWithOptionsAsync)(windows_core::Interface::as_raw(this), options.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn PickWithMessageAsync(targetname: &windows_core::HSTRING, message: &windows_core::HSTRING) -> windows_core::Result> { + pub fn PickWithMessageAsync(targetname: &windows_core::HSTRING, message: &windows_core::HSTRING) -> windows_core::Result> { Self::ICredentialPickerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).PickWithMessageAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(targetname), core::mem::transmute_copy(message), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn PickWithCaptionAsync(targetname: &windows_core::HSTRING, message: &windows_core::HSTRING, caption: &windows_core::HSTRING) -> windows_core::Result> { + pub fn PickWithCaptionAsync(targetname: &windows_core::HSTRING, message: &windows_core::HSTRING, caption: &windows_core::HSTRING) -> windows_core::Result> { Self::ICredentialPickerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).PickWithCaptionAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(targetname), core::mem::transmute_copy(message), core::mem::transmute_copy(caption), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -358,13 +358,13 @@ impl windows_core::RuntimeType for UserConsentVerificationResult { } pub struct UserConsentVerifier; impl UserConsentVerifier { - pub fn CheckAvailabilityAsync() -> windows_core::Result> { + pub fn CheckAvailabilityAsync() -> windows_core::Result> { Self::IUserConsentVerifierStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CheckAvailabilityAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RequestVerificationAsync(message: &windows_core::HSTRING) -> windows_core::Result> { + pub fn RequestVerificationAsync(message: &windows_core::HSTRING) -> windows_core::Result> { Self::IUserConsentVerifierStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestVerificationAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(message), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/Security/Credentials/mod.rs b/crates/libs/windows/src/Windows/Security/Credentials/mod.rs index 96cd6650d1..6d0f69fe4c 100644 --- a/crates/libs/windows/src/Windows/Security/Credentials/mod.rs +++ b/crates/libs/windows/src/Windows/Security/Credentials/mod.rs @@ -319,7 +319,7 @@ impl KeyCredential { } } #[cfg(feature = "Storage_Streams")] - pub fn RequestSignAsync(&self, data: P0) -> windows_core::Result> + pub fn RequestSignAsync(&self, data: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -329,7 +329,7 @@ impl KeyCredential { (windows_core::Interface::vtable(this).RequestSignAsync)(windows_core::Interface::as_raw(this), data.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAttestationAsync(&self) -> windows_core::Result> { + pub fn GetAttestationAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -420,31 +420,31 @@ impl windows_core::RuntimeType for KeyCredentialCreationOption { } pub struct KeyCredentialManager; impl KeyCredentialManager { - pub fn IsSupportedAsync() -> windows_core::Result> { + pub fn IsSupportedAsync() -> windows_core::Result> { Self::IKeyCredentialManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).IsSupportedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RenewAttestationAsync() -> windows_core::Result { + pub fn RenewAttestationAsync() -> windows_core::Result { Self::IKeyCredentialManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RenewAttestationAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RequestCreateAsync(name: &windows_core::HSTRING, option: KeyCredentialCreationOption) -> windows_core::Result> { + pub fn RequestCreateAsync(name: &windows_core::HSTRING, option: KeyCredentialCreationOption) -> windows_core::Result> { Self::IKeyCredentialManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestCreateAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(name), option, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn OpenAsync(name: &windows_core::HSTRING) -> windows_core::Result> { + pub fn OpenAsync(name: &windows_core::HSTRING) -> windows_core::Result> { Self::IKeyCredentialManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).OpenAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(name), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn DeleteAsync(name: &windows_core::HSTRING) -> windows_core::Result { + pub fn DeleteAsync(name: &windows_core::HSTRING) -> windows_core::Result { Self::IKeyCredentialManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeleteAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(name), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -847,21 +847,21 @@ impl WebAccount { } } #[cfg(feature = "Storage_Streams")] - pub fn GetPictureAsync(&self, desizedsize: WebAccountPictureSize) -> windows_core::Result> { + pub fn GetPictureAsync(&self, desizedsize: WebAccountPictureSize) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetPictureAsync)(windows_core::Interface::as_raw(this), desizedsize, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SignOutAsync(&self) -> windows_core::Result { + pub fn SignOutAsync(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).SignOutAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SignOutWithClientIdAsync(&self, clientid: &windows_core::HSTRING) -> windows_core::Result { + pub fn SignOutWithClientIdAsync(&self, clientid: &windows_core::HSTRING) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Security/Cryptography/Certificates/mod.rs b/crates/libs/windows/src/Windows/Security/Cryptography/Certificates/mod.rs index 5e75b9b816..318453cd2f 100644 --- a/crates/libs/windows/src/Windows/Security/Cryptography/Certificates/mod.rs +++ b/crates/libs/windows/src/Windows/Security/Cryptography/Certificates/mod.rs @@ -3,7 +3,7 @@ pub struct Certificate(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(Certificate, windows_core::IUnknown, windows_core::IInspectable); impl Certificate { - pub fn BuildChainAsync(&self, certificates: P0) -> windows_core::Result> + pub fn BuildChainAsync(&self, certificates: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -13,7 +13,7 @@ impl Certificate { (windows_core::Interface::vtable(this).BuildChainAsync)(windows_core::Interface::as_raw(this), certificates.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn BuildChainWithParametersAsync(&self, certificates: P0, parameters: P1) -> windows_core::Result> + pub fn BuildChainWithParametersAsync(&self, certificates: P0, parameters: P1) -> windows_core::Result> where P0: windows_core::Param>, P1: windows_core::Param, @@ -262,7 +262,7 @@ impl windows_core::RuntimeType for CertificateChainPolicy { } pub struct CertificateEnrollmentManager; impl CertificateEnrollmentManager { - pub fn CreateRequestAsync(request: P0) -> windows_core::Result> + pub fn CreateRequestAsync(request: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -271,13 +271,13 @@ impl CertificateEnrollmentManager { (windows_core::Interface::vtable(this).CreateRequestAsync)(windows_core::Interface::as_raw(this), request.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn InstallCertificateAsync(certificate: &windows_core::HSTRING, installoption: InstallOptions) -> windows_core::Result { + pub fn InstallCertificateAsync(certificate: &windows_core::HSTRING, installoption: InstallOptions) -> windows_core::Result { Self::ICertificateEnrollmentManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).InstallCertificateAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(certificate), installoption, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn ImportPfxDataAsync(pfxdata: &windows_core::HSTRING, password: &windows_core::HSTRING, exportable: ExportOption, keyprotectionlevel: KeyProtectionLevel, installoption: InstallOptions, friendlyname: &windows_core::HSTRING) -> windows_core::Result { + pub fn ImportPfxDataAsync(pfxdata: &windows_core::HSTRING, password: &windows_core::HSTRING, exportable: ExportOption, keyprotectionlevel: KeyProtectionLevel, installoption: InstallOptions, friendlyname: &windows_core::HSTRING) -> windows_core::Result { Self::ICertificateEnrollmentManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ImportPfxDataAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(pfxdata), core::mem::transmute_copy(password), exportable, keyprotectionlevel, installoption, core::mem::transmute_copy(friendlyname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -289,13 +289,13 @@ impl CertificateEnrollmentManager { (windows_core::Interface::vtable(this).UserCertificateEnrollmentManager)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn ImportPfxDataToKspAsync(pfxdata: &windows_core::HSTRING, password: &windows_core::HSTRING, exportable: ExportOption, keyprotectionlevel: KeyProtectionLevel, installoption: InstallOptions, friendlyname: &windows_core::HSTRING, keystorageprovider: &windows_core::HSTRING) -> windows_core::Result { + pub fn ImportPfxDataToKspAsync(pfxdata: &windows_core::HSTRING, password: &windows_core::HSTRING, exportable: ExportOption, keyprotectionlevel: KeyProtectionLevel, installoption: InstallOptions, friendlyname: &windows_core::HSTRING, keystorageprovider: &windows_core::HSTRING) -> windows_core::Result { Self::ICertificateEnrollmentManagerStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ImportPfxDataToKspAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(pfxdata), core::mem::transmute_copy(password), exportable, keyprotectionlevel, installoption, core::mem::transmute_copy(friendlyname), core::mem::transmute_copy(keystorageprovider), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn ImportPfxDataToKspWithParametersAsync(pfxdata: &windows_core::HSTRING, password: &windows_core::HSTRING, pfximportparameters: P2) -> windows_core::Result + pub fn ImportPfxDataToKspWithParametersAsync(pfxdata: &windows_core::HSTRING, password: &windows_core::HSTRING, pfximportparameters: P2) -> windows_core::Result where P2: windows_core::Param, { @@ -884,13 +884,13 @@ unsafe impl Send for CertificateStore {} unsafe impl Sync for CertificateStore {} pub struct CertificateStores; impl CertificateStores { - pub fn FindAllAsync() -> windows_core::Result>> { + pub fn FindAllAsync() -> windows_core::Result>> { Self::ICertificateStoresStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAllAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn FindAllWithQueryAsync(query: P0) -> windows_core::Result>> + pub fn FindAllWithQueryAsync(query: P0) -> windows_core::Result>> where P0: windows_core::Param, { @@ -1150,7 +1150,7 @@ impl CmsAttachedSignature { }) } #[cfg(feature = "Storage_Streams")] - pub fn GenerateSignatureAsync(data: P0, signers: P1, certificates: P2) -> windows_core::Result> + pub fn GenerateSignatureAsync(data: P0, signers: P1, certificates: P2) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param>, @@ -1202,7 +1202,7 @@ impl CmsDetachedSignature { } } #[cfg(feature = "Storage_Streams")] - pub fn VerifySignatureAsync(&self, data: P0) -> windows_core::Result> + pub fn VerifySignatureAsync(&self, data: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1223,7 +1223,7 @@ impl CmsDetachedSignature { }) } #[cfg(feature = "Storage_Streams")] - pub fn GenerateSignatureAsync(data: P0, signers: P1, certificates: P2) -> windows_core::Result> + pub fn GenerateSignatureAsync(data: P0, signers: P1, certificates: P2) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param>, @@ -2114,7 +2114,7 @@ impl windows_core::RuntimeName for KeyAlgorithmNames { } pub struct KeyAttestationHelper; impl KeyAttestationHelper { - pub fn DecryptTpmAttestationCredentialAsync(credential: &windows_core::HSTRING) -> windows_core::Result> { + pub fn DecryptTpmAttestationCredentialAsync(credential: &windows_core::HSTRING) -> windows_core::Result> { Self::IKeyAttestationHelperStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DecryptTpmAttestationCredentialAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(credential), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -2126,7 +2126,7 @@ impl KeyAttestationHelper { (windows_core::Interface::vtable(this).GetTpmAttestationCredentialId)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(credential), &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn DecryptTpmAttestationCredentialWithContainerNameAsync(credential: &windows_core::HSTRING, containername: &windows_core::HSTRING) -> windows_core::Result> { + pub fn DecryptTpmAttestationCredentialWithContainerNameAsync(credential: &windows_core::HSTRING, containername: &windows_core::HSTRING) -> windows_core::Result> { Self::IKeyAttestationHelperStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DecryptTpmAttestationCredentialWithContainerNameAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(credential), core::mem::transmute_copy(containername), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -2478,7 +2478,7 @@ unsafe impl Sync for SubjectAlternativeNameInfo {} pub struct UserCertificateEnrollmentManager(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(UserCertificateEnrollmentManager, windows_core::IUnknown, windows_core::IInspectable); impl UserCertificateEnrollmentManager { - pub fn CreateRequestAsync(&self, request: P0) -> windows_core::Result> + pub fn CreateRequestAsync(&self, request: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2488,28 +2488,28 @@ impl UserCertificateEnrollmentManager { (windows_core::Interface::vtable(this).CreateRequestAsync)(windows_core::Interface::as_raw(this), request.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn InstallCertificateAsync(&self, certificate: &windows_core::HSTRING, installoption: InstallOptions) -> windows_core::Result { + pub fn InstallCertificateAsync(&self, certificate: &windows_core::HSTRING, installoption: InstallOptions) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).InstallCertificateAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(certificate), installoption, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ImportPfxDataAsync(&self, pfxdata: &windows_core::HSTRING, password: &windows_core::HSTRING, exportable: ExportOption, keyprotectionlevel: KeyProtectionLevel, installoption: InstallOptions, friendlyname: &windows_core::HSTRING) -> windows_core::Result { + pub fn ImportPfxDataAsync(&self, pfxdata: &windows_core::HSTRING, password: &windows_core::HSTRING, exportable: ExportOption, keyprotectionlevel: KeyProtectionLevel, installoption: InstallOptions, friendlyname: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ImportPfxDataAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(pfxdata), core::mem::transmute_copy(password), exportable, keyprotectionlevel, installoption, core::mem::transmute_copy(friendlyname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ImportPfxDataToKspAsync(&self, pfxdata: &windows_core::HSTRING, password: &windows_core::HSTRING, exportable: ExportOption, keyprotectionlevel: KeyProtectionLevel, installoption: InstallOptions, friendlyname: &windows_core::HSTRING, keystorageprovider: &windows_core::HSTRING) -> windows_core::Result { + pub fn ImportPfxDataToKspAsync(&self, pfxdata: &windows_core::HSTRING, password: &windows_core::HSTRING, exportable: ExportOption, keyprotectionlevel: KeyProtectionLevel, installoption: InstallOptions, friendlyname: &windows_core::HSTRING, keystorageprovider: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ImportPfxDataToKspAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(pfxdata), core::mem::transmute_copy(password), exportable, keyprotectionlevel, installoption, core::mem::transmute_copy(friendlyname), core::mem::transmute_copy(keystorageprovider), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ImportPfxDataToKspWithParametersAsync(&self, pfxdata: &windows_core::HSTRING, password: &windows_core::HSTRING, pfximportparameters: P2) -> windows_core::Result + pub fn ImportPfxDataToKspWithParametersAsync(&self, pfxdata: &windows_core::HSTRING, password: &windows_core::HSTRING, pfximportparameters: P2) -> windows_core::Result where P2: windows_core::Param, { @@ -2537,7 +2537,7 @@ unsafe impl Sync for UserCertificateEnrollmentManager {} pub struct UserCertificateStore(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(UserCertificateStore, windows_core::IUnknown, windows_core::IInspectable); impl UserCertificateStore { - pub fn RequestAddAsync(&self, certificate: P0) -> windows_core::Result> + pub fn RequestAddAsync(&self, certificate: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2547,7 +2547,7 @@ impl UserCertificateStore { (windows_core::Interface::vtable(this).RequestAddAsync)(windows_core::Interface::as_raw(this), certificate.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestDeleteAsync(&self, certificate: P0) -> windows_core::Result> + pub fn RequestDeleteAsync(&self, certificate: P0) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Security/Cryptography/Core/mod.rs b/crates/libs/windows/src/Windows/Security/Cryptography/Core/mod.rs index f82f800eaf..57e3c6d942 100644 --- a/crates/libs/windows/src/Windows/Security/Cryptography/Core/mod.rs +++ b/crates/libs/windows/src/Windows/Security/Cryptography/Core/mod.rs @@ -362,7 +362,7 @@ impl CryptographicEngine { }) } #[cfg(feature = "Storage_Streams")] - pub fn DecryptAsync(key: P0, data: P1, iv: P2) -> windows_core::Result> + pub fn DecryptAsync(key: P0, data: P1, iv: P2) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -374,7 +374,7 @@ impl CryptographicEngine { }) } #[cfg(feature = "Storage_Streams")] - pub fn SignAsync(key: P0, data: P1) -> windows_core::Result> + pub fn SignAsync(key: P0, data: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -385,7 +385,7 @@ impl CryptographicEngine { }) } #[cfg(feature = "Storage_Streams")] - pub fn SignHashedDataAsync(key: P0, data: P1) -> windows_core::Result> + pub fn SignHashedDataAsync(key: P0, data: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -1882,7 +1882,7 @@ unsafe impl Sync for MacAlgorithmProvider {} pub struct PersistedKeyProvider; impl PersistedKeyProvider { #[cfg(feature = "Security_Cryptography_Certificates")] - pub fn OpenKeyPairFromCertificateAsync(certificate: P0, hashalgorithmname: &windows_core::HSTRING, padding: CryptographicPadding) -> windows_core::Result> + pub fn OpenKeyPairFromCertificateAsync(certificate: P0, hashalgorithmname: &windows_core::HSTRING, padding: CryptographicPadding) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Security/Cryptography/DataProtection/mod.rs b/crates/libs/windows/src/Windows/Security/Cryptography/DataProtection/mod.rs index e85a94183a..0e61157bc5 100644 --- a/crates/libs/windows/src/Windows/Security/Cryptography/DataProtection/mod.rs +++ b/crates/libs/windows/src/Windows/Security/Cryptography/DataProtection/mod.rs @@ -11,7 +11,7 @@ impl DataProtectionProvider { SHARED.call(callback) } #[cfg(feature = "Storage_Streams")] - pub fn ProtectAsync(&self, data: P0) -> windows_core::Result> + pub fn ProtectAsync(&self, data: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -22,7 +22,7 @@ impl DataProtectionProvider { } } #[cfg(feature = "Storage_Streams")] - pub fn UnprotectAsync(&self, data: P0) -> windows_core::Result> + pub fn UnprotectAsync(&self, data: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -33,7 +33,7 @@ impl DataProtectionProvider { } } #[cfg(feature = "Storage_Streams")] - pub fn ProtectStreamAsync(&self, src: P0, dest: P1) -> windows_core::Result + pub fn ProtectStreamAsync(&self, src: P0, dest: P1) -> windows_core::Result where P0: windows_core::Param, P1: windows_core::Param, @@ -45,7 +45,7 @@ impl DataProtectionProvider { } } #[cfg(feature = "Storage_Streams")] - pub fn UnprotectStreamAsync(&self, src: P0, dest: P1) -> windows_core::Result + pub fn UnprotectStreamAsync(&self, src: P0, dest: P1) -> windows_core::Result where P0: windows_core::Param, P1: windows_core::Param, diff --git a/crates/libs/windows/src/Windows/Security/DataProtection/mod.rs b/crates/libs/windows/src/Windows/Security/DataProtection/mod.rs index 223eef1115..539a049ec0 100644 --- a/crates/libs/windows/src/Windows/Security/DataProtection/mod.rs +++ b/crates/libs/windows/src/Windows/Security/DataProtection/mod.rs @@ -160,7 +160,7 @@ pub struct UserDataProtectionManager(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(UserDataProtectionManager, windows_core::IUnknown, windows_core::IInspectable); impl UserDataProtectionManager { #[cfg(feature = "Storage")] - pub fn ProtectStorageItemAsync(&self, storageitem: P0, availability: UserDataAvailability) -> windows_core::Result> + pub fn ProtectStorageItemAsync(&self, storageitem: P0, availability: UserDataAvailability) -> windows_core::Result> where P0: windows_core::Param, { @@ -171,7 +171,7 @@ impl UserDataProtectionManager { } } #[cfg(feature = "Storage")] - pub fn GetStorageItemProtectionInfoAsync(&self, storageitem: P0) -> windows_core::Result> + pub fn GetStorageItemProtectionInfoAsync(&self, storageitem: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -182,7 +182,7 @@ impl UserDataProtectionManager { } } #[cfg(feature = "Storage_Streams")] - pub fn ProtectBufferAsync(&self, unprotectedbuffer: P0, availability: UserDataAvailability) -> windows_core::Result> + pub fn ProtectBufferAsync(&self, unprotectedbuffer: P0, availability: UserDataAvailability) -> windows_core::Result> where P0: windows_core::Param, { @@ -193,7 +193,7 @@ impl UserDataProtectionManager { } } #[cfg(feature = "Storage_Streams")] - pub fn UnprotectBufferAsync(&self, protectedbuffer: P0) -> windows_core::Result> + pub fn UnprotectBufferAsync(&self, protectedbuffer: P0) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Security/EnterpriseData/mod.rs b/crates/libs/windows/src/Windows/Security/EnterpriseData/mod.rs index cef0dc392f..7a0e5cf4ae 100644 --- a/crates/libs/windows/src/Windows/Security/EnterpriseData/mod.rs +++ b/crates/libs/windows/src/Windows/Security/EnterpriseData/mod.rs @@ -66,7 +66,7 @@ unsafe impl Sync for DataProtectionInfo {} pub struct DataProtectionManager; impl DataProtectionManager { #[cfg(feature = "Storage_Streams")] - pub fn ProtectAsync(data: P0, identity: &windows_core::HSTRING) -> windows_core::Result> + pub fn ProtectAsync(data: P0, identity: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -76,7 +76,7 @@ impl DataProtectionManager { }) } #[cfg(feature = "Storage_Streams")] - pub fn UnprotectAsync(data: P0) -> windows_core::Result> + pub fn UnprotectAsync(data: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -86,7 +86,7 @@ impl DataProtectionManager { }) } #[cfg(feature = "Storage_Streams")] - pub fn ProtectStreamAsync(unprotectedstream: P0, identity: &windows_core::HSTRING, protectedstream: P2) -> windows_core::Result> + pub fn ProtectStreamAsync(unprotectedstream: P0, identity: &windows_core::HSTRING, protectedstream: P2) -> windows_core::Result> where P0: windows_core::Param, P2: windows_core::Param, @@ -97,7 +97,7 @@ impl DataProtectionManager { }) } #[cfg(feature = "Storage_Streams")] - pub fn UnprotectStreamAsync(protectedstream: P0, unprotectedstream: P1) -> windows_core::Result> + pub fn UnprotectStreamAsync(protectedstream: P0, unprotectedstream: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -108,7 +108,7 @@ impl DataProtectionManager { }) } #[cfg(feature = "Storage_Streams")] - pub fn GetProtectionInfoAsync(protecteddata: P0) -> windows_core::Result> + pub fn GetProtectionInfoAsync(protecteddata: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -118,7 +118,7 @@ impl DataProtectionManager { }) } #[cfg(feature = "Storage_Streams")] - pub fn GetStreamProtectionInfoAsync(protectedstream: P0) -> windows_core::Result> + pub fn GetStreamProtectionInfoAsync(protectedstream: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -216,7 +216,7 @@ unsafe impl Sync for FileProtectionInfo {} pub struct FileProtectionManager; impl FileProtectionManager { #[cfg(feature = "Storage")] - pub fn ProtectAsync(target: P0, identity: &windows_core::HSTRING) -> windows_core::Result> + pub fn ProtectAsync(target: P0, identity: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -226,7 +226,7 @@ impl FileProtectionManager { }) } #[cfg(feature = "Storage")] - pub fn CopyProtectionAsync(source: P0, target: P1) -> windows_core::Result> + pub fn CopyProtectionAsync(source: P0, target: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -237,7 +237,7 @@ impl FileProtectionManager { }) } #[cfg(feature = "Storage")] - pub fn GetProtectionInfoAsync(source: P0) -> windows_core::Result> + pub fn GetProtectionInfoAsync(source: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -247,7 +247,7 @@ impl FileProtectionManager { }) } #[cfg(feature = "Storage_Streams")] - pub fn SaveFileAsContainerAsync(protectedfile: P0) -> windows_core::Result> + pub fn SaveFileAsContainerAsync(protectedfile: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -257,7 +257,7 @@ impl FileProtectionManager { }) } #[cfg(feature = "Storage_Streams")] - pub fn LoadFileFromContainerAsync(containerfile: P0) -> windows_core::Result> + pub fn LoadFileFromContainerAsync(containerfile: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -267,7 +267,7 @@ impl FileProtectionManager { }) } #[cfg(feature = "Storage_Streams")] - pub fn LoadFileFromContainerWithTargetAsync(containerfile: P0, target: P1) -> windows_core::Result> + pub fn LoadFileFromContainerWithTargetAsync(containerfile: P0, target: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -278,7 +278,7 @@ impl FileProtectionManager { }) } #[cfg(feature = "Storage")] - pub fn CreateProtectedAndOpenAsync(parentfolder: P0, desiredname: &windows_core::HSTRING, identity: &windows_core::HSTRING, collisionoption: super::super::Storage::CreationCollisionOption) -> windows_core::Result> + pub fn CreateProtectedAndOpenAsync(parentfolder: P0, desiredname: &windows_core::HSTRING, identity: &windows_core::HSTRING, collisionoption: super::super::Storage::CreationCollisionOption) -> windows_core::Result> where P0: windows_core::Param, { @@ -288,7 +288,7 @@ impl FileProtectionManager { }) } #[cfg(feature = "Storage_Streams")] - pub fn IsContainerAsync(file: P0) -> windows_core::Result> + pub fn IsContainerAsync(file: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -298,7 +298,7 @@ impl FileProtectionManager { }) } #[cfg(feature = "Storage_Streams")] - pub fn LoadFileFromContainerWithTargetAndNameCollisionOptionAsync(containerfile: P0, target: P1, collisionoption: super::super::Storage::NameCollisionOption) -> windows_core::Result> + pub fn LoadFileFromContainerWithTargetAndNameCollisionOptionAsync(containerfile: P0, target: P1, collisionoption: super::super::Storage::NameCollisionOption) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -309,7 +309,7 @@ impl FileProtectionManager { }) } #[cfg(feature = "Storage_Streams")] - pub fn SaveFileAsContainerWithSharingAsync(protectedfile: P0, sharedwithidentities: P1) -> windows_core::Result> + pub fn SaveFileAsContainerWithSharingAsync(protectedfile: P0, sharedwithidentities: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param>, @@ -320,7 +320,7 @@ impl FileProtectionManager { }) } #[cfg(feature = "Storage")] - pub fn UnprotectAsync(target: P0) -> windows_core::Result> + pub fn UnprotectAsync(target: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -330,7 +330,7 @@ impl FileProtectionManager { }) } #[cfg(feature = "Storage")] - pub fn UnprotectWithOptionsAsync(target: P0, options: P1) -> windows_core::Result> + pub fn UnprotectWithOptionsAsync(target: P0, options: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -384,7 +384,7 @@ pub struct FileRevocationManager; #[cfg(feature = "deprecated")] impl FileRevocationManager { #[cfg(feature = "Storage")] - pub fn ProtectAsync(storageitem: P0, enterpriseidentity: &windows_core::HSTRING) -> windows_core::Result> + pub fn ProtectAsync(storageitem: P0, enterpriseidentity: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -394,7 +394,7 @@ impl FileRevocationManager { }) } #[cfg(feature = "Storage")] - pub fn CopyProtectionAsync(sourcestorageitem: P0, targetstorageitem: P1) -> windows_core::Result> + pub fn CopyProtectionAsync(sourcestorageitem: P0, targetstorageitem: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -408,7 +408,7 @@ impl FileRevocationManager { Self::IFileRevocationManagerStatics(|this| unsafe { (windows_core::Interface::vtable(this).Revoke)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(enterpriseidentity)).ok() }) } #[cfg(feature = "Storage")] - pub fn GetStatusAsync(storageitem: P0) -> windows_core::Result> + pub fn GetStatusAsync(storageitem: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1245,7 +1245,7 @@ impl ProtectionPolicyManager { }) } #[cfg(feature = "Networking")] - pub fn GetPrimaryManagedIdentityForNetworkEndpointAsync(endpointhost: P0) -> windows_core::Result> + pub fn GetPrimaryManagedIdentityForNetworkEndpointAsync(endpointhost: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1305,7 +1305,7 @@ impl ProtectionPolicyManager { (windows_core::Interface::vtable(this).CheckAccess)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(sourceidentity), core::mem::transmute_copy(targetidentity), &mut result__).map(|| result__) }) } - pub fn RequestAccessAsync(sourceidentity: &windows_core::HSTRING, targetidentity: &windows_core::HSTRING) -> windows_core::Result> { + pub fn RequestAccessAsync(sourceidentity: &windows_core::HSTRING, targetidentity: &windows_core::HSTRING) -> windows_core::Result> { Self::IProtectionPolicyManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestAccessAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(sourceidentity), core::mem::transmute_copy(targetidentity), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -1323,7 +1323,7 @@ impl ProtectionPolicyManager { (windows_core::Interface::vtable(this).CheckAccessForApp)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(sourceidentity), core::mem::transmute_copy(apppackagefamilyname), &mut result__).map(|| result__) }) } - pub fn RequestAccessForAppAsync(sourceidentity: &windows_core::HSTRING, apppackagefamilyname: &windows_core::HSTRING) -> windows_core::Result> { + pub fn RequestAccessForAppAsync(sourceidentity: &windows_core::HSTRING, apppackagefamilyname: &windows_core::HSTRING) -> windows_core::Result> { Self::IProtectionPolicyManagerStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestAccessForAppAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(sourceidentity), core::mem::transmute_copy(apppackagefamilyname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -1365,7 +1365,7 @@ impl ProtectionPolicyManager { (windows_core::Interface::vtable(this).IsProtectionEnabled)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) }) } - pub fn RequestAccessWithAuditingInfoAsync(sourceidentity: &windows_core::HSTRING, targetidentity: &windows_core::HSTRING, auditinfo: P2) -> windows_core::Result> + pub fn RequestAccessWithAuditingInfoAsync(sourceidentity: &windows_core::HSTRING, targetidentity: &windows_core::HSTRING, auditinfo: P2) -> windows_core::Result> where P2: windows_core::Param, { @@ -1374,7 +1374,7 @@ impl ProtectionPolicyManager { (windows_core::Interface::vtable(this).RequestAccessWithAuditingInfoAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(sourceidentity), core::mem::transmute_copy(targetidentity), auditinfo.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RequestAccessWithMessageAsync(sourceidentity: &windows_core::HSTRING, targetidentity: &windows_core::HSTRING, auditinfo: P2, messagefromapp: &windows_core::HSTRING) -> windows_core::Result> + pub fn RequestAccessWithMessageAsync(sourceidentity: &windows_core::HSTRING, targetidentity: &windows_core::HSTRING, auditinfo: P2, messagefromapp: &windows_core::HSTRING) -> windows_core::Result> where P2: windows_core::Param, { @@ -1383,7 +1383,7 @@ impl ProtectionPolicyManager { (windows_core::Interface::vtable(this).RequestAccessWithMessageAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(sourceidentity), core::mem::transmute_copy(targetidentity), auditinfo.param().abi(), core::mem::transmute_copy(messagefromapp), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RequestAccessForAppWithAuditingInfoAsync(sourceidentity: &windows_core::HSTRING, apppackagefamilyname: &windows_core::HSTRING, auditinfo: P2) -> windows_core::Result> + pub fn RequestAccessForAppWithAuditingInfoAsync(sourceidentity: &windows_core::HSTRING, apppackagefamilyname: &windows_core::HSTRING, auditinfo: P2) -> windows_core::Result> where P2: windows_core::Param, { @@ -1392,7 +1392,7 @@ impl ProtectionPolicyManager { (windows_core::Interface::vtable(this).RequestAccessForAppWithAuditingInfoAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(sourceidentity), core::mem::transmute_copy(apppackagefamilyname), auditinfo.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RequestAccessForAppWithMessageAsync(sourceidentity: &windows_core::HSTRING, apppackagefamilyname: &windows_core::HSTRING, auditinfo: P2, messagefromapp: &windows_core::HSTRING) -> windows_core::Result> + pub fn RequestAccessForAppWithMessageAsync(sourceidentity: &windows_core::HSTRING, apppackagefamilyname: &windows_core::HSTRING, auditinfo: P2, messagefromapp: &windows_core::HSTRING) -> windows_core::Result> where P2: windows_core::Param, { @@ -1413,7 +1413,7 @@ impl ProtectionPolicyManager { (windows_core::Interface::vtable(this).IsRoamableProtectionEnabled)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(identity), &mut result__).map(|| result__) }) } - pub fn RequestAccessWithBehaviorAsync(sourceidentity: &windows_core::HSTRING, targetidentity: &windows_core::HSTRING, auditinfo: P2, messagefromapp: &windows_core::HSTRING, behavior: ProtectionPolicyRequestAccessBehavior) -> windows_core::Result> + pub fn RequestAccessWithBehaviorAsync(sourceidentity: &windows_core::HSTRING, targetidentity: &windows_core::HSTRING, auditinfo: P2, messagefromapp: &windows_core::HSTRING, behavior: ProtectionPolicyRequestAccessBehavior) -> windows_core::Result> where P2: windows_core::Param, { @@ -1422,7 +1422,7 @@ impl ProtectionPolicyManager { (windows_core::Interface::vtable(this).RequestAccessWithBehaviorAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(sourceidentity), core::mem::transmute_copy(targetidentity), auditinfo.param().abi(), core::mem::transmute_copy(messagefromapp), behavior, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RequestAccessForAppWithBehaviorAsync(sourceidentity: &windows_core::HSTRING, apppackagefamilyname: &windows_core::HSTRING, auditinfo: P2, messagefromapp: &windows_core::HSTRING, behavior: ProtectionPolicyRequestAccessBehavior) -> windows_core::Result> + pub fn RequestAccessForAppWithBehaviorAsync(sourceidentity: &windows_core::HSTRING, apppackagefamilyname: &windows_core::HSTRING, auditinfo: P2, messagefromapp: &windows_core::HSTRING, behavior: ProtectionPolicyRequestAccessBehavior) -> windows_core::Result> where P2: windows_core::Param, { @@ -1432,7 +1432,7 @@ impl ProtectionPolicyManager { }) } #[cfg(feature = "Storage")] - pub fn RequestAccessToFilesForAppAsync(sourceitemlist: P0, apppackagefamilyname: &windows_core::HSTRING, auditinfo: P2) -> windows_core::Result> + pub fn RequestAccessToFilesForAppAsync(sourceitemlist: P0, apppackagefamilyname: &windows_core::HSTRING, auditinfo: P2) -> windows_core::Result> where P0: windows_core::Param>, P2: windows_core::Param, @@ -1443,7 +1443,7 @@ impl ProtectionPolicyManager { }) } #[cfg(feature = "Storage")] - pub fn RequestAccessToFilesForAppWithMessageAndBehaviorAsync(sourceitemlist: P0, apppackagefamilyname: &windows_core::HSTRING, auditinfo: P2, messagefromapp: &windows_core::HSTRING, behavior: ProtectionPolicyRequestAccessBehavior) -> windows_core::Result> + pub fn RequestAccessToFilesForAppWithMessageAndBehaviorAsync(sourceitemlist: P0, apppackagefamilyname: &windows_core::HSTRING, auditinfo: P2, messagefromapp: &windows_core::HSTRING, behavior: ProtectionPolicyRequestAccessBehavior) -> windows_core::Result> where P0: windows_core::Param>, P2: windows_core::Param, @@ -1454,7 +1454,7 @@ impl ProtectionPolicyManager { }) } #[cfg(feature = "Storage")] - pub fn RequestAccessToFilesForProcessAsync(sourceitemlist: P0, processid: u32, auditinfo: P2) -> windows_core::Result> + pub fn RequestAccessToFilesForProcessAsync(sourceitemlist: P0, processid: u32, auditinfo: P2) -> windows_core::Result> where P0: windows_core::Param>, P2: windows_core::Param, @@ -1465,7 +1465,7 @@ impl ProtectionPolicyManager { }) } #[cfg(feature = "Storage")] - pub fn RequestAccessToFilesForProcessWithMessageAndBehaviorAsync(sourceitemlist: P0, processid: u32, auditinfo: P2, messagefromapp: &windows_core::HSTRING, behavior: ProtectionPolicyRequestAccessBehavior) -> windows_core::Result> + pub fn RequestAccessToFilesForProcessWithMessageAndBehaviorAsync(sourceitemlist: P0, processid: u32, auditinfo: P2, messagefromapp: &windows_core::HSTRING, behavior: ProtectionPolicyRequestAccessBehavior) -> windows_core::Result> where P0: windows_core::Param>, P2: windows_core::Param, @@ -1476,7 +1476,7 @@ impl ProtectionPolicyManager { }) } #[cfg(feature = "Storage")] - pub fn IsFileProtectionRequiredAsync(target: P0, identity: &windows_core::HSTRING) -> windows_core::Result> + pub fn IsFileProtectionRequiredAsync(target: P0, identity: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -1486,7 +1486,7 @@ impl ProtectionPolicyManager { }) } #[cfg(feature = "Storage")] - pub fn IsFileProtectionRequiredForNewFileAsync(parentfolder: P0, identity: &windows_core::HSTRING, desiredname: &windows_core::HSTRING) -> windows_core::Result> + pub fn IsFileProtectionRequiredForNewFileAsync(parentfolder: P0, identity: &windows_core::HSTRING, desiredname: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Security/ExchangeActiveSyncProvisioning/mod.rs b/crates/libs/windows/src/Windows/Security/ExchangeActiveSyncProvisioning/mod.rs index f96778cead..06dce5c3d4 100644 --- a/crates/libs/windows/src/Windows/Security/ExchangeActiveSyncProvisioning/mod.rs +++ b/crates/libs/windows/src/Windows/Security/ExchangeActiveSyncProvisioning/mod.rs @@ -184,7 +184,7 @@ impl EasClientSecurityPolicy { (windows_core::Interface::vtable(this).CheckCompliance)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ApplyAsync(&self) -> windows_core::Result> { + pub fn ApplyAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Security/Isolation/mod.rs b/crates/libs/windows/src/Windows/Security/Isolation/mod.rs index f3d8a4a75d..d8318eb807 100644 --- a/crates/libs/windows/src/Windows/Security/Isolation/mod.rs +++ b/crates/libs/windows/src/Windows/Security/Isolation/mod.rs @@ -503,14 +503,14 @@ impl IsolatedWindowsEnvironment { (windows_core::Interface::vtable(this).Id)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn StartProcessSilentlyAsync(&self, hostexepath: &windows_core::HSTRING, arguments: &windows_core::HSTRING, activator: IsolatedWindowsEnvironmentActivator) -> windows_core::Result> { + pub fn StartProcessSilentlyAsync(&self, hostexepath: &windows_core::HSTRING, arguments: &windows_core::HSTRING, activator: IsolatedWindowsEnvironmentActivator) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).StartProcessSilentlyAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(hostexepath), core::mem::transmute_copy(arguments), activator, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StartProcessSilentlyWithTelemetryAsync(&self, hostexepath: &windows_core::HSTRING, arguments: &windows_core::HSTRING, activator: IsolatedWindowsEnvironmentActivator, telemetryparameters: P3) -> windows_core::Result> + pub fn StartProcessSilentlyWithTelemetryAsync(&self, hostexepath: &windows_core::HSTRING, arguments: &windows_core::HSTRING, activator: IsolatedWindowsEnvironmentActivator, telemetryparameters: P3) -> windows_core::Result> where P3: windows_core::Param, { @@ -520,7 +520,7 @@ impl IsolatedWindowsEnvironment { (windows_core::Interface::vtable(this).StartProcessSilentlyWithTelemetryAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(hostexepath), core::mem::transmute_copy(arguments), activator, telemetryparameters.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ShareFolderAsync(&self, hostfolder: &windows_core::HSTRING, requestoptions: P1) -> windows_core::Result> + pub fn ShareFolderAsync(&self, hostfolder: &windows_core::HSTRING, requestoptions: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -530,7 +530,7 @@ impl IsolatedWindowsEnvironment { (windows_core::Interface::vtable(this).ShareFolderAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(hostfolder), requestoptions.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ShareFolderWithTelemetryAsync(&self, hostfolder: &windows_core::HSTRING, requestoptions: P1, telemetryparameters: P2) -> windows_core::Result> + pub fn ShareFolderWithTelemetryAsync(&self, hostfolder: &windows_core::HSTRING, requestoptions: P1, telemetryparameters: P2) -> windows_core::Result> where P1: windows_core::Param, P2: windows_core::Param, @@ -541,14 +541,14 @@ impl IsolatedWindowsEnvironment { (windows_core::Interface::vtable(this).ShareFolderWithTelemetryAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(hostfolder), requestoptions.param().abi(), telemetryparameters.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn LaunchFileWithUIAsync(&self, appexepath: &windows_core::HSTRING, argumentstemplate: &windows_core::HSTRING, filepath: &windows_core::HSTRING) -> windows_core::Result> { + pub fn LaunchFileWithUIAsync(&self, appexepath: &windows_core::HSTRING, argumentstemplate: &windows_core::HSTRING, filepath: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).LaunchFileWithUIAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(appexepath), core::mem::transmute_copy(argumentstemplate), core::mem::transmute_copy(filepath), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn LaunchFileWithUIAndTelemetryAsync(&self, appexepath: &windows_core::HSTRING, argumentstemplate: &windows_core::HSTRING, filepath: &windows_core::HSTRING, telemetryparameters: P3) -> windows_core::Result> + pub fn LaunchFileWithUIAndTelemetryAsync(&self, appexepath: &windows_core::HSTRING, argumentstemplate: &windows_core::HSTRING, filepath: &windows_core::HSTRING, telemetryparameters: P3) -> windows_core::Result> where P3: windows_core::Param, { @@ -558,14 +558,14 @@ impl IsolatedWindowsEnvironment { (windows_core::Interface::vtable(this).LaunchFileWithUIAndTelemetryAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(appexepath), core::mem::transmute_copy(argumentstemplate), core::mem::transmute_copy(filepath), telemetryparameters.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TerminateAsync(&self) -> windows_core::Result { + pub fn TerminateAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TerminateAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TerminateWithTelemetryAsync(&self, telemetryparameters: P0) -> windows_core::Result + pub fn TerminateWithTelemetryAsync(&self, telemetryparameters: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -586,7 +586,7 @@ impl IsolatedWindowsEnvironment { let this = self; unsafe { (windows_core::Interface::vtable(this).UnregisterMessageReceiver)(windows_core::Interface::as_raw(this), receiverid).ok() } } - pub fn PostMessageToReceiverAsync(&self, receiverid: windows_core::GUID, message: P1) -> windows_core::Result> + pub fn PostMessageToReceiverAsync(&self, receiverid: windows_core::GUID, message: P1) -> windows_core::Result> where P1: windows_core::Param>, { @@ -596,7 +596,7 @@ impl IsolatedWindowsEnvironment { (windows_core::Interface::vtable(this).PostMessageToReceiverAsync)(windows_core::Interface::as_raw(this), receiverid, message.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn PostMessageToReceiverWithTelemetryAsync(&self, receiverid: windows_core::GUID, message: P1, telemetryparameters: P2) -> windows_core::Result> + pub fn PostMessageToReceiverWithTelemetryAsync(&self, receiverid: windows_core::GUID, message: P1, telemetryparameters: P2) -> windows_core::Result> where P1: windows_core::Param>, P2: windows_core::Param, @@ -614,7 +614,7 @@ impl IsolatedWindowsEnvironment { (windows_core::Interface::vtable(this).GetUserInfo)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ShareFileAsync(&self, filepath: &windows_core::HSTRING, options: P1) -> windows_core::Result> + pub fn ShareFileAsync(&self, filepath: &windows_core::HSTRING, options: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -624,7 +624,7 @@ impl IsolatedWindowsEnvironment { (windows_core::Interface::vtable(this).ShareFileAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(filepath), options.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ShareFileWithTelemetryAsync(&self, filepath: &windows_core::HSTRING, options: P1, telemetryparameters: P2) -> windows_core::Result> + pub fn ShareFileWithTelemetryAsync(&self, filepath: &windows_core::HSTRING, options: P1, telemetryparameters: P2) -> windows_core::Result> where P1: windows_core::Param, P2: windows_core::Param, @@ -639,7 +639,7 @@ impl IsolatedWindowsEnvironment { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).ChangePriority)(windows_core::Interface::as_raw(this), priority).ok() } } - pub fn CreateAsync(options: P0) -> windows_core::Result> + pub fn CreateAsync(options: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -648,7 +648,7 @@ impl IsolatedWindowsEnvironment { (windows_core::Interface::vtable(this).CreateAsync)(windows_core::Interface::as_raw(this), options.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn CreateWithTelemetryAsync(options: P0, telemetryparameters: P1) -> windows_core::Result> + pub fn CreateWithTelemetryAsync(options: P0, telemetryparameters: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -1500,7 +1500,7 @@ impl IsolatedWindowsEnvironmentProcess { let this = self; unsafe { (windows_core::Interface::vtable(this).WaitForExitWithTimeout)(windows_core::Interface::as_raw(this), timeoutmilliseconds).ok() } } - pub fn WaitForExitAsync(&self) -> windows_core::Result { + pub fn WaitForExitAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1911,14 +1911,14 @@ impl IsolatedWindowsEnvironmentUserInfo { (windows_core::Interface::vtable(this).EnvironmentUserName)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn TryWaitForSignInAsync(&self) -> windows_core::Result> { + pub fn TryWaitForSignInAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryWaitForSignInAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryWaitForSignInWithProgressAsync(&self) -> windows_core::Result> { + pub fn TryWaitForSignInWithProgressAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Services/Maps/LocalSearch/mod.rs b/crates/libs/windows/src/Windows/Services/Maps/LocalSearch/mod.rs index cdf66f672b..c2d70a8402 100644 --- a/crates/libs/windows/src/Windows/Services/Maps/LocalSearch/mod.rs +++ b/crates/libs/windows/src/Windows/Services/Maps/LocalSearch/mod.rs @@ -249,7 +249,7 @@ unsafe impl Sync for LocalLocation {} pub struct LocalLocationFinder; impl LocalLocationFinder { #[cfg(feature = "Devices_Geolocation")] - pub fn FindLocalLocationsAsync(searchterm: &windows_core::HSTRING, searcharea: P1, localcategory: &windows_core::HSTRING, maxresults: u32) -> windows_core::Result> + pub fn FindLocalLocationsAsync(searchterm: &windows_core::HSTRING, searcharea: P1, localcategory: &windows_core::HSTRING, maxresults: u32) -> windows_core::Result> where P1: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Services/Maps/OfflineMaps/mod.rs b/crates/libs/windows/src/Windows/Services/Maps/OfflineMaps/mod.rs index d37160572c..6416b5d826 100644 --- a/crates/libs/windows/src/Windows/Services/Maps/OfflineMaps/mod.rs +++ b/crates/libs/windows/src/Windows/Services/Maps/OfflineMaps/mod.rs @@ -99,7 +99,7 @@ impl OfflineMapPackage { (windows_core::Interface::vtable(this).StatusChanged)(windows_core::Interface::as_raw(this), value.param().abi(), &mut result__).map(|| result__) } } - pub fn RequestStartDownloadAsync(&self) -> windows_core::Result> { + pub fn RequestStartDownloadAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -107,7 +107,7 @@ impl OfflineMapPackage { } } #[cfg(feature = "Devices_Geolocation")] - pub fn FindPackagesAsync(querypoint: P0) -> windows_core::Result> + pub fn FindPackagesAsync(querypoint: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -117,7 +117,7 @@ impl OfflineMapPackage { }) } #[cfg(feature = "Devices_Geolocation")] - pub fn FindPackagesInBoundingBoxAsync(queryboundingbox: P0) -> windows_core::Result> + pub fn FindPackagesInBoundingBoxAsync(queryboundingbox: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -127,7 +127,7 @@ impl OfflineMapPackage { }) } #[cfg(feature = "Devices_Geolocation")] - pub fn FindPackagesInGeocircleAsync(querycircle: P0) -> windows_core::Result> + pub fn FindPackagesInGeocircleAsync(querycircle: P0) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Services/Maps/mod.rs b/crates/libs/windows/src/Windows/Services/Maps/mod.rs index 686dfb710d..161aac5012 100644 --- a/crates/libs/windows/src/Windows/Services/Maps/mod.rs +++ b/crates/libs/windows/src/Windows/Services/Maps/mod.rs @@ -806,7 +806,7 @@ impl windows_core::RuntimeType for MapLocationDesiredAccuracy { pub struct MapLocationFinder; impl MapLocationFinder { #[cfg(feature = "Devices_Geolocation")] - pub fn FindLocationsAtAsync(querypoint: P0) -> windows_core::Result> + pub fn FindLocationsAtAsync(querypoint: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -816,7 +816,7 @@ impl MapLocationFinder { }) } #[cfg(feature = "Devices_Geolocation")] - pub fn FindLocationsAsync(searchtext: &windows_core::HSTRING, referencepoint: P1) -> windows_core::Result> + pub fn FindLocationsAsync(searchtext: &windows_core::HSTRING, referencepoint: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -826,7 +826,7 @@ impl MapLocationFinder { }) } #[cfg(feature = "Devices_Geolocation")] - pub fn FindLocationsWithMaxCountAsync(searchtext: &windows_core::HSTRING, referencepoint: P1, maxcount: u32) -> windows_core::Result> + pub fn FindLocationsWithMaxCountAsync(searchtext: &windows_core::HSTRING, referencepoint: P1, maxcount: u32) -> windows_core::Result> where P1: windows_core::Param, { @@ -836,7 +836,7 @@ impl MapLocationFinder { }) } #[cfg(feature = "Devices_Geolocation")] - pub fn FindLocationsAtWithAccuracyAsync(querypoint: P0, accuracy: MapLocationDesiredAccuracy) -> windows_core::Result> + pub fn FindLocationsAtWithAccuracyAsync(querypoint: P0, accuracy: MapLocationDesiredAccuracy) -> windows_core::Result> where P0: windows_core::Param, { @@ -1156,7 +1156,7 @@ unsafe impl Sync for MapRouteDrivingOptions {} pub struct MapRouteFinder; impl MapRouteFinder { #[cfg(feature = "Devices_Geolocation")] - pub fn GetDrivingRouteAsync(startpoint: P0, endpoint: P1) -> windows_core::Result> + pub fn GetDrivingRouteAsync(startpoint: P0, endpoint: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -1167,7 +1167,7 @@ impl MapRouteFinder { }) } #[cfg(feature = "Devices_Geolocation")] - pub fn GetDrivingRouteWithOptimizationAsync(startpoint: P0, endpoint: P1, optimization: MapRouteOptimization) -> windows_core::Result> + pub fn GetDrivingRouteWithOptimizationAsync(startpoint: P0, endpoint: P1, optimization: MapRouteOptimization) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -1178,7 +1178,7 @@ impl MapRouteFinder { }) } #[cfg(feature = "Devices_Geolocation")] - pub fn GetDrivingRouteWithOptimizationAndRestrictionsAsync(startpoint: P0, endpoint: P1, optimization: MapRouteOptimization, restrictions: MapRouteRestrictions) -> windows_core::Result> + pub fn GetDrivingRouteWithOptimizationAndRestrictionsAsync(startpoint: P0, endpoint: P1, optimization: MapRouteOptimization, restrictions: MapRouteRestrictions) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -1189,7 +1189,7 @@ impl MapRouteFinder { }) } #[cfg(feature = "Devices_Geolocation")] - pub fn GetDrivingRouteWithOptimizationRestrictionsAndHeadingAsync(startpoint: P0, endpoint: P1, optimization: MapRouteOptimization, restrictions: MapRouteRestrictions, headingindegrees: f64) -> windows_core::Result> + pub fn GetDrivingRouteWithOptimizationRestrictionsAndHeadingAsync(startpoint: P0, endpoint: P1, optimization: MapRouteOptimization, restrictions: MapRouteRestrictions, headingindegrees: f64) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -1200,7 +1200,7 @@ impl MapRouteFinder { }) } #[cfg(feature = "Devices_Geolocation")] - pub fn GetDrivingRouteFromWaypointsAsync(waypoints: P0) -> windows_core::Result> + pub fn GetDrivingRouteFromWaypointsAsync(waypoints: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -1210,7 +1210,7 @@ impl MapRouteFinder { }) } #[cfg(feature = "Devices_Geolocation")] - pub fn GetDrivingRouteFromWaypointsAndOptimizationAsync(waypoints: P0, optimization: MapRouteOptimization) -> windows_core::Result> + pub fn GetDrivingRouteFromWaypointsAndOptimizationAsync(waypoints: P0, optimization: MapRouteOptimization) -> windows_core::Result> where P0: windows_core::Param>, { @@ -1220,7 +1220,7 @@ impl MapRouteFinder { }) } #[cfg(feature = "Devices_Geolocation")] - pub fn GetDrivingRouteFromWaypointsOptimizationAndRestrictionsAsync(waypoints: P0, optimization: MapRouteOptimization, restrictions: MapRouteRestrictions) -> windows_core::Result> + pub fn GetDrivingRouteFromWaypointsOptimizationAndRestrictionsAsync(waypoints: P0, optimization: MapRouteOptimization, restrictions: MapRouteRestrictions) -> windows_core::Result> where P0: windows_core::Param>, { @@ -1230,7 +1230,7 @@ impl MapRouteFinder { }) } #[cfg(feature = "Devices_Geolocation")] - pub fn GetDrivingRouteFromWaypointsOptimizationRestrictionsAndHeadingAsync(waypoints: P0, optimization: MapRouteOptimization, restrictions: MapRouteRestrictions, headingindegrees: f64) -> windows_core::Result> + pub fn GetDrivingRouteFromWaypointsOptimizationRestrictionsAndHeadingAsync(waypoints: P0, optimization: MapRouteOptimization, restrictions: MapRouteRestrictions, headingindegrees: f64) -> windows_core::Result> where P0: windows_core::Param>, { @@ -1240,7 +1240,7 @@ impl MapRouteFinder { }) } #[cfg(feature = "Devices_Geolocation")] - pub fn GetWalkingRouteAsync(startpoint: P0, endpoint: P1) -> windows_core::Result> + pub fn GetWalkingRouteAsync(startpoint: P0, endpoint: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -1251,7 +1251,7 @@ impl MapRouteFinder { }) } #[cfg(feature = "Devices_Geolocation")] - pub fn GetWalkingRouteFromWaypointsAsync(waypoints: P0) -> windows_core::Result> + pub fn GetWalkingRouteFromWaypointsAsync(waypoints: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -1261,7 +1261,7 @@ impl MapRouteFinder { }) } #[cfg(feature = "Devices_Geolocation")] - pub fn GetDrivingRouteWithOptionsAsync(startpoint: P0, endpoint: P1, options: P2) -> windows_core::Result> + pub fn GetDrivingRouteWithOptionsAsync(startpoint: P0, endpoint: P1, options: P2) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -1272,7 +1272,7 @@ impl MapRouteFinder { (windows_core::Interface::vtable(this).GetDrivingRouteWithOptionsAsync)(windows_core::Interface::as_raw(this), startpoint.param().abi(), endpoint.param().abi(), options.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetDrivingRouteFromEnhancedWaypointsAsync(waypoints: P0) -> windows_core::Result> + pub fn GetDrivingRouteFromEnhancedWaypointsAsync(waypoints: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -1281,7 +1281,7 @@ impl MapRouteFinder { (windows_core::Interface::vtable(this).GetDrivingRouteFromEnhancedWaypointsAsync)(windows_core::Interface::as_raw(this), waypoints.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetDrivingRouteFromEnhancedWaypointsWithOptionsAsync(waypoints: P0, options: P1) -> windows_core::Result> + pub fn GetDrivingRouteFromEnhancedWaypointsWithOptionsAsync(waypoints: P0, options: P1) -> windows_core::Result> where P0: windows_core::Param>, P1: windows_core::Param, diff --git a/crates/libs/windows/src/Windows/Services/Store/mod.rs b/crates/libs/windows/src/Windows/Services/Store/mod.rs index 5f5868ed38..dcc6eecbbd 100644 --- a/crates/libs/windows/src/Windows/Services/Store/mod.rs +++ b/crates/libs/windows/src/Windows/Services/Store/mod.rs @@ -714,14 +714,14 @@ impl StoreAvailability { (windows_core::Interface::vtable(this).ExtendedJsonData)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn RequestPurchaseAsync(&self) -> windows_core::Result> { + pub fn RequestPurchaseAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestPurchaseAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestPurchaseWithPurchasePropertiesAsync(&self, storepurchaseproperties: P0) -> windows_core::Result> + pub fn RequestPurchaseWithPurchasePropertiesAsync(&self, storepurchaseproperties: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -961,35 +961,35 @@ impl StoreContext { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveOfflineLicensesChanged)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn GetCustomerPurchaseIdAsync(&self, serviceticket: &windows_core::HSTRING, publisheruserid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetCustomerPurchaseIdAsync(&self, serviceticket: &windows_core::HSTRING, publisheruserid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetCustomerPurchaseIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(serviceticket), core::mem::transmute_copy(publisheruserid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetCustomerCollectionsIdAsync(&self, serviceticket: &windows_core::HSTRING, publisheruserid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetCustomerCollectionsIdAsync(&self, serviceticket: &windows_core::HSTRING, publisheruserid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetCustomerCollectionsIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(serviceticket), core::mem::transmute_copy(publisheruserid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAppLicenseAsync(&self) -> windows_core::Result> { + pub fn GetAppLicenseAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetAppLicenseAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetStoreProductForCurrentAppAsync(&self) -> windows_core::Result> { + pub fn GetStoreProductForCurrentAppAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetStoreProductForCurrentAppAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetStoreProductsAsync(&self, productkinds: P0, storeids: P1) -> windows_core::Result> + pub fn GetStoreProductsAsync(&self, productkinds: P0, storeids: P1) -> windows_core::Result> where P0: windows_core::Param>, P1: windows_core::Param>, @@ -1000,7 +1000,7 @@ impl StoreContext { (windows_core::Interface::vtable(this).GetStoreProductsAsync)(windows_core::Interface::as_raw(this), productkinds.param().abi(), storeids.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAssociatedStoreProductsAsync(&self, productkinds: P0) -> windows_core::Result> + pub fn GetAssociatedStoreProductsAsync(&self, productkinds: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -1010,7 +1010,7 @@ impl StoreContext { (windows_core::Interface::vtable(this).GetAssociatedStoreProductsAsync)(windows_core::Interface::as_raw(this), productkinds.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAssociatedStoreProductsWithPagingAsync(&self, productkinds: P0, maxitemstoretrieveperpage: u32) -> windows_core::Result> + pub fn GetAssociatedStoreProductsWithPagingAsync(&self, productkinds: P0, maxitemstoretrieveperpage: u32) -> windows_core::Result> where P0: windows_core::Param>, { @@ -1020,7 +1020,7 @@ impl StoreContext { (windows_core::Interface::vtable(this).GetAssociatedStoreProductsWithPagingAsync)(windows_core::Interface::as_raw(this), productkinds.param().abi(), maxitemstoretrieveperpage, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetUserCollectionAsync(&self, productkinds: P0) -> windows_core::Result> + pub fn GetUserCollectionAsync(&self, productkinds: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -1030,7 +1030,7 @@ impl StoreContext { (windows_core::Interface::vtable(this).GetUserCollectionAsync)(windows_core::Interface::as_raw(this), productkinds.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetUserCollectionWithPagingAsync(&self, productkinds: P0, maxitemstoretrieveperpage: u32) -> windows_core::Result> + pub fn GetUserCollectionWithPagingAsync(&self, productkinds: P0, maxitemstoretrieveperpage: u32) -> windows_core::Result> where P0: windows_core::Param>, { @@ -1040,14 +1040,14 @@ impl StoreContext { (windows_core::Interface::vtable(this).GetUserCollectionWithPagingAsync)(windows_core::Interface::as_raw(this), productkinds.param().abi(), maxitemstoretrieveperpage, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportConsumableFulfillmentAsync(&self, productstoreid: &windows_core::HSTRING, quantity: u32, trackingid: windows_core::GUID) -> windows_core::Result> { + pub fn ReportConsumableFulfillmentAsync(&self, productstoreid: &windows_core::HSTRING, quantity: u32, trackingid: windows_core::GUID) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportConsumableFulfillmentAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(productstoreid), quantity, trackingid, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetConsumableBalanceRemainingAsync(&self, productstoreid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetConsumableBalanceRemainingAsync(&self, productstoreid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1055,7 +1055,7 @@ impl StoreContext { } } #[cfg(feature = "ApplicationModel")] - pub fn AcquireStoreLicenseForOptionalPackageAsync(&self, optionalpackage: P0) -> windows_core::Result> + pub fn AcquireStoreLicenseForOptionalPackageAsync(&self, optionalpackage: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1065,14 +1065,14 @@ impl StoreContext { (windows_core::Interface::vtable(this).AcquireStoreLicenseForOptionalPackageAsync)(windows_core::Interface::as_raw(this), optionalpackage.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestPurchaseAsync(&self, storeid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn RequestPurchaseAsync(&self, storeid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestPurchaseAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(storeid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestPurchaseWithPurchasePropertiesAsync(&self, storeid: &windows_core::HSTRING, storepurchaseproperties: P1) -> windows_core::Result> + pub fn RequestPurchaseWithPurchasePropertiesAsync(&self, storeid: &windows_core::HSTRING, storepurchaseproperties: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -1082,14 +1082,14 @@ impl StoreContext { (windows_core::Interface::vtable(this).RequestPurchaseWithPurchasePropertiesAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(storeid), storepurchaseproperties.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAppAndOptionalStorePackageUpdatesAsync(&self) -> windows_core::Result>> { + pub fn GetAppAndOptionalStorePackageUpdatesAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetAppAndOptionalStorePackageUpdatesAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestDownloadStorePackageUpdatesAsync(&self, storepackageupdates: P0) -> windows_core::Result> + pub fn RequestDownloadStorePackageUpdatesAsync(&self, storepackageupdates: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -1099,7 +1099,7 @@ impl StoreContext { (windows_core::Interface::vtable(this).RequestDownloadStorePackageUpdatesAsync)(windows_core::Interface::as_raw(this), storepackageupdates.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestDownloadAndInstallStorePackageUpdatesAsync(&self, storepackageupdates: P0) -> windows_core::Result> + pub fn RequestDownloadAndInstallStorePackageUpdatesAsync(&self, storepackageupdates: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -1109,7 +1109,7 @@ impl StoreContext { (windows_core::Interface::vtable(this).RequestDownloadAndInstallStorePackageUpdatesAsync)(windows_core::Interface::as_raw(this), storepackageupdates.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestDownloadAndInstallStorePackagesAsync(&self, storeids: P0) -> windows_core::Result> + pub fn RequestDownloadAndInstallStorePackagesAsync(&self, storeids: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -1120,7 +1120,7 @@ impl StoreContext { } } #[cfg(feature = "ApplicationModel")] - pub fn FindStoreProductForPackageAsync(&self, productkinds: P0, package: P1) -> windows_core::Result> + pub fn FindStoreProductForPackageAsync(&self, productkinds: P0, package: P1) -> windows_core::Result> where P0: windows_core::Param>, P1: windows_core::Param, @@ -1138,7 +1138,7 @@ impl StoreContext { (windows_core::Interface::vtable(this).CanSilentlyDownloadStorePackageUpdates)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn TrySilentDownloadStorePackageUpdatesAsync(&self, storepackageupdates: P0) -> windows_core::Result> + pub fn TrySilentDownloadStorePackageUpdatesAsync(&self, storepackageupdates: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -1148,7 +1148,7 @@ impl StoreContext { (windows_core::Interface::vtable(this).TrySilentDownloadStorePackageUpdatesAsync)(windows_core::Interface::as_raw(this), storepackageupdates.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TrySilentDownloadAndInstallStorePackageUpdatesAsync(&self, storepackageupdates: P0) -> windows_core::Result> + pub fn TrySilentDownloadAndInstallStorePackageUpdatesAsync(&self, storepackageupdates: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -1159,7 +1159,7 @@ impl StoreContext { } } #[cfg(feature = "ApplicationModel")] - pub fn CanAcquireStoreLicenseForOptionalPackageAsync(&self, optionalpackage: P0) -> windows_core::Result> + pub fn CanAcquireStoreLicenseForOptionalPackageAsync(&self, optionalpackage: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1169,14 +1169,14 @@ impl StoreContext { (windows_core::Interface::vtable(this).CanAcquireStoreLicenseForOptionalPackageAsync)(windows_core::Interface::as_raw(this), optionalpackage.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CanAcquireStoreLicenseAsync(&self, productstoreid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CanAcquireStoreLicenseAsync(&self, productstoreid: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CanAcquireStoreLicenseAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(productstoreid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetStoreProductsWithOptionsAsync(&self, productkinds: P0, storeids: P1, storeproductoptions: P2) -> windows_core::Result> + pub fn GetStoreProductsWithOptionsAsync(&self, productkinds: P0, storeids: P1, storeproductoptions: P2) -> windows_core::Result> where P0: windows_core::Param>, P1: windows_core::Param>, @@ -1188,14 +1188,14 @@ impl StoreContext { (windows_core::Interface::vtable(this).GetStoreProductsWithOptionsAsync)(windows_core::Interface::as_raw(this), productkinds.param().abi(), storeids.param().abi(), storeproductoptions.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAssociatedStoreQueueItemsAsync(&self) -> windows_core::Result>> { + pub fn GetAssociatedStoreQueueItemsAsync(&self) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetAssociatedStoreQueueItemsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetStoreQueueItemsAsync(&self, storeids: P0) -> windows_core::Result>> + pub fn GetStoreQueueItemsAsync(&self, storeids: P0) -> windows_core::Result>> where P0: windows_core::Param>, { @@ -1205,7 +1205,7 @@ impl StoreContext { (windows_core::Interface::vtable(this).GetStoreQueueItemsAsync)(windows_core::Interface::as_raw(this), storeids.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestDownloadAndInstallStorePackagesWithInstallOptionsAsync(&self, storeids: P0, storepackageinstalloptions: P1) -> windows_core::Result> + pub fn RequestDownloadAndInstallStorePackagesWithInstallOptionsAsync(&self, storeids: P0, storepackageinstalloptions: P1) -> windows_core::Result> where P0: windows_core::Param>, P1: windows_core::Param, @@ -1216,7 +1216,7 @@ impl StoreContext { (windows_core::Interface::vtable(this).RequestDownloadAndInstallStorePackagesWithInstallOptionsAsync)(windows_core::Interface::as_raw(this), storeids.param().abi(), storepackageinstalloptions.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DownloadAndInstallStorePackagesAsync(&self, storeids: P0) -> windows_core::Result> + pub fn DownloadAndInstallStorePackagesAsync(&self, storeids: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -1227,7 +1227,7 @@ impl StoreContext { } } #[cfg(feature = "ApplicationModel")] - pub fn RequestUninstallStorePackageAsync(&self, package: P0) -> windows_core::Result> + pub fn RequestUninstallStorePackageAsync(&self, package: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1237,7 +1237,7 @@ impl StoreContext { (windows_core::Interface::vtable(this).RequestUninstallStorePackageAsync)(windows_core::Interface::as_raw(this), package.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestUninstallStorePackageByStoreIdAsync(&self, storeid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn RequestUninstallStorePackageByStoreIdAsync(&self, storeid: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1245,7 +1245,7 @@ impl StoreContext { } } #[cfg(feature = "ApplicationModel")] - pub fn UninstallStorePackageAsync(&self, package: P0) -> windows_core::Result> + pub fn UninstallStorePackageAsync(&self, package: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1255,21 +1255,21 @@ impl StoreContext { (windows_core::Interface::vtable(this).UninstallStorePackageAsync)(windows_core::Interface::as_raw(this), package.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn UninstallStorePackageByStoreIdAsync(&self, storeid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn UninstallStorePackageByStoreIdAsync(&self, storeid: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).UninstallStorePackageByStoreIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(storeid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestRateAndReviewAppAsync(&self) -> windows_core::Result> { + pub fn RequestRateAndReviewAppAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestRateAndReviewAppAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SetInstallOrderForAssociatedStoreQueueItemsAsync(&self, items: P0) -> windows_core::Result>> + pub fn SetInstallOrderForAssociatedStoreQueueItemsAsync(&self, items: P0) -> windows_core::Result>> where P0: windows_core::Param>, { @@ -1279,7 +1279,7 @@ impl StoreContext { (windows_core::Interface::vtable(this).SetInstallOrderForAssociatedStoreQueueItemsAsync)(windows_core::Interface::as_raw(this), items.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetUserPurchaseHistoryAsync(&self, productkinds: P0) -> windows_core::Result> + pub fn GetUserPurchaseHistoryAsync(&self, productkinds: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -1289,7 +1289,7 @@ impl StoreContext { (windows_core::Interface::vtable(this).GetUserPurchaseHistoryAsync)(windows_core::Interface::as_raw(this), productkinds.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAssociatedStoreProductsByInAppOfferTokenAsync(&self, inappoffertokens: P0) -> windows_core::Result> + pub fn GetAssociatedStoreProductsByInAppOfferTokenAsync(&self, inappoffertokens: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -1299,7 +1299,7 @@ impl StoreContext { (windows_core::Interface::vtable(this).GetAssociatedStoreProductsByInAppOfferTokenAsync)(windows_core::Interface::as_raw(this), inappoffertokens.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestPurchaseByInAppOfferTokenAsync(&self, inappoffertoken: &windows_core::HSTRING) -> windows_core::Result> { + pub fn RequestPurchaseByInAppOfferTokenAsync(&self, inappoffertoken: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1846,21 +1846,21 @@ impl StoreProduct { (windows_core::Interface::vtable(this).LinkUri)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetIsAnySkuInstalledAsync(&self) -> windows_core::Result> { + pub fn GetIsAnySkuInstalledAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetIsAnySkuInstalledAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestPurchaseAsync(&self) -> windows_core::Result> { + pub fn RequestPurchaseAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestPurchaseAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestPurchaseWithPurchasePropertiesAsync(&self, storepurchaseproperties: P0) -> windows_core::Result> + pub fn RequestPurchaseWithPurchasePropertiesAsync(&self, storepurchaseproperties: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1948,7 +1948,7 @@ impl StoreProductPagedQueryResult { (windows_core::Interface::vtable(this).ExtendedError)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn GetNextAsync(&self) -> windows_core::Result> { + pub fn GetNextAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2198,21 +2198,21 @@ impl StoreQueueItem { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveStatusChanged)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn CancelInstallAsync(&self) -> windows_core::Result { + pub fn CancelInstallAsync(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CancelInstallAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn PauseInstallAsync(&self) -> windows_core::Result { + pub fn PauseInstallAsync(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).PauseInstallAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ResumeInstallAsync(&self) -> windows_core::Result { + pub fn ResumeInstallAsync(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -2422,7 +2422,7 @@ impl windows_core::RuntimeType for StoreRateAndReviewStatus { } pub struct StoreRequestHelper; impl StoreRequestHelper { - pub fn SendRequestAsync(context: P0, requestkind: u32, parametersasjson: &windows_core::HSTRING) -> windows_core::Result> + pub fn SendRequestAsync(context: P0, requestkind: u32, parametersasjson: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -2582,21 +2582,21 @@ impl StoreSku { (windows_core::Interface::vtable(this).CollectionData)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetIsInstalledAsync(&self) -> windows_core::Result> { + pub fn GetIsInstalledAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetIsInstalledAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestPurchaseAsync(&self) -> windows_core::Result> { + pub fn RequestPurchaseAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestPurchaseAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestPurchaseWithPurchasePropertiesAsync(&self, storepurchaseproperties: P0) -> windows_core::Result> + pub fn RequestPurchaseWithPurchasePropertiesAsync(&self, storepurchaseproperties: P0) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Services/TargetedContent/mod.rs b/crates/libs/windows/src/Windows/Services/TargetedContent/mod.rs index 24cf7385f9..5a4ed77d62 100644 --- a/crates/libs/windows/src/Windows/Services/TargetedContent/mod.rs +++ b/crates/libs/windows/src/Windows/Services/TargetedContent/mod.rs @@ -202,7 +202,7 @@ pub struct ITargetedContentValue_Vtbl { pub struct TargetedContentAction(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(TargetedContentAction, windows_core::IUnknown, windows_core::IInspectable); impl TargetedContentAction { - pub fn InvokeAsync(&self) -> windows_core::Result { + pub fn InvokeAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -408,7 +408,7 @@ impl TargetedContentContainer { (windows_core::Interface::vtable(this).SelectSingleObject)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(path), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAsync(contentid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetAsync(contentid: &windows_core::HSTRING) -> windows_core::Result> { Self::ITargetedContentContainerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(contentid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -439,7 +439,7 @@ pub struct TargetedContentFile(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(TargetedContentFile, windows_core::IUnknown, windows_core::IInspectable, super::super::Storage::Streams::IRandomAccessStreamReference); #[cfg(feature = "Storage_Streams")] impl TargetedContentFile { - pub fn OpenReadAsync(&self) -> windows_core::Result> { + pub fn OpenReadAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -474,7 +474,7 @@ windows_core::imp::interface_hierarchy!(TargetedContentImage, windows_core::IUnk windows_core::imp::required_hierarchy!(TargetedContentImage, super::super::Storage::Streams::IRandomAccessStreamReference); #[cfg(feature = "Storage_Streams")] impl TargetedContentImage { - pub fn OpenReadAsync(&self) -> windows_core::Result> { + pub fn OpenReadAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -720,7 +720,7 @@ impl TargetedContentSubscription { (windows_core::Interface::vtable(this).Id)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn GetContentContainerAsync(&self) -> windows_core::Result> { + pub fn GetContentContainerAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -769,7 +769,7 @@ impl TargetedContentSubscription { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveStateChanged)(windows_core::Interface::as_raw(this), cookie).ok() } } - pub fn GetAsync(subscriptionid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetAsync(subscriptionid: &windows_core::HSTRING) -> windows_core::Result> { Self::ITargetedContentSubscriptionStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(subscriptionid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/Storage/AccessCache/mod.rs b/crates/libs/windows/src/Windows/Storage/AccessCache/mod.rs index 47c9f510b5..0beab565dd 100644 --- a/crates/libs/windows/src/Windows/Storage/AccessCache/mod.rs +++ b/crates/libs/windows/src/Windows/Storage/AccessCache/mod.rs @@ -200,7 +200,7 @@ impl IStorageItemAccessList { let this = self; unsafe { (windows_core::Interface::vtable(this).AddOrReplace)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(token), file.param().abi(), core::mem::transmute_copy(metadata)).ok() } } - pub fn GetItemAsync(&self, token: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetItemAsync(&self, token: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -208,7 +208,7 @@ impl IStorageItemAccessList { } } #[cfg(feature = "Storage_Streams")] - pub fn GetFileAsync(&self, token: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetFileAsync(&self, token: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -216,14 +216,14 @@ impl IStorageItemAccessList { } } #[cfg(feature = "Storage_Search")] - pub fn GetFolderAsync(&self, token: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetFolderAsync(&self, token: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFolderAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(token), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetItemWithOptionsAsync(&self, token: &windows_core::HSTRING, options: AccessCacheOptions) -> windows_core::Result> { + pub fn GetItemWithOptionsAsync(&self, token: &windows_core::HSTRING, options: AccessCacheOptions) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -231,7 +231,7 @@ impl IStorageItemAccessList { } } #[cfg(feature = "Storage_Streams")] - pub fn GetFileWithOptionsAsync(&self, token: &windows_core::HSTRING, options: AccessCacheOptions) -> windows_core::Result> { + pub fn GetFileWithOptionsAsync(&self, token: &windows_core::HSTRING, options: AccessCacheOptions) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -239,7 +239,7 @@ impl IStorageItemAccessList { } } #[cfg(feature = "Storage_Search")] - pub fn GetFolderWithOptionsAsync(&self, token: &windows_core::HSTRING, options: AccessCacheOptions) -> windows_core::Result> { + pub fn GetFolderWithOptionsAsync(&self, token: &windows_core::HSTRING, options: AccessCacheOptions) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -296,12 +296,12 @@ pub trait IStorageItemAccessList_Impl: windows_core::IUnknownImpl { fn Add(&self, file: windows_core::Ref<'_, super::IStorageItem>, metadata: &windows_core::HSTRING) -> windows_core::Result; fn AddOrReplaceOverloadDefaultMetadata(&self, token: &windows_core::HSTRING, file: windows_core::Ref<'_, super::IStorageItem>) -> windows_core::Result<()>; fn AddOrReplace(&self, token: &windows_core::HSTRING, file: windows_core::Ref<'_, super::IStorageItem>, metadata: &windows_core::HSTRING) -> windows_core::Result<()>; - fn GetItemAsync(&self, token: &windows_core::HSTRING) -> windows_core::Result>; - fn GetFileAsync(&self, token: &windows_core::HSTRING) -> windows_core::Result>; - fn GetFolderAsync(&self, token: &windows_core::HSTRING) -> windows_core::Result>; - fn GetItemWithOptionsAsync(&self, token: &windows_core::HSTRING, options: AccessCacheOptions) -> windows_core::Result>; - fn GetFileWithOptionsAsync(&self, token: &windows_core::HSTRING, options: AccessCacheOptions) -> windows_core::Result>; - fn GetFolderWithOptionsAsync(&self, token: &windows_core::HSTRING, options: AccessCacheOptions) -> windows_core::Result>; + fn GetItemAsync(&self, token: &windows_core::HSTRING) -> windows_core::Result>; + fn GetFileAsync(&self, token: &windows_core::HSTRING) -> windows_core::Result>; + fn GetFolderAsync(&self, token: &windows_core::HSTRING) -> windows_core::Result>; + fn GetItemWithOptionsAsync(&self, token: &windows_core::HSTRING, options: AccessCacheOptions) -> windows_core::Result>; + fn GetFileWithOptionsAsync(&self, token: &windows_core::HSTRING, options: AccessCacheOptions) -> windows_core::Result>; + fn GetFolderWithOptionsAsync(&self, token: &windows_core::HSTRING, options: AccessCacheOptions) -> windows_core::Result>; fn Remove(&self, token: &windows_core::HSTRING) -> windows_core::Result<()>; fn ContainsItem(&self, token: &windows_core::HSTRING) -> windows_core::Result; fn Clear(&self) -> windows_core::Result<()>; @@ -686,7 +686,7 @@ impl StorageItemAccessList { let this = self; unsafe { (windows_core::Interface::vtable(this).AddOrReplace)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(token), file.param().abi(), core::mem::transmute_copy(metadata)).ok() } } - pub fn GetItemAsync(&self, token: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetItemAsync(&self, token: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -694,7 +694,7 @@ impl StorageItemAccessList { } } #[cfg(feature = "Storage_Streams")] - pub fn GetFileAsync(&self, token: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetFileAsync(&self, token: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -702,14 +702,14 @@ impl StorageItemAccessList { } } #[cfg(feature = "Storage_Search")] - pub fn GetFolderAsync(&self, token: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetFolderAsync(&self, token: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFolderAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(token), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetItemWithOptionsAsync(&self, token: &windows_core::HSTRING, options: AccessCacheOptions) -> windows_core::Result> { + pub fn GetItemWithOptionsAsync(&self, token: &windows_core::HSTRING, options: AccessCacheOptions) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -717,7 +717,7 @@ impl StorageItemAccessList { } } #[cfg(feature = "Storage_Streams")] - pub fn GetFileWithOptionsAsync(&self, token: &windows_core::HSTRING, options: AccessCacheOptions) -> windows_core::Result> { + pub fn GetFileWithOptionsAsync(&self, token: &windows_core::HSTRING, options: AccessCacheOptions) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -725,7 +725,7 @@ impl StorageItemAccessList { } } #[cfg(feature = "Storage_Search")] - pub fn GetFolderWithOptionsAsync(&self, token: &windows_core::HSTRING, options: AccessCacheOptions) -> windows_core::Result> { + pub fn GetFolderWithOptionsAsync(&self, token: &windows_core::HSTRING, options: AccessCacheOptions) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -822,7 +822,7 @@ impl StorageItemMostRecentlyUsedList { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).AddOrReplace)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(token), file.param().abi(), core::mem::transmute_copy(metadata)).ok() } } - pub fn GetItemAsync(&self, token: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetItemAsync(&self, token: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -830,7 +830,7 @@ impl StorageItemMostRecentlyUsedList { } } #[cfg(feature = "Storage_Streams")] - pub fn GetFileAsync(&self, token: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetFileAsync(&self, token: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -838,14 +838,14 @@ impl StorageItemMostRecentlyUsedList { } } #[cfg(feature = "Storage_Search")] - pub fn GetFolderAsync(&self, token: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetFolderAsync(&self, token: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFolderAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(token), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetItemWithOptionsAsync(&self, token: &windows_core::HSTRING, options: AccessCacheOptions) -> windows_core::Result> { + pub fn GetItemWithOptionsAsync(&self, token: &windows_core::HSTRING, options: AccessCacheOptions) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -853,7 +853,7 @@ impl StorageItemMostRecentlyUsedList { } } #[cfg(feature = "Storage_Streams")] - pub fn GetFileWithOptionsAsync(&self, token: &windows_core::HSTRING, options: AccessCacheOptions) -> windows_core::Result> { + pub fn GetFileWithOptionsAsync(&self, token: &windows_core::HSTRING, options: AccessCacheOptions) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -861,7 +861,7 @@ impl StorageItemMostRecentlyUsedList { } } #[cfg(feature = "Storage_Search")] - pub fn GetFolderWithOptionsAsync(&self, token: &windows_core::HSTRING, options: AccessCacheOptions) -> windows_core::Result> { + pub fn GetFolderWithOptionsAsync(&self, token: &windows_core::HSTRING, options: AccessCacheOptions) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Storage/BulkAccess/mod.rs b/crates/libs/windows/src/Windows/Storage/BulkAccess/mod.rs index 15b017a4c8..ca4a8689a0 100644 --- a/crates/libs/windows/src/Windows/Storage/BulkAccess/mod.rs +++ b/crates/libs/windows/src/Windows/Storage/BulkAccess/mod.rs @@ -8,14 +8,14 @@ windows_core::imp::interface_hierarchy!(FileInformation, windows_core::IUnknown, windows_core::imp::required_hierarchy!(FileInformation, super::Streams::IInputStreamReference, super::Streams::IRandomAccessStreamReference, super::IStorageFile, super::IStorageFile2, super::IStorageFilePropertiesWithAvailability, super::IStorageItem, super::IStorageItem2, super::IStorageItemProperties, super::IStorageItemPropertiesWithProvider); #[cfg(feature = "Storage_Streams")] impl FileInformation { - pub fn OpenSequentialReadAsync(&self) -> windows_core::Result> { + pub fn OpenSequentialReadAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).OpenSequentialReadAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn OpenReadAsync(&self) -> windows_core::Result> { + pub fn OpenReadAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -36,21 +36,21 @@ impl FileInformation { (windows_core::Interface::vtable(this).ContentType)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn OpenAsync(&self, accessmode: super::FileAccessMode) -> windows_core::Result> { + pub fn OpenAsync(&self, accessmode: super::FileAccessMode) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).OpenAsync)(windows_core::Interface::as_raw(this), accessmode, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn OpenTransactedWriteAsync(&self) -> windows_core::Result> { + pub fn OpenTransactedWriteAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).OpenTransactedWriteAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CopyOverloadDefaultNameAndOptions(&self, destinationfolder: P0) -> windows_core::Result> + pub fn CopyOverloadDefaultNameAndOptions(&self, destinationfolder: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -60,7 +60,7 @@ impl FileInformation { (windows_core::Interface::vtable(this).CopyOverloadDefaultNameAndOptions)(windows_core::Interface::as_raw(this), destinationfolder.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CopyOverloadDefaultOptions(&self, destinationfolder: P0, desirednewname: &windows_core::HSTRING) -> windows_core::Result> + pub fn CopyOverloadDefaultOptions(&self, destinationfolder: P0, desirednewname: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -70,7 +70,7 @@ impl FileInformation { (windows_core::Interface::vtable(this).CopyOverloadDefaultOptions)(windows_core::Interface::as_raw(this), destinationfolder.param().abi(), core::mem::transmute_copy(desirednewname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CopyOverload(&self, destinationfolder: P0, desirednewname: &windows_core::HSTRING, option: super::NameCollisionOption) -> windows_core::Result> + pub fn CopyOverload(&self, destinationfolder: P0, desirednewname: &windows_core::HSTRING, option: super::NameCollisionOption) -> windows_core::Result> where P0: windows_core::Param, { @@ -80,7 +80,7 @@ impl FileInformation { (windows_core::Interface::vtable(this).CopyOverload)(windows_core::Interface::as_raw(this), destinationfolder.param().abi(), core::mem::transmute_copy(desirednewname), option, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CopyAndReplaceAsync(&self, filetoreplace: P0) -> windows_core::Result + pub fn CopyAndReplaceAsync(&self, filetoreplace: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -90,7 +90,7 @@ impl FileInformation { (windows_core::Interface::vtable(this).CopyAndReplaceAsync)(windows_core::Interface::as_raw(this), filetoreplace.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn MoveOverloadDefaultNameAndOptions(&self, destinationfolder: P0) -> windows_core::Result + pub fn MoveOverloadDefaultNameAndOptions(&self, destinationfolder: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -100,7 +100,7 @@ impl FileInformation { (windows_core::Interface::vtable(this).MoveOverloadDefaultNameAndOptions)(windows_core::Interface::as_raw(this), destinationfolder.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn MoveOverloadDefaultOptions(&self, destinationfolder: P0, desirednewname: &windows_core::HSTRING) -> windows_core::Result + pub fn MoveOverloadDefaultOptions(&self, destinationfolder: P0, desirednewname: &windows_core::HSTRING) -> windows_core::Result where P0: windows_core::Param, { @@ -110,7 +110,7 @@ impl FileInformation { (windows_core::Interface::vtable(this).MoveOverloadDefaultOptions)(windows_core::Interface::as_raw(this), destinationfolder.param().abi(), core::mem::transmute_copy(desirednewname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn MoveOverload(&self, destinationfolder: P0, desirednewname: &windows_core::HSTRING, option: super::NameCollisionOption) -> windows_core::Result + pub fn MoveOverload(&self, destinationfolder: P0, desirednewname: &windows_core::HSTRING, option: super::NameCollisionOption) -> windows_core::Result where P0: windows_core::Param, { @@ -120,7 +120,7 @@ impl FileInformation { (windows_core::Interface::vtable(this).MoveOverload)(windows_core::Interface::as_raw(this), destinationfolder.param().abi(), core::mem::transmute_copy(desirednewname), option, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn MoveAndReplaceAsync(&self, filetoreplace: P0) -> windows_core::Result + pub fn MoveAndReplaceAsync(&self, filetoreplace: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -130,14 +130,14 @@ impl FileInformation { (windows_core::Interface::vtable(this).MoveAndReplaceAsync)(windows_core::Interface::as_raw(this), filetoreplace.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn OpenWithOptionsAsync(&self, accessmode: super::FileAccessMode, options: super::StorageOpenOptions) -> windows_core::Result> { + pub fn OpenWithOptionsAsync(&self, accessmode: super::FileAccessMode, options: super::StorageOpenOptions) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).OpenWithOptionsAsync)(windows_core::Interface::as_raw(this), accessmode, options, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn OpenTransactedWriteWithOptionsAsync(&self, options: super::StorageOpenOptions) -> windows_core::Result> { + pub fn OpenTransactedWriteWithOptionsAsync(&self, options: super::StorageOpenOptions) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -151,28 +151,28 @@ impl FileInformation { (windows_core::Interface::vtable(this).IsAvailable)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn RenameAsyncOverloadDefaultOptions(&self, desiredname: &windows_core::HSTRING) -> windows_core::Result { + pub fn RenameAsyncOverloadDefaultOptions(&self, desiredname: &windows_core::HSTRING) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RenameAsyncOverloadDefaultOptions)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(desiredname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RenameAsync(&self, desiredname: &windows_core::HSTRING, option: super::NameCollisionOption) -> windows_core::Result { + pub fn RenameAsync(&self, desiredname: &windows_core::HSTRING, option: super::NameCollisionOption) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RenameAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(desiredname), option, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAsyncOverloadDefaultOptions(&self) -> windows_core::Result { + pub fn DeleteAsyncOverloadDefaultOptions(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeleteAsyncOverloadDefaultOptions)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAsync(&self, option: super::StorageDeleteOption) -> windows_core::Result { + pub fn DeleteAsync(&self, option: super::StorageDeleteOption) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -180,7 +180,7 @@ impl FileInformation { } } #[cfg(feature = "Storage_FileProperties")] - pub fn GetBasicPropertiesAsync(&self) -> windows_core::Result> { + pub fn GetBasicPropertiesAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -223,7 +223,7 @@ impl FileInformation { } } #[cfg(feature = "Storage_Search")] - pub fn GetParentAsync(&self) -> windows_core::Result> { + pub fn GetParentAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -317,7 +317,7 @@ impl FileInformation { unsafe { (windows_core::Interface::vtable(this).RemovePropertiesUpdated)(windows_core::Interface::as_raw(this), eventcookie).ok() } } #[cfg(feature = "Storage_FileProperties")] - pub fn GetThumbnailAsyncOverloadDefaultSizeDefaultOptions(&self, mode: super::FileProperties::ThumbnailMode) -> windows_core::Result> { + pub fn GetThumbnailAsyncOverloadDefaultSizeDefaultOptions(&self, mode: super::FileProperties::ThumbnailMode) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -325,7 +325,7 @@ impl FileInformation { } } #[cfg(feature = "Storage_FileProperties")] - pub fn GetThumbnailAsyncOverloadDefaultOptions(&self, mode: super::FileProperties::ThumbnailMode, requestedsize: u32) -> windows_core::Result> { + pub fn GetThumbnailAsyncOverloadDefaultOptions(&self, mode: super::FileProperties::ThumbnailMode, requestedsize: u32) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -333,7 +333,7 @@ impl FileInformation { } } #[cfg(feature = "Storage_FileProperties")] - pub fn GetThumbnailAsync(&self, mode: super::FileProperties::ThumbnailMode, requestedsize: u32, options: super::FileProperties::ThumbnailOptions) -> windows_core::Result> { + pub fn GetThumbnailAsync(&self, mode: super::FileProperties::ThumbnailMode, requestedsize: u32, options: super::FileProperties::ThumbnailOptions) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -395,14 +395,14 @@ impl windows_core::RuntimeName for FileInformation { pub struct FileInformationFactory(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(FileInformationFactory, windows_core::IUnknown, windows_core::IInspectable); impl FileInformationFactory { - pub fn GetItemsAsync(&self, startindex: u32, maxitemstoretrieve: u32) -> windows_core::Result>> { + pub fn GetItemsAsync(&self, startindex: u32, maxitemstoretrieve: u32) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetItemsAsync)(windows_core::Interface::as_raw(this), startindex, maxitemstoretrieve, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetItemsAsyncDefaultStartAndCount(&self) -> windows_core::Result>> { + pub fn GetItemsAsyncDefaultStartAndCount(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -410,7 +410,7 @@ impl FileInformationFactory { } } #[cfg(feature = "Storage_Streams")] - pub fn GetFilesAsync(&self, startindex: u32, maxitemstoretrieve: u32) -> windows_core::Result>> { + pub fn GetFilesAsync(&self, startindex: u32, maxitemstoretrieve: u32) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -418,7 +418,7 @@ impl FileInformationFactory { } } #[cfg(feature = "Storage_Streams")] - pub fn GetFilesAsyncDefaultStartAndCount(&self) -> windows_core::Result>> { + pub fn GetFilesAsyncDefaultStartAndCount(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -426,7 +426,7 @@ impl FileInformationFactory { } } #[cfg(feature = "Storage_Search")] - pub fn GetFoldersAsync(&self, startindex: u32, maxitemstoretrieve: u32) -> windows_core::Result>> { + pub fn GetFoldersAsync(&self, startindex: u32, maxitemstoretrieve: u32) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -434,7 +434,7 @@ impl FileInformationFactory { } } #[cfg(feature = "Storage_Search")] - pub fn GetFoldersAsyncDefaultStartAndCount(&self) -> windows_core::Result>> { + pub fn GetFoldersAsyncDefaultStartAndCount(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -530,7 +530,7 @@ windows_core::imp::required_hierarchy!(FolderInformation, super::IStorageFolder, #[cfg(feature = "Storage_Search")] impl FolderInformation { #[cfg(feature = "Storage_Streams")] - pub fn CreateFileAsyncOverloadDefaultOptions(&self, desiredname: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CreateFileAsyncOverloadDefaultOptions(&self, desiredname: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -538,21 +538,21 @@ impl FolderInformation { } } #[cfg(feature = "Storage_Streams")] - pub fn CreateFileAsync(&self, desiredname: &windows_core::HSTRING, options: super::CreationCollisionOption) -> windows_core::Result> { + pub fn CreateFileAsync(&self, desiredname: &windows_core::HSTRING, options: super::CreationCollisionOption) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreateFileAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(desiredname), options, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateFolderAsyncOverloadDefaultOptions(&self, desiredname: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CreateFolderAsyncOverloadDefaultOptions(&self, desiredname: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreateFolderAsyncOverloadDefaultOptions)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(desiredname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateFolderAsync(&self, desiredname: &windows_core::HSTRING, options: super::CreationCollisionOption) -> windows_core::Result> { + pub fn CreateFolderAsync(&self, desiredname: &windows_core::HSTRING, options: super::CreationCollisionOption) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -560,21 +560,21 @@ impl FolderInformation { } } #[cfg(feature = "Storage_Streams")] - pub fn GetFileAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetFileAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFileAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(name), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetFolderAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetFolderAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFolderAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(name), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetItemAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetItemAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -582,35 +582,35 @@ impl FolderInformation { } } #[cfg(feature = "Storage_Streams")] - pub fn GetFilesAsyncOverloadDefaultOptionsStartAndCount(&self) -> windows_core::Result>> { + pub fn GetFilesAsyncOverloadDefaultOptionsStartAndCount(&self) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFilesAsyncOverloadDefaultOptionsStartAndCount)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetFoldersAsyncOverloadDefaultOptionsStartAndCount(&self) -> windows_core::Result>> { + pub fn GetFoldersAsyncOverloadDefaultOptionsStartAndCount(&self) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFoldersAsyncOverloadDefaultOptionsStartAndCount)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetItemsAsyncOverloadDefaultStartAndCount(&self) -> windows_core::Result>> { + pub fn GetItemsAsyncOverloadDefaultStartAndCount(&self) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetItemsAsyncOverloadDefaultStartAndCount)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryGetItemAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { + pub fn TryGetItemAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryGetItemAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(name), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetIndexedStateAsync(&self) -> windows_core::Result> { + pub fn GetIndexedStateAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -683,7 +683,7 @@ impl FolderInformation { } } #[cfg(feature = "Storage_Streams")] - pub fn GetFilesAsync(&self, query: super::Search::CommonFileQuery, startindex: u32, maxitemstoretrieve: u32) -> windows_core::Result>> { + pub fn GetFilesAsync(&self, query: super::Search::CommonFileQuery, startindex: u32, maxitemstoretrieve: u32) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -691,28 +691,28 @@ impl FolderInformation { } } #[cfg(feature = "Storage_Streams")] - pub fn GetFilesAsyncOverloadDefaultStartAndCount(&self, query: super::Search::CommonFileQuery) -> windows_core::Result>> { + pub fn GetFilesAsyncOverloadDefaultStartAndCount(&self, query: super::Search::CommonFileQuery) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFilesAsyncOverloadDefaultStartAndCount)(windows_core::Interface::as_raw(this), query, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetFoldersAsync(&self, query: super::Search::CommonFolderQuery, startindex: u32, maxitemstoretrieve: u32) -> windows_core::Result>> { + pub fn GetFoldersAsync(&self, query: super::Search::CommonFolderQuery, startindex: u32, maxitemstoretrieve: u32) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFoldersAsync)(windows_core::Interface::as_raw(this), query, startindex, maxitemstoretrieve, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetFoldersAsyncOverloadDefaultStartAndCount(&self, query: super::Search::CommonFolderQuery) -> windows_core::Result>> { + pub fn GetFoldersAsyncOverloadDefaultStartAndCount(&self, query: super::Search::CommonFolderQuery) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFoldersAsyncOverloadDefaultStartAndCount)(windows_core::Interface::as_raw(this), query, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetItemsAsync(&self, startindex: u32, maxitemstoretrieve: u32) -> windows_core::Result>> { + pub fn GetItemsAsync(&self, startindex: u32, maxitemstoretrieve: u32) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -743,28 +743,28 @@ impl FolderInformation { (windows_core::Interface::vtable(this).IsCommonFileQuerySupported)(windows_core::Interface::as_raw(this), query, &mut result__).map(|| result__) } } - pub fn RenameAsyncOverloadDefaultOptions(&self, desiredname: &windows_core::HSTRING) -> windows_core::Result { + pub fn RenameAsyncOverloadDefaultOptions(&self, desiredname: &windows_core::HSTRING) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RenameAsyncOverloadDefaultOptions)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(desiredname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RenameAsync(&self, desiredname: &windows_core::HSTRING, option: super::NameCollisionOption) -> windows_core::Result { + pub fn RenameAsync(&self, desiredname: &windows_core::HSTRING, option: super::NameCollisionOption) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RenameAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(desiredname), option, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAsyncOverloadDefaultOptions(&self) -> windows_core::Result { + pub fn DeleteAsyncOverloadDefaultOptions(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeleteAsyncOverloadDefaultOptions)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAsync(&self, option: super::StorageDeleteOption) -> windows_core::Result { + pub fn DeleteAsync(&self, option: super::StorageDeleteOption) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -772,7 +772,7 @@ impl FolderInformation { } } #[cfg(feature = "Storage_FileProperties")] - pub fn GetBasicPropertiesAsync(&self) -> windows_core::Result> { + pub fn GetBasicPropertiesAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -814,7 +814,7 @@ impl FolderInformation { (windows_core::Interface::vtable(this).IsOfType)(windows_core::Interface::as_raw(this), r#type, &mut result__).map(|| result__) } } - pub fn GetParentAsync(&self) -> windows_core::Result> { + pub fn GetParentAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -908,7 +908,7 @@ impl FolderInformation { unsafe { (windows_core::Interface::vtable(this).RemovePropertiesUpdated)(windows_core::Interface::as_raw(this), eventcookie).ok() } } #[cfg(all(feature = "Storage_FileProperties", feature = "Storage_Streams"))] - pub fn GetThumbnailAsyncOverloadDefaultSizeDefaultOptions(&self, mode: super::FileProperties::ThumbnailMode) -> windows_core::Result> { + pub fn GetThumbnailAsyncOverloadDefaultSizeDefaultOptions(&self, mode: super::FileProperties::ThumbnailMode) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -916,7 +916,7 @@ impl FolderInformation { } } #[cfg(all(feature = "Storage_FileProperties", feature = "Storage_Streams"))] - pub fn GetThumbnailAsyncOverloadDefaultOptions(&self, mode: super::FileProperties::ThumbnailMode, requestedsize: u32) -> windows_core::Result> { + pub fn GetThumbnailAsyncOverloadDefaultOptions(&self, mode: super::FileProperties::ThumbnailMode, requestedsize: u32) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -924,7 +924,7 @@ impl FolderInformation { } } #[cfg(all(feature = "Storage_FileProperties", feature = "Storage_Streams"))] - pub fn GetThumbnailAsync(&self, mode: super::FileProperties::ThumbnailMode, requestedsize: u32, options: super::FileProperties::ThumbnailOptions) -> windows_core::Result> { + pub fn GetThumbnailAsync(&self, mode: super::FileProperties::ThumbnailMode, requestedsize: u32, options: super::FileProperties::ThumbnailOptions) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Storage/Compression/mod.rs b/crates/libs/windows/src/Windows/Storage/Compression/mod.rs index 52cc086bc7..7c00098fdd 100644 --- a/crates/libs/windows/src/Windows/Storage/Compression/mod.rs +++ b/crates/libs/windows/src/Windows/Storage/Compression/mod.rs @@ -29,7 +29,7 @@ impl Compressor { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).Close)(windows_core::Interface::as_raw(this)).ok() } } - pub fn FinishAsync(&self) -> windows_core::Result> { + pub fn FinishAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -61,7 +61,7 @@ impl Compressor { (windows_core::Interface::vtable(this).CreateCompressorEx)(windows_core::Interface::as_raw(this), underlyingstream.param().abi(), algorithm, blocksize, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn WriteAsync(&self, buffer: P0) -> windows_core::Result> + pub fn WriteAsync(&self, buffer: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -71,7 +71,7 @@ impl Compressor { (windows_core::Interface::vtable(this).WriteAsync)(windows_core::Interface::as_raw(this), buffer.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FlushAsync(&self) -> windows_core::Result> { + pub fn FlushAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -130,7 +130,7 @@ impl Decompressor { (windows_core::Interface::vtable(this).CreateDecompressor)(windows_core::Interface::as_raw(this), underlyingstream.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn ReadAsync(&self, buffer: P0, count: u32, options: super::Streams::InputStreamOptions) -> windows_core::Result> + pub fn ReadAsync(&self, buffer: P0, count: u32, options: super::Streams::InputStreamOptions) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Storage/FileProperties/mod.rs b/crates/libs/windows/src/Windows/Storage/FileProperties/mod.rs index 626e0df0f8..7d982e30bd 100644 --- a/crates/libs/windows/src/Windows/Storage/FileProperties/mod.rs +++ b/crates/libs/windows/src/Windows/Storage/FileProperties/mod.rs @@ -25,7 +25,7 @@ impl BasicProperties { (windows_core::Interface::vtable(this).ItemDate)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn RetrievePropertiesAsync(&self, propertiestoretrieve: P0) -> windows_core::Result>> + pub fn RetrievePropertiesAsync(&self, propertiestoretrieve: P0) -> windows_core::Result>> where P0: windows_core::Param>, { @@ -35,7 +35,7 @@ impl BasicProperties { (windows_core::Interface::vtable(this).RetrievePropertiesAsync)(windows_core::Interface::as_raw(this), propertiestoretrieve.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SavePropertiesAsync(&self, propertiestosave: P0) -> windows_core::Result + pub fn SavePropertiesAsync(&self, propertiestosave: P0) -> windows_core::Result where P0: windows_core::Param>>, { @@ -45,7 +45,7 @@ impl BasicProperties { (windows_core::Interface::vtable(this).SavePropertiesAsync)(windows_core::Interface::as_raw(this), propertiestosave.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SavePropertiesAsyncOverloadDefault(&self) -> windows_core::Result { + pub fn SavePropertiesAsyncOverloadDefault(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -105,7 +105,7 @@ impl DocumentProperties { let this = self; unsafe { (windows_core::Interface::vtable(this).SetComment)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(value)).ok() } } - pub fn RetrievePropertiesAsync(&self, propertiestoretrieve: P0) -> windows_core::Result>> + pub fn RetrievePropertiesAsync(&self, propertiestoretrieve: P0) -> windows_core::Result>> where P0: windows_core::Param>, { @@ -115,7 +115,7 @@ impl DocumentProperties { (windows_core::Interface::vtable(this).RetrievePropertiesAsync)(windows_core::Interface::as_raw(this), propertiestoretrieve.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SavePropertiesAsync(&self, propertiestosave: P0) -> windows_core::Result + pub fn SavePropertiesAsync(&self, propertiestosave: P0) -> windows_core::Result where P0: windows_core::Param>>, { @@ -125,7 +125,7 @@ impl DocumentProperties { (windows_core::Interface::vtable(this).SavePropertiesAsync)(windows_core::Interface::as_raw(this), propertiestosave.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SavePropertiesAsyncOverloadDefault(&self) -> windows_core::Result { + pub fn SavePropertiesAsyncOverloadDefault(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -146,7 +146,7 @@ impl windows_core::RuntimeName for DocumentProperties { pub struct GeotagHelper; impl GeotagHelper { #[cfg(all(feature = "Devices_Geolocation", feature = "Storage_Streams"))] - pub fn GetGeotagAsync(file: P0) -> windows_core::Result> + pub fn GetGeotagAsync(file: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -156,7 +156,7 @@ impl GeotagHelper { }) } #[cfg(all(feature = "Devices_Geolocation", feature = "Storage_Streams"))] - pub fn SetGeotagFromGeolocatorAsync(file: P0, geolocator: P1) -> windows_core::Result + pub fn SetGeotagFromGeolocatorAsync(file: P0, geolocator: P1) -> windows_core::Result where P0: windows_core::Param, P1: windows_core::Param, @@ -167,7 +167,7 @@ impl GeotagHelper { }) } #[cfg(all(feature = "Devices_Geolocation", feature = "Storage_Streams"))] - pub fn SetGeotagAsync(file: P0, geopoint: P1) -> windows_core::Result + pub fn SetGeotagAsync(file: P0, geopoint: P1) -> windows_core::Result where P0: windows_core::Param, P1: windows_core::Param, @@ -306,7 +306,7 @@ impl windows_core::RuntimeType for IStorageItemExtraProperties { } windows_core::imp::interface_hierarchy!(IStorageItemExtraProperties, windows_core::IUnknown, windows_core::IInspectable); impl IStorageItemExtraProperties { - pub fn RetrievePropertiesAsync(&self, propertiestoretrieve: P0) -> windows_core::Result>> + pub fn RetrievePropertiesAsync(&self, propertiestoretrieve: P0) -> windows_core::Result>> where P0: windows_core::Param>, { @@ -316,7 +316,7 @@ impl IStorageItemExtraProperties { (windows_core::Interface::vtable(this).RetrievePropertiesAsync)(windows_core::Interface::as_raw(this), propertiestoretrieve.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SavePropertiesAsync(&self, propertiestosave: P0) -> windows_core::Result + pub fn SavePropertiesAsync(&self, propertiestosave: P0) -> windows_core::Result where P0: windows_core::Param>>, { @@ -326,7 +326,7 @@ impl IStorageItemExtraProperties { (windows_core::Interface::vtable(this).SavePropertiesAsync)(windows_core::Interface::as_raw(this), propertiestosave.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SavePropertiesAsyncOverloadDefault(&self) -> windows_core::Result { + pub fn SavePropertiesAsyncOverloadDefault(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -338,9 +338,9 @@ impl windows_core::RuntimeName for IStorageItemExtraProperties { const NAME: &'static str = "Windows.Storage.FileProperties.IStorageItemExtraProperties"; } pub trait IStorageItemExtraProperties_Impl: windows_core::IUnknownImpl { - fn RetrievePropertiesAsync(&self, propertiesToRetrieve: windows_core::Ref<'_, windows_collections::IIterable>) -> windows_core::Result>>; - fn SavePropertiesAsync(&self, propertiesToSave: windows_core::Ref<'_, windows_collections::IIterable>>) -> windows_core::Result; - fn SavePropertiesAsyncOverloadDefault(&self) -> windows_core::Result; + fn RetrievePropertiesAsync(&self, propertiesToRetrieve: windows_core::Ref<'_, windows_collections::IIterable>) -> windows_core::Result>>; + fn SavePropertiesAsync(&self, propertiesToSave: windows_core::Ref<'_, windows_collections::IIterable>>) -> windows_core::Result; + fn SavePropertiesAsyncOverloadDefault(&self) -> windows_core::Result; } impl IStorageItemExtraProperties_Vtbl { pub const fn new() -> Self { @@ -552,7 +552,7 @@ impl ImageProperties { (windows_core::Interface::vtable(this).PeopleNames)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RetrievePropertiesAsync(&self, propertiestoretrieve: P0) -> windows_core::Result>> + pub fn RetrievePropertiesAsync(&self, propertiestoretrieve: P0) -> windows_core::Result>> where P0: windows_core::Param>, { @@ -562,7 +562,7 @@ impl ImageProperties { (windows_core::Interface::vtable(this).RetrievePropertiesAsync)(windows_core::Interface::as_raw(this), propertiestoretrieve.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SavePropertiesAsync(&self, propertiestosave: P0) -> windows_core::Result + pub fn SavePropertiesAsync(&self, propertiestosave: P0) -> windows_core::Result where P0: windows_core::Param>>, { @@ -572,7 +572,7 @@ impl ImageProperties { (windows_core::Interface::vtable(this).SavePropertiesAsync)(windows_core::Interface::as_raw(this), propertiestosave.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SavePropertiesAsyncOverloadDefault(&self) -> windows_core::Result { + pub fn SavePropertiesAsyncOverloadDefault(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -744,7 +744,7 @@ impl MusicProperties { let this = self; unsafe { (windows_core::Interface::vtable(this).SetYear)(windows_core::Interface::as_raw(this), value).ok() } } - pub fn RetrievePropertiesAsync(&self, propertiestoretrieve: P0) -> windows_core::Result>> + pub fn RetrievePropertiesAsync(&self, propertiestoretrieve: P0) -> windows_core::Result>> where P0: windows_core::Param>, { @@ -754,7 +754,7 @@ impl MusicProperties { (windows_core::Interface::vtable(this).RetrievePropertiesAsync)(windows_core::Interface::as_raw(this), propertiestoretrieve.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SavePropertiesAsync(&self, propertiestosave: P0) -> windows_core::Result + pub fn SavePropertiesAsync(&self, propertiestosave: P0) -> windows_core::Result where P0: windows_core::Param>>, { @@ -764,7 +764,7 @@ impl MusicProperties { (windows_core::Interface::vtable(this).SavePropertiesAsync)(windows_core::Interface::as_raw(this), propertiestosave.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SavePropertiesAsyncOverloadDefault(&self) -> windows_core::Result { + pub fn SavePropertiesAsyncOverloadDefault(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -858,35 +858,35 @@ pub struct StorageItemContentProperties(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(StorageItemContentProperties, windows_core::IUnknown, windows_core::IInspectable); windows_core::imp::required_hierarchy!(StorageItemContentProperties, IStorageItemExtraProperties); impl StorageItemContentProperties { - pub fn GetMusicPropertiesAsync(&self) -> windows_core::Result> { + pub fn GetMusicPropertiesAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetMusicPropertiesAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetVideoPropertiesAsync(&self) -> windows_core::Result> { + pub fn GetVideoPropertiesAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetVideoPropertiesAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetImagePropertiesAsync(&self) -> windows_core::Result> { + pub fn GetImagePropertiesAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetImagePropertiesAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetDocumentPropertiesAsync(&self) -> windows_core::Result> { + pub fn GetDocumentPropertiesAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetDocumentPropertiesAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RetrievePropertiesAsync(&self, propertiestoretrieve: P0) -> windows_core::Result>> + pub fn RetrievePropertiesAsync(&self, propertiestoretrieve: P0) -> windows_core::Result>> where P0: windows_core::Param>, { @@ -896,7 +896,7 @@ impl StorageItemContentProperties { (windows_core::Interface::vtable(this).RetrievePropertiesAsync)(windows_core::Interface::as_raw(this), propertiestoretrieve.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SavePropertiesAsync(&self, propertiestosave: P0) -> windows_core::Result + pub fn SavePropertiesAsync(&self, propertiestosave: P0) -> windows_core::Result where P0: windows_core::Param>>, { @@ -906,7 +906,7 @@ impl StorageItemContentProperties { (windows_core::Interface::vtable(this).SavePropertiesAsync)(windows_core::Interface::as_raw(this), propertiestosave.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SavePropertiesAsyncOverloadDefault(&self) -> windows_core::Result { + pub fn SavePropertiesAsyncOverloadDefault(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -945,7 +945,7 @@ impl StorageItemThumbnail { (windows_core::Interface::vtable(this).ContentType)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn ReadAsync(&self, buffer: P0, count: u32, options: super::Streams::InputStreamOptions) -> windows_core::Result> + pub fn ReadAsync(&self, buffer: P0, count: u32, options: super::Streams::InputStreamOptions) -> windows_core::Result> where P0: windows_core::Param, { @@ -955,7 +955,7 @@ impl StorageItemThumbnail { (windows_core::Interface::vtable(this).ReadAsync)(windows_core::Interface::as_raw(this), buffer.param().abi(), count, options, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn WriteAsync(&self, buffer: P0) -> windows_core::Result> + pub fn WriteAsync(&self, buffer: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -965,7 +965,7 @@ impl StorageItemThumbnail { (windows_core::Interface::vtable(this).WriteAsync)(windows_core::Interface::as_raw(this), buffer.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FlushAsync(&self) -> windows_core::Result> { + pub fn FlushAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1170,7 +1170,7 @@ pub struct VideoProperties(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(VideoProperties, windows_core::IUnknown, windows_core::IInspectable); windows_core::imp::required_hierarchy!(VideoProperties, IStorageItemExtraProperties); impl VideoProperties { - pub fn RetrievePropertiesAsync(&self, propertiestoretrieve: P0) -> windows_core::Result>> + pub fn RetrievePropertiesAsync(&self, propertiestoretrieve: P0) -> windows_core::Result>> where P0: windows_core::Param>, { @@ -1180,7 +1180,7 @@ impl VideoProperties { (windows_core::Interface::vtable(this).RetrievePropertiesAsync)(windows_core::Interface::as_raw(this), propertiestoretrieve.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SavePropertiesAsync(&self, propertiestosave: P0) -> windows_core::Result + pub fn SavePropertiesAsync(&self, propertiestosave: P0) -> windows_core::Result where P0: windows_core::Param>>, { @@ -1190,7 +1190,7 @@ impl VideoProperties { (windows_core::Interface::vtable(this).SavePropertiesAsync)(windows_core::Interface::as_raw(this), propertiestosave.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SavePropertiesAsyncOverloadDefault(&self) -> windows_core::Result { + pub fn SavePropertiesAsyncOverloadDefault(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Storage/Pickers/mod.rs b/crates/libs/windows/src/Windows/Storage/Pickers/mod.rs index 36252c7d23..3547c5f42b 100644 --- a/crates/libs/windows/src/Windows/Storage/Pickers/mod.rs +++ b/crates/libs/windows/src/Windows/Storage/Pickers/mod.rs @@ -167,7 +167,7 @@ impl FileOpenPicker { } } #[cfg(feature = "Storage_Streams")] - pub fn PickSingleFileAsync(&self) -> windows_core::Result> { + pub fn PickSingleFileAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -175,7 +175,7 @@ impl FileOpenPicker { } } #[cfg(feature = "Storage_Streams")] - pub fn PickMultipleFilesAsync(&self) -> windows_core::Result>> { + pub fn PickMultipleFilesAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -209,7 +209,7 @@ impl FileOpenPicker { } } #[cfg(all(feature = "Storage_Streams", feature = "deprecated"))] - pub fn ResumePickSingleFileAsync() -> windows_core::Result> { + pub fn ResumePickSingleFileAsync() -> windows_core::Result> { Self::IFileOpenPickerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ResumePickSingleFileAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -226,7 +226,7 @@ impl FileOpenPicker { }) } #[cfg(feature = "Storage_Streams")] - pub fn PickSingleFileAsync2(&self, pickeroperationid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn PickSingleFileAsync2(&self, pickeroperationid: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -513,7 +513,7 @@ impl FileSavePicker { unsafe { (windows_core::Interface::vtable(this).SetSuggestedFileName)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(value)).ok() } } #[cfg(feature = "Storage_Streams")] - pub fn PickSaveFileAsync(&self) -> windows_core::Result> { + pub fn PickSaveFileAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -643,7 +643,7 @@ impl FolderPicker { } } #[cfg(feature = "Storage_Search")] - pub fn PickSingleFolderAsync(&self) -> windows_core::Result> { + pub fn PickSingleFolderAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Storage/Provider/mod.rs b/crates/libs/windows/src/Windows/Storage/Provider/mod.rs index f9d0d32005..3374ac0db5 100644 --- a/crates/libs/windows/src/Windows/Storage/Provider/mod.rs +++ b/crates/libs/windows/src/Windows/Storage/Provider/mod.rs @@ -764,7 +764,7 @@ impl windows_core::RuntimeType for IStorageProviderShareLinkSource { } windows_core::imp::interface_hierarchy!(IStorageProviderShareLinkSource, windows_core::IUnknown, windows_core::IInspectable); impl IStorageProviderShareLinkSource { - pub fn CreateLinkAsync(&self, storageitemlist: P0) -> windows_core::Result> + pub fn CreateLinkAsync(&self, storageitemlist: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -774,7 +774,7 @@ impl IStorageProviderShareLinkSource { (windows_core::Interface::vtable(this).CreateLinkAsync)(windows_core::Interface::as_raw(this), storageitemlist.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetDefaultAccessControlStringAsync(&self, storageitemlist: P0) -> windows_core::Result> + pub fn GetDefaultAccessControlStringAsync(&self, storageitemlist: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -784,7 +784,7 @@ impl IStorageProviderShareLinkSource { (windows_core::Interface::vtable(this).GetDefaultAccessControlStringAsync)(windows_core::Interface::as_raw(this), storageitemlist.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetState(&self, storageitemlist: P0) -> windows_core::Result> + pub fn GetState(&self, storageitemlist: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -799,9 +799,9 @@ impl windows_core::RuntimeName for IStorageProviderShareLinkSource { const NAME: &'static str = "Windows.Storage.Provider.IStorageProviderShareLinkSource"; } pub trait IStorageProviderShareLinkSource_Impl: windows_core::IUnknownImpl { - fn CreateLinkAsync(&self, storageItemList: windows_core::Ref<'_, windows_collections::IVectorView>) -> windows_core::Result>; - fn GetDefaultAccessControlStringAsync(&self, storageItemList: windows_core::Ref<'_, windows_collections::IVectorView>) -> windows_core::Result>; - fn GetState(&self, storageItemList: windows_core::Ref<'_, windows_collections::IVectorView>) -> windows_core::Result>; + fn CreateLinkAsync(&self, storageItemList: windows_core::Ref<'_, windows_collections::IVectorView>) -> windows_core::Result>; + fn GetDefaultAccessControlStringAsync(&self, storageItemList: windows_core::Ref<'_, windows_collections::IVectorView>) -> windows_core::Result>; + fn GetState(&self, storageItemList: windows_core::Ref<'_, windows_collections::IVectorView>) -> windows_core::Result>; } impl IStorageProviderShareLinkSource_Vtbl { pub const fn new() -> Self { @@ -1624,7 +1624,7 @@ impl core::ops::Not for StorageProviderInSyncPolicy { } pub struct StorageProviderItemProperties; impl StorageProviderItemProperties { - pub fn SetAsync(item: P0, itemproperties: P1) -> windows_core::Result + pub fn SetAsync(item: P0, itemproperties: P1) -> windows_core::Result where P0: windows_core::Param, P1: windows_core::Param>, diff --git a/crates/libs/windows/src/Windows/Storage/Search/mod.rs b/crates/libs/windows/src/Windows/Storage/Search/mod.rs index 823b297305..19685d78e5 100644 --- a/crates/libs/windows/src/Windows/Storage/Search/mod.rs +++ b/crates/libs/windows/src/Windows/Storage/Search/mod.rs @@ -44,7 +44,7 @@ impl windows_core::RuntimeType for CommonFolderQuery { pub struct ContentIndexer(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(ContentIndexer, windows_core::IUnknown, windows_core::IInspectable); impl ContentIndexer { - pub fn AddAsync(&self, indexablecontent: P0) -> windows_core::Result + pub fn AddAsync(&self, indexablecontent: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -54,7 +54,7 @@ impl ContentIndexer { (windows_core::Interface::vtable(this).AddAsync)(windows_core::Interface::as_raw(this), indexablecontent.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn UpdateAsync(&self, indexablecontent: P0) -> windows_core::Result + pub fn UpdateAsync(&self, indexablecontent: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -64,14 +64,14 @@ impl ContentIndexer { (windows_core::Interface::vtable(this).UpdateAsync)(windows_core::Interface::as_raw(this), indexablecontent.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAsync(&self, contentid: &windows_core::HSTRING) -> windows_core::Result { + pub fn DeleteAsync(&self, contentid: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeleteAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(contentid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteMultipleAsync(&self, contentids: P0) -> windows_core::Result + pub fn DeleteMultipleAsync(&self, contentids: P0) -> windows_core::Result where P0: windows_core::Param>, { @@ -81,14 +81,14 @@ impl ContentIndexer { (windows_core::Interface::vtable(this).DeleteMultipleAsync)(windows_core::Interface::as_raw(this), contentids.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAllAsync(&self) -> windows_core::Result { + pub fn DeleteAllAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeleteAllAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RetrievePropertiesAsync(&self, contentid: &windows_core::HSTRING, propertiestoretrieve: P1) -> windows_core::Result>> + pub fn RetrievePropertiesAsync(&self, contentid: &windows_core::HSTRING, propertiestoretrieve: P1) -> windows_core::Result>> where P1: windows_core::Param>, { @@ -171,35 +171,35 @@ unsafe impl Sync for ContentIndexer {} pub struct ContentIndexerQuery(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(ContentIndexerQuery, windows_core::IUnknown, windows_core::IInspectable); impl ContentIndexerQuery { - pub fn GetCountAsync(&self) -> windows_core::Result> { + pub fn GetCountAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetCountAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetPropertiesAsync(&self) -> windows_core::Result>>> { + pub fn GetPropertiesAsync(&self) -> windows_core::Result>>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetPropertiesAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetPropertiesRangeAsync(&self, startindex: u32, maxitems: u32) -> windows_core::Result>>> { + pub fn GetPropertiesRangeAsync(&self, startindex: u32, maxitems: u32) -> windows_core::Result>>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetPropertiesRangeAsync)(windows_core::Interface::as_raw(this), startindex, maxitems, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAsync(&self) -> windows_core::Result>> { + pub fn GetAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetRangeAsync(&self, startindex: u32, maxitems: u32) -> windows_core::Result>> { + pub fn GetRangeAsync(&self, startindex: u32, maxitems: u32) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -559,7 +559,7 @@ impl windows_core::RuntimeType for IStorageFolderQueryOperations { } windows_core::imp::interface_hierarchy!(IStorageFolderQueryOperations, windows_core::IUnknown, windows_core::IInspectable); impl IStorageFolderQueryOperations { - pub fn GetIndexedStateAsync(&self) -> windows_core::Result> { + pub fn GetIndexedStateAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -632,7 +632,7 @@ impl IStorageFolderQueryOperations { } } #[cfg(feature = "Storage_Streams")] - pub fn GetFilesAsync(&self, query: CommonFileQuery, startindex: u32, maxitemstoretrieve: u32) -> windows_core::Result>> { + pub fn GetFilesAsync(&self, query: CommonFileQuery, startindex: u32, maxitemstoretrieve: u32) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -640,28 +640,28 @@ impl IStorageFolderQueryOperations { } } #[cfg(feature = "Storage_Streams")] - pub fn GetFilesAsyncOverloadDefaultStartAndCount(&self, query: CommonFileQuery) -> windows_core::Result>> { + pub fn GetFilesAsyncOverloadDefaultStartAndCount(&self, query: CommonFileQuery) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFilesAsyncOverloadDefaultStartAndCount)(windows_core::Interface::as_raw(this), query, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetFoldersAsync(&self, query: CommonFolderQuery, startindex: u32, maxitemstoretrieve: u32) -> windows_core::Result>> { + pub fn GetFoldersAsync(&self, query: CommonFolderQuery, startindex: u32, maxitemstoretrieve: u32) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFoldersAsync)(windows_core::Interface::as_raw(this), query, startindex, maxitemstoretrieve, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetFoldersAsyncOverloadDefaultStartAndCount(&self, query: CommonFolderQuery) -> windows_core::Result>> { + pub fn GetFoldersAsyncOverloadDefaultStartAndCount(&self, query: CommonFolderQuery) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFoldersAsyncOverloadDefaultStartAndCount)(windows_core::Interface::as_raw(this), query, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetItemsAsync(&self, startindex: u32, maxitemstoretrieve: u32) -> windows_core::Result>> { + pub fn GetItemsAsync(&self, startindex: u32, maxitemstoretrieve: u32) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -699,7 +699,7 @@ impl windows_core::RuntimeName for IStorageFolderQueryOperations { } #[cfg(feature = "Storage_Streams")] pub trait IStorageFolderQueryOperations_Impl: windows_core::IUnknownImpl { - fn GetIndexedStateAsync(&self) -> windows_core::Result>; + fn GetIndexedStateAsync(&self) -> windows_core::Result>; fn CreateFileQueryOverloadDefault(&self) -> windows_core::Result; fn CreateFileQuery(&self, query: CommonFileQuery) -> windows_core::Result; fn CreateFileQueryWithOptions(&self, queryOptions: windows_core::Ref<'_, QueryOptions>) -> windows_core::Result; @@ -708,11 +708,11 @@ pub trait IStorageFolderQueryOperations_Impl: windows_core::IUnknownImpl { fn CreateFolderQueryWithOptions(&self, queryOptions: windows_core::Ref<'_, QueryOptions>) -> windows_core::Result; fn CreateItemQuery(&self) -> windows_core::Result; fn CreateItemQueryWithOptions(&self, queryOptions: windows_core::Ref<'_, QueryOptions>) -> windows_core::Result; - fn GetFilesAsync(&self, query: CommonFileQuery, startIndex: u32, maxItemsToRetrieve: u32) -> windows_core::Result>>; - fn GetFilesAsyncOverloadDefaultStartAndCount(&self, query: CommonFileQuery) -> windows_core::Result>>; - fn GetFoldersAsync(&self, query: CommonFolderQuery, startIndex: u32, maxItemsToRetrieve: u32) -> windows_core::Result>>; - fn GetFoldersAsyncOverloadDefaultStartAndCount(&self, query: CommonFolderQuery) -> windows_core::Result>>; - fn GetItemsAsync(&self, startIndex: u32, maxItemsToRetrieve: u32) -> windows_core::Result>>; + fn GetFilesAsync(&self, query: CommonFileQuery, startIndex: u32, maxItemsToRetrieve: u32) -> windows_core::Result>>; + fn GetFilesAsyncOverloadDefaultStartAndCount(&self, query: CommonFileQuery) -> windows_core::Result>>; + fn GetFoldersAsync(&self, query: CommonFolderQuery, startIndex: u32, maxItemsToRetrieve: u32) -> windows_core::Result>>; + fn GetFoldersAsyncOverloadDefaultStartAndCount(&self, query: CommonFolderQuery) -> windows_core::Result>>; + fn GetItemsAsync(&self, startIndex: u32, maxItemsToRetrieve: u32) -> windows_core::Result>>; fn AreQueryOptionsSupported(&self, queryOptions: windows_core::Ref<'_, QueryOptions>) -> windows_core::Result; fn IsCommonFolderQuerySupported(&self, query: CommonFolderQuery) -> windows_core::Result; fn IsCommonFileQuerySupported(&self, query: CommonFileQuery) -> windows_core::Result; @@ -1036,7 +1036,7 @@ impl windows_core::RuntimeType for IStorageQueryResultBase { } windows_core::imp::interface_hierarchy!(IStorageQueryResultBase, windows_core::IUnknown, windows_core::IInspectable); impl IStorageQueryResultBase { - pub fn GetItemCountAsync(&self) -> windows_core::Result> { + pub fn GetItemCountAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1078,7 +1078,7 @@ impl IStorageQueryResultBase { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveOptionsChanged)(windows_core::Interface::as_raw(this), eventcookie).ok() } } - pub fn FindStartIndexAsync(&self, value: P0) -> windows_core::Result> + pub fn FindStartIndexAsync(&self, value: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1107,13 +1107,13 @@ impl windows_core::RuntimeName for IStorageQueryResultBase { const NAME: &'static str = "Windows.Storage.Search.IStorageQueryResultBase"; } pub trait IStorageQueryResultBase_Impl: windows_core::IUnknownImpl { - fn GetItemCountAsync(&self) -> windows_core::Result>; + fn GetItemCountAsync(&self) -> windows_core::Result>; fn Folder(&self) -> windows_core::Result; fn ContentsChanged(&self, handler: windows_core::Ref<'_, super::super::Foundation::TypedEventHandler>) -> windows_core::Result; fn RemoveContentsChanged(&self, eventCookie: i64) -> windows_core::Result<()>; fn OptionsChanged(&self, changedHandler: windows_core::Ref<'_, super::super::Foundation::TypedEventHandler>) -> windows_core::Result; fn RemoveOptionsChanged(&self, eventCookie: i64) -> windows_core::Result<()>; - fn FindStartIndexAsync(&self, value: windows_core::Ref<'_, windows_core::IInspectable>) -> windows_core::Result>; + fn FindStartIndexAsync(&self, value: windows_core::Ref<'_, windows_core::IInspectable>) -> windows_core::Result>; fn GetCurrentQueryOptions(&self) -> windows_core::Result; fn ApplyNewQueryOptions(&self, newQueryOptions: windows_core::Ref<'_, QueryOptions>) -> windows_core::Result<()>; } @@ -1633,7 +1633,7 @@ windows_core::imp::interface_hierarchy!(StorageFileQueryResult, windows_core::IU windows_core::imp::required_hierarchy!(StorageFileQueryResult, IStorageQueryResultBase); impl StorageFileQueryResult { #[cfg(feature = "Storage_Streams")] - pub fn GetFilesAsync(&self, startindex: u32, maxnumberofitems: u32) -> windows_core::Result>> { + pub fn GetFilesAsync(&self, startindex: u32, maxnumberofitems: u32) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1641,7 +1641,7 @@ impl StorageFileQueryResult { } } #[cfg(feature = "Storage_Streams")] - pub fn GetFilesAsyncDefaultStartAndCount(&self) -> windows_core::Result>> { + pub fn GetFilesAsyncDefaultStartAndCount(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1659,7 +1659,7 @@ impl StorageFileQueryResult { (windows_core::Interface::vtable(this).GetMatchingPropertiesWithRanges)(windows_core::Interface::as_raw(this), file.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetItemCountAsync(&self) -> windows_core::Result> { + pub fn GetItemCountAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1701,7 +1701,7 @@ impl StorageFileQueryResult { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).RemoveOptionsChanged)(windows_core::Interface::as_raw(this), eventcookie).ok() } } - pub fn FindStartIndexAsync(&self, value: P0) -> windows_core::Result> + pub fn FindStartIndexAsync(&self, value: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1742,21 +1742,21 @@ pub struct StorageFolderQueryResult(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(StorageFolderQueryResult, windows_core::IUnknown, windows_core::IInspectable); windows_core::imp::required_hierarchy!(StorageFolderQueryResult, IStorageQueryResultBase); impl StorageFolderQueryResult { - pub fn GetFoldersAsync(&self, startindex: u32, maxnumberofitems: u32) -> windows_core::Result>> { + pub fn GetFoldersAsync(&self, startindex: u32, maxnumberofitems: u32) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFoldersAsync)(windows_core::Interface::as_raw(this), startindex, maxnumberofitems, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetFoldersAsyncDefaultStartAndCount(&self) -> windows_core::Result>> { + pub fn GetFoldersAsyncDefaultStartAndCount(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFoldersAsyncDefaultStartAndCount)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetItemCountAsync(&self) -> windows_core::Result> { + pub fn GetItemCountAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1798,7 +1798,7 @@ impl StorageFolderQueryResult { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).RemoveOptionsChanged)(windows_core::Interface::as_raw(this), eventcookie).ok() } } - pub fn FindStartIndexAsync(&self, value: P0) -> windows_core::Result> + pub fn FindStartIndexAsync(&self, value: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1839,21 +1839,21 @@ pub struct StorageItemQueryResult(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(StorageItemQueryResult, windows_core::IUnknown, windows_core::IInspectable); windows_core::imp::required_hierarchy!(StorageItemQueryResult, IStorageQueryResultBase); impl StorageItemQueryResult { - pub fn GetItemsAsync(&self, startindex: u32, maxnumberofitems: u32) -> windows_core::Result>> { + pub fn GetItemsAsync(&self, startindex: u32, maxnumberofitems: u32) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetItemsAsync)(windows_core::Interface::as_raw(this), startindex, maxnumberofitems, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetItemsAsyncDefaultStartAndCount(&self) -> windows_core::Result>> { + pub fn GetItemsAsyncDefaultStartAndCount(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetItemsAsyncDefaultStartAndCount)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetItemCountAsync(&self) -> windows_core::Result> { + pub fn GetItemCountAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1895,7 +1895,7 @@ impl StorageItemQueryResult { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).RemoveOptionsChanged)(windows_core::Interface::as_raw(this), eventcookie).ok() } } - pub fn FindStartIndexAsync(&self, value: P0) -> windows_core::Result> + pub fn FindStartIndexAsync(&self, value: P0) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Storage/Streams/mod.rs b/crates/libs/windows/src/Windows/Storage/Streams/mod.rs index f916c2104a..267b23e359 100644 --- a/crates/libs/windows/src/Windows/Storage/Streams/mod.rs +++ b/crates/libs/windows/src/Windows/Storage/Streams/mod.rs @@ -298,7 +298,7 @@ impl windows_core::RuntimeName for DataReader { } unsafe impl Send for DataReader {} unsafe impl Sync for DataReader {} -pub type DataReaderLoadOperation = super::super::Foundation::IAsyncOperation; +pub type DataReaderLoadOperation = windows_async::IAsyncOperation; #[repr(transparent)] #[derive(Clone, Debug, Eq, PartialEq)] pub struct DataWriter(windows_core::IUnknown); @@ -436,7 +436,7 @@ impl DataWriter { (windows_core::Interface::vtable(this).StoreAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FlushAsync(&self) -> windows_core::Result> { + pub fn FlushAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -483,7 +483,7 @@ impl windows_core::RuntimeName for DataWriter { } unsafe impl Send for DataWriter {} unsafe impl Sync for DataWriter {} -pub type DataWriterStoreOperation = super::super::Foundation::IAsyncOperation; +pub type DataWriterStoreOperation = windows_async::IAsyncOperation; #[repr(transparent)] #[derive(Clone, Debug, Eq, PartialEq)] pub struct FileInputStream(windows_core::IUnknown); @@ -494,7 +494,7 @@ impl FileInputStream { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).Close)(windows_core::Interface::as_raw(this)).ok() } } - pub fn ReadAsync(&self, buffer: P0, count: u32, options: InputStreamOptions) -> windows_core::Result> + pub fn ReadAsync(&self, buffer: P0, count: u32, options: InputStreamOptions) -> windows_core::Result> where P0: windows_core::Param, { @@ -543,7 +543,7 @@ impl FileOutputStream { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).Close)(windows_core::Interface::as_raw(this)).ok() } } - pub fn WriteAsync(&self, buffer: P0) -> windows_core::Result> + pub fn WriteAsync(&self, buffer: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -553,7 +553,7 @@ impl FileOutputStream { (windows_core::Interface::vtable(this).WriteAsync)(windows_core::Interface::as_raw(this), buffer.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FlushAsync(&self) -> windows_core::Result> { + pub fn FlushAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -583,32 +583,32 @@ impl FileRandomAccessStream { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).Close)(windows_core::Interface::as_raw(this)).ok() } } - pub fn OpenAsync(filepath: &windows_core::HSTRING, accessmode: super::FileAccessMode) -> windows_core::Result> { + pub fn OpenAsync(filepath: &windows_core::HSTRING, accessmode: super::FileAccessMode) -> windows_core::Result> { Self::IFileRandomAccessStreamStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).OpenAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(filepath), accessmode, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn OpenWithOptionsAsync(filepath: &windows_core::HSTRING, accessmode: super::FileAccessMode, sharingoptions: super::StorageOpenOptions, opendisposition: FileOpenDisposition) -> windows_core::Result> { + pub fn OpenWithOptionsAsync(filepath: &windows_core::HSTRING, accessmode: super::FileAccessMode, sharingoptions: super::StorageOpenOptions, opendisposition: FileOpenDisposition) -> windows_core::Result> { Self::IFileRandomAccessStreamStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).OpenWithOptionsAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(filepath), accessmode, sharingoptions, opendisposition, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn OpenTransactedWriteAsync(filepath: &windows_core::HSTRING) -> windows_core::Result> { + pub fn OpenTransactedWriteAsync(filepath: &windows_core::HSTRING) -> windows_core::Result> { Self::IFileRandomAccessStreamStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).OpenTransactedWriteAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(filepath), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn OpenTransactedWriteWithOptionsAsync(filepath: &windows_core::HSTRING, openoptions: super::StorageOpenOptions, opendisposition: FileOpenDisposition) -> windows_core::Result> { + pub fn OpenTransactedWriteWithOptionsAsync(filepath: &windows_core::HSTRING, openoptions: super::StorageOpenOptions, opendisposition: FileOpenDisposition) -> windows_core::Result> { Self::IFileRandomAccessStreamStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).OpenTransactedWriteWithOptionsAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(filepath), openoptions, opendisposition, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "System")] - pub fn OpenForUserAsync(user: P0, filepath: &windows_core::HSTRING, accessmode: super::FileAccessMode) -> windows_core::Result> + pub fn OpenForUserAsync(user: P0, filepath: &windows_core::HSTRING, accessmode: super::FileAccessMode) -> windows_core::Result> where P0: windows_core::Param, { @@ -618,7 +618,7 @@ impl FileRandomAccessStream { }) } #[cfg(feature = "System")] - pub fn OpenForUserWithOptionsAsync(user: P0, filepath: &windows_core::HSTRING, accessmode: super::FileAccessMode, sharingoptions: super::StorageOpenOptions, opendisposition: FileOpenDisposition) -> windows_core::Result> + pub fn OpenForUserWithOptionsAsync(user: P0, filepath: &windows_core::HSTRING, accessmode: super::FileAccessMode, sharingoptions: super::StorageOpenOptions, opendisposition: FileOpenDisposition) -> windows_core::Result> where P0: windows_core::Param, { @@ -628,7 +628,7 @@ impl FileRandomAccessStream { }) } #[cfg(feature = "System")] - pub fn OpenTransactedWriteForUserAsync(user: P0, filepath: &windows_core::HSTRING) -> windows_core::Result> + pub fn OpenTransactedWriteForUserAsync(user: P0, filepath: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -638,7 +638,7 @@ impl FileRandomAccessStream { }) } #[cfg(feature = "System")] - pub fn OpenTransactedWriteForUserWithOptionsAsync(user: P0, filepath: &windows_core::HSTRING, openoptions: super::StorageOpenOptions, opendisposition: FileOpenDisposition) -> windows_core::Result> + pub fn OpenTransactedWriteForUserWithOptionsAsync(user: P0, filepath: &windows_core::HSTRING, openoptions: super::StorageOpenOptions, opendisposition: FileOpenDisposition) -> windows_core::Result> where P0: windows_core::Param, { @@ -647,7 +647,7 @@ impl FileRandomAccessStream { (windows_core::Interface::vtable(this).OpenTransactedWriteForUserWithOptionsAsync)(windows_core::Interface::as_raw(this), user.param().abi(), core::mem::transmute_copy(filepath), openoptions, opendisposition, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn ReadAsync(&self, buffer: P0, count: u32, options: InputStreamOptions) -> windows_core::Result> + pub fn ReadAsync(&self, buffer: P0, count: u32, options: InputStreamOptions) -> windows_core::Result> where P0: windows_core::Param, { @@ -657,7 +657,7 @@ impl FileRandomAccessStream { (windows_core::Interface::vtable(this).ReadAsync)(windows_core::Interface::as_raw(this), buffer.param().abi(), count, options, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn WriteAsync(&self, buffer: P0) -> windows_core::Result> + pub fn WriteAsync(&self, buffer: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -667,7 +667,7 @@ impl FileRandomAccessStream { (windows_core::Interface::vtable(this).WriteAsync)(windows_core::Interface::as_raw(this), buffer.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FlushAsync(&self) -> windows_core::Result> { + pub fn FlushAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1607,7 +1607,7 @@ impl IDataWriter { (windows_core::Interface::vtable(this).StoreAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FlushAsync(&self) -> windows_core::Result> { + pub fn FlushAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1657,7 +1657,7 @@ pub trait IDataWriter_Impl: windows_core::IUnknownImpl { fn WriteString(&self, value: &windows_core::HSTRING) -> windows_core::Result; fn MeasureString(&self, value: &windows_core::HSTRING) -> windows_core::Result; fn StoreAsync(&self) -> windows_core::Result; - fn FlushAsync(&self) -> windows_core::Result>; + fn FlushAsync(&self) -> windows_core::Result>; fn DetachBuffer(&self) -> windows_core::Result; fn DetachStream(&self) -> windows_core::Result; } @@ -1993,7 +1993,7 @@ impl windows_core::RuntimeType for IInputStream { windows_core::imp::interface_hierarchy!(IInputStream, windows_core::IUnknown, windows_core::IInspectable); windows_core::imp::required_hierarchy!(IInputStream, super::super::Foundation::IClosable); impl IInputStream { - pub fn ReadAsync(&self, buffer: P0, count: u32, options: InputStreamOptions) -> windows_core::Result> + pub fn ReadAsync(&self, buffer: P0, count: u32, options: InputStreamOptions) -> windows_core::Result> where P0: windows_core::Param, { @@ -2012,7 +2012,7 @@ impl windows_core::RuntimeName for IInputStream { const NAME: &'static str = "Windows.Storage.Streams.IInputStream"; } pub trait IInputStream_Impl: super::super::Foundation::IClosable_Impl { - fn ReadAsync(&self, buffer: windows_core::Ref<'_, IBuffer>, count: u32, options: InputStreamOptions) -> windows_core::Result>; + fn ReadAsync(&self, buffer: windows_core::Ref<'_, IBuffer>, count: u32, options: InputStreamOptions) -> windows_core::Result>; } impl IInputStream_Vtbl { pub const fn new() -> Self { @@ -2046,7 +2046,7 @@ impl windows_core::RuntimeType for IInputStreamReference { } windows_core::imp::interface_hierarchy!(IInputStreamReference, windows_core::IUnknown, windows_core::IInspectable); impl IInputStreamReference { - pub fn OpenSequentialReadAsync(&self) -> windows_core::Result> { + pub fn OpenSequentialReadAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2058,7 +2058,7 @@ impl windows_core::RuntimeName for IInputStreamReference { const NAME: &'static str = "Windows.Storage.Streams.IInputStreamReference"; } pub trait IInputStreamReference_Impl: windows_core::IUnknownImpl { - fn OpenSequentialReadAsync(&self) -> windows_core::Result>; + fn OpenSequentialReadAsync(&self) -> windows_core::Result>; } impl IInputStreamReference_Vtbl { pub const fn new() -> Self { @@ -2096,7 +2096,7 @@ impl windows_core::RuntimeType for IOutputStream { windows_core::imp::interface_hierarchy!(IOutputStream, windows_core::IUnknown, windows_core::IInspectable); windows_core::imp::required_hierarchy!(IOutputStream, super::super::Foundation::IClosable); impl IOutputStream { - pub fn WriteAsync(&self, buffer: P0) -> windows_core::Result> + pub fn WriteAsync(&self, buffer: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2106,7 +2106,7 @@ impl IOutputStream { (windows_core::Interface::vtable(this).WriteAsync)(windows_core::Interface::as_raw(this), buffer.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FlushAsync(&self) -> windows_core::Result> { + pub fn FlushAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2122,8 +2122,8 @@ impl windows_core::RuntimeName for IOutputStream { const NAME: &'static str = "Windows.Storage.Streams.IOutputStream"; } pub trait IOutputStream_Impl: super::super::Foundation::IClosable_Impl { - fn WriteAsync(&self, buffer: windows_core::Ref<'_, IBuffer>) -> windows_core::Result>; - fn FlushAsync(&self) -> windows_core::Result>; + fn WriteAsync(&self, buffer: windows_core::Ref<'_, IBuffer>) -> windows_core::Result>; + fn FlushAsync(&self) -> windows_core::Result>; } impl IOutputStream_Vtbl { pub const fn new() -> Self { @@ -2317,7 +2317,7 @@ impl IRandomAccessStream { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).Close)(windows_core::Interface::as_raw(this)).ok() } } - pub fn ReadAsync(&self, buffer: P0, count: u32, options: InputStreamOptions) -> windows_core::Result> + pub fn ReadAsync(&self, buffer: P0, count: u32, options: InputStreamOptions) -> windows_core::Result> where P0: windows_core::Param, { @@ -2327,7 +2327,7 @@ impl IRandomAccessStream { (windows_core::Interface::vtable(this).ReadAsync)(windows_core::Interface::as_raw(this), buffer.param().abi(), count, options, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn WriteAsync(&self, buffer: P0) -> windows_core::Result> + pub fn WriteAsync(&self, buffer: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2337,7 +2337,7 @@ impl IRandomAccessStream { (windows_core::Interface::vtable(this).WriteAsync)(windows_core::Interface::as_raw(this), buffer.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FlushAsync(&self) -> windows_core::Result> { + pub fn FlushAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -2496,7 +2496,7 @@ impl windows_core::RuntimeType for IRandomAccessStreamReference { } windows_core::imp::interface_hierarchy!(IRandomAccessStreamReference, windows_core::IUnknown, windows_core::IInspectable); impl IRandomAccessStreamReference { - pub fn OpenReadAsync(&self) -> windows_core::Result> { + pub fn OpenReadAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2508,7 +2508,7 @@ impl windows_core::RuntimeName for IRandomAccessStreamReference { const NAME: &'static str = "Windows.Storage.Streams.IRandomAccessStreamReference"; } pub trait IRandomAccessStreamReference_Impl: windows_core::IUnknownImpl { - fn OpenReadAsync(&self) -> windows_core::Result>; + fn OpenReadAsync(&self) -> windows_core::Result>; } impl IRandomAccessStreamReference_Vtbl { pub const fn new() -> Self { @@ -2579,7 +2579,7 @@ impl IRandomAccessStreamWithContentType { (windows_core::Interface::vtable(this).ContentType)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn ReadAsync(&self, buffer: P0, count: u32, options: InputStreamOptions) -> windows_core::Result> + pub fn ReadAsync(&self, buffer: P0, count: u32, options: InputStreamOptions) -> windows_core::Result> where P0: windows_core::Param, { @@ -2589,7 +2589,7 @@ impl IRandomAccessStreamWithContentType { (windows_core::Interface::vtable(this).ReadAsync)(windows_core::Interface::as_raw(this), buffer.param().abi(), count, options, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn WriteAsync(&self, buffer: P0) -> windows_core::Result> + pub fn WriteAsync(&self, buffer: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2599,7 +2599,7 @@ impl IRandomAccessStreamWithContentType { (windows_core::Interface::vtable(this).WriteAsync)(windows_core::Interface::as_raw(this), buffer.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FlushAsync(&self) -> windows_core::Result> { + pub fn FlushAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -2697,7 +2697,7 @@ impl InMemoryRandomAccessStream { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).Close)(windows_core::Interface::as_raw(this)).ok() } } - pub fn ReadAsync(&self, buffer: P0, count: u32, options: InputStreamOptions) -> windows_core::Result> + pub fn ReadAsync(&self, buffer: P0, count: u32, options: InputStreamOptions) -> windows_core::Result> where P0: windows_core::Param, { @@ -2707,7 +2707,7 @@ impl InMemoryRandomAccessStream { (windows_core::Interface::vtable(this).ReadAsync)(windows_core::Interface::as_raw(this), buffer.param().abi(), count, options, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn WriteAsync(&self, buffer: P0) -> windows_core::Result> + pub fn WriteAsync(&self, buffer: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2717,7 +2717,7 @@ impl InMemoryRandomAccessStream { (windows_core::Interface::vtable(this).WriteAsync)(windows_core::Interface::as_raw(this), buffer.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FlushAsync(&self) -> windows_core::Result> { + pub fn FlushAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -2851,7 +2851,7 @@ impl InputStreamOverStream { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).Close)(windows_core::Interface::as_raw(this)).ok() } } - pub fn ReadAsync(&self, buffer: P0, count: u32, options: InputStreamOptions) -> windows_core::Result> + pub fn ReadAsync(&self, buffer: P0, count: u32, options: InputStreamOptions) -> windows_core::Result> where P0: windows_core::Param, { @@ -2884,7 +2884,7 @@ impl OutputStreamOverStream { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).Close)(windows_core::Interface::as_raw(this)).ok() } } - pub fn WriteAsync(&self, buffer: P0) -> windows_core::Result> + pub fn WriteAsync(&self, buffer: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2894,7 +2894,7 @@ impl OutputStreamOverStream { (windows_core::Interface::vtable(this).WriteAsync)(windows_core::Interface::as_raw(this), buffer.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FlushAsync(&self) -> windows_core::Result> { + pub fn FlushAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2916,7 +2916,7 @@ unsafe impl Send for OutputStreamOverStream {} unsafe impl Sync for OutputStreamOverStream {} pub struct RandomAccessStream; impl RandomAccessStream { - pub fn CopyAsync(source: P0, destination: P1) -> windows_core::Result> + pub fn CopyAsync(source: P0, destination: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -2926,7 +2926,7 @@ impl RandomAccessStream { (windows_core::Interface::vtable(this).CopyAsync)(windows_core::Interface::as_raw(this), source.param().abi(), destination.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn CopySizeAsync(source: P0, destination: P1, bytestocopy: u64) -> windows_core::Result> + pub fn CopySizeAsync(source: P0, destination: P1, bytestocopy: u64) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -2936,7 +2936,7 @@ impl RandomAccessStream { (windows_core::Interface::vtable(this).CopySizeAsync)(windows_core::Interface::as_raw(this), source.param().abi(), destination.param().abi(), bytestocopy, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn CopyAndCloseAsync(source: P0, destination: P1) -> windows_core::Result> + pub fn CopyAndCloseAsync(source: P0, destination: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -2964,7 +2964,7 @@ impl RandomAccessStreamOverStream { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).Close)(windows_core::Interface::as_raw(this)).ok() } } - pub fn ReadAsync(&self, buffer: P0, count: u32, options: InputStreamOptions) -> windows_core::Result> + pub fn ReadAsync(&self, buffer: P0, count: u32, options: InputStreamOptions) -> windows_core::Result> where P0: windows_core::Param, { @@ -2974,7 +2974,7 @@ impl RandomAccessStreamOverStream { (windows_core::Interface::vtable(this).ReadAsync)(windows_core::Interface::as_raw(this), buffer.param().abi(), count, options, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn WriteAsync(&self, buffer: P0) -> windows_core::Result> + pub fn WriteAsync(&self, buffer: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2984,7 +2984,7 @@ impl RandomAccessStreamOverStream { (windows_core::Interface::vtable(this).WriteAsync)(windows_core::Interface::as_raw(this), buffer.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FlushAsync(&self) -> windows_core::Result> { + pub fn FlushAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -3066,7 +3066,7 @@ unsafe impl Sync for RandomAccessStreamOverStream {} pub struct RandomAccessStreamReference(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(RandomAccessStreamReference, windows_core::IUnknown, windows_core::IInspectable, IRandomAccessStreamReference); impl RandomAccessStreamReference { - pub fn OpenReadAsync(&self) -> windows_core::Result> { + pub fn OpenReadAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Storage/mod.rs b/crates/libs/windows/src/Windows/Storage/mod.rs index 5b109b45d0..36d464741a 100644 --- a/crates/libs/windows/src/Windows/Storage/mod.rs +++ b/crates/libs/windows/src/Windows/Storage/mod.rs @@ -128,7 +128,7 @@ impl ApplicationData { (windows_core::Interface::vtable(this).Version)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn SetVersionAsync(&self, desiredversion: u32, handler: P1) -> windows_core::Result + pub fn SetVersionAsync(&self, desiredversion: u32, handler: P1) -> windows_core::Result where P1: windows_core::Param, { @@ -138,14 +138,14 @@ impl ApplicationData { (windows_core::Interface::vtable(this).SetVersionAsync)(windows_core::Interface::as_raw(this), desiredversion, handler.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ClearAllAsync(&self) -> windows_core::Result { + pub fn ClearAllAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ClearAllAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ClearAsync(&self, locality: ApplicationDataLocality) -> windows_core::Result { + pub fn ClearAsync(&self, locality: ApplicationDataLocality) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -231,7 +231,7 @@ impl ApplicationData { (windows_core::Interface::vtable(this).GetPublisherCacheFolder)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(foldername), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ClearPublisherCacheFolderAsync(&self, foldername: &windows_core::HSTRING) -> windows_core::Result { + pub fn ClearPublisherCacheFolderAsync(&self, foldername: &windows_core::HSTRING) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -253,7 +253,7 @@ impl ApplicationData { }) } #[cfg(feature = "System")] - pub fn GetForUserAsync(user: P0) -> windows_core::Result> + pub fn GetForUserAsync(user: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -686,7 +686,7 @@ impl CachedFileManager { Self::ICachedFileManagerStatics(|this| unsafe { (windows_core::Interface::vtable(this).DeferUpdates)(windows_core::Interface::as_raw(this), file.param().abi()).ok() }) } #[cfg(all(feature = "Storage_Provider", feature = "Storage_Streams"))] - pub fn CompleteUpdatesAsync(file: P0) -> windows_core::Result> + pub fn CompleteUpdatesAsync(file: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -721,35 +721,35 @@ impl windows_core::RuntimeType for CreationCollisionOption { pub struct DownloadsFolder; impl DownloadsFolder { #[cfg(feature = "Storage_Streams")] - pub fn CreateFileAsync(desiredname: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CreateFileAsync(desiredname: &windows_core::HSTRING) -> windows_core::Result> { Self::IDownloadsFolderStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreateFileAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(desiredname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "Storage_Search")] - pub fn CreateFolderAsync(desiredname: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CreateFolderAsync(desiredname: &windows_core::HSTRING) -> windows_core::Result> { Self::IDownloadsFolderStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreateFolderAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(desiredname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "Storage_Streams")] - pub fn CreateFileWithCollisionOptionAsync(desiredname: &windows_core::HSTRING, option: CreationCollisionOption) -> windows_core::Result> { + pub fn CreateFileWithCollisionOptionAsync(desiredname: &windows_core::HSTRING, option: CreationCollisionOption) -> windows_core::Result> { Self::IDownloadsFolderStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreateFileWithCollisionOptionAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(desiredname), option, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "Storage_Search")] - pub fn CreateFolderWithCollisionOptionAsync(desiredname: &windows_core::HSTRING, option: CreationCollisionOption) -> windows_core::Result> { + pub fn CreateFolderWithCollisionOptionAsync(desiredname: &windows_core::HSTRING, option: CreationCollisionOption) -> windows_core::Result> { Self::IDownloadsFolderStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreateFolderWithCollisionOptionAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(desiredname), option, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(all(feature = "Storage_Streams", feature = "System"))] - pub fn CreateFileForUserAsync(user: P0, desiredname: &windows_core::HSTRING) -> windows_core::Result> + pub fn CreateFileForUserAsync(user: P0, desiredname: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -759,7 +759,7 @@ impl DownloadsFolder { }) } #[cfg(all(feature = "Storage_Search", feature = "System"))] - pub fn CreateFolderForUserAsync(user: P0, desiredname: &windows_core::HSTRING) -> windows_core::Result> + pub fn CreateFolderForUserAsync(user: P0, desiredname: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -769,7 +769,7 @@ impl DownloadsFolder { }) } #[cfg(all(feature = "Storage_Streams", feature = "System"))] - pub fn CreateFileForUserWithCollisionOptionAsync(user: P0, desiredname: &windows_core::HSTRING, option: CreationCollisionOption) -> windows_core::Result> + pub fn CreateFileForUserWithCollisionOptionAsync(user: P0, desiredname: &windows_core::HSTRING, option: CreationCollisionOption) -> windows_core::Result> where P0: windows_core::Param, { @@ -779,7 +779,7 @@ impl DownloadsFolder { }) } #[cfg(all(feature = "Storage_Search", feature = "System"))] - pub fn CreateFolderForUserWithCollisionOptionAsync(user: P0, desiredname: &windows_core::HSTRING, option: CreationCollisionOption) -> windows_core::Result> + pub fn CreateFolderForUserWithCollisionOptionAsync(user: P0, desiredname: &windows_core::HSTRING, option: CreationCollisionOption) -> windows_core::Result> where P0: windows_core::Param, { @@ -866,7 +866,7 @@ impl core::ops::Not for FileAttributes { pub struct FileIO; impl FileIO { #[cfg(feature = "Storage_Streams")] - pub fn ReadTextAsync(file: P0) -> windows_core::Result> + pub fn ReadTextAsync(file: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -876,7 +876,7 @@ impl FileIO { }) } #[cfg(feature = "Storage_Streams")] - pub fn ReadTextWithEncodingAsync(file: P0, encoding: Streams::UnicodeEncoding) -> windows_core::Result> + pub fn ReadTextWithEncodingAsync(file: P0, encoding: Streams::UnicodeEncoding) -> windows_core::Result> where P0: windows_core::Param, { @@ -886,7 +886,7 @@ impl FileIO { }) } #[cfg(feature = "Storage_Streams")] - pub fn WriteTextAsync(file: P0, contents: &windows_core::HSTRING) -> windows_core::Result + pub fn WriteTextAsync(file: P0, contents: &windows_core::HSTRING) -> windows_core::Result where P0: windows_core::Param, { @@ -896,7 +896,7 @@ impl FileIO { }) } #[cfg(feature = "Storage_Streams")] - pub fn WriteTextWithEncodingAsync(file: P0, contents: &windows_core::HSTRING, encoding: Streams::UnicodeEncoding) -> windows_core::Result + pub fn WriteTextWithEncodingAsync(file: P0, contents: &windows_core::HSTRING, encoding: Streams::UnicodeEncoding) -> windows_core::Result where P0: windows_core::Param, { @@ -906,7 +906,7 @@ impl FileIO { }) } #[cfg(feature = "Storage_Streams")] - pub fn AppendTextAsync(file: P0, contents: &windows_core::HSTRING) -> windows_core::Result + pub fn AppendTextAsync(file: P0, contents: &windows_core::HSTRING) -> windows_core::Result where P0: windows_core::Param, { @@ -916,7 +916,7 @@ impl FileIO { }) } #[cfg(feature = "Storage_Streams")] - pub fn AppendTextWithEncodingAsync(file: P0, contents: &windows_core::HSTRING, encoding: Streams::UnicodeEncoding) -> windows_core::Result + pub fn AppendTextWithEncodingAsync(file: P0, contents: &windows_core::HSTRING, encoding: Streams::UnicodeEncoding) -> windows_core::Result where P0: windows_core::Param, { @@ -926,7 +926,7 @@ impl FileIO { }) } #[cfg(feature = "Storage_Streams")] - pub fn ReadLinesAsync(file: P0) -> windows_core::Result>> + pub fn ReadLinesAsync(file: P0) -> windows_core::Result>> where P0: windows_core::Param, { @@ -936,7 +936,7 @@ impl FileIO { }) } #[cfg(feature = "Storage_Streams")] - pub fn ReadLinesWithEncodingAsync(file: P0, encoding: Streams::UnicodeEncoding) -> windows_core::Result>> + pub fn ReadLinesWithEncodingAsync(file: P0, encoding: Streams::UnicodeEncoding) -> windows_core::Result>> where P0: windows_core::Param, { @@ -946,7 +946,7 @@ impl FileIO { }) } #[cfg(feature = "Storage_Streams")] - pub fn WriteLinesAsync(file: P0, lines: P1) -> windows_core::Result + pub fn WriteLinesAsync(file: P0, lines: P1) -> windows_core::Result where P0: windows_core::Param, P1: windows_core::Param>, @@ -957,7 +957,7 @@ impl FileIO { }) } #[cfg(feature = "Storage_Streams")] - pub fn WriteLinesWithEncodingAsync(file: P0, lines: P1, encoding: Streams::UnicodeEncoding) -> windows_core::Result + pub fn WriteLinesWithEncodingAsync(file: P0, lines: P1, encoding: Streams::UnicodeEncoding) -> windows_core::Result where P0: windows_core::Param, P1: windows_core::Param>, @@ -968,7 +968,7 @@ impl FileIO { }) } #[cfg(feature = "Storage_Streams")] - pub fn AppendLinesAsync(file: P0, lines: P1) -> windows_core::Result + pub fn AppendLinesAsync(file: P0, lines: P1) -> windows_core::Result where P0: windows_core::Param, P1: windows_core::Param>, @@ -979,7 +979,7 @@ impl FileIO { }) } #[cfg(feature = "Storage_Streams")] - pub fn AppendLinesWithEncodingAsync(file: P0, lines: P1, encoding: Streams::UnicodeEncoding) -> windows_core::Result + pub fn AppendLinesWithEncodingAsync(file: P0, lines: P1, encoding: Streams::UnicodeEncoding) -> windows_core::Result where P0: windows_core::Param, P1: windows_core::Param>, @@ -990,7 +990,7 @@ impl FileIO { }) } #[cfg(feature = "Storage_Streams")] - pub fn ReadBufferAsync(file: P0) -> windows_core::Result> + pub fn ReadBufferAsync(file: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1000,7 +1000,7 @@ impl FileIO { }) } #[cfg(feature = "Storage_Streams")] - pub fn WriteBufferAsync(file: P0, buffer: P1) -> windows_core::Result + pub fn WriteBufferAsync(file: P0, buffer: P1) -> windows_core::Result where P0: windows_core::Param, P1: windows_core::Param, @@ -1011,7 +1011,7 @@ impl FileIO { }) } #[cfg(feature = "Storage_Streams")] - pub fn WriteBytesAsync(file: P0, buffer: &[u8]) -> windows_core::Result + pub fn WriteBytesAsync(file: P0, buffer: &[u8]) -> windows_core::Result where P0: windows_core::Param, { @@ -1501,21 +1501,21 @@ impl IStorageFile { (windows_core::Interface::vtable(this).ContentType)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn OpenAsync(&self, accessmode: FileAccessMode) -> windows_core::Result> { + pub fn OpenAsync(&self, accessmode: FileAccessMode) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).OpenAsync)(windows_core::Interface::as_raw(this), accessmode, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn OpenTransactedWriteAsync(&self) -> windows_core::Result> { + pub fn OpenTransactedWriteAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).OpenTransactedWriteAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CopyOverloadDefaultNameAndOptions(&self, destinationfolder: P0) -> windows_core::Result> + pub fn CopyOverloadDefaultNameAndOptions(&self, destinationfolder: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1525,7 +1525,7 @@ impl IStorageFile { (windows_core::Interface::vtable(this).CopyOverloadDefaultNameAndOptions)(windows_core::Interface::as_raw(this), destinationfolder.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CopyOverloadDefaultOptions(&self, destinationfolder: P0, desirednewname: &windows_core::HSTRING) -> windows_core::Result> + pub fn CopyOverloadDefaultOptions(&self, destinationfolder: P0, desirednewname: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -1535,7 +1535,7 @@ impl IStorageFile { (windows_core::Interface::vtable(this).CopyOverloadDefaultOptions)(windows_core::Interface::as_raw(this), destinationfolder.param().abi(), core::mem::transmute_copy(desirednewname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CopyOverload(&self, destinationfolder: P0, desirednewname: &windows_core::HSTRING, option: NameCollisionOption) -> windows_core::Result> + pub fn CopyOverload(&self, destinationfolder: P0, desirednewname: &windows_core::HSTRING, option: NameCollisionOption) -> windows_core::Result> where P0: windows_core::Param, { @@ -1545,7 +1545,7 @@ impl IStorageFile { (windows_core::Interface::vtable(this).CopyOverload)(windows_core::Interface::as_raw(this), destinationfolder.param().abi(), core::mem::transmute_copy(desirednewname), option, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CopyAndReplaceAsync(&self, filetoreplace: P0) -> windows_core::Result + pub fn CopyAndReplaceAsync(&self, filetoreplace: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -1555,7 +1555,7 @@ impl IStorageFile { (windows_core::Interface::vtable(this).CopyAndReplaceAsync)(windows_core::Interface::as_raw(this), filetoreplace.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn MoveOverloadDefaultNameAndOptions(&self, destinationfolder: P0) -> windows_core::Result + pub fn MoveOverloadDefaultNameAndOptions(&self, destinationfolder: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -1565,7 +1565,7 @@ impl IStorageFile { (windows_core::Interface::vtable(this).MoveOverloadDefaultNameAndOptions)(windows_core::Interface::as_raw(this), destinationfolder.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn MoveOverloadDefaultOptions(&self, destinationfolder: P0, desirednewname: &windows_core::HSTRING) -> windows_core::Result + pub fn MoveOverloadDefaultOptions(&self, destinationfolder: P0, desirednewname: &windows_core::HSTRING) -> windows_core::Result where P0: windows_core::Param, { @@ -1575,7 +1575,7 @@ impl IStorageFile { (windows_core::Interface::vtable(this).MoveOverloadDefaultOptions)(windows_core::Interface::as_raw(this), destinationfolder.param().abi(), core::mem::transmute_copy(desirednewname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn MoveOverload(&self, destinationfolder: P0, desirednewname: &windows_core::HSTRING, option: NameCollisionOption) -> windows_core::Result + pub fn MoveOverload(&self, destinationfolder: P0, desirednewname: &windows_core::HSTRING, option: NameCollisionOption) -> windows_core::Result where P0: windows_core::Param, { @@ -1585,7 +1585,7 @@ impl IStorageFile { (windows_core::Interface::vtable(this).MoveOverload)(windows_core::Interface::as_raw(this), destinationfolder.param().abi(), core::mem::transmute_copy(desirednewname), option, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn MoveAndReplaceAsync(&self, filetoreplace: P0) -> windows_core::Result + pub fn MoveAndReplaceAsync(&self, filetoreplace: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -1595,42 +1595,42 @@ impl IStorageFile { (windows_core::Interface::vtable(this).MoveAndReplaceAsync)(windows_core::Interface::as_raw(this), filetoreplace.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn OpenSequentialReadAsync(&self) -> windows_core::Result> { + pub fn OpenSequentialReadAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).OpenSequentialReadAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn OpenReadAsync(&self) -> windows_core::Result> { + pub fn OpenReadAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).OpenReadAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RenameAsyncOverloadDefaultOptions(&self, desiredname: &windows_core::HSTRING) -> windows_core::Result { + pub fn RenameAsyncOverloadDefaultOptions(&self, desiredname: &windows_core::HSTRING) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RenameAsyncOverloadDefaultOptions)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(desiredname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RenameAsync(&self, desiredname: &windows_core::HSTRING, option: NameCollisionOption) -> windows_core::Result { + pub fn RenameAsync(&self, desiredname: &windows_core::HSTRING, option: NameCollisionOption) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RenameAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(desiredname), option, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAsyncOverloadDefaultOptions(&self) -> windows_core::Result { + pub fn DeleteAsyncOverloadDefaultOptions(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeleteAsyncOverloadDefaultOptions)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAsync(&self, option: StorageDeleteOption) -> windows_core::Result { + pub fn DeleteAsync(&self, option: StorageDeleteOption) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1638,7 +1638,7 @@ impl IStorageFile { } } #[cfg(feature = "Storage_FileProperties")] - pub fn GetBasicPropertiesAsync(&self) -> windows_core::Result> { + pub fn GetBasicPropertiesAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1689,16 +1689,16 @@ impl windows_core::RuntimeName for IStorageFile { pub trait IStorageFile_Impl: Streams::IInputStreamReference_Impl + Streams::IRandomAccessStreamReference_Impl + IStorageItem_Impl { fn FileType(&self) -> windows_core::Result; fn ContentType(&self) -> windows_core::Result; - fn OpenAsync(&self, accessMode: FileAccessMode) -> windows_core::Result>; - fn OpenTransactedWriteAsync(&self) -> windows_core::Result>; - fn CopyOverloadDefaultNameAndOptions(&self, destinationFolder: windows_core::Ref<'_, IStorageFolder>) -> windows_core::Result>; - fn CopyOverloadDefaultOptions(&self, destinationFolder: windows_core::Ref<'_, IStorageFolder>, desiredNewName: &windows_core::HSTRING) -> windows_core::Result>; - fn CopyOverload(&self, destinationFolder: windows_core::Ref<'_, IStorageFolder>, desiredNewName: &windows_core::HSTRING, option: NameCollisionOption) -> windows_core::Result>; - fn CopyAndReplaceAsync(&self, fileToReplace: windows_core::Ref<'_, IStorageFile>) -> windows_core::Result; - fn MoveOverloadDefaultNameAndOptions(&self, destinationFolder: windows_core::Ref<'_, IStorageFolder>) -> windows_core::Result; - fn MoveOverloadDefaultOptions(&self, destinationFolder: windows_core::Ref<'_, IStorageFolder>, desiredNewName: &windows_core::HSTRING) -> windows_core::Result; - fn MoveOverload(&self, destinationFolder: windows_core::Ref<'_, IStorageFolder>, desiredNewName: &windows_core::HSTRING, option: NameCollisionOption) -> windows_core::Result; - fn MoveAndReplaceAsync(&self, fileToReplace: windows_core::Ref<'_, IStorageFile>) -> windows_core::Result; + fn OpenAsync(&self, accessMode: FileAccessMode) -> windows_core::Result>; + fn OpenTransactedWriteAsync(&self) -> windows_core::Result>; + fn CopyOverloadDefaultNameAndOptions(&self, destinationFolder: windows_core::Ref<'_, IStorageFolder>) -> windows_core::Result>; + fn CopyOverloadDefaultOptions(&self, destinationFolder: windows_core::Ref<'_, IStorageFolder>, desiredNewName: &windows_core::HSTRING) -> windows_core::Result>; + fn CopyOverload(&self, destinationFolder: windows_core::Ref<'_, IStorageFolder>, desiredNewName: &windows_core::HSTRING, option: NameCollisionOption) -> windows_core::Result>; + fn CopyAndReplaceAsync(&self, fileToReplace: windows_core::Ref<'_, IStorageFile>) -> windows_core::Result; + fn MoveOverloadDefaultNameAndOptions(&self, destinationFolder: windows_core::Ref<'_, IStorageFolder>) -> windows_core::Result; + fn MoveOverloadDefaultOptions(&self, destinationFolder: windows_core::Ref<'_, IStorageFolder>, desiredNewName: &windows_core::HSTRING) -> windows_core::Result; + fn MoveOverload(&self, destinationFolder: windows_core::Ref<'_, IStorageFolder>, desiredNewName: &windows_core::HSTRING, option: NameCollisionOption) -> windows_core::Result; + fn MoveAndReplaceAsync(&self, fileToReplace: windows_core::Ref<'_, IStorageFile>) -> windows_core::Result; } #[cfg(all(feature = "Storage_FileProperties", feature = "Storage_Streams"))] impl IStorageFile_Vtbl { @@ -1903,14 +1903,14 @@ impl windows_core::RuntimeType for IStorageFile2 { windows_core::imp::interface_hierarchy!(IStorageFile2, windows_core::IUnknown, windows_core::IInspectable); impl IStorageFile2 { #[cfg(feature = "Storage_Streams")] - pub fn OpenWithOptionsAsync(&self, accessmode: FileAccessMode, options: StorageOpenOptions) -> windows_core::Result> { + pub fn OpenWithOptionsAsync(&self, accessmode: FileAccessMode, options: StorageOpenOptions) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).OpenWithOptionsAsync)(windows_core::Interface::as_raw(this), accessmode, options, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn OpenTransactedWriteWithOptionsAsync(&self, options: StorageOpenOptions) -> windows_core::Result> { + pub fn OpenTransactedWriteWithOptionsAsync(&self, options: StorageOpenOptions) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1924,8 +1924,8 @@ impl windows_core::RuntimeName for IStorageFile2 { } #[cfg(feature = "Storage_Streams")] pub trait IStorageFile2_Impl: windows_core::IUnknownImpl { - fn OpenWithOptionsAsync(&self, accessMode: FileAccessMode, options: StorageOpenOptions) -> windows_core::Result>; - fn OpenTransactedWriteWithOptionsAsync(&self, options: StorageOpenOptions) -> windows_core::Result>; + fn OpenWithOptionsAsync(&self, accessMode: FileAccessMode, options: StorageOpenOptions) -> windows_core::Result>; + fn OpenTransactedWriteWithOptionsAsync(&self, options: StorageOpenOptions) -> windows_core::Result>; } #[cfg(feature = "Storage_Streams")] impl IStorageFile2_Vtbl { @@ -2075,7 +2075,7 @@ windows_core::imp::interface_hierarchy!(IStorageFolder, windows_core::IUnknown, windows_core::imp::required_hierarchy!(IStorageFolder, IStorageItem); impl IStorageFolder { #[cfg(feature = "Storage_Streams")] - pub fn CreateFileAsyncOverloadDefaultOptions(&self, desiredname: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CreateFileAsyncOverloadDefaultOptions(&self, desiredname: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2083,7 +2083,7 @@ impl IStorageFolder { } } #[cfg(feature = "Storage_Streams")] - pub fn CreateFileAsync(&self, desiredname: &windows_core::HSTRING, options: CreationCollisionOption) -> windows_core::Result> { + pub fn CreateFileAsync(&self, desiredname: &windows_core::HSTRING, options: CreationCollisionOption) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2091,7 +2091,7 @@ impl IStorageFolder { } } #[cfg(feature = "Storage_Search")] - pub fn CreateFolderAsyncOverloadDefaultOptions(&self, desiredname: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CreateFolderAsyncOverloadDefaultOptions(&self, desiredname: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2099,7 +2099,7 @@ impl IStorageFolder { } } #[cfg(feature = "Storage_Search")] - pub fn CreateFolderAsync(&self, desiredname: &windows_core::HSTRING, options: CreationCollisionOption) -> windows_core::Result> { + pub fn CreateFolderAsync(&self, desiredname: &windows_core::HSTRING, options: CreationCollisionOption) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2107,7 +2107,7 @@ impl IStorageFolder { } } #[cfg(feature = "Storage_Streams")] - pub fn GetFileAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetFileAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2115,14 +2115,14 @@ impl IStorageFolder { } } #[cfg(feature = "Storage_Search")] - pub fn GetFolderAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetFolderAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFolderAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(name), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetItemAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetItemAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2130,7 +2130,7 @@ impl IStorageFolder { } } #[cfg(feature = "Storage_Streams")] - pub fn GetFilesAsyncOverloadDefaultOptionsStartAndCount(&self) -> windows_core::Result>> { + pub fn GetFilesAsyncOverloadDefaultOptionsStartAndCount(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2138,42 +2138,42 @@ impl IStorageFolder { } } #[cfg(feature = "Storage_Search")] - pub fn GetFoldersAsyncOverloadDefaultOptionsStartAndCount(&self) -> windows_core::Result>> { + pub fn GetFoldersAsyncOverloadDefaultOptionsStartAndCount(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFoldersAsyncOverloadDefaultOptionsStartAndCount)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetItemsAsyncOverloadDefaultStartAndCount(&self) -> windows_core::Result>> { + pub fn GetItemsAsyncOverloadDefaultStartAndCount(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetItemsAsyncOverloadDefaultStartAndCount)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RenameAsyncOverloadDefaultOptions(&self, desiredname: &windows_core::HSTRING) -> windows_core::Result { + pub fn RenameAsyncOverloadDefaultOptions(&self, desiredname: &windows_core::HSTRING) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RenameAsyncOverloadDefaultOptions)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(desiredname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RenameAsync(&self, desiredname: &windows_core::HSTRING, option: NameCollisionOption) -> windows_core::Result { + pub fn RenameAsync(&self, desiredname: &windows_core::HSTRING, option: NameCollisionOption) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RenameAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(desiredname), option, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAsyncOverloadDefaultOptions(&self) -> windows_core::Result { + pub fn DeleteAsyncOverloadDefaultOptions(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeleteAsyncOverloadDefaultOptions)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAsync(&self, option: StorageDeleteOption) -> windows_core::Result { + pub fn DeleteAsync(&self, option: StorageDeleteOption) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -2181,7 +2181,7 @@ impl IStorageFolder { } } #[cfg(feature = "Storage_FileProperties")] - pub fn GetBasicPropertiesAsync(&self) -> windows_core::Result> { + pub fn GetBasicPropertiesAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -2230,16 +2230,16 @@ impl windows_core::RuntimeName for IStorageFolder { } #[cfg(all(feature = "Storage_FileProperties", feature = "Storage_Search", feature = "Storage_Streams"))] pub trait IStorageFolder_Impl: IStorageItem_Impl { - fn CreateFileAsyncOverloadDefaultOptions(&self, desiredName: &windows_core::HSTRING) -> windows_core::Result>; - fn CreateFileAsync(&self, desiredName: &windows_core::HSTRING, options: CreationCollisionOption) -> windows_core::Result>; - fn CreateFolderAsyncOverloadDefaultOptions(&self, desiredName: &windows_core::HSTRING) -> windows_core::Result>; - fn CreateFolderAsync(&self, desiredName: &windows_core::HSTRING, options: CreationCollisionOption) -> windows_core::Result>; - fn GetFileAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result>; - fn GetFolderAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result>; - fn GetItemAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result>; - fn GetFilesAsyncOverloadDefaultOptionsStartAndCount(&self) -> windows_core::Result>>; - fn GetFoldersAsyncOverloadDefaultOptionsStartAndCount(&self) -> windows_core::Result>>; - fn GetItemsAsyncOverloadDefaultStartAndCount(&self) -> windows_core::Result>>; + fn CreateFileAsyncOverloadDefaultOptions(&self, desiredName: &windows_core::HSTRING) -> windows_core::Result>; + fn CreateFileAsync(&self, desiredName: &windows_core::HSTRING, options: CreationCollisionOption) -> windows_core::Result>; + fn CreateFolderAsyncOverloadDefaultOptions(&self, desiredName: &windows_core::HSTRING) -> windows_core::Result>; + fn CreateFolderAsync(&self, desiredName: &windows_core::HSTRING, options: CreationCollisionOption) -> windows_core::Result>; + fn GetFileAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result>; + fn GetFolderAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result>; + fn GetItemAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result>; + fn GetFilesAsyncOverloadDefaultOptionsStartAndCount(&self) -> windows_core::Result>>; + fn GetFoldersAsyncOverloadDefaultOptionsStartAndCount(&self) -> windows_core::Result>>; + fn GetItemsAsyncOverloadDefaultStartAndCount(&self) -> windows_core::Result>>; } #[cfg(all(feature = "Storage_FileProperties", feature = "Storage_Search", feature = "Storage_Streams"))] impl IStorageFolder_Vtbl { @@ -2436,7 +2436,7 @@ impl windows_core::RuntimeType for IStorageFolder2 { } windows_core::imp::interface_hierarchy!(IStorageFolder2, windows_core::IUnknown, windows_core::IInspectable); impl IStorageFolder2 { - pub fn TryGetItemAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { + pub fn TryGetItemAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2448,7 +2448,7 @@ impl windows_core::RuntimeName for IStorageFolder2 { const NAME: &'static str = "Windows.Storage.IStorageFolder2"; } pub trait IStorageFolder2_Impl: windows_core::IUnknownImpl { - fn TryGetItemAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result>; + fn TryGetItemAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result>; } impl IStorageFolder2_Vtbl { pub const fn new() -> Self { @@ -2515,28 +2515,28 @@ impl windows_core::RuntimeType for IStorageItem { } windows_core::imp::interface_hierarchy!(IStorageItem, windows_core::IUnknown, windows_core::IInspectable); impl IStorageItem { - pub fn RenameAsyncOverloadDefaultOptions(&self, desiredname: &windows_core::HSTRING) -> windows_core::Result { + pub fn RenameAsyncOverloadDefaultOptions(&self, desiredname: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RenameAsyncOverloadDefaultOptions)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(desiredname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RenameAsync(&self, desiredname: &windows_core::HSTRING, option: NameCollisionOption) -> windows_core::Result { + pub fn RenameAsync(&self, desiredname: &windows_core::HSTRING, option: NameCollisionOption) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RenameAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(desiredname), option, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAsyncOverloadDefaultOptions(&self) -> windows_core::Result { + pub fn DeleteAsyncOverloadDefaultOptions(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeleteAsyncOverloadDefaultOptions)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAsync(&self, option: StorageDeleteOption) -> windows_core::Result { + pub fn DeleteAsync(&self, option: StorageDeleteOption) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2544,7 +2544,7 @@ impl IStorageItem { } } #[cfg(feature = "Storage_FileProperties")] - pub fn GetBasicPropertiesAsync(&self) -> windows_core::Result> { + pub fn GetBasicPropertiesAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2593,11 +2593,11 @@ impl windows_core::RuntimeName for IStorageItem { } #[cfg(feature = "Storage_FileProperties")] pub trait IStorageItem_Impl: windows_core::IUnknownImpl { - fn RenameAsyncOverloadDefaultOptions(&self, desiredName: &windows_core::HSTRING) -> windows_core::Result; - fn RenameAsync(&self, desiredName: &windows_core::HSTRING, option: NameCollisionOption) -> windows_core::Result; - fn DeleteAsyncOverloadDefaultOptions(&self) -> windows_core::Result; - fn DeleteAsync(&self, option: StorageDeleteOption) -> windows_core::Result; - fn GetBasicPropertiesAsync(&self) -> windows_core::Result>; + fn RenameAsyncOverloadDefaultOptions(&self, desiredName: &windows_core::HSTRING) -> windows_core::Result; + fn RenameAsync(&self, desiredName: &windows_core::HSTRING, option: NameCollisionOption) -> windows_core::Result; + fn DeleteAsyncOverloadDefaultOptions(&self) -> windows_core::Result; + fn DeleteAsync(&self, option: StorageDeleteOption) -> windows_core::Result; + fn GetBasicPropertiesAsync(&self) -> windows_core::Result>; fn Name(&self) -> windows_core::Result; fn Path(&self) -> windows_core::Result; fn Attributes(&self) -> windows_core::Result; @@ -2777,7 +2777,7 @@ windows_core::imp::interface_hierarchy!(IStorageItem2, windows_core::IUnknown, w windows_core::imp::required_hierarchy!(IStorageItem2, IStorageItem); impl IStorageItem2 { #[cfg(feature = "Storage_Search")] - pub fn GetParentAsync(&self) -> windows_core::Result> { + pub fn GetParentAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2794,28 +2794,28 @@ impl IStorageItem2 { (windows_core::Interface::vtable(this).IsEqual)(windows_core::Interface::as_raw(this), item.param().abi(), &mut result__).map(|| result__) } } - pub fn RenameAsyncOverloadDefaultOptions(&self, desiredname: &windows_core::HSTRING) -> windows_core::Result { + pub fn RenameAsyncOverloadDefaultOptions(&self, desiredname: &windows_core::HSTRING) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RenameAsyncOverloadDefaultOptions)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(desiredname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RenameAsync(&self, desiredname: &windows_core::HSTRING, option: NameCollisionOption) -> windows_core::Result { + pub fn RenameAsync(&self, desiredname: &windows_core::HSTRING, option: NameCollisionOption) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RenameAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(desiredname), option, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAsyncOverloadDefaultOptions(&self) -> windows_core::Result { + pub fn DeleteAsyncOverloadDefaultOptions(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeleteAsyncOverloadDefaultOptions)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAsync(&self, option: StorageDeleteOption) -> windows_core::Result { + pub fn DeleteAsync(&self, option: StorageDeleteOption) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -2823,7 +2823,7 @@ impl IStorageItem2 { } } #[cfg(feature = "Storage_FileProperties")] - pub fn GetBasicPropertiesAsync(&self) -> windows_core::Result> { + pub fn GetBasicPropertiesAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -2872,7 +2872,7 @@ impl windows_core::RuntimeName for IStorageItem2 { } #[cfg(all(feature = "Storage_FileProperties", feature = "Storage_Search"))] pub trait IStorageItem2_Impl: IStorageItem_Impl { - fn GetParentAsync(&self) -> windows_core::Result>; + fn GetParentAsync(&self) -> windows_core::Result>; fn IsEqual(&self, item: windows_core::Ref<'_, IStorageItem>) -> windows_core::Result; } #[cfg(all(feature = "Storage_FileProperties", feature = "Storage_Search"))] @@ -2929,7 +2929,7 @@ impl windows_core::RuntimeType for IStorageItemProperties { windows_core::imp::interface_hierarchy!(IStorageItemProperties, windows_core::IUnknown, windows_core::IInspectable); impl IStorageItemProperties { #[cfg(all(feature = "Storage_FileProperties", feature = "Storage_Streams"))] - pub fn GetThumbnailAsyncOverloadDefaultSizeDefaultOptions(&self, mode: FileProperties::ThumbnailMode) -> windows_core::Result> { + pub fn GetThumbnailAsyncOverloadDefaultSizeDefaultOptions(&self, mode: FileProperties::ThumbnailMode) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2937,7 +2937,7 @@ impl IStorageItemProperties { } } #[cfg(all(feature = "Storage_FileProperties", feature = "Storage_Streams"))] - pub fn GetThumbnailAsyncOverloadDefaultOptions(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32) -> windows_core::Result> { + pub fn GetThumbnailAsyncOverloadDefaultOptions(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2945,7 +2945,7 @@ impl IStorageItemProperties { } } #[cfg(all(feature = "Storage_FileProperties", feature = "Storage_Streams"))] - pub fn GetThumbnailAsync(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32, options: FileProperties::ThumbnailOptions) -> windows_core::Result> { + pub fn GetThumbnailAsync(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32, options: FileProperties::ThumbnailOptions) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2988,9 +2988,9 @@ impl windows_core::RuntimeName for IStorageItemProperties { } #[cfg(all(feature = "Storage_FileProperties", feature = "Storage_Streams"))] pub trait IStorageItemProperties_Impl: windows_core::IUnknownImpl { - fn GetThumbnailAsyncOverloadDefaultSizeDefaultOptions(&self, mode: FileProperties::ThumbnailMode) -> windows_core::Result>; - fn GetThumbnailAsyncOverloadDefaultOptions(&self, mode: FileProperties::ThumbnailMode, requestedSize: u32) -> windows_core::Result>; - fn GetThumbnailAsync(&self, mode: FileProperties::ThumbnailMode, requestedSize: u32, options: FileProperties::ThumbnailOptions) -> windows_core::Result>; + fn GetThumbnailAsyncOverloadDefaultSizeDefaultOptions(&self, mode: FileProperties::ThumbnailMode) -> windows_core::Result>; + fn GetThumbnailAsyncOverloadDefaultOptions(&self, mode: FileProperties::ThumbnailMode, requestedSize: u32) -> windows_core::Result>; + fn GetThumbnailAsync(&self, mode: FileProperties::ThumbnailMode, requestedSize: u32, options: FileProperties::ThumbnailOptions) -> windows_core::Result>; fn DisplayName(&self) -> windows_core::Result; fn DisplayType(&self) -> windows_core::Result; fn FolderRelativeId(&self) -> windows_core::Result; @@ -3136,7 +3136,7 @@ windows_core::imp::interface_hierarchy!(IStorageItemProperties2, windows_core::I windows_core::imp::required_hierarchy!(IStorageItemProperties2, IStorageItemProperties); impl IStorageItemProperties2 { #[cfg(all(feature = "Storage_FileProperties", feature = "Storage_Streams"))] - pub fn GetScaledImageAsThumbnailAsyncOverloadDefaultSizeDefaultOptions(&self, mode: FileProperties::ThumbnailMode) -> windows_core::Result> { + pub fn GetScaledImageAsThumbnailAsyncOverloadDefaultSizeDefaultOptions(&self, mode: FileProperties::ThumbnailMode) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -3144,7 +3144,7 @@ impl IStorageItemProperties2 { } } #[cfg(all(feature = "Storage_FileProperties", feature = "Storage_Streams"))] - pub fn GetScaledImageAsThumbnailAsyncOverloadDefaultOptions(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32) -> windows_core::Result> { + pub fn GetScaledImageAsThumbnailAsyncOverloadDefaultOptions(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -3152,7 +3152,7 @@ impl IStorageItemProperties2 { } } #[cfg(all(feature = "Storage_FileProperties", feature = "Storage_Streams"))] - pub fn GetScaledImageAsThumbnailAsync(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32, options: FileProperties::ThumbnailOptions) -> windows_core::Result> { + pub fn GetScaledImageAsThumbnailAsync(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32, options: FileProperties::ThumbnailOptions) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -3160,7 +3160,7 @@ impl IStorageItemProperties2 { } } #[cfg(all(feature = "Storage_FileProperties", feature = "Storage_Streams"))] - pub fn GetThumbnailAsyncOverloadDefaultSizeDefaultOptions(&self, mode: FileProperties::ThumbnailMode) -> windows_core::Result> { + pub fn GetThumbnailAsyncOverloadDefaultSizeDefaultOptions(&self, mode: FileProperties::ThumbnailMode) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -3168,7 +3168,7 @@ impl IStorageItemProperties2 { } } #[cfg(all(feature = "Storage_FileProperties", feature = "Storage_Streams"))] - pub fn GetThumbnailAsyncOverloadDefaultOptions(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32) -> windows_core::Result> { + pub fn GetThumbnailAsyncOverloadDefaultOptions(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -3176,7 +3176,7 @@ impl IStorageItemProperties2 { } } #[cfg(all(feature = "Storage_FileProperties", feature = "Storage_Streams"))] - pub fn GetThumbnailAsync(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32, options: FileProperties::ThumbnailOptions) -> windows_core::Result> { + pub fn GetThumbnailAsync(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32, options: FileProperties::ThumbnailOptions) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -3219,9 +3219,9 @@ impl windows_core::RuntimeName for IStorageItemProperties2 { } #[cfg(all(feature = "Storage_FileProperties", feature = "Storage_Streams"))] pub trait IStorageItemProperties2_Impl: IStorageItemProperties_Impl { - fn GetScaledImageAsThumbnailAsyncOverloadDefaultSizeDefaultOptions(&self, mode: FileProperties::ThumbnailMode) -> windows_core::Result>; - fn GetScaledImageAsThumbnailAsyncOverloadDefaultOptions(&self, mode: FileProperties::ThumbnailMode, requestedSize: u32) -> windows_core::Result>; - fn GetScaledImageAsThumbnailAsync(&self, mode: FileProperties::ThumbnailMode, requestedSize: u32, options: FileProperties::ThumbnailOptions) -> windows_core::Result>; + fn GetScaledImageAsThumbnailAsyncOverloadDefaultSizeDefaultOptions(&self, mode: FileProperties::ThumbnailMode) -> windows_core::Result>; + fn GetScaledImageAsThumbnailAsyncOverloadDefaultOptions(&self, mode: FileProperties::ThumbnailMode, requestedSize: u32) -> windows_core::Result>; + fn GetScaledImageAsThumbnailAsync(&self, mode: FileProperties::ThumbnailMode, requestedSize: u32, options: FileProperties::ThumbnailOptions) -> windows_core::Result>; } #[cfg(all(feature = "Storage_FileProperties", feature = "Storage_Streams"))] impl IStorageItemProperties2_Vtbl { @@ -3307,7 +3307,7 @@ impl IStorageItemPropertiesWithProvider { } } #[cfg(all(feature = "Storage_FileProperties", feature = "Storage_Streams"))] - pub fn GetThumbnailAsyncOverloadDefaultSizeDefaultOptions(&self, mode: FileProperties::ThumbnailMode) -> windows_core::Result> { + pub fn GetThumbnailAsyncOverloadDefaultSizeDefaultOptions(&self, mode: FileProperties::ThumbnailMode) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -3315,7 +3315,7 @@ impl IStorageItemPropertiesWithProvider { } } #[cfg(all(feature = "Storage_FileProperties", feature = "Storage_Streams"))] - pub fn GetThumbnailAsyncOverloadDefaultOptions(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32) -> windows_core::Result> { + pub fn GetThumbnailAsyncOverloadDefaultOptions(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -3323,7 +3323,7 @@ impl IStorageItemPropertiesWithProvider { } } #[cfg(all(feature = "Storage_FileProperties", feature = "Storage_Streams"))] - pub fn GetThumbnailAsync(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32, options: FileProperties::ThumbnailOptions) -> windows_core::Result> { + pub fn GetThumbnailAsync(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32, options: FileProperties::ThumbnailOptions) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -3909,7 +3909,7 @@ impl KnownFolders { }) } #[cfg(all(feature = "Storage_Search", feature = "System"))] - pub fn GetFolderForUserAsync(user: P0, folderid: KnownFolderId) -> windows_core::Result> + pub fn GetFolderForUserAsync(user: P0, folderid: KnownFolderId) -> windows_core::Result> where P0: windows_core::Param, { @@ -3918,14 +3918,14 @@ impl KnownFolders { (windows_core::Interface::vtable(this).GetFolderForUserAsync)(windows_core::Interface::as_raw(this), user.param().abi(), folderid, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RequestAccessAsync(folderid: KnownFolderId) -> windows_core::Result> { + pub fn RequestAccessAsync(folderid: KnownFolderId) -> windows_core::Result> { Self::IKnownFoldersStatics4(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestAccessAsync)(windows_core::Interface::as_raw(this), folderid, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "System")] - pub fn RequestAccessForUserAsync(user: P0, folderid: KnownFolderId) -> windows_core::Result> + pub fn RequestAccessForUserAsync(user: P0, folderid: KnownFolderId) -> windows_core::Result> where P0: windows_core::Param, { @@ -3935,7 +3935,7 @@ impl KnownFolders { }) } #[cfg(feature = "Storage_Search")] - pub fn GetFolderAsync(folderid: KnownFolderId) -> windows_core::Result> { + pub fn GetFolderAsync(folderid: KnownFolderId) -> windows_core::Result> { Self::IKnownFoldersStatics4(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFolderAsync)(windows_core::Interface::as_raw(this), folderid, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -4021,59 +4021,59 @@ impl windows_core::RuntimeType for NameCollisionOption { } pub struct PathIO; impl PathIO { - pub fn ReadTextAsync(absolutepath: &windows_core::HSTRING) -> windows_core::Result> { + pub fn ReadTextAsync(absolutepath: &windows_core::HSTRING) -> windows_core::Result> { Self::IPathIOStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReadTextAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(absolutepath), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "Storage_Streams")] - pub fn ReadTextWithEncodingAsync(absolutepath: &windows_core::HSTRING, encoding: Streams::UnicodeEncoding) -> windows_core::Result> { + pub fn ReadTextWithEncodingAsync(absolutepath: &windows_core::HSTRING, encoding: Streams::UnicodeEncoding) -> windows_core::Result> { Self::IPathIOStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReadTextWithEncodingAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(absolutepath), encoding, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn WriteTextAsync(absolutepath: &windows_core::HSTRING, contents: &windows_core::HSTRING) -> windows_core::Result { + pub fn WriteTextAsync(absolutepath: &windows_core::HSTRING, contents: &windows_core::HSTRING) -> windows_core::Result { Self::IPathIOStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).WriteTextAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(absolutepath), core::mem::transmute_copy(contents), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "Storage_Streams")] - pub fn WriteTextWithEncodingAsync(absolutepath: &windows_core::HSTRING, contents: &windows_core::HSTRING, encoding: Streams::UnicodeEncoding) -> windows_core::Result { + pub fn WriteTextWithEncodingAsync(absolutepath: &windows_core::HSTRING, contents: &windows_core::HSTRING, encoding: Streams::UnicodeEncoding) -> windows_core::Result { Self::IPathIOStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).WriteTextWithEncodingAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(absolutepath), core::mem::transmute_copy(contents), encoding, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn AppendTextAsync(absolutepath: &windows_core::HSTRING, contents: &windows_core::HSTRING) -> windows_core::Result { + pub fn AppendTextAsync(absolutepath: &windows_core::HSTRING, contents: &windows_core::HSTRING) -> windows_core::Result { Self::IPathIOStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).AppendTextAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(absolutepath), core::mem::transmute_copy(contents), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "Storage_Streams")] - pub fn AppendTextWithEncodingAsync(absolutepath: &windows_core::HSTRING, contents: &windows_core::HSTRING, encoding: Streams::UnicodeEncoding) -> windows_core::Result { + pub fn AppendTextWithEncodingAsync(absolutepath: &windows_core::HSTRING, contents: &windows_core::HSTRING, encoding: Streams::UnicodeEncoding) -> windows_core::Result { Self::IPathIOStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).AppendTextWithEncodingAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(absolutepath), core::mem::transmute_copy(contents), encoding, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn ReadLinesAsync(absolutepath: &windows_core::HSTRING) -> windows_core::Result>> { + pub fn ReadLinesAsync(absolutepath: &windows_core::HSTRING) -> windows_core::Result>> { Self::IPathIOStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReadLinesAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(absolutepath), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "Storage_Streams")] - pub fn ReadLinesWithEncodingAsync(absolutepath: &windows_core::HSTRING, encoding: Streams::UnicodeEncoding) -> windows_core::Result>> { + pub fn ReadLinesWithEncodingAsync(absolutepath: &windows_core::HSTRING, encoding: Streams::UnicodeEncoding) -> windows_core::Result>> { Self::IPathIOStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReadLinesWithEncodingAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(absolutepath), encoding, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn WriteLinesAsync(absolutepath: &windows_core::HSTRING, lines: P1) -> windows_core::Result + pub fn WriteLinesAsync(absolutepath: &windows_core::HSTRING, lines: P1) -> windows_core::Result where P1: windows_core::Param>, { @@ -4083,7 +4083,7 @@ impl PathIO { }) } #[cfg(feature = "Storage_Streams")] - pub fn WriteLinesWithEncodingAsync(absolutepath: &windows_core::HSTRING, lines: P1, encoding: Streams::UnicodeEncoding) -> windows_core::Result + pub fn WriteLinesWithEncodingAsync(absolutepath: &windows_core::HSTRING, lines: P1, encoding: Streams::UnicodeEncoding) -> windows_core::Result where P1: windows_core::Param>, { @@ -4092,7 +4092,7 @@ impl PathIO { (windows_core::Interface::vtable(this).WriteLinesWithEncodingAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(absolutepath), lines.param().abi(), encoding, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn AppendLinesAsync(absolutepath: &windows_core::HSTRING, lines: P1) -> windows_core::Result + pub fn AppendLinesAsync(absolutepath: &windows_core::HSTRING, lines: P1) -> windows_core::Result where P1: windows_core::Param>, { @@ -4102,7 +4102,7 @@ impl PathIO { }) } #[cfg(feature = "Storage_Streams")] - pub fn AppendLinesWithEncodingAsync(absolutepath: &windows_core::HSTRING, lines: P1, encoding: Streams::UnicodeEncoding) -> windows_core::Result + pub fn AppendLinesWithEncodingAsync(absolutepath: &windows_core::HSTRING, lines: P1, encoding: Streams::UnicodeEncoding) -> windows_core::Result where P1: windows_core::Param>, { @@ -4112,14 +4112,14 @@ impl PathIO { }) } #[cfg(feature = "Storage_Streams")] - pub fn ReadBufferAsync(absolutepath: &windows_core::HSTRING) -> windows_core::Result> { + pub fn ReadBufferAsync(absolutepath: &windows_core::HSTRING) -> windows_core::Result> { Self::IPathIOStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReadBufferAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(absolutepath), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "Storage_Streams")] - pub fn WriteBufferAsync(absolutepath: &windows_core::HSTRING, buffer: P1) -> windows_core::Result + pub fn WriteBufferAsync(absolutepath: &windows_core::HSTRING, buffer: P1) -> windows_core::Result where P1: windows_core::Param, { @@ -4128,7 +4128,7 @@ impl PathIO { (windows_core::Interface::vtable(this).WriteBufferAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(absolutepath), buffer.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn WriteBytesAsync(absolutepath: &windows_core::HSTRING, buffer: &[u8]) -> windows_core::Result { + pub fn WriteBytesAsync(absolutepath: &windows_core::HSTRING, buffer: &[u8]) -> windows_core::Result { Self::IPathIOStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).WriteBytesAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(absolutepath), buffer.len().try_into().unwrap(), buffer.as_ptr(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -4226,14 +4226,14 @@ windows_core::imp::interface_hierarchy!(StorageFile, windows_core::IUnknown, win windows_core::imp::required_hierarchy!(StorageFile, Streams::IInputStreamReference, Streams::IRandomAccessStreamReference, IStorageFile2, IStorageFilePropertiesWithAvailability, IStorageItem, IStorageItem2, IStorageItemProperties, IStorageItemProperties2, IStorageItemPropertiesWithProvider); #[cfg(feature = "Storage_Streams")] impl StorageFile { - pub fn OpenSequentialReadAsync(&self) -> windows_core::Result> { + pub fn OpenSequentialReadAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).OpenSequentialReadAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn OpenReadAsync(&self) -> windows_core::Result> { + pub fn OpenReadAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -4254,21 +4254,21 @@ impl StorageFile { (windows_core::Interface::vtable(this).ContentType)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn OpenAsync(&self, accessmode: FileAccessMode) -> windows_core::Result> { + pub fn OpenAsync(&self, accessmode: FileAccessMode) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).OpenAsync)(windows_core::Interface::as_raw(this), accessmode, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn OpenTransactedWriteAsync(&self) -> windows_core::Result> { + pub fn OpenTransactedWriteAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).OpenTransactedWriteAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CopyOverloadDefaultNameAndOptions(&self, destinationfolder: P0) -> windows_core::Result> + pub fn CopyOverloadDefaultNameAndOptions(&self, destinationfolder: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -4278,7 +4278,7 @@ impl StorageFile { (windows_core::Interface::vtable(this).CopyOverloadDefaultNameAndOptions)(windows_core::Interface::as_raw(this), destinationfolder.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CopyOverloadDefaultOptions(&self, destinationfolder: P0, desirednewname: &windows_core::HSTRING) -> windows_core::Result> + pub fn CopyOverloadDefaultOptions(&self, destinationfolder: P0, desirednewname: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -4288,7 +4288,7 @@ impl StorageFile { (windows_core::Interface::vtable(this).CopyOverloadDefaultOptions)(windows_core::Interface::as_raw(this), destinationfolder.param().abi(), core::mem::transmute_copy(desirednewname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CopyOverload(&self, destinationfolder: P0, desirednewname: &windows_core::HSTRING, option: NameCollisionOption) -> windows_core::Result> + pub fn CopyOverload(&self, destinationfolder: P0, desirednewname: &windows_core::HSTRING, option: NameCollisionOption) -> windows_core::Result> where P0: windows_core::Param, { @@ -4298,7 +4298,7 @@ impl StorageFile { (windows_core::Interface::vtable(this).CopyOverload)(windows_core::Interface::as_raw(this), destinationfolder.param().abi(), core::mem::transmute_copy(desirednewname), option, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CopyAndReplaceAsync(&self, filetoreplace: P0) -> windows_core::Result + pub fn CopyAndReplaceAsync(&self, filetoreplace: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -4308,7 +4308,7 @@ impl StorageFile { (windows_core::Interface::vtable(this).CopyAndReplaceAsync)(windows_core::Interface::as_raw(this), filetoreplace.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn MoveOverloadDefaultNameAndOptions(&self, destinationfolder: P0) -> windows_core::Result + pub fn MoveOverloadDefaultNameAndOptions(&self, destinationfolder: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -4318,7 +4318,7 @@ impl StorageFile { (windows_core::Interface::vtable(this).MoveOverloadDefaultNameAndOptions)(windows_core::Interface::as_raw(this), destinationfolder.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn MoveOverloadDefaultOptions(&self, destinationfolder: P0, desirednewname: &windows_core::HSTRING) -> windows_core::Result + pub fn MoveOverloadDefaultOptions(&self, destinationfolder: P0, desirednewname: &windows_core::HSTRING) -> windows_core::Result where P0: windows_core::Param, { @@ -4328,7 +4328,7 @@ impl StorageFile { (windows_core::Interface::vtable(this).MoveOverloadDefaultOptions)(windows_core::Interface::as_raw(this), destinationfolder.param().abi(), core::mem::transmute_copy(desirednewname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn MoveOverload(&self, destinationfolder: P0, desirednewname: &windows_core::HSTRING, option: NameCollisionOption) -> windows_core::Result + pub fn MoveOverload(&self, destinationfolder: P0, desirednewname: &windows_core::HSTRING, option: NameCollisionOption) -> windows_core::Result where P0: windows_core::Param, { @@ -4338,7 +4338,7 @@ impl StorageFile { (windows_core::Interface::vtable(this).MoveOverload)(windows_core::Interface::as_raw(this), destinationfolder.param().abi(), core::mem::transmute_copy(desirednewname), option, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn MoveAndReplaceAsync(&self, filetoreplace: P0) -> windows_core::Result + pub fn MoveAndReplaceAsync(&self, filetoreplace: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -4348,14 +4348,14 @@ impl StorageFile { (windows_core::Interface::vtable(this).MoveAndReplaceAsync)(windows_core::Interface::as_raw(this), filetoreplace.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn OpenWithOptionsAsync(&self, accessmode: FileAccessMode, options: StorageOpenOptions) -> windows_core::Result> { + pub fn OpenWithOptionsAsync(&self, accessmode: FileAccessMode, options: StorageOpenOptions) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).OpenWithOptionsAsync)(windows_core::Interface::as_raw(this), accessmode, options, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn OpenTransactedWriteWithOptionsAsync(&self, options: StorageOpenOptions) -> windows_core::Result> { + pub fn OpenTransactedWriteWithOptionsAsync(&self, options: StorageOpenOptions) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -4369,13 +4369,13 @@ impl StorageFile { (windows_core::Interface::vtable(this).IsAvailable)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn GetFileFromPathAsync(path: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetFileFromPathAsync(path: &windows_core::HSTRING) -> windows_core::Result> { Self::IStorageFileStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFileFromPathAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(path), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetFileFromApplicationUriAsync(uri: P0) -> windows_core::Result> + pub fn GetFileFromApplicationUriAsync(uri: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -4384,7 +4384,7 @@ impl StorageFile { (windows_core::Interface::vtable(this).GetFileFromApplicationUriAsync)(windows_core::Interface::as_raw(this), uri.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn CreateStreamedFileAsync(displaynamewithextension: &windows_core::HSTRING, datarequested: P1, thumbnail: P2) -> windows_core::Result> + pub fn CreateStreamedFileAsync(displaynamewithextension: &windows_core::HSTRING, datarequested: P1, thumbnail: P2) -> windows_core::Result> where P1: windows_core::Param, P2: windows_core::Param, @@ -4394,7 +4394,7 @@ impl StorageFile { (windows_core::Interface::vtable(this).CreateStreamedFileAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(displaynamewithextension), datarequested.param().abi(), thumbnail.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn ReplaceWithStreamedFileAsync(filetoreplace: P0, datarequested: P1, thumbnail: P2) -> windows_core::Result> + pub fn ReplaceWithStreamedFileAsync(filetoreplace: P0, datarequested: P1, thumbnail: P2) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -4405,7 +4405,7 @@ impl StorageFile { (windows_core::Interface::vtable(this).ReplaceWithStreamedFileAsync)(windows_core::Interface::as_raw(this), filetoreplace.param().abi(), datarequested.param().abi(), thumbnail.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn CreateStreamedFileFromUriAsync(displaynamewithextension: &windows_core::HSTRING, uri: P1, thumbnail: P2) -> windows_core::Result> + pub fn CreateStreamedFileFromUriAsync(displaynamewithextension: &windows_core::HSTRING, uri: P1, thumbnail: P2) -> windows_core::Result> where P1: windows_core::Param, P2: windows_core::Param, @@ -4415,7 +4415,7 @@ impl StorageFile { (windows_core::Interface::vtable(this).CreateStreamedFileFromUriAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(displaynamewithextension), uri.param().abi(), thumbnail.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn ReplaceWithStreamedFileFromUriAsync(filetoreplace: P0, uri: P1, thumbnail: P2) -> windows_core::Result> + pub fn ReplaceWithStreamedFileFromUriAsync(filetoreplace: P0, uri: P1, thumbnail: P2) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -4427,7 +4427,7 @@ impl StorageFile { }) } #[cfg(feature = "System")] - pub fn GetFileFromPathForUserAsync(user: P0, path: &windows_core::HSTRING) -> windows_core::Result> + pub fn GetFileFromPathForUserAsync(user: P0, path: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -4436,28 +4436,28 @@ impl StorageFile { (windows_core::Interface::vtable(this).GetFileFromPathForUserAsync)(windows_core::Interface::as_raw(this), user.param().abi(), core::mem::transmute_copy(path), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RenameAsyncOverloadDefaultOptions(&self, desiredname: &windows_core::HSTRING) -> windows_core::Result { + pub fn RenameAsyncOverloadDefaultOptions(&self, desiredname: &windows_core::HSTRING) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RenameAsyncOverloadDefaultOptions)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(desiredname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RenameAsync(&self, desiredname: &windows_core::HSTRING, option: NameCollisionOption) -> windows_core::Result { + pub fn RenameAsync(&self, desiredname: &windows_core::HSTRING, option: NameCollisionOption) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RenameAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(desiredname), option, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAsyncOverloadDefaultOptions(&self) -> windows_core::Result { + pub fn DeleteAsyncOverloadDefaultOptions(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeleteAsyncOverloadDefaultOptions)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAsync(&self, option: StorageDeleteOption) -> windows_core::Result { + pub fn DeleteAsync(&self, option: StorageDeleteOption) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -4465,7 +4465,7 @@ impl StorageFile { } } #[cfg(feature = "Storage_FileProperties")] - pub fn GetBasicPropertiesAsync(&self) -> windows_core::Result> { + pub fn GetBasicPropertiesAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -4508,7 +4508,7 @@ impl StorageFile { } } #[cfg(feature = "Storage_Search")] - pub fn GetParentAsync(&self) -> windows_core::Result> { + pub fn GetParentAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -4526,7 +4526,7 @@ impl StorageFile { } } #[cfg(feature = "Storage_FileProperties")] - pub fn GetThumbnailAsyncOverloadDefaultSizeDefaultOptions(&self, mode: FileProperties::ThumbnailMode) -> windows_core::Result> { + pub fn GetThumbnailAsyncOverloadDefaultSizeDefaultOptions(&self, mode: FileProperties::ThumbnailMode) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -4534,7 +4534,7 @@ impl StorageFile { } } #[cfg(feature = "Storage_FileProperties")] - pub fn GetThumbnailAsyncOverloadDefaultOptions(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32) -> windows_core::Result> { + pub fn GetThumbnailAsyncOverloadDefaultOptions(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -4542,7 +4542,7 @@ impl StorageFile { } } #[cfg(feature = "Storage_FileProperties")] - pub fn GetThumbnailAsync(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32, options: FileProperties::ThumbnailOptions) -> windows_core::Result> { + pub fn GetThumbnailAsync(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32, options: FileProperties::ThumbnailOptions) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -4579,7 +4579,7 @@ impl StorageFile { } } #[cfg(feature = "Storage_FileProperties")] - pub fn GetScaledImageAsThumbnailAsyncOverloadDefaultSizeDefaultOptions(&self, mode: FileProperties::ThumbnailMode) -> windows_core::Result> { + pub fn GetScaledImageAsThumbnailAsyncOverloadDefaultSizeDefaultOptions(&self, mode: FileProperties::ThumbnailMode) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -4587,7 +4587,7 @@ impl StorageFile { } } #[cfg(feature = "Storage_FileProperties")] - pub fn GetScaledImageAsThumbnailAsyncOverloadDefaultOptions(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32) -> windows_core::Result> { + pub fn GetScaledImageAsThumbnailAsyncOverloadDefaultOptions(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -4595,7 +4595,7 @@ impl StorageFile { } } #[cfg(feature = "Storage_FileProperties")] - pub fn GetScaledImageAsThumbnailAsync(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32, options: FileProperties::ThumbnailOptions) -> windows_core::Result> { + pub fn GetScaledImageAsThumbnailAsync(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32, options: FileProperties::ThumbnailOptions) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -4642,7 +4642,7 @@ windows_core::imp::required_hierarchy!(StorageFolder, IStorageFolder2, Search::I #[cfg(feature = "Storage_Search")] impl StorageFolder { #[cfg(feature = "Storage_Streams")] - pub fn CreateFileAsyncOverloadDefaultOptions(&self, desiredname: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CreateFileAsyncOverloadDefaultOptions(&self, desiredname: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -4650,21 +4650,21 @@ impl StorageFolder { } } #[cfg(feature = "Storage_Streams")] - pub fn CreateFileAsync(&self, desiredname: &windows_core::HSTRING, options: CreationCollisionOption) -> windows_core::Result> { + pub fn CreateFileAsync(&self, desiredname: &windows_core::HSTRING, options: CreationCollisionOption) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreateFileAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(desiredname), options, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateFolderAsyncOverloadDefaultOptions(&self, desiredname: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CreateFolderAsyncOverloadDefaultOptions(&self, desiredname: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreateFolderAsyncOverloadDefaultOptions)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(desiredname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateFolderAsync(&self, desiredname: &windows_core::HSTRING, options: CreationCollisionOption) -> windows_core::Result> { + pub fn CreateFolderAsync(&self, desiredname: &windows_core::HSTRING, options: CreationCollisionOption) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -4672,21 +4672,21 @@ impl StorageFolder { } } #[cfg(feature = "Storage_Streams")] - pub fn GetFileAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetFileAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFileAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(name), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetFolderAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetFolderAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFolderAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(name), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetItemAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetItemAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -4694,28 +4694,28 @@ impl StorageFolder { } } #[cfg(feature = "Storage_Streams")] - pub fn GetFilesAsyncOverloadDefaultOptionsStartAndCount(&self) -> windows_core::Result>> { + pub fn GetFilesAsyncOverloadDefaultOptionsStartAndCount(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFilesAsyncOverloadDefaultOptionsStartAndCount)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetFoldersAsyncOverloadDefaultOptionsStartAndCount(&self) -> windows_core::Result>> { + pub fn GetFoldersAsyncOverloadDefaultOptionsStartAndCount(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFoldersAsyncOverloadDefaultOptionsStartAndCount)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetItemsAsyncOverloadDefaultStartAndCount(&self) -> windows_core::Result>> { + pub fn GetItemsAsyncOverloadDefaultStartAndCount(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetItemsAsyncOverloadDefaultStartAndCount)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryGetItemAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { + pub fn TryGetItemAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -4729,7 +4729,7 @@ impl StorageFolder { (windows_core::Interface::vtable(this).TryGetChangeTracker)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetIndexedStateAsync(&self) -> windows_core::Result> { + pub fn GetIndexedStateAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -4802,7 +4802,7 @@ impl StorageFolder { } } #[cfg(feature = "Storage_Streams")] - pub fn GetFilesAsync(&self, query: Search::CommonFileQuery, startindex: u32, maxitemstoretrieve: u32) -> windows_core::Result>> { + pub fn GetFilesAsync(&self, query: Search::CommonFileQuery, startindex: u32, maxitemstoretrieve: u32) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -4810,28 +4810,28 @@ impl StorageFolder { } } #[cfg(feature = "Storage_Streams")] - pub fn GetFilesAsyncOverloadDefaultStartAndCount(&self, query: Search::CommonFileQuery) -> windows_core::Result>> { + pub fn GetFilesAsyncOverloadDefaultStartAndCount(&self, query: Search::CommonFileQuery) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFilesAsyncOverloadDefaultStartAndCount)(windows_core::Interface::as_raw(this), query, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetFoldersAsync(&self, query: Search::CommonFolderQuery, startindex: u32, maxitemstoretrieve: u32) -> windows_core::Result>> { + pub fn GetFoldersAsync(&self, query: Search::CommonFolderQuery, startindex: u32, maxitemstoretrieve: u32) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFoldersAsync)(windows_core::Interface::as_raw(this), query, startindex, maxitemstoretrieve, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetFoldersAsyncOverloadDefaultStartAndCount(&self, query: Search::CommonFolderQuery) -> windows_core::Result>> { + pub fn GetFoldersAsyncOverloadDefaultStartAndCount(&self, query: Search::CommonFolderQuery) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFoldersAsyncOverloadDefaultStartAndCount)(windows_core::Interface::as_raw(this), query, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetItemsAsync(&self, startindex: u32, maxitemstoretrieve: u32) -> windows_core::Result>> { + pub fn GetItemsAsync(&self, startindex: u32, maxitemstoretrieve: u32) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -4862,14 +4862,14 @@ impl StorageFolder { (windows_core::Interface::vtable(this).IsCommonFileQuerySupported)(windows_core::Interface::as_raw(this), query, &mut result__).map(|| result__) } } - pub fn GetFolderFromPathAsync(path: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetFolderFromPathAsync(path: &windows_core::HSTRING) -> windows_core::Result> { Self::IStorageFolderStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFolderFromPathAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(path), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "System")] - pub fn GetFolderFromPathForUserAsync(user: P0, path: &windows_core::HSTRING) -> windows_core::Result> + pub fn GetFolderFromPathForUserAsync(user: P0, path: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -4878,28 +4878,28 @@ impl StorageFolder { (windows_core::Interface::vtable(this).GetFolderFromPathForUserAsync)(windows_core::Interface::as_raw(this), user.param().abi(), core::mem::transmute_copy(path), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RenameAsyncOverloadDefaultOptions(&self, desiredname: &windows_core::HSTRING) -> windows_core::Result { + pub fn RenameAsyncOverloadDefaultOptions(&self, desiredname: &windows_core::HSTRING) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RenameAsyncOverloadDefaultOptions)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(desiredname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RenameAsync(&self, desiredname: &windows_core::HSTRING, option: NameCollisionOption) -> windows_core::Result { + pub fn RenameAsync(&self, desiredname: &windows_core::HSTRING, option: NameCollisionOption) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RenameAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(desiredname), option, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAsyncOverloadDefaultOptions(&self) -> windows_core::Result { + pub fn DeleteAsyncOverloadDefaultOptions(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeleteAsyncOverloadDefaultOptions)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAsync(&self, option: StorageDeleteOption) -> windows_core::Result { + pub fn DeleteAsync(&self, option: StorageDeleteOption) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -4907,7 +4907,7 @@ impl StorageFolder { } } #[cfg(feature = "Storage_FileProperties")] - pub fn GetBasicPropertiesAsync(&self) -> windows_core::Result> { + pub fn GetBasicPropertiesAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -4949,7 +4949,7 @@ impl StorageFolder { (windows_core::Interface::vtable(this).IsOfType)(windows_core::Interface::as_raw(this), r#type, &mut result__).map(|| result__) } } - pub fn GetParentAsync(&self) -> windows_core::Result> { + pub fn GetParentAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -4967,7 +4967,7 @@ impl StorageFolder { } } #[cfg(all(feature = "Storage_FileProperties", feature = "Storage_Streams"))] - pub fn GetThumbnailAsyncOverloadDefaultSizeDefaultOptions(&self, mode: FileProperties::ThumbnailMode) -> windows_core::Result> { + pub fn GetThumbnailAsyncOverloadDefaultSizeDefaultOptions(&self, mode: FileProperties::ThumbnailMode) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -4975,7 +4975,7 @@ impl StorageFolder { } } #[cfg(all(feature = "Storage_FileProperties", feature = "Storage_Streams"))] - pub fn GetThumbnailAsyncOverloadDefaultOptions(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32) -> windows_core::Result> { + pub fn GetThumbnailAsyncOverloadDefaultOptions(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -4983,7 +4983,7 @@ impl StorageFolder { } } #[cfg(all(feature = "Storage_FileProperties", feature = "Storage_Streams"))] - pub fn GetThumbnailAsync(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32, options: FileProperties::ThumbnailOptions) -> windows_core::Result> { + pub fn GetThumbnailAsync(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32, options: FileProperties::ThumbnailOptions) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -5020,7 +5020,7 @@ impl StorageFolder { } } #[cfg(all(feature = "Storage_FileProperties", feature = "Storage_Streams"))] - pub fn GetScaledImageAsThumbnailAsyncOverloadDefaultSizeDefaultOptions(&self, mode: FileProperties::ThumbnailMode) -> windows_core::Result> { + pub fn GetScaledImageAsThumbnailAsyncOverloadDefaultSizeDefaultOptions(&self, mode: FileProperties::ThumbnailMode) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -5028,7 +5028,7 @@ impl StorageFolder { } } #[cfg(all(feature = "Storage_FileProperties", feature = "Storage_Streams"))] - pub fn GetScaledImageAsThumbnailAsyncOverloadDefaultOptions(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32) -> windows_core::Result> { + pub fn GetScaledImageAsThumbnailAsyncOverloadDefaultOptions(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -5036,7 +5036,7 @@ impl StorageFolder { } } #[cfg(all(feature = "Storage_FileProperties", feature = "Storage_Streams"))] - pub fn GetScaledImageAsThumbnailAsync(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32, options: FileProperties::ThumbnailOptions) -> windows_core::Result> { + pub fn GetScaledImageAsThumbnailAsync(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32, options: FileProperties::ThumbnailOptions) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -5125,7 +5125,7 @@ pub struct StorageLibrary(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(StorageLibrary, windows_core::IUnknown, windows_core::IInspectable); impl StorageLibrary { #[cfg(feature = "Storage_Search")] - pub fn RequestAddFolderAsync(&self) -> windows_core::Result> { + pub fn RequestAddFolderAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -5133,7 +5133,7 @@ impl StorageLibrary { } } #[cfg(feature = "Storage_Search")] - pub fn RequestRemoveFolderAsync(&self, folder: P0) -> windows_core::Result> + pub fn RequestRemoveFolderAsync(&self, folder: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -5180,21 +5180,21 @@ impl StorageLibrary { (windows_core::Interface::vtable(this).ChangeTracker)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn AreFolderSuggestionsAvailableAsync(&self) -> windows_core::Result> { + pub fn AreFolderSuggestionsAvailableAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).AreFolderSuggestionsAvailableAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetLibraryAsync(libraryid: KnownLibraryId) -> windows_core::Result> { + pub fn GetLibraryAsync(libraryid: KnownLibraryId) -> windows_core::Result> { Self::IStorageLibraryStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetLibraryAsync)(windows_core::Interface::as_raw(this), libraryid, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "System")] - pub fn GetLibraryForUserAsync(user: P0, libraryid: KnownLibraryId) -> windows_core::Result> + pub fn GetLibraryForUserAsync(user: P0, libraryid: KnownLibraryId) -> windows_core::Result> where P0: windows_core::Param, { @@ -5255,7 +5255,7 @@ impl StorageLibraryChange { (windows_core::Interface::vtable(this).IsOfType)(windows_core::Interface::as_raw(this), r#type, &mut result__).map(|| result__) } } - pub fn GetStorageItemAsync(&self) -> windows_core::Result> { + pub fn GetStorageItemAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -5280,14 +5280,14 @@ unsafe impl Sync for StorageLibraryChange {} pub struct StorageLibraryChangeReader(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(StorageLibraryChangeReader, windows_core::IUnknown, windows_core::IInspectable); impl StorageLibraryChangeReader { - pub fn ReadBatchAsync(&self) -> windows_core::Result>> { + pub fn ReadBatchAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReadBatchAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn AcceptChangesAsync(&self) -> windows_core::Result { + pub fn AcceptChangesAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -5509,7 +5509,7 @@ impl StorageProvider { (windows_core::Interface::vtable(this).DisplayName)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn IsPropertySupportedForPartialFileAsync(&self, propertycanonicalname: &windows_core::HSTRING) -> windows_core::Result> { + pub fn IsPropertySupportedForPartialFileAsync(&self, propertycanonicalname: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -5545,7 +5545,7 @@ impl StorageStreamTransaction { (windows_core::Interface::vtable(this).Stream)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CommitAsync(&self) -> windows_core::Result { + pub fn CommitAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -5577,7 +5577,7 @@ impl StreamedFileDataRequest { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).Close)(windows_core::Interface::as_raw(this)).ok() } } - pub fn WriteAsync(&self, buffer: P0) -> windows_core::Result> + pub fn WriteAsync(&self, buffer: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -5587,7 +5587,7 @@ impl StreamedFileDataRequest { (windows_core::Interface::vtable(this).WriteAsync)(windows_core::Interface::as_raw(this), buffer.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FlushAsync(&self) -> windows_core::Result> { + pub fn FlushAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/System/Diagnostics/mod.rs b/crates/libs/windows/src/Windows/System/Diagnostics/mod.rs index 321027223a..00338ddc74 100644 --- a/crates/libs/windows/src/Windows/System/Diagnostics/mod.rs +++ b/crates/libs/windows/src/Windows/System/Diagnostics/mod.rs @@ -61,7 +61,7 @@ pub struct DiagnosticInvoker(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(DiagnosticInvoker, windows_core::IUnknown, windows_core::IInspectable); impl DiagnosticInvoker { #[cfg(feature = "Data_Json")] - pub fn RunDiagnosticActionAsync(&self, context: P0) -> windows_core::Result> + pub fn RunDiagnosticActionAsync(&self, context: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -71,7 +71,7 @@ impl DiagnosticInvoker { (windows_core::Interface::vtable(this).RunDiagnosticActionAsync)(windows_core::Interface::as_raw(this), context.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RunDiagnosticActionFromStringAsync(&self, context: &windows_core::HSTRING) -> windows_core::Result> { + pub fn RunDiagnosticActionFromStringAsync(&self, context: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/System/Implementation/FileExplorer/mod.rs b/crates/libs/windows/src/Windows/System/Implementation/FileExplorer/mod.rs index 1c3e70536b..4b308fde19 100644 --- a/crates/libs/windows/src/Windows/System/Implementation/FileExplorer/mod.rs +++ b/crates/libs/windows/src/Windows/System/Implementation/FileExplorer/mod.rs @@ -159,7 +159,7 @@ impl windows_core::RuntimeType for ISysStorageProviderHttpRequestProvider { windows_core::imp::interface_hierarchy!(ISysStorageProviderHttpRequestProvider, windows_core::IUnknown, windows_core::IInspectable); impl ISysStorageProviderHttpRequestProvider { #[cfg(feature = "Web_Http")] - pub fn SendRequestAsync(&self, request: P0) -> windows_core::Result> + pub fn SendRequestAsync(&self, request: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -176,7 +176,7 @@ impl windows_core::RuntimeName for ISysStorageProviderHttpRequestProvider { } #[cfg(feature = "Web_Http")] pub trait ISysStorageProviderHttpRequestProvider_Impl: windows_core::IUnknownImpl { - fn SendRequestAsync(&self, request: windows_core::Ref<'_, super::super::super::Web::Http::HttpRequestMessage>) -> windows_core::Result>; + fn SendRequestAsync(&self, request: windows_core::Ref<'_, super::super::super::Web::Http::HttpRequestMessage>) -> windows_core::Result>; } #[cfg(feature = "Web_Http")] impl ISysStorageProviderHttpRequestProvider_Vtbl { diff --git a/crates/libs/windows/src/Windows/System/Inventory/mod.rs b/crates/libs/windows/src/Windows/System/Inventory/mod.rs index 2bbe7a3f0a..39f62a7578 100644 --- a/crates/libs/windows/src/Windows/System/Inventory/mod.rs +++ b/crates/libs/windows/src/Windows/System/Inventory/mod.rs @@ -53,7 +53,7 @@ impl InstalledDesktopApp { (windows_core::Interface::vtable(this).DisplayVersion)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn GetInventoryAsync() -> windows_core::Result>> { + pub fn GetInventoryAsync() -> windows_core::Result>> { Self::IInstalledDesktopAppStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetInventoryAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/System/Profile/mod.rs b/crates/libs/windows/src/Windows/System/Profile/mod.rs index 9e985c2673..95a2c65a48 100644 --- a/crates/libs/windows/src/Windows/System/Profile/mod.rs +++ b/crates/libs/windows/src/Windows/System/Profile/mod.rs @@ -14,7 +14,7 @@ impl AnalyticsInfo { (windows_core::Interface::vtable(this).DeviceForm)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn GetSystemPropertiesAsync(attributenames: P0) -> windows_core::Result>> + pub fn GetSystemPropertiesAsync(attributenames: P0) -> windows_core::Result>> where P0: windows_core::Param>, { diff --git a/crates/libs/windows/src/Windows/System/RemoteSystems/mod.rs b/crates/libs/windows/src/Windows/System/RemoteSystems/mod.rs index 8f7280a1cd..601307c1bc 100644 --- a/crates/libs/windows/src/Windows/System/RemoteSystems/mod.rs +++ b/crates/libs/windows/src/Windows/System/RemoteSystems/mod.rs @@ -810,7 +810,7 @@ impl RemoteSystem { (windows_core::Interface::vtable(this).IsAvailableBySpatialProximity)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn GetCapabilitySupportedAsync(&self, capabilityname: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetCapabilitySupportedAsync(&self, capabilityname: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -853,7 +853,7 @@ impl RemoteSystem { } } #[cfg(feature = "Networking")] - pub fn FindByHostNameAsync(hostname: P0) -> windows_core::Result> + pub fn FindByHostNameAsync(hostname: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -877,7 +877,7 @@ impl RemoteSystem { (windows_core::Interface::vtable(this).CreateWatcherWithFilters)(windows_core::Interface::as_raw(this), filters.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RequestAccessAsync() -> windows_core::Result> { + pub fn RequestAccessAsync() -> windows_core::Result> { Self::IRemoteSystemStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestAccessAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -1059,7 +1059,7 @@ impl RemoteSystemAppRegistration { (windows_core::Interface::vtable(this).Attributes)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SaveAsync(&self) -> windows_core::Result> { + pub fn SaveAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1532,7 +1532,7 @@ impl RemoteSystemSession { (windows_core::Interface::vtable(this).CreateParticipantWatcher)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SendInvitationAsync(&self, invitee: P0) -> windows_core::Result> + pub fn SendInvitationAsync(&self, invitee: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1609,7 +1609,7 @@ impl RemoteSystemSessionController { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveJoinRequested)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn RemoveParticipantAsync(&self, pparticipant: P0) -> windows_core::Result> + pub fn RemoveParticipantAsync(&self, pparticipant: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1619,7 +1619,7 @@ impl RemoteSystemSessionController { (windows_core::Interface::vtable(this).RemoveParticipantAsync)(windows_core::Interface::as_raw(this), pparticipant.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateSessionAsync(&self) -> windows_core::Result> { + pub fn CreateSessionAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1762,7 +1762,7 @@ impl RemoteSystemSessionInfo { (windows_core::Interface::vtable(this).ControllerDisplayName)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn JoinAsync(&self) -> windows_core::Result> { + pub fn JoinAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2000,7 +2000,7 @@ impl RemoteSystemSessionMessageChannel { } } #[cfg(feature = "Foundation_Collections")] - pub fn BroadcastValueSetAsync(&self, messagedata: P0) -> windows_core::Result> + pub fn BroadcastValueSetAsync(&self, messagedata: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2011,7 +2011,7 @@ impl RemoteSystemSessionMessageChannel { } } #[cfg(feature = "Foundation_Collections")] - pub fn SendValueSetAsync(&self, messagedata: P0, participant: P1) -> windows_core::Result> + pub fn SendValueSetAsync(&self, messagedata: P0, participant: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -2023,7 +2023,7 @@ impl RemoteSystemSessionMessageChannel { } } #[cfg(feature = "Foundation_Collections")] - pub fn SendValueSetToParticipantsAsync(&self, messagedata: P0, participants: P1) -> windows_core::Result> + pub fn SendValueSetToParticipantsAsync(&self, messagedata: P0, participants: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param>, diff --git a/crates/libs/windows/src/Windows/System/Threading/Core/mod.rs b/crates/libs/windows/src/Windows/System/Threading/Core/mod.rs index f35f85a6c9..e1a8795bdf 100644 --- a/crates/libs/windows/src/Windows/System/Threading/Core/mod.rs +++ b/crates/libs/windows/src/Windows/System/Threading/Core/mod.rs @@ -45,7 +45,7 @@ pub struct ISignalNotifierStatics_Vtbl { pub struct PreallocatedWorkItem(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(PreallocatedWorkItem, windows_core::IUnknown, windows_core::IInspectable); impl PreallocatedWorkItem { - pub fn RunAsync(&self) -> windows_core::Result { + pub fn RunAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/System/Threading/mod.rs b/crates/libs/windows/src/Windows/System/Threading/mod.rs index 4ac6ebdd32..a0dac60215 100644 --- a/crates/libs/windows/src/Windows/System/Threading/mod.rs +++ b/crates/libs/windows/src/Windows/System/Threading/mod.rs @@ -36,7 +36,7 @@ pub struct IThreadPoolTimerStatics_Vtbl { } pub struct ThreadPool; impl ThreadPool { - pub fn RunAsync(handler: P0) -> windows_core::Result + pub fn RunAsync(handler: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -45,7 +45,7 @@ impl ThreadPool { (windows_core::Interface::vtable(this).RunAsync)(windows_core::Interface::as_raw(this), handler.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RunWithPriorityAsync(handler: P0, priority: WorkItemPriority) -> windows_core::Result + pub fn RunWithPriorityAsync(handler: P0, priority: WorkItemPriority) -> windows_core::Result where P0: windows_core::Param, { @@ -54,7 +54,7 @@ impl ThreadPool { (windows_core::Interface::vtable(this).RunWithPriorityAsync)(windows_core::Interface::as_raw(this), handler.param().abi(), priority, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RunWithPriorityAndOptionsAsync(handler: P0, priority: WorkItemPriority, options: WorkItemOptions) -> windows_core::Result + pub fn RunWithPriorityAndOptionsAsync(handler: P0, priority: WorkItemPriority, options: WorkItemOptions) -> windows_core::Result where P0: windows_core::Param, { @@ -290,13 +290,13 @@ impl windows_core::RuntimeType for WorkItemHandler { const SIGNATURE: windows_core::imp::ConstBuffer = windows_core::imp::ConstBuffer::for_interface::(); } impl WorkItemHandler { - pub fn new) -> windows_core::Result<()> + Send + 'static>(invoke: F) -> Self { + pub fn new) -> windows_core::Result<()> + Send + 'static>(invoke: F) -> Self { let com = WorkItemHandlerBox { vtable: &WorkItemHandlerBox::::VTABLE, count: windows_core::imp::RefCount::new(1), invoke }; unsafe { core::mem::transmute(windows_core::imp::Box::new(com)) } } pub fn Invoke(&self, operation: P0) -> windows_core::Result<()> where - P0: windows_core::Param, + P0: windows_core::Param, { let this = self; unsafe { (windows_core::Interface::vtable(this).Invoke)(windows_core::Interface::as_raw(this), operation.param().abi()).ok() } @@ -308,12 +308,12 @@ pub struct WorkItemHandler_Vtbl { Invoke: unsafe extern "system" fn(this: *mut core::ffi::c_void, operation: *mut core::ffi::c_void) -> windows_core::HRESULT, } #[repr(C)] -struct WorkItemHandlerBox) -> windows_core::Result<()> + Send + 'static> { +struct WorkItemHandlerBox) -> windows_core::Result<()> + Send + 'static> { vtable: *const WorkItemHandler_Vtbl, invoke: F, count: windows_core::imp::RefCount, } -impl) -> windows_core::Result<()> + Send + 'static> WorkItemHandlerBox { +impl) -> windows_core::Result<()> + Send + 'static> WorkItemHandlerBox { const VTABLE: WorkItemHandler_Vtbl = WorkItemHandler_Vtbl { base__: windows_core::IUnknown_Vtbl { QueryInterface: Self::QueryInterface, AddRef: Self::AddRef, Release: Self::Release }, Invoke: Self::Invoke }; unsafe extern "system" fn QueryInterface(this: *mut core::ffi::c_void, iid: *const windows_core::GUID, interface: *mut *mut core::ffi::c_void) -> windows_core::HRESULT { unsafe { diff --git a/crates/libs/windows/src/Windows/System/Update/mod.rs b/crates/libs/windows/src/Windows/System/Update/mod.rs index 8b41fbff97..ca0b9043f1 100644 --- a/crates/libs/windows/src/Windows/System/Update/mod.rs +++ b/crates/libs/windows/src/Windows/System/Update/mod.rs @@ -292,13 +292,13 @@ impl SystemUpdateManager { (windows_core::Interface::vtable(this).GetAutomaticRebootBlockIds)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn BlockAutomaticRebootAsync(lockid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn BlockAutomaticRebootAsync(lockid: &windows_core::HSTRING) -> windows_core::Result> { Self::ISystemUpdateManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).BlockAutomaticRebootAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(lockid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn UnblockAutomaticRebootAsync(lockid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn UnblockAutomaticRebootAsync(lockid: &windows_core::HSTRING) -> windows_core::Result> { Self::ISystemUpdateManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).UnblockAutomaticRebootAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(lockid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/System/UserProfile/mod.rs b/crates/libs/windows/src/Windows/System/UserProfile/mod.rs index 1e4d0fc02b..553480353e 100644 --- a/crates/libs/windows/src/Windows/System/UserProfile/mod.rs +++ b/crates/libs/windows/src/Windows/System/UserProfile/mod.rs @@ -644,7 +644,7 @@ pub struct IUserProfilePersonalizationSettingsStatics_Vtbl { } pub struct LockScreen; impl LockScreen { - pub fn RequestSetImageFeedAsync(syndicationfeeduri: P0) -> windows_core::Result> + pub fn RequestSetImageFeedAsync(syndicationfeeduri: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -673,7 +673,7 @@ impl LockScreen { }) } #[cfg(feature = "Storage_Streams")] - pub fn SetImageFileAsync(value: P0) -> windows_core::Result + pub fn SetImageFileAsync(value: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -683,7 +683,7 @@ impl LockScreen { }) } #[cfg(feature = "Storage_Streams")] - pub fn SetImageStreamAsync(value: P0) -> windows_core::Result + pub fn SetImageStreamAsync(value: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -759,7 +759,7 @@ impl UserInformation { }) } #[cfg(feature = "Storage_Streams")] - pub fn SetAccountPictureAsync(image: P0) -> windows_core::Result> + pub fn SetAccountPictureAsync(image: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -769,7 +769,7 @@ impl UserInformation { }) } #[cfg(feature = "Storage_Streams")] - pub fn SetAccountPicturesAsync(smallimage: P0, largeimage: P1, video: P2) -> windows_core::Result> + pub fn SetAccountPicturesAsync(smallimage: P0, largeimage: P1, video: P2) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -781,7 +781,7 @@ impl UserInformation { }) } #[cfg(feature = "Storage_Streams")] - pub fn SetAccountPictureFromStreamAsync(image: P0) -> windows_core::Result> + pub fn SetAccountPictureFromStreamAsync(image: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -791,7 +791,7 @@ impl UserInformation { }) } #[cfg(feature = "Storage_Streams")] - pub fn SetAccountPicturesFromStreamsAsync(smallimage: P0, largeimage: P1, video: P2) -> windows_core::Result> + pub fn SetAccountPicturesFromStreamsAsync(smallimage: P0, largeimage: P1, video: P2) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -814,37 +814,37 @@ impl UserInformation { pub fn RemoveAccountPictureChanged(token: i64) -> windows_core::Result<()> { Self::IUserInformationStatics(|this| unsafe { (windows_core::Interface::vtable(this).RemoveAccountPictureChanged)(windows_core::Interface::as_raw(this), token).ok() }) } - pub fn GetDisplayNameAsync() -> windows_core::Result> { + pub fn GetDisplayNameAsync() -> windows_core::Result> { Self::IUserInformationStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetDisplayNameAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetFirstNameAsync() -> windows_core::Result> { + pub fn GetFirstNameAsync() -> windows_core::Result> { Self::IUserInformationStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFirstNameAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetLastNameAsync() -> windows_core::Result> { + pub fn GetLastNameAsync() -> windows_core::Result> { Self::IUserInformationStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetLastNameAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetPrincipalNameAsync() -> windows_core::Result> { + pub fn GetPrincipalNameAsync() -> windows_core::Result> { Self::IUserInformationStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetPrincipalNameAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetSessionInitiationProtocolUriAsync() -> windows_core::Result> { + pub fn GetSessionInitiationProtocolUriAsync() -> windows_core::Result> { Self::IUserInformationStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetSessionInitiationProtocolUriAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetDomainNameAsync() -> windows_core::Result> { + pub fn GetDomainNameAsync() -> windows_core::Result> { Self::IUserInformationStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetDomainNameAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -865,7 +865,7 @@ pub struct UserProfilePersonalizationSettings(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(UserProfilePersonalizationSettings, windows_core::IUnknown, windows_core::IInspectable); impl UserProfilePersonalizationSettings { #[cfg(feature = "Storage_Streams")] - pub fn TrySetLockScreenImageAsync(&self, imagefile: P0) -> windows_core::Result> + pub fn TrySetLockScreenImageAsync(&self, imagefile: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -876,7 +876,7 @@ impl UserProfilePersonalizationSettings { } } #[cfg(feature = "Storage_Streams")] - pub fn TrySetWallpaperImageAsync(&self, imagefile: P0) -> windows_core::Result> + pub fn TrySetWallpaperImageAsync(&self, imagefile: P0) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/System/mod.rs b/crates/libs/windows/src/Windows/System/mod.rs index 07da49ffa5..306051f47b 100644 --- a/crates/libs/windows/src/Windows/System/mod.rs +++ b/crates/libs/windows/src/Windows/System/mod.rs @@ -79,14 +79,14 @@ impl AppDiagnosticInfo { (windows_core::Interface::vtable(this).CreateResourceGroupWatcher)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn LaunchAsync(&self) -> windows_core::Result> { + pub fn LaunchAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).LaunchAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestInfoAsync() -> windows_core::Result>> { + pub fn RequestInfoAsync() -> windows_core::Result>> { Self::IAppDiagnosticInfoStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestInfoAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -98,25 +98,25 @@ impl AppDiagnosticInfo { (windows_core::Interface::vtable(this).CreateWatcher)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RequestAccessAsync() -> windows_core::Result> { + pub fn RequestAccessAsync() -> windows_core::Result> { Self::IAppDiagnosticInfoStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestAccessAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RequestInfoForPackageAsync(packagefamilyname: &windows_core::HSTRING) -> windows_core::Result>> { + pub fn RequestInfoForPackageAsync(packagefamilyname: &windows_core::HSTRING) -> windows_core::Result>> { Self::IAppDiagnosticInfoStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestInfoForPackageAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(packagefamilyname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RequestInfoForAppAsync() -> windows_core::Result>> { + pub fn RequestInfoForAppAsync() -> windows_core::Result>> { Self::IAppDiagnosticInfoStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestInfoForAppAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RequestInfoForAppUserModelId(appusermodelid: &windows_core::HSTRING) -> windows_core::Result>> { + pub fn RequestInfoForAppUserModelId(appusermodelid: &windows_core::HSTRING) -> windows_core::Result>> { Self::IAppDiagnosticInfoStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestInfoForAppUserModelId)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(appusermodelid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -523,21 +523,21 @@ impl AppResourceGroupInfo { (windows_core::Interface::vtable(this).GetStateReport)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StartSuspendAsync(&self) -> windows_core::Result> { + pub fn StartSuspendAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).StartSuspendAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StartResumeAsync(&self) -> windows_core::Result> { + pub fn StartResumeAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).StartResumeAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StartTerminateAsync(&self) -> windows_core::Result> { + pub fn StartTerminateAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -895,14 +895,14 @@ impl AppUriHandlerRegistration { (windows_core::Interface::vtable(this).User)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAppAddedHostsAsync(&self) -> windows_core::Result>> { + pub fn GetAppAddedHostsAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetAppAddedHostsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SetAppAddedHostsAsync(&self, hosts: P0) -> windows_core::Result + pub fn SetAppAddedHostsAsync(&self, hosts: P0) -> windows_core::Result where P0: windows_core::Param>, { @@ -1167,7 +1167,7 @@ impl DispatcherQueueController { (windows_core::Interface::vtable(this).DispatcherQueue)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ShutdownQueueAsync(&self) -> windows_core::Result { + pub fn ShutdownQueueAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2669,7 +2669,7 @@ impl windows_core::RuntimeType for LaunchUriStatus { pub struct Launcher; impl Launcher { #[cfg(feature = "Storage_Streams")] - pub fn LaunchFileAsync(file: P0) -> windows_core::Result> + pub fn LaunchFileAsync(file: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2679,7 +2679,7 @@ impl Launcher { }) } #[cfg(feature = "Storage_Streams")] - pub fn LaunchFileWithOptionsAsync(file: P0, options: P1) -> windows_core::Result> + pub fn LaunchFileWithOptionsAsync(file: P0, options: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -2689,7 +2689,7 @@ impl Launcher { (windows_core::Interface::vtable(this).LaunchFileWithOptionsAsync)(windows_core::Interface::as_raw(this), file.param().abi(), options.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn LaunchUriAsync(uri: P0) -> windows_core::Result> + pub fn LaunchUriAsync(uri: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2698,7 +2698,7 @@ impl Launcher { (windows_core::Interface::vtable(this).LaunchUriAsync)(windows_core::Interface::as_raw(this), uri.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn LaunchUriWithOptionsAsync(uri: P0, options: P1) -> windows_core::Result> + pub fn LaunchUriWithOptionsAsync(uri: P0, options: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -2708,7 +2708,7 @@ impl Launcher { (windows_core::Interface::vtable(this).LaunchUriWithOptionsAsync)(windows_core::Interface::as_raw(this), uri.param().abi(), options.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn LaunchUriForResultsAsync(uri: P0, options: P1) -> windows_core::Result> + pub fn LaunchUriForResultsAsync(uri: P0, options: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -2719,7 +2719,7 @@ impl Launcher { }) } #[cfg(feature = "Foundation_Collections")] - pub fn LaunchUriForResultsWithDataAsync(uri: P0, options: P1, inputdata: P2) -> windows_core::Result> + pub fn LaunchUriForResultsWithDataAsync(uri: P0, options: P1, inputdata: P2) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -2731,7 +2731,7 @@ impl Launcher { }) } #[cfg(feature = "Foundation_Collections")] - pub fn LaunchUriWithDataAsync(uri: P0, options: P1, inputdata: P2) -> windows_core::Result> + pub fn LaunchUriWithDataAsync(uri: P0, options: P1, inputdata: P2) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -2742,7 +2742,7 @@ impl Launcher { (windows_core::Interface::vtable(this).LaunchUriWithDataAsync)(windows_core::Interface::as_raw(this), uri.param().abi(), options.param().abi(), inputdata.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn QueryUriSupportAsync(uri: P0, launchquerysupporttype: LaunchQuerySupportType) -> windows_core::Result> + pub fn QueryUriSupportAsync(uri: P0, launchquerysupporttype: LaunchQuerySupportType) -> windows_core::Result> where P0: windows_core::Param, { @@ -2751,7 +2751,7 @@ impl Launcher { (windows_core::Interface::vtable(this).QueryUriSupportAsync)(windows_core::Interface::as_raw(this), uri.param().abi(), launchquerysupporttype, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn QueryUriSupportWithPackageFamilyNameAsync(uri: P0, launchquerysupporttype: LaunchQuerySupportType, packagefamilyname: &windows_core::HSTRING) -> windows_core::Result> + pub fn QueryUriSupportWithPackageFamilyNameAsync(uri: P0, launchquerysupporttype: LaunchQuerySupportType, packagefamilyname: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -2761,7 +2761,7 @@ impl Launcher { }) } #[cfg(feature = "Storage_Streams")] - pub fn QueryFileSupportAsync(file: P0) -> windows_core::Result> + pub fn QueryFileSupportAsync(file: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2771,7 +2771,7 @@ impl Launcher { }) } #[cfg(feature = "Storage_Streams")] - pub fn QueryFileSupportWithPackageFamilyNameAsync(file: P0, packagefamilyname: &windows_core::HSTRING) -> windows_core::Result> + pub fn QueryFileSupportWithPackageFamilyNameAsync(file: P0, packagefamilyname: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -2781,28 +2781,28 @@ impl Launcher { }) } #[cfg(feature = "ApplicationModel")] - pub fn FindUriSchemeHandlersAsync(scheme: &windows_core::HSTRING) -> windows_core::Result>> { + pub fn FindUriSchemeHandlersAsync(scheme: &windows_core::HSTRING) -> windows_core::Result>> { Self::ILauncherStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindUriSchemeHandlersAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(scheme), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "ApplicationModel")] - pub fn FindUriSchemeHandlersWithLaunchUriTypeAsync(scheme: &windows_core::HSTRING, launchquerysupporttype: LaunchQuerySupportType) -> windows_core::Result>> { + pub fn FindUriSchemeHandlersWithLaunchUriTypeAsync(scheme: &windows_core::HSTRING, launchquerysupporttype: LaunchQuerySupportType) -> windows_core::Result>> { Self::ILauncherStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindUriSchemeHandlersWithLaunchUriTypeAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(scheme), launchquerysupporttype, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "ApplicationModel")] - pub fn FindFileHandlersAsync(extension: &windows_core::HSTRING) -> windows_core::Result>> { + pub fn FindFileHandlersAsync(extension: &windows_core::HSTRING) -> windows_core::Result>> { Self::ILauncherStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindFileHandlersAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(extension), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "Storage")] - pub fn LaunchFolderAsync(folder: P0) -> windows_core::Result> + pub fn LaunchFolderAsync(folder: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2812,7 +2812,7 @@ impl Launcher { }) } #[cfg(feature = "Storage")] - pub fn LaunchFolderWithOptionsAsync(folder: P0, options: P1) -> windows_core::Result> + pub fn LaunchFolderWithOptionsAsync(folder: P0, options: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -2822,7 +2822,7 @@ impl Launcher { (windows_core::Interface::vtable(this).LaunchFolderWithOptionsAsync)(windows_core::Interface::as_raw(this), folder.param().abi(), options.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn QueryAppUriSupportAsync(uri: P0) -> windows_core::Result> + pub fn QueryAppUriSupportAsync(uri: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2831,7 +2831,7 @@ impl Launcher { (windows_core::Interface::vtable(this).QueryAppUriSupportAsync)(windows_core::Interface::as_raw(this), uri.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn QueryAppUriSupportWithPackageFamilyNameAsync(uri: P0, packagefamilyname: &windows_core::HSTRING) -> windows_core::Result> + pub fn QueryAppUriSupportWithPackageFamilyNameAsync(uri: P0, packagefamilyname: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -2841,7 +2841,7 @@ impl Launcher { }) } #[cfg(feature = "ApplicationModel")] - pub fn FindAppUriHandlersAsync(uri: P0) -> windows_core::Result>> + pub fn FindAppUriHandlersAsync(uri: P0) -> windows_core::Result>> where P0: windows_core::Param, { @@ -2850,7 +2850,7 @@ impl Launcher { (windows_core::Interface::vtable(this).FindAppUriHandlersAsync)(windows_core::Interface::as_raw(this), uri.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn LaunchUriForUserAsync(user: P0, uri: P1) -> windows_core::Result> + pub fn LaunchUriForUserAsync(user: P0, uri: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -2860,7 +2860,7 @@ impl Launcher { (windows_core::Interface::vtable(this).LaunchUriForUserAsync)(windows_core::Interface::as_raw(this), user.param().abi(), uri.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn LaunchUriWithOptionsForUserAsync(user: P0, uri: P1, options: P2) -> windows_core::Result> + pub fn LaunchUriWithOptionsForUserAsync(user: P0, uri: P1, options: P2) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -2872,7 +2872,7 @@ impl Launcher { }) } #[cfg(feature = "Foundation_Collections")] - pub fn LaunchUriWithDataForUserAsync(user: P0, uri: P1, options: P2, inputdata: P3) -> windows_core::Result> + pub fn LaunchUriWithDataForUserAsync(user: P0, uri: P1, options: P2, inputdata: P3) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -2884,7 +2884,7 @@ impl Launcher { (windows_core::Interface::vtable(this).LaunchUriWithDataForUserAsync)(windows_core::Interface::as_raw(this), user.param().abi(), uri.param().abi(), options.param().abi(), inputdata.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn LaunchUriForResultsForUserAsync(user: P0, uri: P1, options: P2) -> windows_core::Result> + pub fn LaunchUriForResultsForUserAsync(user: P0, uri: P1, options: P2) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -2896,7 +2896,7 @@ impl Launcher { }) } #[cfg(feature = "Foundation_Collections")] - pub fn LaunchUriForResultsWithDataForUserAsync(user: P0, uri: P1, options: P2, inputdata: P3) -> windows_core::Result> + pub fn LaunchUriForResultsWithDataForUserAsync(user: P0, uri: P1, options: P2, inputdata: P3) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -2908,13 +2908,13 @@ impl Launcher { (windows_core::Interface::vtable(this).LaunchUriForResultsWithDataForUserAsync)(windows_core::Interface::as_raw(this), user.param().abi(), uri.param().abi(), options.param().abi(), inputdata.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn LaunchFolderPathAsync(path: &windows_core::HSTRING) -> windows_core::Result> { + pub fn LaunchFolderPathAsync(path: &windows_core::HSTRING) -> windows_core::Result> { Self::ILauncherStatics5(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).LaunchFolderPathAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(path), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn LaunchFolderPathWithOptionsAsync(path: &windows_core::HSTRING, options: P1) -> windows_core::Result> + pub fn LaunchFolderPathWithOptionsAsync(path: &windows_core::HSTRING, options: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -2923,7 +2923,7 @@ impl Launcher { (windows_core::Interface::vtable(this).LaunchFolderPathWithOptionsAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(path), options.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn LaunchFolderPathForUserAsync(user: P0, path: &windows_core::HSTRING) -> windows_core::Result> + pub fn LaunchFolderPathForUserAsync(user: P0, path: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -2932,7 +2932,7 @@ impl Launcher { (windows_core::Interface::vtable(this).LaunchFolderPathForUserAsync)(windows_core::Interface::as_raw(this), user.param().abi(), core::mem::transmute_copy(path), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn LaunchFolderPathWithOptionsForUserAsync(user: P0, path: &windows_core::HSTRING, options: P2) -> windows_core::Result> + pub fn LaunchFolderPathWithOptionsForUserAsync(user: P0, path: &windows_core::HSTRING, options: P2) -> windows_core::Result> where P0: windows_core::Param, P2: windows_core::Param, @@ -3304,13 +3304,13 @@ impl windows_core::RuntimeType for PowerState { } pub struct ProcessLauncher; impl ProcessLauncher { - pub fn RunToCompletionAsync(filename: &windows_core::HSTRING, args: &windows_core::HSTRING) -> windows_core::Result> { + pub fn RunToCompletionAsync(filename: &windows_core::HSTRING, args: &windows_core::HSTRING) -> windows_core::Result> { Self::IProcessLauncherStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RunToCompletionAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(filename), core::mem::transmute_copy(args), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RunToCompletionAsyncWithOptions(filename: &windows_core::HSTRING, args: &windows_core::HSTRING, options: P2) -> windows_core::Result> + pub fn RunToCompletionAsyncWithOptions(filename: &windows_core::HSTRING, args: &windows_core::HSTRING, options: P2) -> windows_core::Result> where P2: windows_core::Param, { @@ -3534,7 +3534,7 @@ impl windows_core::RuntimeType for RemoteLaunchUriStatus { pub struct RemoteLauncher; impl RemoteLauncher { #[cfg(feature = "System_RemoteSystems")] - pub fn LaunchUriAsync(remotesystemconnectionrequest: P0, uri: P1) -> windows_core::Result> + pub fn LaunchUriAsync(remotesystemconnectionrequest: P0, uri: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -3545,7 +3545,7 @@ impl RemoteLauncher { }) } #[cfg(feature = "System_RemoteSystems")] - pub fn LaunchUriWithOptionsAsync(remotesystemconnectionrequest: P0, uri: P1, options: P2) -> windows_core::Result> + pub fn LaunchUriWithOptionsAsync(remotesystemconnectionrequest: P0, uri: P1, options: P2) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -3557,7 +3557,7 @@ impl RemoteLauncher { }) } #[cfg(all(feature = "Foundation_Collections", feature = "System_RemoteSystems"))] - pub fn LaunchUriWithDataAsync(remotesystemconnectionrequest: P0, uri: P1, options: P2, inputdata: P3) -> windows_core::Result> + pub fn LaunchUriWithDataAsync(remotesystemconnectionrequest: P0, uri: P1, options: P2, inputdata: P3) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -3691,7 +3691,7 @@ impl TimeZoneSettings { pub fn ChangeTimeZoneByDisplayName(timezonedisplayname: &windows_core::HSTRING) -> windows_core::Result<()> { Self::ITimeZoneSettingsStatics(|this| unsafe { (windows_core::Interface::vtable(this).ChangeTimeZoneByDisplayName)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(timezonedisplayname)).ok() }) } - pub fn AutoUpdateTimeZoneAsync(timeout: super::Foundation::TimeSpan) -> windows_core::Result> { + pub fn AutoUpdateTimeZoneAsync(timeout: super::Foundation::TimeSpan) -> windows_core::Result> { Self::ITimeZoneSettingsStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).AutoUpdateTimeZoneAsync)(windows_core::Interface::as_raw(this), timeout, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -3735,7 +3735,7 @@ impl User { (windows_core::Interface::vtable(this).Type)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn GetPropertyAsync(&self, value: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetPropertyAsync(&self, value: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -3743,7 +3743,7 @@ impl User { } } #[cfg(feature = "Foundation_Collections")] - pub fn GetPropertiesAsync(&self, values: P0) -> windows_core::Result> + pub fn GetPropertiesAsync(&self, values: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -3754,14 +3754,14 @@ impl User { } } #[cfg(feature = "Storage_Streams")] - pub fn GetPictureAsync(&self, desiredsize: UserPictureSize) -> windows_core::Result> { + pub fn GetPictureAsync(&self, desiredsize: UserPictureSize) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetPictureAsync)(windows_core::Interface::as_raw(this), desiredsize, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CheckUserAgeConsentGroupAsync(&self, consentgroup: UserAgeConsentGroup) -> windows_core::Result> { + pub fn CheckUserAgeConsentGroupAsync(&self, consentgroup: UserAgeConsentGroup) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -3774,21 +3774,21 @@ impl User { (windows_core::Interface::vtable(this).CreateWatcher)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn FindAllAsync() -> windows_core::Result>> { + pub fn FindAllAsync() -> windows_core::Result>> { Self::IUserStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAllAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "deprecated")] - pub fn FindAllAsyncByType(r#type: UserType) -> windows_core::Result>> { + pub fn FindAllAsyncByType(r#type: UserType) -> windows_core::Result>> { Self::IUserStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAllAsyncByType)(windows_core::Interface::as_raw(this), r#type, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "deprecated")] - pub fn FindAllAsyncByTypeAndStatus(r#type: UserType, status: UserAuthenticationStatus) -> windows_core::Result>> { + pub fn FindAllAsyncByTypeAndStatus(r#type: UserType, status: UserAuthenticationStatus) -> windows_core::Result>> { Self::IUserStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAllAsyncByTypeAndStatus)(windows_core::Interface::as_raw(this), r#type, status, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -4075,7 +4075,7 @@ impl UserPicker { let this = self; unsafe { (windows_core::Interface::vtable(this).SetSuggestedSelectedUser)(windows_core::Interface::as_raw(this), value.param().abi()).ok() } } - pub fn PickSingleUserAsync(&self) -> windows_core::Result> { + pub fn PickSingleUserAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/UI/ApplicationSettings/mod.rs b/crates/libs/windows/src/Windows/UI/ApplicationSettings/mod.rs index a4eee46778..a3ab34e95f 100644 --- a/crates/libs/windows/src/Windows/UI/ApplicationSettings/mod.rs +++ b/crates/libs/windows/src/Windows/UI/ApplicationSettings/mod.rs @@ -26,20 +26,20 @@ impl AccountsSettingsPane { pub fn Show() -> windows_core::Result<()> { Self::IAccountsSettingsPaneStatics(|this| unsafe { (windows_core::Interface::vtable(this).Show)(windows_core::Interface::as_raw(this)).ok() }) } - pub fn ShowManageAccountsAsync() -> windows_core::Result { + pub fn ShowManageAccountsAsync() -> windows_core::Result { Self::IAccountsSettingsPaneStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ShowManageAccountsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn ShowAddAccountAsync() -> windows_core::Result { + pub fn ShowAddAccountAsync() -> windows_core::Result { Self::IAccountsSettingsPaneStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ShowAddAccountAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "System")] - pub fn ShowManageAccountsForUserAsync(user: P0) -> windows_core::Result + pub fn ShowManageAccountsForUserAsync(user: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -49,7 +49,7 @@ impl AccountsSettingsPane { }) } #[cfg(feature = "System")] - pub fn ShowAddAccountForUserAsync(user: P0) -> windows_core::Result + pub fn ShowAddAccountForUserAsync(user: P0) -> windows_core::Result where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/UI/Composition/Core/mod.rs b/crates/libs/windows/src/Windows/UI/Composition/Core/mod.rs index 97e63e3169..f7ccfefaa0 100644 --- a/crates/libs/windows/src/Windows/UI/Composition/Core/mod.rs +++ b/crates/libs/windows/src/Windows/UI/Composition/Core/mod.rs @@ -26,7 +26,7 @@ impl CompositorController { let this = self; unsafe { (windows_core::Interface::vtable(this).Commit)(windows_core::Interface::as_raw(this)).ok() } } - pub fn EnsurePreviousCommitCompletedAsync(&self) -> windows_core::Result { + pub fn EnsurePreviousCommitCompletedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/UI/Composition/mod.rs b/crates/libs/windows/src/Windows/UI/Composition/mod.rs index 821e8fafb2..fa8f5c9878 100644 --- a/crates/libs/windows/src/Windows/UI/Composition/mod.rs +++ b/crates/libs/windows/src/Windows/UI/Composition/mod.rs @@ -6093,7 +6093,7 @@ impl CompositionGraphicsDevice { unsafe { (windows_core::Interface::vtable(this).Trim)(windows_core::Interface::as_raw(this)).ok() } } #[cfg(feature = "Graphics_DirectX")] - pub fn CaptureAsync(&self, capturevisual: P0, size: super::super::Graphics::SizeInt32, pixelformat: super::super::Graphics::DirectX::DirectXPixelFormat, alphamode: super::super::Graphics::DirectX::DirectXAlphaMode, sdrboost: f32) -> windows_core::Result> + pub fn CaptureAsync(&self, capturevisual: P0, size: super::super::Graphics::SizeInt32, pixelformat: super::super::Graphics::DirectX::DirectXPixelFormat, alphamode: super::super::Graphics::DirectX::DirectXAlphaMode, sdrboost: f32) -> windows_core::Result> where P0: windows_core::Param, { @@ -12452,7 +12452,7 @@ impl Compositor { (windows_core::Interface::vtable(this).CreateViewBox)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestCommitAsync(&self) -> windows_core::Result { + pub fn RequestCommitAsync(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/UI/Core/mod.rs b/crates/libs/windows/src/Windows/UI/Core/mod.rs index d136abdffc..f3dcb01c3b 100644 --- a/crates/libs/windows/src/Windows/UI/Core/mod.rs +++ b/crates/libs/windows/src/Windows/UI/Core/mod.rs @@ -694,7 +694,7 @@ impl CoreDispatcher { let this = self; unsafe { (windows_core::Interface::vtable(this).ProcessEvents)(windows_core::Interface::as_raw(this), options).ok() } } - pub fn RunAsync(&self, priority: CoreDispatcherPriority, agilecallback: P1) -> windows_core::Result + pub fn RunAsync(&self, priority: CoreDispatcherPriority, agilecallback: P1) -> windows_core::Result where P1: windows_core::Param, { @@ -704,7 +704,7 @@ impl CoreDispatcher { (windows_core::Interface::vtable(this).RunAsync)(windows_core::Interface::as_raw(this), priority, agilecallback.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RunIdleAsync(&self, agilecallback: P0) -> windows_core::Result + pub fn RunIdleAsync(&self, agilecallback: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -714,7 +714,7 @@ impl CoreDispatcher { (windows_core::Interface::vtable(this).RunIdleAsync)(windows_core::Interface::as_raw(this), agilecallback.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryRunAsync(&self, priority: CoreDispatcherPriority, agilecallback: P1) -> windows_core::Result> + pub fn TryRunAsync(&self, priority: CoreDispatcherPriority, agilecallback: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -724,7 +724,7 @@ impl CoreDispatcher { (windows_core::Interface::vtable(this).TryRunAsync)(windows_core::Interface::as_raw(this), priority, agilecallback.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryRunIdleAsync(&self, agilecallback: P0) -> windows_core::Result> + pub fn TryRunIdleAsync(&self, agilecallback: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1942,7 +1942,7 @@ impl CoreWindowDialog { unsafe { (windows_core::Interface::vtable(this).SetBackButtonCommand)(windows_core::Interface::as_raw(this), value.param().abi()).ok() } } #[cfg(feature = "UI_Popups")] - pub fn ShowAsync(&self) -> windows_core::Result> { + pub fn ShowAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2101,7 +2101,7 @@ impl CoreWindowFlyout { unsafe { (windows_core::Interface::vtable(this).SetBackButtonCommand)(windows_core::Interface::as_raw(this), value.param().abi()).ok() } } #[cfg(feature = "UI_Popups")] - pub fn ShowAsync(&self) -> windows_core::Result> { + pub fn ShowAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/UI/Input/Inking/Analysis/mod.rs b/crates/libs/windows/src/Windows/UI/Input/Inking/Analysis/mod.rs index 11d1fee05f..9aeb6c56a5 100644 --- a/crates/libs/windows/src/Windows/UI/Input/Inking/Analysis/mod.rs +++ b/crates/libs/windows/src/Windows/UI/Input/Inking/Analysis/mod.rs @@ -1198,7 +1198,7 @@ impl InkAnalyzer { let this = self; unsafe { (windows_core::Interface::vtable(this).SetStrokeDataKind)(windows_core::Interface::as_raw(this), strokeid, strokekind).ok() } } - pub fn AnalyzeAsync(&self) -> windows_core::Result> { + pub fn AnalyzeAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/UI/Input/Inking/mod.rs b/crates/libs/windows/src/Windows/UI/Input/Inking/mod.rs index 7e7d13f9d2..068199930e 100644 --- a/crates/libs/windows/src/Windows/UI/Input/Inking/mod.rs +++ b/crates/libs/windows/src/Windows/UI/Input/Inking/mod.rs @@ -618,7 +618,7 @@ impl IInkRecognizerContainer { let this = self; unsafe { (windows_core::Interface::vtable(this).SetDefaultRecognizer)(windows_core::Interface::as_raw(this), recognizer.param().abi()).ok() } } - pub fn RecognizeAsync(&self, strokecollection: P0, recognitiontarget: InkRecognitionTarget) -> windows_core::Result>> + pub fn RecognizeAsync(&self, strokecollection: P0, recognitiontarget: InkRecognitionTarget) -> windows_core::Result>> where P0: windows_core::Param, { @@ -641,7 +641,7 @@ impl windows_core::RuntimeName for IInkRecognizerContainer { } pub trait IInkRecognizerContainer_Impl: windows_core::IUnknownImpl { fn SetDefaultRecognizer(&self, recognizer: windows_core::Ref<'_, InkRecognizer>) -> windows_core::Result<()>; - fn RecognizeAsync(&self, strokeCollection: windows_core::Ref<'_, InkStrokeContainer>, recognitionTarget: InkRecognitionTarget) -> windows_core::Result>>; + fn RecognizeAsync(&self, strokeCollection: windows_core::Ref<'_, InkStrokeContainer>, recognitionTarget: InkRecognitionTarget) -> windows_core::Result>>; fn GetRecognizers(&self) -> windows_core::Result>; } impl IInkRecognizerContainer_Vtbl { @@ -846,7 +846,7 @@ impl IInkStrokeContainer { } } #[cfg(feature = "Storage_Streams")] - pub fn LoadAsync(&self, inputstream: P0) -> windows_core::Result> + pub fn LoadAsync(&self, inputstream: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -857,7 +857,7 @@ impl IInkStrokeContainer { } } #[cfg(feature = "Storage_Streams")] - pub fn SaveAsync(&self, outputstream: P0) -> windows_core::Result> + pub fn SaveAsync(&self, outputstream: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -904,8 +904,8 @@ pub trait IInkStrokeContainer_Impl: windows_core::IUnknownImpl { fn CopySelectedToClipboard(&self) -> windows_core::Result<()>; fn PasteFromClipboard(&self, position: &super::super::super::Foundation::Point) -> windows_core::Result; fn CanPasteFromClipboard(&self) -> windows_core::Result; - fn LoadAsync(&self, inputStream: windows_core::Ref<'_, super::super::super::Storage::Streams::IInputStream>) -> windows_core::Result>; - fn SaveAsync(&self, outputStream: windows_core::Ref<'_, super::super::super::Storage::Streams::IOutputStream>) -> windows_core::Result>; + fn LoadAsync(&self, inputStream: windows_core::Ref<'_, super::super::super::Storage::Streams::IInputStream>) -> windows_core::Result>; + fn SaveAsync(&self, outputStream: windows_core::Ref<'_, super::super::super::Storage::Streams::IOutputStream>) -> windows_core::Result>; fn UpdateRecognitionResults(&self, recognitionResults: windows_core::Ref<'_, windows_collections::IVectorView>) -> windows_core::Result<()>; fn GetStrokes(&self) -> windows_core::Result>; fn GetRecognitionResults(&self) -> windows_core::Result>; @@ -1660,7 +1660,7 @@ impl InkManager { let this = self; unsafe { (windows_core::Interface::vtable(this).SetDefaultDrawingAttributes)(windows_core::Interface::as_raw(this), drawingattributes.param().abi()).ok() } } - pub fn RecognizeAsync(&self, recognitiontarget: InkRecognitionTarget) -> windows_core::Result>> { + pub fn RecognizeAsync(&self, recognitiontarget: InkRecognitionTarget) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1674,7 +1674,7 @@ impl InkManager { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).SetDefaultRecognizer)(windows_core::Interface::as_raw(this), recognizer.param().abi()).ok() } } - pub fn RecognizeAsync2(&self, strokecollection: P0, recognitiontarget: InkRecognitionTarget) -> windows_core::Result>> + pub fn RecognizeAsync2(&self, strokecollection: P0, recognitiontarget: InkRecognitionTarget) -> windows_core::Result>> where P0: windows_core::Param, { @@ -1755,7 +1755,7 @@ impl InkManager { } } #[cfg(feature = "Storage_Streams")] - pub fn LoadAsync(&self, inputstream: P0) -> windows_core::Result> + pub fn LoadAsync(&self, inputstream: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1766,7 +1766,7 @@ impl InkManager { } } #[cfg(feature = "Storage_Streams")] - pub fn SaveAsync(&self, outputstream: P0) -> windows_core::Result> + pub fn SaveAsync(&self, outputstream: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2517,7 +2517,7 @@ impl InkRecognizerContainer { let this = self; unsafe { (windows_core::Interface::vtable(this).SetDefaultRecognizer)(windows_core::Interface::as_raw(this), recognizer.param().abi()).ok() } } - pub fn RecognizeAsync(&self, strokecollection: P0, recognitiontarget: InkRecognitionTarget) -> windows_core::Result>> + pub fn RecognizeAsync(&self, strokecollection: P0, recognitiontarget: InkRecognitionTarget) -> windows_core::Result>> where P0: windows_core::Param, { @@ -2841,7 +2841,7 @@ impl InkStrokeContainer { } } #[cfg(feature = "Storage_Streams")] - pub fn LoadAsync(&self, inputstream: P0) -> windows_core::Result> + pub fn LoadAsync(&self, inputstream: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2852,7 +2852,7 @@ impl InkStrokeContainer { } } #[cfg(feature = "Storage_Streams")] - pub fn SaveAsync(&self, outputstream: P0) -> windows_core::Result> + pub fn SaveAsync(&self, outputstream: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2895,7 +2895,7 @@ impl InkStrokeContainer { unsafe { (windows_core::Interface::vtable(this).Clear)(windows_core::Interface::as_raw(this)).ok() } } #[cfg(feature = "Storage_Streams")] - pub fn SaveWithFormatAsync(&self, outputstream: P0, inkpersistenceformat: InkPersistenceFormat) -> windows_core::Result> + pub fn SaveWithFormatAsync(&self, outputstream: P0, inkpersistenceformat: InkPersistenceFormat) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/UI/Input/Spatial/mod.rs b/crates/libs/windows/src/Windows/UI/Input/Spatial/mod.rs index cbcccd4a0c..7376a91d19 100644 --- a/crates/libs/windows/src/Windows/UI/Input/Spatial/mod.rs +++ b/crates/libs/windows/src/Windows/UI/Input/Spatial/mod.rs @@ -1048,7 +1048,7 @@ impl SpatialInteractionController { } } #[cfg(feature = "Storage_Streams")] - pub fn TryGetRenderableModelAsync(&self) -> windows_core::Result> { + pub fn TryGetRenderableModelAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1417,7 +1417,7 @@ impl SpatialInteractionSource { } } #[cfg(feature = "Perception_People")] - pub fn TryCreateHandMeshObserverAsync(&self) -> windows_core::Result> { + pub fn TryCreateHandMeshObserverAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/UI/Notifications/Management/mod.rs b/crates/libs/windows/src/Windows/UI/Notifications/Management/mod.rs index 895eee8ea2..fd3f242b63 100644 --- a/crates/libs/windows/src/Windows/UI/Notifications/Management/mod.rs +++ b/crates/libs/windows/src/Windows/UI/Notifications/Management/mod.rs @@ -28,7 +28,7 @@ pub struct IUserNotificationListenerStatics_Vtbl { pub struct UserNotificationListener(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(UserNotificationListener, windows_core::IUnknown, windows_core::IInspectable); impl UserNotificationListener { - pub fn RequestAccessAsync(&self) -> windows_core::Result> { + pub fn RequestAccessAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -56,7 +56,7 @@ impl UserNotificationListener { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveNotificationChanged)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn GetNotificationsAsync(&self, kinds: super::NotificationKinds) -> windows_core::Result>> { + pub fn GetNotificationsAsync(&self, kinds: super::NotificationKinds) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/UI/Notifications/mod.rs b/crates/libs/windows/src/Windows/UI/Notifications/mod.rs index c67d00fa49..0adfc6473c 100644 --- a/crates/libs/windows/src/Windows/UI/Notifications/mod.rs +++ b/crates/libs/windows/src/Windows/UI/Notifications/mod.rs @@ -2669,7 +2669,7 @@ unsafe impl Sync for ToastCollection {} pub struct ToastCollectionManager(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(ToastCollectionManager, windows_core::IUnknown, windows_core::IInspectable); impl ToastCollectionManager { - pub fn SaveToastCollectionAsync(&self, collection: P0) -> windows_core::Result + pub fn SaveToastCollectionAsync(&self, collection: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -2679,28 +2679,28 @@ impl ToastCollectionManager { (windows_core::Interface::vtable(this).SaveToastCollectionAsync)(windows_core::Interface::as_raw(this), collection.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FindAllToastCollectionsAsync(&self) -> windows_core::Result>> { + pub fn FindAllToastCollectionsAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAllToastCollectionsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetToastCollectionAsync(&self, collectionid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetToastCollectionAsync(&self, collectionid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetToastCollectionAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(collectionid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RemoveToastCollectionAsync(&self, collectionid: &windows_core::HSTRING) -> windows_core::Result { + pub fn RemoveToastCollectionAsync(&self, collectionid: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RemoveToastCollectionAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(collectionid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RemoveAllToastCollectionsAsync(&self) -> windows_core::Result { + pub fn RemoveAllToastCollectionsAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -3220,14 +3220,14 @@ impl ToastNotificationManagerForUser { (windows_core::Interface::vtable(this).User)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetToastNotifierForToastCollectionIdAsync(&self, collectionid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetToastNotifierForToastCollectionIdAsync(&self, collectionid: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetToastNotifierForToastCollectionIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(collectionid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetHistoryForToastCollectionIdAsync(&self, collectionid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetHistoryForToastCollectionIdAsync(&self, collectionid: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/UI/Popups/mod.rs b/crates/libs/windows/src/Windows/UI/Popups/mod.rs index 973ca8092d..6fd10e3ea2 100644 --- a/crates/libs/windows/src/Windows/UI/Popups/mod.rs +++ b/crates/libs/windows/src/Windows/UI/Popups/mod.rs @@ -247,7 +247,7 @@ impl MessageDialog { let this = self; unsafe { (windows_core::Interface::vtable(this).SetContent)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(value)).ok() } } - pub fn ShowAsync(&self) -> windows_core::Result> { + pub fn ShowAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -373,21 +373,21 @@ impl PopupMenu { (windows_core::Interface::vtable(this).Commands)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ShowAsync(&self, invocationpoint: super::super::Foundation::Point) -> windows_core::Result> { + pub fn ShowAsync(&self, invocationpoint: super::super::Foundation::Point) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ShowAsync)(windows_core::Interface::as_raw(this), invocationpoint, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ShowAsyncWithRect(&self, selection: super::super::Foundation::Rect) -> windows_core::Result> { + pub fn ShowAsyncWithRect(&self, selection: super::super::Foundation::Rect) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ShowAsyncWithRect)(windows_core::Interface::as_raw(this), selection, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ShowAsyncWithRectAndPlacement(&self, selection: super::super::Foundation::Rect, preferredplacement: Placement) -> windows_core::Result> { + pub fn ShowAsyncWithRectAndPlacement(&self, selection: super::super::Foundation::Rect, preferredplacement: Placement) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/UI/Shell/mod.rs b/crates/libs/windows/src/Windows/UI/Shell/mod.rs index 1054d11f65..6bc303d87e 100644 --- a/crates/libs/windows/src/Windows/UI/Shell/mod.rs +++ b/crates/libs/windows/src/Windows/UI/Shell/mod.rs @@ -717,7 +717,7 @@ impl TaskbarManager { (windows_core::Interface::vtable(this).IsPinningAllowed)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn IsCurrentAppPinnedAsync(&self) -> windows_core::Result> { + pub fn IsCurrentAppPinnedAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -725,7 +725,7 @@ impl TaskbarManager { } } #[cfg(feature = "ApplicationModel_Core")] - pub fn IsAppListEntryPinnedAsync(&self, applistentry: P0) -> windows_core::Result> + pub fn IsAppListEntryPinnedAsync(&self, applistentry: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -735,7 +735,7 @@ impl TaskbarManager { (windows_core::Interface::vtable(this).IsAppListEntryPinnedAsync)(windows_core::Interface::as_raw(this), applistentry.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestPinCurrentAppAsync(&self) -> windows_core::Result> { + pub fn RequestPinCurrentAppAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -743,7 +743,7 @@ impl TaskbarManager { } } #[cfg(feature = "ApplicationModel_Core")] - pub fn RequestPinAppListEntryAsync(&self, applistentry: P0) -> windows_core::Result> + pub fn RequestPinAppListEntryAsync(&self, applistentry: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -753,7 +753,7 @@ impl TaskbarManager { (windows_core::Interface::vtable(this).RequestPinAppListEntryAsync)(windows_core::Interface::as_raw(this), applistentry.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn IsSecondaryTilePinnedAsync(&self, tileid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn IsSecondaryTilePinnedAsync(&self, tileid: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -761,7 +761,7 @@ impl TaskbarManager { } } #[cfg(feature = "UI_StartScreen")] - pub fn RequestPinSecondaryTileAsync(&self, secondarytile: P0) -> windows_core::Result> + pub fn RequestPinSecondaryTileAsync(&self, secondarytile: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -771,7 +771,7 @@ impl TaskbarManager { (windows_core::Interface::vtable(this).RequestPinSecondaryTileAsync)(windows_core::Interface::as_raw(this), secondarytile.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryUnpinSecondaryTileAsync(&self, tileid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn TryUnpinSecondaryTileAsync(&self, tileid: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/UI/StartScreen/mod.rs b/crates/libs/windows/src/Windows/UI/StartScreen/mod.rs index 1fc3dd9545..7d43a5cbf4 100644 --- a/crates/libs/windows/src/Windows/UI/StartScreen/mod.rs +++ b/crates/libs/windows/src/Windows/UI/StartScreen/mod.rs @@ -401,14 +401,14 @@ impl JumpList { let this = self; unsafe { (windows_core::Interface::vtable(this).SetSystemGroupKind)(windows_core::Interface::as_raw(this), value).ok() } } - pub fn SaveAsync(&self) -> windows_core::Result { + pub fn SaveAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).SaveAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn LoadCurrentAsync() -> windows_core::Result> { + pub fn LoadCurrentAsync() -> windows_core::Result> { Self::IJumpListStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).LoadCurrentAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -736,21 +736,21 @@ impl SecondaryTile { (windows_core::Interface::vtable(this).BackgroundColor)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn RequestCreateAsync(&self) -> windows_core::Result> { + pub fn RequestCreateAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestCreateAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestCreateAsyncWithPoint(&self, invocationpoint: super::super::Foundation::Point) -> windows_core::Result> { + pub fn RequestCreateAsyncWithPoint(&self, invocationpoint: super::super::Foundation::Point) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestCreateAsyncWithPoint)(windows_core::Interface::as_raw(this), invocationpoint, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestCreateAsyncWithRect(&self, selection: super::super::Foundation::Rect) -> windows_core::Result> { + pub fn RequestCreateAsyncWithRect(&self, selection: super::super::Foundation::Rect) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -758,28 +758,28 @@ impl SecondaryTile { } } #[cfg(feature = "UI_Popups")] - pub fn RequestCreateAsyncWithRectAndPlacement(&self, selection: super::super::Foundation::Rect, preferredplacement: super::Popups::Placement) -> windows_core::Result> { + pub fn RequestCreateAsyncWithRectAndPlacement(&self, selection: super::super::Foundation::Rect, preferredplacement: super::Popups::Placement) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestCreateAsyncWithRectAndPlacement)(windows_core::Interface::as_raw(this), selection, preferredplacement, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestDeleteAsync(&self) -> windows_core::Result> { + pub fn RequestDeleteAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestDeleteAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestDeleteAsyncWithPoint(&self, invocationpoint: super::super::Foundation::Point) -> windows_core::Result> { + pub fn RequestDeleteAsyncWithPoint(&self, invocationpoint: super::super::Foundation::Point) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestDeleteAsyncWithPoint)(windows_core::Interface::as_raw(this), invocationpoint, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestDeleteAsyncWithRect(&self, selection: super::super::Foundation::Rect) -> windows_core::Result> { + pub fn RequestDeleteAsyncWithRect(&self, selection: super::super::Foundation::Rect) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -787,14 +787,14 @@ impl SecondaryTile { } } #[cfg(feature = "UI_Popups")] - pub fn RequestDeleteAsyncWithRectAndPlacement(&self, selection: super::super::Foundation::Rect, preferredplacement: super::Popups::Placement) -> windows_core::Result> { + pub fn RequestDeleteAsyncWithRectAndPlacement(&self, selection: super::super::Foundation::Rect, preferredplacement: super::Popups::Placement) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestDeleteAsyncWithRectAndPlacement)(windows_core::Interface::as_raw(this), selection, preferredplacement, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn UpdateAsync(&self) -> windows_core::Result> { + pub fn UpdateAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -886,19 +886,19 @@ impl SecondaryTile { (windows_core::Interface::vtable(this).Exists)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(tileid), &mut result__).map(|| result__) }) } - pub fn FindAllAsync() -> windows_core::Result>> { + pub fn FindAllAsync() -> windows_core::Result>> { Self::ISecondaryTileStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAllAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn FindAllForApplicationAsync(applicationid: &windows_core::HSTRING) -> windows_core::Result>> { + pub fn FindAllForApplicationAsync(applicationid: &windows_core::HSTRING) -> windows_core::Result>> { Self::ISecondaryTileStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAllForApplicationAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(applicationid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn FindAllForPackageAsync() -> windows_core::Result>> { + pub fn FindAllForPackageAsync() -> windows_core::Result>> { Self::ISecondaryTileStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAllForPackageAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -1136,7 +1136,7 @@ impl StartScreenManager { } } #[cfg(feature = "ApplicationModel_Core")] - pub fn ContainsAppListEntryAsync(&self, applistentry: P0) -> windows_core::Result> + pub fn ContainsAppListEntryAsync(&self, applistentry: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1147,7 +1147,7 @@ impl StartScreenManager { } } #[cfg(feature = "ApplicationModel_Core")] - pub fn RequestAddAppListEntryAsync(&self, applistentry: P0) -> windows_core::Result> + pub fn RequestAddAppListEntryAsync(&self, applistentry: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1157,14 +1157,14 @@ impl StartScreenManager { (windows_core::Interface::vtable(this).RequestAddAppListEntryAsync)(windows_core::Interface::as_raw(this), applistentry.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ContainsSecondaryTileAsync(&self, tileid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn ContainsSecondaryTileAsync(&self, tileid: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ContainsSecondaryTileAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(tileid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryRemoveSecondaryTileAsync(&self, tileid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn TryRemoveSecondaryTileAsync(&self, tileid: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/UI/UIAutomation/Core/mod.rs b/crates/libs/windows/src/Windows/UI/UIAutomation/Core/mod.rs index 7098f45c14..39be8e4ce3 100644 --- a/crates/libs/windows/src/Windows/UI/UIAutomation/Core/mod.rs +++ b/crates/libs/windows/src/Windows/UI/UIAutomation/Core/mod.rs @@ -454,7 +454,7 @@ impl RemoteAutomationClientSession { let this = self; unsafe { (windows_core::Interface::vtable(this).Stop)(windows_core::Interface::as_raw(this)).ok() } } - pub fn CreateWindowAsync(&self, remotewindowid: u64, remoteprocessid: u32, parentautomationelement: P2) -> windows_core::Result> + pub fn CreateWindowAsync(&self, remotewindowid: u64, remoteprocessid: u32, parentautomationelement: P2) -> windows_core::Result> where P2: windows_core::Param, { @@ -610,7 +610,7 @@ impl RemoteAutomationWindow { (windows_core::Interface::vtable(this).AutomationProvider)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn UnregisterAsync(&self) -> windows_core::Result { + pub fn UnregisterAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/UI/ViewManagement/Core/mod.rs b/crates/libs/windows/src/Windows/UI/ViewManagement/Core/mod.rs index cffead7a1f..4b1672ac03 100644 --- a/crates/libs/windows/src/Windows/UI/ViewManagement/Core/mod.rs +++ b/crates/libs/windows/src/Windows/UI/ViewManagement/Core/mod.rs @@ -826,7 +826,7 @@ impl UISettingsController { let this = self; unsafe { (windows_core::Interface::vtable(this).SetTextScaleFactor)(windows_core::Interface::as_raw(this), value).ok() } } - pub fn RequestDefaultAsync() -> windows_core::Result> { + pub fn RequestDefaultAsync() -> windows_core::Result> { Self::IUISettingsControllerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestDefaultAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/UI/ViewManagement/mod.rs b/crates/libs/windows/src/Windows/UI/ViewManagement/mod.rs index c1e9930f2d..c2ef353ec4 100644 --- a/crates/libs/windows/src/Windows/UI/ViewManagement/mod.rs +++ b/crates/libs/windows/src/Windows/UI/ViewManagement/mod.rs @@ -58,14 +58,14 @@ unsafe impl Sync for AccessibilitySettings {} pub struct ActivationViewSwitcher(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(ActivationViewSwitcher, windows_core::IUnknown, windows_core::IInspectable); impl ActivationViewSwitcher { - pub fn ShowAsStandaloneAsync(&self, viewid: i32) -> windows_core::Result { + pub fn ShowAsStandaloneAsync(&self, viewid: i32) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ShowAsStandaloneAsync)(windows_core::Interface::as_raw(this), viewid, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ShowAsStandaloneWithSizePreferenceAsync(&self, viewid: i32, sizepreference: ViewSizePreference) -> windows_core::Result { + pub fn ShowAsStandaloneWithSizePreferenceAsync(&self, viewid: i32, sizepreference: ViewSizePreference) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -289,14 +289,14 @@ impl ApplicationView { (windows_core::Interface::vtable(this).IsViewModeSupported)(windows_core::Interface::as_raw(this), viewmode, &mut result__).map(|| result__) } } - pub fn TryEnterViewModeAsync(&self, viewmode: ApplicationViewMode) -> windows_core::Result> { + pub fn TryEnterViewModeAsync(&self, viewmode: ApplicationViewMode) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryEnterViewModeAsync)(windows_core::Interface::as_raw(this), viewmode, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryEnterViewModeWithPreferencesAsync(&self, viewmode: ApplicationViewMode, viewmodepreferences: P1) -> windows_core::Result> + pub fn TryEnterViewModeWithPreferencesAsync(&self, viewmode: ApplicationViewMode, viewmodepreferences: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -306,7 +306,7 @@ impl ApplicationView { (windows_core::Interface::vtable(this).TryEnterViewModeWithPreferencesAsync)(windows_core::Interface::as_raw(this), viewmode, viewmodepreferences.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryConsolidateAsync(&self) -> windows_core::Result> { + pub fn TryConsolidateAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -579,43 +579,43 @@ impl ApplicationViewSwitcher { pub fn DisableShowingMainViewOnActivation() -> windows_core::Result<()> { Self::IApplicationViewSwitcherStatics(|this| unsafe { (windows_core::Interface::vtable(this).DisableShowingMainViewOnActivation)(windows_core::Interface::as_raw(this)).ok() }) } - pub fn TryShowAsStandaloneAsync(viewid: i32) -> windows_core::Result> { + pub fn TryShowAsStandaloneAsync(viewid: i32) -> windows_core::Result> { Self::IApplicationViewSwitcherStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryShowAsStandaloneAsync)(windows_core::Interface::as_raw(this), viewid, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn TryShowAsStandaloneWithSizePreferenceAsync(viewid: i32, sizepreference: ViewSizePreference) -> windows_core::Result> { + pub fn TryShowAsStandaloneWithSizePreferenceAsync(viewid: i32, sizepreference: ViewSizePreference) -> windows_core::Result> { Self::IApplicationViewSwitcherStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryShowAsStandaloneWithSizePreferenceAsync)(windows_core::Interface::as_raw(this), viewid, sizepreference, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn TryShowAsStandaloneWithAnchorViewAndSizePreferenceAsync(viewid: i32, sizepreference: ViewSizePreference, anchorviewid: i32, anchorsizepreference: ViewSizePreference) -> windows_core::Result> { + pub fn TryShowAsStandaloneWithAnchorViewAndSizePreferenceAsync(viewid: i32, sizepreference: ViewSizePreference, anchorviewid: i32, anchorsizepreference: ViewSizePreference) -> windows_core::Result> { Self::IApplicationViewSwitcherStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryShowAsStandaloneWithAnchorViewAndSizePreferenceAsync)(windows_core::Interface::as_raw(this), viewid, sizepreference, anchorviewid, anchorsizepreference, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn SwitchAsync(viewid: i32) -> windows_core::Result { + pub fn SwitchAsync(viewid: i32) -> windows_core::Result { Self::IApplicationViewSwitcherStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).SwitchAsync)(windows_core::Interface::as_raw(this), viewid, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn SwitchFromViewAsync(toviewid: i32, fromviewid: i32) -> windows_core::Result { + pub fn SwitchFromViewAsync(toviewid: i32, fromviewid: i32) -> windows_core::Result { Self::IApplicationViewSwitcherStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).SwitchFromViewAsync)(windows_core::Interface::as_raw(this), toviewid, fromviewid, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn SwitchFromViewWithOptionsAsync(toviewid: i32, fromviewid: i32, options: ApplicationViewSwitchingOptions) -> windows_core::Result { + pub fn SwitchFromViewWithOptionsAsync(toviewid: i32, fromviewid: i32, options: ApplicationViewSwitchingOptions) -> windows_core::Result { Self::IApplicationViewSwitcherStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).SwitchFromViewWithOptionsAsync)(windows_core::Interface::as_raw(this), toviewid, fromviewid, options, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn PrepareForCustomAnimatedSwitchAsync(toviewid: i32, fromviewid: i32, options: ApplicationViewSwitchingOptions) -> windows_core::Result> { + pub fn PrepareForCustomAnimatedSwitchAsync(toviewid: i32, fromviewid: i32, options: ApplicationViewSwitchingOptions) -> windows_core::Result> { Self::IApplicationViewSwitcherStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).PrepareForCustomAnimatedSwitchAsync)(windows_core::Interface::as_raw(this), toviewid, fromviewid, options, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -624,13 +624,13 @@ impl ApplicationViewSwitcher { pub fn DisableSystemViewActivationPolicy() -> windows_core::Result<()> { Self::IApplicationViewSwitcherStatics2(|this| unsafe { (windows_core::Interface::vtable(this).DisableSystemViewActivationPolicy)(windows_core::Interface::as_raw(this)).ok() }) } - pub fn TryShowAsViewModeAsync(viewid: i32, viewmode: ApplicationViewMode) -> windows_core::Result> { + pub fn TryShowAsViewModeAsync(viewid: i32, viewmode: ApplicationViewMode) -> windows_core::Result> { Self::IApplicationViewSwitcherStatics3(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryShowAsViewModeAsync)(windows_core::Interface::as_raw(this), viewid, viewmode, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn TryShowAsViewModeWithPreferencesAsync(viewid: i32, viewmode: ApplicationViewMode, viewmodepreferences: P2) -> windows_core::Result> + pub fn TryShowAsViewModeWithPreferencesAsync(viewid: i32, viewmode: ApplicationViewMode, viewmodepreferences: P2) -> windows_core::Result> where P2: windows_core::Param, { @@ -1712,19 +1712,19 @@ impl windows_core::RuntimeName for InputPaneVisibilityEventArgs { } pub struct ProjectionManager; impl ProjectionManager { - pub fn StartProjectingAsync(projectionviewid: i32, anchorviewid: i32) -> windows_core::Result { + pub fn StartProjectingAsync(projectionviewid: i32, anchorviewid: i32) -> windows_core::Result { Self::IProjectionManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).StartProjectingAsync)(windows_core::Interface::as_raw(this), projectionviewid, anchorviewid, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn SwapDisplaysForViewsAsync(projectionviewid: i32, anchorviewid: i32) -> windows_core::Result { + pub fn SwapDisplaysForViewsAsync(projectionviewid: i32, anchorviewid: i32) -> windows_core::Result { Self::IProjectionManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).SwapDisplaysForViewsAsync)(windows_core::Interface::as_raw(this), projectionviewid, anchorviewid, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn StopProjectingAsync(projectionviewid: i32, anchorviewid: i32) -> windows_core::Result { + pub fn StopProjectingAsync(projectionviewid: i32, anchorviewid: i32) -> windows_core::Result { Self::IProjectionManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).StopProjectingAsync)(windows_core::Interface::as_raw(this), projectionviewid, anchorviewid, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -1749,7 +1749,7 @@ impl ProjectionManager { Self::IProjectionManagerStatics(|this| unsafe { (windows_core::Interface::vtable(this).RemoveProjectionDisplayAvailableChanged)(windows_core::Interface::as_raw(this), token).ok() }) } #[cfg(feature = "Devices_Enumeration")] - pub fn StartProjectingWithDeviceInfoAsync(projectionviewid: i32, anchorviewid: i32, displaydeviceinfo: P2) -> windows_core::Result + pub fn StartProjectingWithDeviceInfoAsync(projectionviewid: i32, anchorviewid: i32, displaydeviceinfo: P2) -> windows_core::Result where P2: windows_core::Param, { @@ -1758,14 +1758,14 @@ impl ProjectionManager { (windows_core::Interface::vtable(this).StartProjectingWithDeviceInfoAsync)(windows_core::Interface::as_raw(this), projectionviewid, anchorviewid, displaydeviceinfo.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RequestStartProjectingAsync(projectionviewid: i32, anchorviewid: i32, selection: super::super::Foundation::Rect) -> windows_core::Result> { + pub fn RequestStartProjectingAsync(projectionviewid: i32, anchorviewid: i32, selection: super::super::Foundation::Rect) -> windows_core::Result> { Self::IProjectionManagerStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestStartProjectingAsync)(windows_core::Interface::as_raw(this), projectionviewid, anchorviewid, selection, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "UI_Popups")] - pub fn RequestStartProjectingWithPlacementAsync(projectionviewid: i32, anchorviewid: i32, selection: super::super::Foundation::Rect, prefferedplacement: super::Popups::Placement) -> windows_core::Result> { + pub fn RequestStartProjectingWithPlacementAsync(projectionviewid: i32, anchorviewid: i32, selection: super::super::Foundation::Rect, prefferedplacement: super::Popups::Placement) -> windows_core::Result> { Self::IProjectionManagerStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestStartProjectingWithPlacementAsync)(windows_core::Interface::as_raw(this), projectionviewid, anchorviewid, selection, prefferedplacement, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -1807,14 +1807,14 @@ impl windows_core::RuntimeType for ScreenCaptureDisabledBehavior { pub struct StatusBar(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(StatusBar, windows_core::IUnknown, windows_core::IInspectable); impl StatusBar { - pub fn ShowAsync(&self) -> windows_core::Result { + pub fn ShowAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ShowAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn HideAsync(&self) -> windows_core::Result { + pub fn HideAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1930,14 +1930,14 @@ unsafe impl Sync for StatusBar {} pub struct StatusBarProgressIndicator(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(StatusBarProgressIndicator, windows_core::IUnknown, windows_core::IInspectable); impl StatusBarProgressIndicator { - pub fn ShowAsync(&self) -> windows_core::Result { + pub fn ShowAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ShowAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn HideAsync(&self) -> windows_core::Result { + pub fn HideAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/UI/WebUI/mod.rs b/crates/libs/windows/src/Windows/UI/WebUI/mod.rs index 5a133046be..f11128e6cc 100644 --- a/crates/libs/windows/src/Windows/UI/WebUI/mod.rs +++ b/crates/libs/windows/src/Windows/UI/WebUI/mod.rs @@ -1383,14 +1383,14 @@ impl WebUIApplication { Self::IWebUIActivationStatics2(|this| unsafe { (windows_core::Interface::vtable(this).EnablePrelaunch)(windows_core::Interface::as_raw(this), value).ok() }) } #[cfg(feature = "ApplicationModel_Core")] - pub fn RequestRestartAsync(launcharguments: &windows_core::HSTRING) -> windows_core::Result> { + pub fn RequestRestartAsync(launcharguments: &windows_core::HSTRING) -> windows_core::Result> { Self::IWebUIActivationStatics3(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestRestartAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(launcharguments), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(all(feature = "ApplicationModel_Core", feature = "System"))] - pub fn RequestRestartForUserAsync(user: P0, launcharguments: &windows_core::HSTRING) -> windows_core::Result> + pub fn RequestRestartForUserAsync(user: P0, launcharguments: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -4752,13 +4752,13 @@ impl WebUIView { let this = self; unsafe { (windows_core::Interface::vtable(this).SetIgnoreApplicationContentUriRulesNavigationRestrictions)(windows_core::Interface::as_raw(this), value).ok() } } - pub fn CreateAsync() -> windows_core::Result> { + pub fn CreateAsync() -> windows_core::Result> { Self::IWebUIViewStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreateAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn CreateWithUriAsync(uri: P0) -> windows_core::Result> + pub fn CreateWithUriAsync(uri: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -4878,7 +4878,7 @@ impl WebUIView { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).NavigateWithHttpRequestMessage)(windows_core::Interface::as_raw(this), requestmessage.param().abi()).ok() } } - pub fn InvokeScriptAsync(&self, scriptname: &windows_core::HSTRING, arguments: P1) -> windows_core::Result> + pub fn InvokeScriptAsync(&self, scriptname: &windows_core::HSTRING, arguments: P1) -> windows_core::Result> where P1: windows_core::Param>, { @@ -4889,7 +4889,7 @@ impl WebUIView { } } #[cfg(feature = "Storage_Streams")] - pub fn CapturePreviewToStreamAsync(&self, stream: P0) -> windows_core::Result + pub fn CapturePreviewToStreamAsync(&self, stream: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -4900,7 +4900,7 @@ impl WebUIView { } } #[cfg(feature = "ApplicationModel_DataTransfer")] - pub fn CaptureSelectedContentToDataPackageAsync(&self) -> windows_core::Result> { + pub fn CaptureSelectedContentToDataPackageAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/UI/WindowManagement/mod.rs b/crates/libs/windows/src/Windows/UI/WindowManagement/mod.rs index d375c95e14..e5a0c7c574 100644 --- a/crates/libs/windows/src/Windows/UI/WindowManagement/mod.rs +++ b/crates/libs/windows/src/Windows/UI/WindowManagement/mod.rs @@ -84,7 +84,7 @@ impl AppWindow { (windows_core::Interface::vtable(this).WindowingEnvironment)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CloseAsync(&self) -> windows_core::Result { + pub fn CloseAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -145,7 +145,7 @@ impl AppWindow { let this = self; unsafe { (windows_core::Interface::vtable(this).RequestSize)(windows_core::Interface::as_raw(this), framesize).ok() } } - pub fn TryShowAsync(&self) -> windows_core::Result> { + pub fn TryShowAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -194,7 +194,7 @@ impl AppWindow { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveCloseRequested)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn TryCreateAsync() -> windows_core::Result> { + pub fn TryCreateAsync() -> windows_core::Result> { Self::IAppWindowStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryCreateAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/Web/AtomPub/mod.rs b/crates/libs/windows/src/Windows/Web/AtomPub/mod.rs index 0f6bbbd3fb..61d9e5c679 100644 --- a/crates/libs/windows/src/Windows/Web/AtomPub/mod.rs +++ b/crates/libs/windows/src/Windows/Web/AtomPub/mod.rs @@ -15,7 +15,7 @@ impl AtomPubClient { static SHARED: windows_core::imp::FactoryCache = windows_core::imp::FactoryCache::new(); SHARED.call(callback) } - pub fn RetrieveServiceDocumentAsync(&self, uri: P0) -> windows_core::Result> + pub fn RetrieveServiceDocumentAsync(&self, uri: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -26,7 +26,7 @@ impl AtomPubClient { } } #[cfg(feature = "Storage_Streams")] - pub fn RetrieveMediaResourceAsync(&self, uri: P0) -> windows_core::Result> + pub fn RetrieveMediaResourceAsync(&self, uri: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -36,7 +36,7 @@ impl AtomPubClient { (windows_core::Interface::vtable(this).RetrieveMediaResourceAsync)(windows_core::Interface::as_raw(this), uri.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RetrieveResourceAsync(&self, uri: P0) -> windows_core::Result> + pub fn RetrieveResourceAsync(&self, uri: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -46,7 +46,7 @@ impl AtomPubClient { (windows_core::Interface::vtable(this).RetrieveResourceAsync)(windows_core::Interface::as_raw(this), uri.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateResourceAsync(&self, uri: P0, description: &windows_core::HSTRING, item: P2) -> windows_core::Result> + pub fn CreateResourceAsync(&self, uri: P0, description: &windows_core::HSTRING, item: P2) -> windows_core::Result> where P0: windows_core::Param, P2: windows_core::Param, @@ -58,7 +58,7 @@ impl AtomPubClient { } } #[cfg(feature = "Storage_Streams")] - pub fn CreateMediaResourceAsync(&self, uri: P0, mediatype: &windows_core::HSTRING, description: &windows_core::HSTRING, mediastream: P3) -> windows_core::Result> + pub fn CreateMediaResourceAsync(&self, uri: P0, mediatype: &windows_core::HSTRING, description: &windows_core::HSTRING, mediastream: P3) -> windows_core::Result> where P0: windows_core::Param, P3: windows_core::Param, @@ -70,7 +70,7 @@ impl AtomPubClient { } } #[cfg(feature = "Storage_Streams")] - pub fn UpdateMediaResourceAsync(&self, uri: P0, mediatype: &windows_core::HSTRING, mediastream: P2) -> windows_core::Result> + pub fn UpdateMediaResourceAsync(&self, uri: P0, mediatype: &windows_core::HSTRING, mediastream: P2) -> windows_core::Result> where P0: windows_core::Param, P2: windows_core::Param, @@ -81,7 +81,7 @@ impl AtomPubClient { (windows_core::Interface::vtable(this).UpdateMediaResourceAsync)(windows_core::Interface::as_raw(this), uri.param().abi(), core::mem::transmute_copy(mediatype), mediastream.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn UpdateResourceAsync(&self, uri: P0, item: P1) -> windows_core::Result> + pub fn UpdateResourceAsync(&self, uri: P0, item: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -92,7 +92,7 @@ impl AtomPubClient { (windows_core::Interface::vtable(this).UpdateResourceAsync)(windows_core::Interface::as_raw(this), uri.param().abi(), item.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn UpdateResourceItemAsync(&self, item: P0) -> windows_core::Result> + pub fn UpdateResourceItemAsync(&self, item: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -102,7 +102,7 @@ impl AtomPubClient { (windows_core::Interface::vtable(this).UpdateResourceItemAsync)(windows_core::Interface::as_raw(this), item.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteResourceAsync(&self, uri: P0) -> windows_core::Result> + pub fn DeleteResourceAsync(&self, uri: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -112,7 +112,7 @@ impl AtomPubClient { (windows_core::Interface::vtable(this).DeleteResourceAsync)(windows_core::Interface::as_raw(this), uri.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteResourceItemAsync(&self, item: P0) -> windows_core::Result> + pub fn DeleteResourceItemAsync(&self, item: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -205,7 +205,7 @@ impl AtomPubClient { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).SetRequestHeader)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(name), core::mem::transmute_copy(value)).ok() } } - pub fn RetrieveFeedAsync(&self, uri: P0) -> windows_core::Result> + pub fn RetrieveFeedAsync(&self, uri: P0) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Web/Http/Filters/mod.rs b/crates/libs/windows/src/Windows/Web/Http/Filters/mod.rs index 6e480bc278..b900b7df3e 100644 --- a/crates/libs/windows/src/Windows/Web/Http/Filters/mod.rs +++ b/crates/libs/windows/src/Windows/Web/Http/Filters/mod.rs @@ -198,7 +198,7 @@ impl HttpBaseProtocolFilter { (windows_core::Interface::vtable(this).CreateForUser)(windows_core::Interface::as_raw(this), user.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn SendRequestAsync(&self, request: P0) -> windows_core::Result> + pub fn SendRequestAsync(&self, request: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -496,7 +496,7 @@ impl windows_core::RuntimeType for IHttpFilter { windows_core::imp::interface_hierarchy!(IHttpFilter, windows_core::IUnknown, windows_core::IInspectable); windows_core::imp::required_hierarchy!(IHttpFilter, super::super::super::Foundation::IClosable); impl IHttpFilter { - pub fn SendRequestAsync(&self, request: P0) -> windows_core::Result> + pub fn SendRequestAsync(&self, request: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -515,7 +515,7 @@ impl windows_core::RuntimeName for IHttpFilter { const NAME: &'static str = "Windows.Web.Http.Filters.IHttpFilter"; } pub trait IHttpFilter_Impl: super::super::super::Foundation::IClosable_Impl { - fn SendRequestAsync(&self, request: windows_core::Ref<'_, super::HttpRequestMessage>) -> windows_core::Result>; + fn SendRequestAsync(&self, request: windows_core::Ref<'_, super::HttpRequestMessage>) -> windows_core::Result>; } impl IHttpFilter_Vtbl { pub const fn new() -> Self { diff --git a/crates/libs/windows/src/Windows/Web/Http/mod.rs b/crates/libs/windows/src/Windows/Web/Http/mod.rs index f335383de0..5933a0219a 100644 --- a/crates/libs/windows/src/Windows/Web/Http/mod.rs +++ b/crates/libs/windows/src/Windows/Web/Http/mod.rs @@ -42,7 +42,7 @@ impl HttpBufferContent { (windows_core::Interface::vtable(this).Headers)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn BufferAllAsync(&self) -> windows_core::Result> { + pub fn BufferAllAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -50,7 +50,7 @@ impl HttpBufferContent { } } #[cfg(feature = "Storage_Streams")] - pub fn ReadAsBufferAsync(&self) -> windows_core::Result> { + pub fn ReadAsBufferAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -58,14 +58,14 @@ impl HttpBufferContent { } } #[cfg(feature = "Storage_Streams")] - pub fn ReadAsInputStreamAsync(&self) -> windows_core::Result> { + pub fn ReadAsInputStreamAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReadAsInputStreamAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReadAsStringAsync(&self) -> windows_core::Result> { + pub fn ReadAsStringAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -80,7 +80,7 @@ impl HttpBufferContent { } } #[cfg(feature = "Storage_Streams")] - pub fn WriteToStreamAsync(&self, outputstream: P0) -> windows_core::Result> + pub fn WriteToStreamAsync(&self, outputstream: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -131,7 +131,7 @@ impl HttpClient { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).Close)(windows_core::Interface::as_raw(this)).ok() } } - pub fn DeleteAsync(&self, uri: P0) -> windows_core::Result> + pub fn DeleteAsync(&self, uri: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -141,7 +141,7 @@ impl HttpClient { (windows_core::Interface::vtable(this).DeleteAsync)(windows_core::Interface::as_raw(this), uri.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAsync(&self, uri: P0) -> windows_core::Result> + pub fn GetAsync(&self, uri: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -151,7 +151,7 @@ impl HttpClient { (windows_core::Interface::vtable(this).GetAsync)(windows_core::Interface::as_raw(this), uri.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetWithOptionAsync(&self, uri: P0, completionoption: HttpCompletionOption) -> windows_core::Result> + pub fn GetWithOptionAsync(&self, uri: P0, completionoption: HttpCompletionOption) -> windows_core::Result> where P0: windows_core::Param, { @@ -162,7 +162,7 @@ impl HttpClient { } } #[cfg(feature = "Storage_Streams")] - pub fn GetBufferAsync(&self, uri: P0) -> windows_core::Result> + pub fn GetBufferAsync(&self, uri: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -173,7 +173,7 @@ impl HttpClient { } } #[cfg(feature = "Storage_Streams")] - pub fn GetInputStreamAsync(&self, uri: P0) -> windows_core::Result> + pub fn GetInputStreamAsync(&self, uri: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -183,7 +183,7 @@ impl HttpClient { (windows_core::Interface::vtable(this).GetInputStreamAsync)(windows_core::Interface::as_raw(this), uri.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetStringAsync(&self, uri: P0) -> windows_core::Result> + pub fn GetStringAsync(&self, uri: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -193,7 +193,7 @@ impl HttpClient { (windows_core::Interface::vtable(this).GetStringAsync)(windows_core::Interface::as_raw(this), uri.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn PostAsync(&self, uri: P0, content: P1) -> windows_core::Result> + pub fn PostAsync(&self, uri: P0, content: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -204,7 +204,7 @@ impl HttpClient { (windows_core::Interface::vtable(this).PostAsync)(windows_core::Interface::as_raw(this), uri.param().abi(), content.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn PutAsync(&self, uri: P0, content: P1) -> windows_core::Result> + pub fn PutAsync(&self, uri: P0, content: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -215,7 +215,7 @@ impl HttpClient { (windows_core::Interface::vtable(this).PutAsync)(windows_core::Interface::as_raw(this), uri.param().abi(), content.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SendRequestAsync(&self, request: P0) -> windows_core::Result> + pub fn SendRequestAsync(&self, request: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -225,7 +225,7 @@ impl HttpClient { (windows_core::Interface::vtable(this).SendRequestAsync)(windows_core::Interface::as_raw(this), request.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SendRequestWithOptionAsync(&self, request: P0, completionoption: HttpCompletionOption) -> windows_core::Result> + pub fn SendRequestWithOptionAsync(&self, request: P0, completionoption: HttpCompletionOption) -> windows_core::Result> where P0: windows_core::Param, { @@ -243,7 +243,7 @@ impl HttpClient { (windows_core::Interface::vtable(this).DefaultRequestHeaders)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryDeleteAsync(&self, uri: P0) -> windows_core::Result> + pub fn TryDeleteAsync(&self, uri: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -253,7 +253,7 @@ impl HttpClient { (windows_core::Interface::vtable(this).TryDeleteAsync)(windows_core::Interface::as_raw(this), uri.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryGetAsync(&self, uri: P0) -> windows_core::Result> + pub fn TryGetAsync(&self, uri: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -263,7 +263,7 @@ impl HttpClient { (windows_core::Interface::vtable(this).TryGetAsync)(windows_core::Interface::as_raw(this), uri.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryGetAsync2(&self, uri: P0, completionoption: HttpCompletionOption) -> windows_core::Result> + pub fn TryGetAsync2(&self, uri: P0, completionoption: HttpCompletionOption) -> windows_core::Result> where P0: windows_core::Param, { @@ -273,7 +273,7 @@ impl HttpClient { (windows_core::Interface::vtable(this).TryGetAsync2)(windows_core::Interface::as_raw(this), uri.param().abi(), completionoption, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryGetBufferAsync(&self, uri: P0) -> windows_core::Result> + pub fn TryGetBufferAsync(&self, uri: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -283,7 +283,7 @@ impl HttpClient { (windows_core::Interface::vtable(this).TryGetBufferAsync)(windows_core::Interface::as_raw(this), uri.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryGetInputStreamAsync(&self, uri: P0) -> windows_core::Result> + pub fn TryGetInputStreamAsync(&self, uri: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -293,7 +293,7 @@ impl HttpClient { (windows_core::Interface::vtable(this).TryGetInputStreamAsync)(windows_core::Interface::as_raw(this), uri.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryGetStringAsync(&self, uri: P0) -> windows_core::Result> + pub fn TryGetStringAsync(&self, uri: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -303,7 +303,7 @@ impl HttpClient { (windows_core::Interface::vtable(this).TryGetStringAsync)(windows_core::Interface::as_raw(this), uri.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryPostAsync(&self, uri: P0, content: P1) -> windows_core::Result> + pub fn TryPostAsync(&self, uri: P0, content: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -314,7 +314,7 @@ impl HttpClient { (windows_core::Interface::vtable(this).TryPostAsync)(windows_core::Interface::as_raw(this), uri.param().abi(), content.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryPutAsync(&self, uri: P0, content: P1) -> windows_core::Result> + pub fn TryPutAsync(&self, uri: P0, content: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -325,7 +325,7 @@ impl HttpClient { (windows_core::Interface::vtable(this).TryPutAsync)(windows_core::Interface::as_raw(this), uri.param().abi(), content.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TrySendRequestAsync(&self, request: P0) -> windows_core::Result> + pub fn TrySendRequestAsync(&self, request: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -335,7 +335,7 @@ impl HttpClient { (windows_core::Interface::vtable(this).TrySendRequestAsync)(windows_core::Interface::as_raw(this), request.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TrySendRequestAsync2(&self, request: P0, completionoption: HttpCompletionOption) -> windows_core::Result> + pub fn TrySendRequestAsync2(&self, request: P0, completionoption: HttpCompletionOption) -> windows_core::Result> where P0: windows_core::Param, { @@ -651,7 +651,7 @@ impl HttpFormUrlEncodedContent { (windows_core::Interface::vtable(this).Headers)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn BufferAllAsync(&self) -> windows_core::Result> { + pub fn BufferAllAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -659,7 +659,7 @@ impl HttpFormUrlEncodedContent { } } #[cfg(feature = "Storage_Streams")] - pub fn ReadAsBufferAsync(&self) -> windows_core::Result> { + pub fn ReadAsBufferAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -667,14 +667,14 @@ impl HttpFormUrlEncodedContent { } } #[cfg(feature = "Storage_Streams")] - pub fn ReadAsInputStreamAsync(&self) -> windows_core::Result> { + pub fn ReadAsInputStreamAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReadAsInputStreamAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReadAsStringAsync(&self) -> windows_core::Result> { + pub fn ReadAsStringAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -689,7 +689,7 @@ impl HttpFormUrlEncodedContent { } } #[cfg(feature = "Storage_Streams")] - pub fn WriteToStreamAsync(&self, outputstream: P0) -> windows_core::Result> + pub fn WriteToStreamAsync(&self, outputstream: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1043,7 +1043,7 @@ impl HttpMultipartContent { (windows_core::Interface::vtable(this).Headers)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn BufferAllAsync(&self) -> windows_core::Result> { + pub fn BufferAllAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1051,7 +1051,7 @@ impl HttpMultipartContent { } } #[cfg(feature = "Storage_Streams")] - pub fn ReadAsBufferAsync(&self) -> windows_core::Result> { + pub fn ReadAsBufferAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1059,14 +1059,14 @@ impl HttpMultipartContent { } } #[cfg(feature = "Storage_Streams")] - pub fn ReadAsInputStreamAsync(&self) -> windows_core::Result> { + pub fn ReadAsInputStreamAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReadAsInputStreamAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReadAsStringAsync(&self) -> windows_core::Result> { + pub fn ReadAsStringAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1081,7 +1081,7 @@ impl HttpMultipartContent { } } #[cfg(feature = "Storage_Streams")] - pub fn WriteToStreamAsync(&self, outputstream: P0) -> windows_core::Result> + pub fn WriteToStreamAsync(&self, outputstream: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1180,7 +1180,7 @@ impl HttpMultipartFormDataContent { (windows_core::Interface::vtable(this).Headers)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn BufferAllAsync(&self) -> windows_core::Result> { + pub fn BufferAllAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1188,7 +1188,7 @@ impl HttpMultipartFormDataContent { } } #[cfg(feature = "Storage_Streams")] - pub fn ReadAsBufferAsync(&self) -> windows_core::Result> { + pub fn ReadAsBufferAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1196,14 +1196,14 @@ impl HttpMultipartFormDataContent { } } #[cfg(feature = "Storage_Streams")] - pub fn ReadAsInputStreamAsync(&self) -> windows_core::Result> { + pub fn ReadAsInputStreamAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReadAsInputStreamAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReadAsStringAsync(&self) -> windows_core::Result> { + pub fn ReadAsStringAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1218,7 +1218,7 @@ impl HttpMultipartFormDataContent { } } #[cfg(feature = "Storage_Streams")] - pub fn WriteToStreamAsync(&self, outputstream: P0) -> windows_core::Result> + pub fn WriteToStreamAsync(&self, outputstream: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1763,7 +1763,7 @@ impl HttpStreamContent { (windows_core::Interface::vtable(this).Headers)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn BufferAllAsync(&self) -> windows_core::Result> { + pub fn BufferAllAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1771,7 +1771,7 @@ impl HttpStreamContent { } } #[cfg(feature = "Storage_Streams")] - pub fn ReadAsBufferAsync(&self) -> windows_core::Result> { + pub fn ReadAsBufferAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1779,14 +1779,14 @@ impl HttpStreamContent { } } #[cfg(feature = "Storage_Streams")] - pub fn ReadAsInputStreamAsync(&self) -> windows_core::Result> { + pub fn ReadAsInputStreamAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReadAsInputStreamAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReadAsStringAsync(&self) -> windows_core::Result> { + pub fn ReadAsStringAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1801,7 +1801,7 @@ impl HttpStreamContent { } } #[cfg(feature = "Storage_Streams")] - pub fn WriteToStreamAsync(&self, outputstream: P0) -> windows_core::Result> + pub fn WriteToStreamAsync(&self, outputstream: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1863,7 +1863,7 @@ impl HttpStringContent { (windows_core::Interface::vtable(this).Headers)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn BufferAllAsync(&self) -> windows_core::Result> { + pub fn BufferAllAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1871,7 +1871,7 @@ impl HttpStringContent { } } #[cfg(feature = "Storage_Streams")] - pub fn ReadAsBufferAsync(&self) -> windows_core::Result> { + pub fn ReadAsBufferAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1879,14 +1879,14 @@ impl HttpStringContent { } } #[cfg(feature = "Storage_Streams")] - pub fn ReadAsInputStreamAsync(&self) -> windows_core::Result> { + pub fn ReadAsInputStreamAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReadAsInputStreamAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReadAsStringAsync(&self) -> windows_core::Result> { + pub fn ReadAsStringAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1901,7 +1901,7 @@ impl HttpStringContent { } } #[cfg(feature = "Storage_Streams")] - pub fn WriteToStreamAsync(&self, outputstream: P0) -> windows_core::Result> + pub fn WriteToStreamAsync(&self, outputstream: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2127,7 +2127,7 @@ impl IHttpContent { (windows_core::Interface::vtable(this).Headers)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn BufferAllAsync(&self) -> windows_core::Result> { + pub fn BufferAllAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2135,7 +2135,7 @@ impl IHttpContent { } } #[cfg(feature = "Storage_Streams")] - pub fn ReadAsBufferAsync(&self) -> windows_core::Result> { + pub fn ReadAsBufferAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2143,14 +2143,14 @@ impl IHttpContent { } } #[cfg(feature = "Storage_Streams")] - pub fn ReadAsInputStreamAsync(&self) -> windows_core::Result> { + pub fn ReadAsInputStreamAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReadAsInputStreamAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReadAsStringAsync(&self) -> windows_core::Result> { + pub fn ReadAsStringAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2165,7 +2165,7 @@ impl IHttpContent { } } #[cfg(feature = "Storage_Streams")] - pub fn WriteToStreamAsync(&self, outputstream: P0) -> windows_core::Result> + pub fn WriteToStreamAsync(&self, outputstream: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2187,12 +2187,12 @@ impl windows_core::RuntimeName for IHttpContent { #[cfg(all(feature = "Storage_Streams", feature = "Web_Http_Headers"))] pub trait IHttpContent_Impl: super::super::Foundation::IClosable_Impl { fn Headers(&self) -> windows_core::Result; - fn BufferAllAsync(&self) -> windows_core::Result>; - fn ReadAsBufferAsync(&self) -> windows_core::Result>; - fn ReadAsInputStreamAsync(&self) -> windows_core::Result>; - fn ReadAsStringAsync(&self) -> windows_core::Result>; + fn BufferAllAsync(&self) -> windows_core::Result>; + fn ReadAsBufferAsync(&self) -> windows_core::Result>; + fn ReadAsInputStreamAsync(&self) -> windows_core::Result>; + fn ReadAsStringAsync(&self) -> windows_core::Result>; fn TryComputeLength(&self, length: &mut u64) -> windows_core::Result; - fn WriteToStreamAsync(&self, outputStream: windows_core::Ref<'_, super::super::Storage::Streams::IOutputStream>) -> windows_core::Result>; + fn WriteToStreamAsync(&self, outputStream: windows_core::Ref<'_, super::super::Storage::Streams::IOutputStream>) -> windows_core::Result>; } #[cfg(all(feature = "Storage_Streams", feature = "Web_Http_Headers"))] impl IHttpContent_Vtbl { diff --git a/crates/libs/windows/src/Windows/Web/Syndication/mod.rs b/crates/libs/windows/src/Windows/Web/Syndication/mod.rs index cd642fdffa..8653a2489f 100644 --- a/crates/libs/windows/src/Windows/Web/Syndication/mod.rs +++ b/crates/libs/windows/src/Windows/Web/Syndication/mod.rs @@ -120,7 +120,7 @@ impl ISyndicationClient { let this = self; unsafe { (windows_core::Interface::vtable(this).SetRequestHeader)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(name), core::mem::transmute_copy(value)).ok() } } - pub fn RetrieveFeedAsync(&self, uri: P0) -> windows_core::Result> + pub fn RetrieveFeedAsync(&self, uri: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -148,7 +148,7 @@ pub trait ISyndicationClient_Impl: windows_core::IUnknownImpl { fn BypassCacheOnRetrieve(&self) -> windows_core::Result; fn SetBypassCacheOnRetrieve(&self, value: bool) -> windows_core::Result<()>; fn SetRequestHeader(&self, name: &windows_core::HSTRING, value: &windows_core::HSTRING) -> windows_core::Result<()>; - fn RetrieveFeedAsync(&self, uri: windows_core::Ref<'_, super::super::Foundation::Uri>) -> windows_core::Result>; + fn RetrieveFeedAsync(&self, uri: windows_core::Ref<'_, super::super::Foundation::Uri>) -> windows_core::Result>; } #[cfg(feature = "Security_Credentials")] impl ISyndicationClient_Vtbl { @@ -1375,7 +1375,7 @@ impl SyndicationClient { let this = self; unsafe { (windows_core::Interface::vtable(this).SetRequestHeader)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(name), core::mem::transmute_copy(value)).ok() } } - pub fn RetrieveFeedAsync(&self, uri: P0) -> windows_core::Result> + pub fn RetrieveFeedAsync(&self, uri: P0) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Web/UI/Interop/mod.rs b/crates/libs/windows/src/Windows/Web/UI/Interop/mod.rs index dab058cc28..cac4e89d8e 100644 --- a/crates/libs/windows/src/Windows/Web/UI/Interop/mod.rs +++ b/crates/libs/windows/src/Windows/Web/UI/Interop/mod.rs @@ -218,7 +218,7 @@ impl WebViewControl { let this = self; unsafe { (windows_core::Interface::vtable(this).NavigateWithHttpRequestMessage)(windows_core::Interface::as_raw(this), requestmessage.param().abi()).ok() } } - pub fn InvokeScriptAsync(&self, scriptname: &windows_core::HSTRING, arguments: P1) -> windows_core::Result> + pub fn InvokeScriptAsync(&self, scriptname: &windows_core::HSTRING, arguments: P1) -> windows_core::Result> where P1: windows_core::Param>, { @@ -229,7 +229,7 @@ impl WebViewControl { } } #[cfg(feature = "Storage_Streams")] - pub fn CapturePreviewToStreamAsync(&self, stream: P0) -> windows_core::Result + pub fn CapturePreviewToStreamAsync(&self, stream: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -240,7 +240,7 @@ impl WebViewControl { } } #[cfg(feature = "ApplicationModel_DataTransfer")] - pub fn CaptureSelectedContentToDataPackageAsync(&self) -> windows_core::Result> { + pub fn CaptureSelectedContentToDataPackageAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -756,7 +756,7 @@ impl WebViewControlProcess { (windows_core::Interface::vtable(this).IsPrivateNetworkClientServerCapabilityEnabled)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn CreateWebViewControlAsync(&self, hostwindowhandle: i64, bounds: super::super::super::Foundation::Rect) -> windows_core::Result> { + pub fn CreateWebViewControlAsync(&self, hostwindowhandle: i64, bounds: super::super::super::Foundation::Rect) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Web/UI/mod.rs b/crates/libs/windows/src/Windows/Web/UI/mod.rs index 0e036273ca..a808d55ff8 100644 --- a/crates/libs/windows/src/Windows/Web/UI/mod.rs +++ b/crates/libs/windows/src/Windows/Web/UI/mod.rs @@ -118,7 +118,7 @@ impl IWebViewControl { let this = self; unsafe { (windows_core::Interface::vtable(this).NavigateWithHttpRequestMessage)(windows_core::Interface::as_raw(this), requestmessage.param().abi()).ok() } } - pub fn InvokeScriptAsync(&self, scriptname: &windows_core::HSTRING, arguments: P1) -> windows_core::Result> + pub fn InvokeScriptAsync(&self, scriptname: &windows_core::HSTRING, arguments: P1) -> windows_core::Result> where P1: windows_core::Param>, { @@ -129,7 +129,7 @@ impl IWebViewControl { } } #[cfg(feature = "Storage_Streams")] - pub fn CapturePreviewToStreamAsync(&self, stream: P0) -> windows_core::Result + pub fn CapturePreviewToStreamAsync(&self, stream: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -140,7 +140,7 @@ impl IWebViewControl { } } #[cfg(feature = "ApplicationModel_DataTransfer")] - pub fn CaptureSelectedContentToDataPackageAsync(&self) -> windows_core::Result> { + pub fn CaptureSelectedContentToDataPackageAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -421,9 +421,9 @@ pub trait IWebViewControl_Impl: windows_core::IUnknownImpl { fn NavigateToString(&self, text: &windows_core::HSTRING) -> windows_core::Result<()>; fn NavigateToLocalStreamUri(&self, source: windows_core::Ref<'_, super::super::Foundation::Uri>, streamResolver: windows_core::Ref<'_, super::IUriToStreamResolver>) -> windows_core::Result<()>; fn NavigateWithHttpRequestMessage(&self, requestMessage: windows_core::Ref<'_, super::Http::HttpRequestMessage>) -> windows_core::Result<()>; - fn InvokeScriptAsync(&self, scriptName: &windows_core::HSTRING, arguments: windows_core::Ref<'_, windows_collections::IIterable>) -> windows_core::Result>; - fn CapturePreviewToStreamAsync(&self, stream: windows_core::Ref<'_, super::super::Storage::Streams::IRandomAccessStream>) -> windows_core::Result; - fn CaptureSelectedContentToDataPackageAsync(&self) -> windows_core::Result>; + fn InvokeScriptAsync(&self, scriptName: &windows_core::HSTRING, arguments: windows_core::Ref<'_, windows_collections::IIterable>) -> windows_core::Result>; + fn CapturePreviewToStreamAsync(&self, stream: windows_core::Ref<'_, super::super::Storage::Streams::IRandomAccessStream>) -> windows_core::Result; + fn CaptureSelectedContentToDataPackageAsync(&self) -> windows_core::Result>; fn BuildLocalStreamUri(&self, contentIdentifier: &windows_core::HSTRING, relativePath: &windows_core::HSTRING) -> windows_core::Result; fn GetDeferredPermissionRequestById(&self, id: u32, result: windows_core::OutRef<'_, WebViewControlDeferredPermissionRequest>) -> windows_core::Result<()>; fn NavigationStarting(&self, handler: windows_core::Ref<'_, super::super::Foundation::TypedEventHandler>) -> windows_core::Result; diff --git a/crates/libs/windows/src/Windows/Web/mod.rs b/crates/libs/windows/src/Windows/Web/mod.rs index d972862fe6..8530d2c3c6 100644 --- a/crates/libs/windows/src/Windows/Web/mod.rs +++ b/crates/libs/windows/src/Windows/Web/mod.rs @@ -13,7 +13,7 @@ impl windows_core::RuntimeType for IUriToStreamResolver { windows_core::imp::interface_hierarchy!(IUriToStreamResolver, windows_core::IUnknown, windows_core::IInspectable); impl IUriToStreamResolver { #[cfg(feature = "Storage_Streams")] - pub fn UriToStreamAsync(&self, uri: P0) -> windows_core::Result> + pub fn UriToStreamAsync(&self, uri: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -30,7 +30,7 @@ impl windows_core::RuntimeName for IUriToStreamResolver { } #[cfg(feature = "Storage_Streams")] pub trait IUriToStreamResolver_Impl: windows_core::IUnknownImpl { - fn UriToStreamAsync(&self, uri: windows_core::Ref<'_, super::Foundation::Uri>) -> windows_core::Result>; + fn UriToStreamAsync(&self, uri: windows_core::Ref<'_, super::Foundation::Uri>) -> windows_core::Result>; } #[cfg(feature = "Storage_Streams")] impl IUriToStreamResolver_Vtbl { diff --git a/crates/libs/windows/src/extensions/Foundation.rs b/crates/libs/windows/src/extensions/Foundation.rs index 5b5d65f9dc..14dc7df636 100644 --- a/crates/libs/windows/src/extensions/Foundation.rs +++ b/crates/libs/windows/src/extensions/Foundation.rs @@ -1,7 +1 @@ -#[cfg(feature = "std")] -pub mod Async; -#[cfg(feature = "std")] -pub mod AsyncReady; -#[cfg(feature = "std")] -pub mod AsyncSpawn; pub mod TimeSpan; From 97d01a3070f74c082c370f214e185ee648a010f3 Mon Sep 17 00:00:00 2001 From: Kenny Kerr Date: Fri, 14 Feb 2025 08:46:11 -0600 Subject: [PATCH 3/9] samples --- crates/samples/windows/consent/Cargo.toml | 3 +++ crates/samples/windows/consent/src/main.rs | 5 +++-- 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/crates/samples/windows/consent/Cargo.toml b/crates/samples/windows/consent/Cargo.toml index 729e341101..dfd9b46f2f 100644 --- a/crates/samples/windows/consent/Cargo.toml +++ b/crates/samples/windows/consent/Cargo.toml @@ -10,3 +10,6 @@ features = [ "Security_Credentials_UI", "Win32_System_WinRT", ] + +[dependencies.windows-async] +workspace = true diff --git a/crates/samples/windows/consent/src/main.rs b/crates/samples/windows/consent/src/main.rs index f70c5a684f..b430884225 100644 --- a/crates/samples/windows/consent/src/main.rs +++ b/crates/samples/windows/consent/src/main.rs @@ -1,8 +1,9 @@ use windows::{ - core::*, Foundation::*, Security::Credentials::UI::*, Win32::Foundation::*, - Win32::System::WinRT::*, + core::*, Security::Credentials::UI::*, Win32::Foundation::*, Win32::System::WinRT::*, }; +use windows_async::*; + fn main() -> Result<()> { unsafe { let interop = factory::()?; From ad68ce2aaefdb7a176847ae66a35d73749de807f Mon Sep 17 00:00:00 2001 From: Kenny Kerr Date: Fri, 14 Feb 2025 08:46:26 -0600 Subject: [PATCH 4/9] support --- .github/workflows/clippy.yml | 2 + .github/workflows/no-default-features.yml | 2 + .github/workflows/raw-dylib.yml | 6 +- .github/workflows/test.yml | 6 +- Cargo.toml | 1 + crates/libs/collections/readme.md | 2 +- .../src/extensions/Foundation/Async.rs | 304 ---------------- .../src/extensions/Foundation/AsyncReady.rs | 221 ------------ .../src/extensions/Foundation/AsyncSpawn.rs | 331 ----------------- crates/tests/bindgen/src/lib.rs | 7 - .../bindgen/src/reference_async_action.rs | 245 ------------- ...erence_async_action_reference_namespace.rs | 182 ---------- .../reference_async_action_reference_type.rs | 107 ------ .../src/reference_async_info_no_status.rs | 146 -------- .../src/reference_async_info_status_filter.rs | 193 ---------- .../reference_async_info_status_reference.rs | 177 ---------- .../bindgen/src/reference_class_ref_static.rs | 334 ------------------ crates/tests/misc/agile/tests/tests.rs | 12 - crates/tests/misc/async/Cargo.toml | 3 + crates/tests/misc/async/tests/agile.rs | 19 + crates/tests/misc/async/tests/async_info.rs | 3 +- .../misc/async/tests/completed_finished.rs | 3 +- .../tests/misc/async/tests/completed_get.rs | 3 +- .../tests/misc/async/tests/completed_once.rs | 3 +- .../misc/async/tests/completed_started.rs | 3 +- crates/tests/misc/async/tests/dropped.rs | 3 +- crates/tests/misc/async/tests/error.rs | 3 +- crates/tests/misc/async/tests/progress.rs | 3 +- crates/tests/misc/async/tests/started.rs | 3 +- crates/tests/misc/implement/Cargo.toml | 3 + .../implement/tests/as_interface_param.rs | 3 +- crates/tests/misc/match/Cargo.toml | 3 + crates/tests/misc/match/tests/tests.rs | 3 +- crates/tests/winrt/old/Cargo.toml | 3 + crates/tests/winrt/old/tests/delegates.rs | 4 +- crates/tests/winrt/old/tests/enum.rs | 3 +- crates/tests/winrt/old/tests/generic_guids.rs | 1 + crates/tests/winrt/old/tests/send_sync.rs | 1 + crates/tools/bindgen/src/main.rs | 9 - crates/tools/bindings/src/async.txt | 18 + crates/tools/bindings/src/collections.txt | 8 +- crates/tools/bindings/src/main.rs | 1 + crates/tools/bindings/src/numerics.txt | 10 +- crates/tools/bindings/src/windows.txt | 39 +- 44 files changed, 128 insertions(+), 2308 deletions(-) delete mode 100644 crates/libs/windows/src/extensions/Foundation/Async.rs delete mode 100644 crates/libs/windows/src/extensions/Foundation/AsyncReady.rs delete mode 100644 crates/libs/windows/src/extensions/Foundation/AsyncSpawn.rs delete mode 100644 crates/tests/bindgen/src/reference_async_action.rs delete mode 100644 crates/tests/bindgen/src/reference_async_action_reference_namespace.rs delete mode 100644 crates/tests/bindgen/src/reference_async_action_reference_type.rs delete mode 100644 crates/tests/bindgen/src/reference_async_info_no_status.rs delete mode 100644 crates/tests/bindgen/src/reference_async_info_status_filter.rs delete mode 100644 crates/tests/bindgen/src/reference_async_info_status_reference.rs delete mode 100644 crates/tests/bindgen/src/reference_class_ref_static.rs create mode 100644 crates/tests/misc/async/tests/agile.rs create mode 100644 crates/tools/bindings/src/async.txt diff --git a/.github/workflows/clippy.yml b/.github/workflows/clippy.yml index a812af1f0a..5fa358a578 100644 --- a/.github/workflows/clippy.yml +++ b/.github/workflows/clippy.yml @@ -303,6 +303,8 @@ jobs: run: cargo clippy -p tool_yml - name: Clippy windows run: cargo clippy -p windows + - name: Clippy windows-async + run: cargo clippy -p windows-async - name: Clippy windows-bindgen run: cargo clippy -p windows-bindgen - name: Clippy windows-collections diff --git a/.github/workflows/no-default-features.yml b/.github/workflows/no-default-features.yml index 086b43418e..919071e8bc 100644 --- a/.github/workflows/no-default-features.yml +++ b/.github/workflows/no-default-features.yml @@ -37,6 +37,8 @@ jobs: run: cargo check -p helpers --no-default-features - name: Check windows run: cargo check -p windows --no-default-features + - name: Check windows-async + run: cargo check -p windows-async --no-default-features - name: Check windows-bindgen run: cargo check -p windows-bindgen --no-default-features - name: Check windows-collections diff --git a/.github/workflows/raw-dylib.yml b/.github/workflows/raw-dylib.yml index 5e0b87b93d..383c2af479 100644 --- a/.github/workflows/raw-dylib.yml +++ b/.github/workflows/raw-dylib.yml @@ -334,6 +334,8 @@ jobs: run: cargo test -p tool_yml --target ${{ matrix.target }} ${{ matrix.etc }} - name: Test windows run: cargo test -p windows --target ${{ matrix.target }} ${{ matrix.etc }} + - name: Test windows-async + run: cargo test -p windows-async --target ${{ matrix.target }} ${{ matrix.etc }} - name: Test windows-bindgen run: cargo test -p windows-bindgen --target ${{ matrix.target }} ${{ matrix.etc }} - name: Test windows-collections @@ -362,10 +364,10 @@ jobs: run: cargo test -p windows-version --target ${{ matrix.target }} ${{ matrix.etc }} - name: Test windows_aarch64_gnullvm run: cargo test -p windows_aarch64_gnullvm --target ${{ matrix.target }} ${{ matrix.etc }} - - name: Test windows_aarch64_msvc - run: cargo test -p windows_aarch64_msvc --target ${{ matrix.target }} ${{ matrix.etc }} - name: Clean run: cargo clean + - name: Test windows_aarch64_msvc + run: cargo test -p windows_aarch64_msvc --target ${{ matrix.target }} ${{ matrix.etc }} - name: Test windows_i686_gnu run: cargo test -p windows_i686_gnu --target ${{ matrix.target }} ${{ matrix.etc }} - name: Test windows_i686_gnullvm diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index e21d9ae102..1df4570347 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -331,6 +331,8 @@ jobs: run: cargo test -p tool_yml --target ${{ matrix.target }} ${{ matrix.etc }} - name: Test windows run: cargo test -p windows --target ${{ matrix.target }} ${{ matrix.etc }} + - name: Test windows-async + run: cargo test -p windows-async --target ${{ matrix.target }} ${{ matrix.etc }} - name: Test windows-bindgen run: cargo test -p windows-bindgen --target ${{ matrix.target }} ${{ matrix.etc }} - name: Test windows-collections @@ -359,10 +361,10 @@ jobs: run: cargo test -p windows-version --target ${{ matrix.target }} ${{ matrix.etc }} - name: Test windows_aarch64_gnullvm run: cargo test -p windows_aarch64_gnullvm --target ${{ matrix.target }} ${{ matrix.etc }} - - name: Test windows_aarch64_msvc - run: cargo test -p windows_aarch64_msvc --target ${{ matrix.target }} ${{ matrix.etc }} - name: Clean run: cargo clean + - name: Test windows_aarch64_msvc + run: cargo test -p windows_aarch64_msvc --target ${{ matrix.target }} ${{ matrix.etc }} - name: Test windows_i686_gnu run: cargo test -p windows_i686_gnu --target ${{ matrix.target }} ${{ matrix.etc }} - name: Test windows_i686_gnullvm diff --git a/Cargo.toml b/Cargo.toml index e7557e4b8d..9fc27ce764 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -24,6 +24,7 @@ unexpected_cfgs = { level = "warn", check-cfg = ['cfg(windows_raw_dylib, windows [workspace.dependencies] cppwinrt = { path = "crates/libs/cppwinrt" } windows = { path = "crates/libs/windows" } +windows-async = { path = "crates/libs/async" } windows-bindgen = { path = "crates/libs/bindgen" } windows-collections = { path = "crates/libs/collections" } windows-core = { path = "crates/libs/core" } diff --git a/crates/libs/collections/readme.md b/crates/libs/collections/readme.md index 96d7fdd211..abe9c8caf1 100644 --- a/crates/libs/collections/readme.md +++ b/crates/libs/collections/readme.md @@ -1,6 +1,6 @@ ## Windows collection types -The [windows-collections](https://crates.io/crates/windows-collections) crate provides stock collection support for Windows APIs +The [windows-collections](https://crates.io/crates/windows-collections) crate provides stock collection support for Windows APIs. * [Getting started](https://kennykerr.ca/rust-getting-started/) * [Samples](https://github.com/microsoft/windows-rs/tree/master/crates/samples) diff --git a/crates/libs/windows/src/extensions/Foundation/Async.rs b/crates/libs/windows/src/extensions/Foundation/Async.rs deleted file mode 100644 index f15ba384be..0000000000 --- a/crates/libs/windows/src/extensions/Foundation/Async.rs +++ /dev/null @@ -1,304 +0,0 @@ -use crate::core::{imp::Waiter, *}; -use crate::Foundation::*; -use std::future::{Future, IntoFuture}; -use std::pin::Pin; -use std::sync::{Arc, Mutex}; -use std::task::{Context, Poll, Waker}; - -// An `Async` represents a WinRT async execution object or type. There are precisely four such types: -// - IAsyncAction -// - IAsyncActionWithProgress -// - IAsyncOperation -// - IAsyncOperationWithProgress -// -// All four implementations are provided here and there is thus no need to implement this trait. -// This trait provides an abstraction over the relevant differences so that the `AsyncFuture` -// implementation below can be reused for all of them. -pub trait Async: Interface { - // The type of value produced on completion. - type Output: Clone; - - // The type of the delegate use for completion notification. - type CompletedHandler: Interface; - - // Sets the handler or callback to invoke when execution completes. This handler can only be set once. - fn set_completed(&self, handler: F) -> Result<()>; - - // Calls the given handler with the current object and status. - fn invoke_completed(&self, hander: &Self::CompletedHandler, status: AsyncStatus); - - // Returns the value produced on completion. This should only be called when execution completes. - fn get_results(&self) -> Result; -} - -// The `AsyncFuture` is needed to store some extra state needed to keep async execution up to date with possible changes -// to Rust execution context. Each async type implements `IntoFuture` rather than implementing `Future` directly so that -// this adapter may be used. -pub struct AsyncFuture { - // Represents the async execution and provides the virtual methods for setting up a `Completed` handler and - // calling `GetResults` when execution is completed. - inner: A, - - // Provides the `Status` virtual method and saves repeated calls to `QueryInterface` during polling. - status: IAsyncInfo, - - // A shared waker is needed to keep the `Completed` handler updated. - // - `Option` is used to avoid allocations for async objects that have already completed. - // - `Arc` is used to share the `Waker` with the `Completed` handler and potentially replace the `Waker` - // since we don't have the ability to replace the `Completed` handler itself. - // - `Mutex` is used to synchronize replacing the `Waker` across threads. - waker: Option>>, -} - -impl AsyncFuture { - fn new(inner: A) -> Self { - Self { - // All four async interfaces implement `IAsyncInfo` so this `cast` will always succeed. - status: inner.cast().unwrap(), - inner, - waker: None, - } - } -} - -unsafe impl Send for AsyncFuture {} -unsafe impl Sync for AsyncFuture {} -impl Unpin for AsyncFuture {} - -impl Future for AsyncFuture { - type Output = Result; - - fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { - // A status of `Started` just means async execution is still in flight. Since WinRT async is always - // "hot start", if its not `Started` then its ready for us to call `GetResults` so we can skip all of - // the remaining set up. - if self.status.Status()? != AsyncStatus::Started { - return Poll::Ready(self.inner.get_results()); - } - - if let Some(shared_waker) = &self.waker { - // We have a shared waker which means we're either getting polled again or been transfered to - // another execution context. As we can't tell the difference, we need to update the shared waker - // to make sure we've got the "current" waker. - let mut guard = shared_waker.lock().unwrap(); - guard.clone_from(cx.waker()); - - // It may be possible that the `Completed` handler acquired the lock and signaled the old waker - // before we managed to acquire the lock to update it with the current waker. We check the status - // again here just in case this happens. - if self.status.Status()? != AsyncStatus::Started { - return Poll::Ready(self.inner.get_results()); - } - } else { - // If we don't have a saved waker it means this is the first time we're getting polled and should - // create the shared waker and set up a `Completed` handler. - let shared_waker = Arc::new(Mutex::new(cx.waker().clone())); - self.waker = Some(shared_waker.clone()); - - // Note that the handler can only be set once, which is why we need a shared waker in the first - // place. On the other hand, the handler will get called even if async execution has already - // completed, so we can just return `Pending` after setting the Completed handler. - self.inner.set_completed(move || { - shared_waker.lock().unwrap().wake_by_ref(); - })?; - }; - - Poll::Pending - } -} - -// -// The four `Async` trait implementations. -// - -impl Async for IAsyncAction { - type Output = (); - type CompletedHandler = AsyncActionCompletedHandler; - - fn set_completed(&self, handler: F) -> Result<()> { - self.SetCompleted(&AsyncActionCompletedHandler::new(move |_, _| { - handler(); - Ok(()) - })) - } - - fn invoke_completed(&self, handler: &Self::CompletedHandler, status: AsyncStatus) { - _ = handler.Invoke(self, status); - } - - fn get_results(&self) -> Result { - self.GetResults() - } -} - -impl Async for IAsyncOperation { - type Output = T; - type CompletedHandler = AsyncOperationCompletedHandler; - - fn set_completed(&self, handler: F) -> Result<()> { - self.SetCompleted(&AsyncOperationCompletedHandler::new(move |_, _| { - handler(); - Ok(()) - })) - } - - fn invoke_completed(&self, handler: &Self::CompletedHandler, status: AsyncStatus) { - _ = handler.Invoke(self, status); - } - - fn get_results(&self) -> Result { - self.GetResults() - } -} - -impl Async for IAsyncActionWithProgress

{ - type Output = (); - type CompletedHandler = AsyncActionWithProgressCompletedHandler

; - - fn set_completed(&self, handler: F) -> Result<()> { - self.SetCompleted(&AsyncActionWithProgressCompletedHandler::new(move |_, _| { - handler(); - Ok(()) - })) - } - - fn invoke_completed(&self, handler: &Self::CompletedHandler, status: AsyncStatus) { - _ = handler.Invoke(self, status); - } - - fn get_results(&self) -> Result { - self.GetResults() - } -} - -impl Async for IAsyncOperationWithProgress { - type Output = T; - type CompletedHandler = AsyncOperationWithProgressCompletedHandler; - - fn set_completed(&self, handler: F) -> Result<()> { - self.SetCompleted(&AsyncOperationWithProgressCompletedHandler::new(move |_, _| { - handler(); - Ok(()) - })) - } - - fn invoke_completed(&self, handler: &Self::CompletedHandler, status: AsyncStatus) { - _ = handler.Invoke(self, status); - } - - fn get_results(&self) -> Result { - self.GetResults() - } -} - -// -// The four `IntoFuture` trait implementations. -// - -impl IntoFuture for IAsyncAction { - type Output = Result<()>; - type IntoFuture = AsyncFuture; - - fn into_future(self) -> Self::IntoFuture { - AsyncFuture::new(self) - } -} - -impl IntoFuture for IAsyncOperation { - type Output = Result; - type IntoFuture = AsyncFuture; - - fn into_future(self) -> Self::IntoFuture { - AsyncFuture::new(self) - } -} - -impl IntoFuture for IAsyncActionWithProgress

{ - type Output = Result<()>; - type IntoFuture = AsyncFuture; - - fn into_future(self) -> Self::IntoFuture { - AsyncFuture::new(self) - } -} - -impl IntoFuture for IAsyncOperationWithProgress { - type Output = Result; - type IntoFuture = AsyncFuture; - - fn into_future(self) -> Self::IntoFuture { - AsyncFuture::new(self) - } -} - -// -// The four `get` implementations for synchronous completion. -// - -impl IAsyncAction { - /// Waits for the `IAsyncAction` to finish. - pub fn get(&self) -> Result<()> { - if self.Status()? == AsyncStatus::Started { - let (_waiter, signaler) = Waiter::new()?; - self.SetCompleted(&AsyncActionCompletedHandler::new(move |_, _| { - // This is safe because the waiter will only be dropped after being signaled. - unsafe { - signaler.signal(); - } - Ok(()) - }))?; - } - self.GetResults() - } -} - -impl IAsyncOperation { - /// Waits for the `IAsyncOperation` to finish. - pub fn get(&self) -> Result { - if self.Status()? == AsyncStatus::Started { - let (_waiter, signaler) = Waiter::new()?; - self.SetCompleted(&AsyncOperationCompletedHandler::new(move |_, _| { - // This is safe because the waiter will only be dropped after being signaled. - unsafe { - signaler.signal(); - } - Ok(()) - }))?; - } - self.GetResults() - } -} - -impl IAsyncActionWithProgress

{ - /// Waits for the `IAsyncActionWithProgress

` to finish. - pub fn get(&self) -> Result<()> { - if self.Status()? == AsyncStatus::Started { - let (_waiter, signaler) = Waiter::new()?; - self.SetCompleted(&AsyncActionWithProgressCompletedHandler::new(move |_, _| { - // This is safe because the waiter will only be dropped after being signaled. - unsafe { - signaler.signal(); - } - Ok(()) - }))?; - } - self.GetResults() - } -} - -impl IAsyncOperationWithProgress { - /// Waits for the `IAsyncOperationWithProgress` to finish. - pub fn get(&self) -> Result { - if self.Status()? == AsyncStatus::Started { - let (_waiter, signaler) = Waiter::new()?; - self.SetCompleted(&AsyncOperationWithProgressCompletedHandler::new(move |_, _| { - // This is safe because the waiter will only be dropped after being signaled. - unsafe { - signaler.signal(); - } - Ok(()) - }))?; - } - self.GetResults() - } -} diff --git a/crates/libs/windows/src/extensions/Foundation/AsyncReady.rs b/crates/libs/windows/src/extensions/Foundation/AsyncReady.rs deleted file mode 100644 index 182944b2a2..0000000000 --- a/crates/libs/windows/src/extensions/Foundation/AsyncReady.rs +++ /dev/null @@ -1,221 +0,0 @@ -use super::Async::Async; -use crate::{core::*, Foundation::*}; -use std::sync::atomic::{AtomicBool, Ordering}; - -struct ReadyState { - set_completed: AtomicBool, - result: Result, -} - -impl ReadyState { - fn new(result: Result) -> Self { - Self { set_completed: AtomicBool::new(false), result } - } - - fn status(&self) -> AsyncStatus { - if self.result.is_ok() { - AsyncStatus::Completed - } else { - AsyncStatus::Error - } - } - - // The "Ready" implementations don't need to store the handler since the handler is invoked immediately - // but still need to confirm that `SetCompleted` is called at most once. - fn invoke_completed(&self, sender: &T, handler: Ref<'_, T::CompletedHandler>) -> Result<()> { - if !self.set_completed.swap(true, Ordering::SeqCst) { - sender.invoke_completed(handler.ok()?, self.status()); - Ok(()) - } else { - Err(Error::from_hresult(HRESULT(0x80000018u32 as i32))) // E_ILLEGAL_DELEGATE_ASSIGNMENT - } - } - - // The `From` implementation is not used here since we don't want to transfer any error object to the calling thread. - // That happens when `GetResults` is called. - fn error_code(&self) -> Result { - Ok(match &self.result { - Ok(_) => HRESULT(0), - Err(error) => error.code(), - }) - } -} - -#[implement(IAsyncAction, IAsyncInfo)] -struct ReadyAction(ReadyState); - -#[implement(IAsyncOperation, IAsyncInfo)] -struct ReadyOperation(ReadyState>) -where - T: RuntimeType + 'static; - -#[implement(IAsyncActionWithProgress

, IAsyncInfo)] -struct ReadyActionWithProgress

(ReadyState>) -where - P: RuntimeType + 'static; - -#[implement(IAsyncOperationWithProgress, IAsyncInfo)] -struct ReadyOperationWithProgress(ReadyState>) -where - T: RuntimeType + 'static, - P: RuntimeType + 'static; - -impl IAsyncInfo_Impl for ReadyAction_Impl { - fn Id(&self) -> Result { - Ok(1) - } - fn Status(&self) -> Result { - Ok(self.0.status()) - } - fn ErrorCode(&self) -> Result { - self.0.error_code() - } - fn Cancel(&self) -> Result<()> { - Ok(()) - } - fn Close(&self) -> Result<()> { - Ok(()) - } -} - -impl IAsyncInfo_Impl for ReadyOperation_Impl { - fn Id(&self) -> Result { - Ok(1) - } - fn Status(&self) -> Result { - Ok(self.0.status()) - } - fn ErrorCode(&self) -> Result { - self.0.error_code() - } - fn Cancel(&self) -> Result<()> { - Ok(()) - } - fn Close(&self) -> Result<()> { - Ok(()) - } -} - -impl IAsyncInfo_Impl for ReadyActionWithProgress_Impl

{ - fn Id(&self) -> Result { - Ok(1) - } - fn Status(&self) -> Result { - Ok(self.0.status()) - } - fn ErrorCode(&self) -> Result { - self.0.error_code() - } - fn Cancel(&self) -> Result<()> { - Ok(()) - } - fn Close(&self) -> Result<()> { - Ok(()) - } -} - -impl IAsyncInfo_Impl for ReadyOperationWithProgress_Impl { - fn Id(&self) -> Result { - Ok(1) - } - fn Status(&self) -> Result { - Ok(self.0.status()) - } - fn ErrorCode(&self) -> Result { - self.0.error_code() - } - fn Cancel(&self) -> Result<()> { - Ok(()) - } - fn Close(&self) -> Result<()> { - Ok(()) - } -} - -impl IAsyncAction_Impl for ReadyAction_Impl { - fn SetCompleted(&self, handler: Ref<'_, AsyncActionCompletedHandler>) -> Result<()> { - self.0.invoke_completed(&self.as_interface(), handler) - } - fn Completed(&self) -> Result { - Err(Error::empty()) - } - fn GetResults(&self) -> Result<()> { - self.0.result.clone() - } -} - -impl IAsyncOperation_Impl for ReadyOperation_Impl { - fn SetCompleted(&self, handler: Ref<'_, AsyncOperationCompletedHandler>) -> Result<()> { - self.0.invoke_completed(&self.as_interface(), handler) - } - fn Completed(&self) -> Result> { - Err(Error::empty()) - } - fn GetResults(&self) -> Result { - self.0.result.clone() - } -} - -impl IAsyncActionWithProgress_Impl

for ReadyActionWithProgress_Impl

{ - fn SetCompleted(&self, handler: Ref<'_, AsyncActionWithProgressCompletedHandler

>) -> Result<()> { - self.0.invoke_completed(&self.as_interface(), handler) - } - fn Completed(&self) -> Result> { - Err(Error::empty()) - } - fn GetResults(&self) -> Result<()> { - self.0.result.clone() - } - fn SetProgress(&self, _: Ref<'_, AsyncActionProgressHandler

>) -> Result<()> { - Ok(()) - } - fn Progress(&self) -> Result> { - Err(Error::empty()) - } -} - -impl IAsyncOperationWithProgress_Impl for ReadyOperationWithProgress_Impl { - fn SetCompleted(&self, handler: Ref<'_, AsyncOperationWithProgressCompletedHandler>) -> Result<()> { - self.0.invoke_completed(&self.as_interface(), handler) - } - fn Completed(&self) -> Result> { - Err(Error::empty()) - } - fn GetResults(&self) -> Result { - self.0.result.clone() - } - fn SetProgress(&self, _: Ref<'_, AsyncOperationProgressHandler>) -> Result<()> { - Ok(()) - } - fn Progress(&self) -> Result> { - Err(Error::empty()) - } -} - -impl IAsyncAction { - /// Creates an `IAsyncAction` that is immediately ready with a value. - pub fn ready(result: Result<()>) -> Self { - ReadyAction(ReadyState::new(result)).into() - } -} - -impl IAsyncOperation { - /// Creates an `IAsyncOperation` that is immediately ready with a value. - pub fn ready(result: Result) -> Self { - ReadyOperation(ReadyState::new(result)).into() - } -} - -impl IAsyncActionWithProgress

{ - /// Creates an `IAsyncActionWithProgress

` that is immediately ready with a value. - pub fn ready(result: Result<()>) -> Self { - ReadyActionWithProgress(ReadyState::new(result)).into() - } -} - -impl IAsyncOperationWithProgress { - /// Creates an `IAsyncOperationWithProgress` that is immediately ready with a value. - pub fn ready(result: Result) -> Self { - ReadyOperationWithProgress(ReadyState::new(result)).into() - } -} diff --git a/crates/libs/windows/src/extensions/Foundation/AsyncSpawn.rs b/crates/libs/windows/src/extensions/Foundation/AsyncSpawn.rs deleted file mode 100644 index 32eaacc5e9..0000000000 --- a/crates/libs/windows/src/extensions/Foundation/AsyncSpawn.rs +++ /dev/null @@ -1,331 +0,0 @@ -use super::Async::Async; -use crate::{core::*, Foundation::*}; -use core::ffi::c_void; -use std::sync::Mutex; - -struct State { - result: Option>, - completed: Option, - completed_assigned: bool, -} - -impl State { - fn status(&self) -> AsyncStatus { - match &self.result { - None => AsyncStatus::Started, - Some(Ok(_)) => AsyncStatus::Completed, - Some(Err(_)) => AsyncStatus::Error, - } - } - - fn error_code(&self) -> HRESULT { - match &self.result { - Some(Err(error)) => error.code(), - _ => HRESULT(0), - } - } - - fn get_results(&self) -> Result { - match &self.result { - Some(result) => result.clone(), - None => Err(Error::from_hresult(HRESULT(0x8000000Eu32 as i32))), // E_ILLEGAL_METHOD_CALL - } - } -} - -struct SyncState(Mutex>); - -impl SyncState { - fn new() -> Self { - Self(Mutex::new(State { result: None, completed: None, completed_assigned: false })) - } - - fn status(&self) -> AsyncStatus { - self.0.lock().unwrap().status() - } - - fn error_code(&self) -> HRESULT { - self.0.lock().unwrap().error_code() - } - - fn get_results(&self) -> Result { - self.0.lock().unwrap().get_results() - } - - fn set_completed(&self, sender: &T, handler: Ref<'_, T::CompletedHandler>) -> Result<()> { - let mut guard = self.0.lock().unwrap(); - - if guard.completed_assigned { - Err(Error::from_hresult(HRESULT(0x80000018u32 as i32))) // E_ILLEGAL_DELEGATE_ASSIGNMENT - } else { - guard.completed_assigned = true; - let status = guard.status(); - let handler = handler.ok()?; - - if status == AsyncStatus::Started { - guard.completed = Some(handler.clone()); - } else { - drop(guard); - sender.invoke_completed(handler, status); - } - - Ok(()) - } - } - - fn spawn(&self, sender: &T, f: F) - where - F: FnOnce() -> Result + Send + 'static, - { - let result = f(); - let mut guard = self.0.lock().unwrap(); - debug_assert!(guard.result.is_none()); - guard.result = Some(result); - let status = guard.status(); - let completed = guard.completed.take(); - - drop(guard); - - if let Some(completed) = completed { - sender.invoke_completed(&completed, status); - } - } -} - -unsafe impl Send for SyncState {} - -#[implement(IAsyncAction, IAsyncInfo)] -struct Action(SyncState); - -#[implement(IAsyncOperation, IAsyncInfo)] -struct Operation(SyncState>) -where - T: RuntimeType + 'static; - -#[implement(IAsyncActionWithProgress

, IAsyncInfo)] -struct ActionWithProgress

(SyncState>) -where - P: RuntimeType + 'static; - -#[implement(IAsyncOperationWithProgress, IAsyncInfo)] -struct OperationWithProgress(SyncState>) -where - T: RuntimeType + 'static, - P: RuntimeType + 'static; - -impl IAsyncInfo_Impl for Action_Impl { - fn Id(&self) -> Result { - Ok(1) - } - fn Status(&self) -> Result { - Ok(self.0.status()) - } - fn ErrorCode(&self) -> Result { - Ok(self.0.error_code()) - } - fn Cancel(&self) -> Result<()> { - Ok(()) - } - fn Close(&self) -> Result<()> { - Ok(()) - } -} - -impl IAsyncInfo_Impl for Operation_Impl { - fn Id(&self) -> Result { - Ok(1) - } - fn Status(&self) -> Result { - Ok(self.0.status()) - } - fn ErrorCode(&self) -> Result { - Ok(self.0.error_code()) - } - fn Cancel(&self) -> Result<()> { - Ok(()) - } - fn Close(&self) -> Result<()> { - Ok(()) - } -} - -impl IAsyncInfo_Impl for ActionWithProgress_Impl

{ - fn Id(&self) -> Result { - Ok(1) - } - fn Status(&self) -> Result { - Ok(self.0.status()) - } - fn ErrorCode(&self) -> Result { - Ok(self.0.error_code()) - } - fn Cancel(&self) -> Result<()> { - Ok(()) - } - fn Close(&self) -> Result<()> { - Ok(()) - } -} - -impl IAsyncInfo_Impl for OperationWithProgress_Impl { - fn Id(&self) -> Result { - Ok(1) - } - fn Status(&self) -> Result { - Ok(self.0.status()) - } - fn ErrorCode(&self) -> Result { - Ok(self.0.error_code()) - } - fn Cancel(&self) -> Result<()> { - Ok(()) - } - fn Close(&self) -> Result<()> { - Ok(()) - } -} - -impl IAsyncAction_Impl for Action_Impl { - fn SetCompleted(&self, handler: Ref<'_, AsyncActionCompletedHandler>) -> Result<()> { - self.0.set_completed(&self.as_interface(), handler) - } - fn Completed(&self) -> Result { - Err(Error::empty()) - } - fn GetResults(&self) -> Result<()> { - self.0.get_results() - } -} - -impl IAsyncOperation_Impl for Operation_Impl { - fn SetCompleted(&self, handler: Ref<'_, AsyncOperationCompletedHandler>) -> Result<()> { - self.0.set_completed(&self.as_interface(), handler) - } - fn Completed(&self) -> Result> { - Err(Error::empty()) - } - fn GetResults(&self) -> Result { - self.0.get_results() - } -} - -impl IAsyncActionWithProgress_Impl

for ActionWithProgress_Impl

{ - fn SetCompleted(&self, handler: Ref<'_, AsyncActionWithProgressCompletedHandler

>) -> Result<()> { - self.0.set_completed(&self.as_interface(), handler) - } - fn Completed(&self) -> Result> { - Err(Error::empty()) - } - fn GetResults(&self) -> Result<()> { - self.0.get_results() - } - fn SetProgress(&self, _: Ref<'_, AsyncActionProgressHandler

>) -> Result<()> { - Ok(()) - } - fn Progress(&self) -> Result> { - Err(Error::empty()) - } -} - -impl IAsyncOperationWithProgress_Impl for OperationWithProgress_Impl { - fn SetCompleted(&self, handler: Ref<'_, AsyncOperationWithProgressCompletedHandler>) -> Result<()> { - self.0.set_completed(&self.as_interface(), handler) - } - fn Completed(&self) -> Result> { - Err(Error::empty()) - } - fn GetResults(&self) -> Result { - self.0.get_results() - } - fn SetProgress(&self, _: Ref<'_, AsyncOperationProgressHandler>) -> Result<()> { - Ok(()) - } - fn Progress(&self) -> Result> { - Err(Error::empty()) - } -} - -impl IAsyncAction { - /// Creates an `IAsyncAction` that waits for the closure to execute on the Windows thread pool. - pub fn spawn(f: F) -> Self - where - F: FnOnce() -> Result<()> + Send + 'static, - { - let object = ComObject::new(Action(SyncState::new())); - let interface = object.to_interface(); - - spawn(move || { - object.0.spawn(&object.as_interface(), f); - }); - - interface - } -} - -impl IAsyncOperation { - /// Creates an `IAsyncOperation` that waits for the closure to execute on the Windows thread pool. - pub fn spawn(f: F) -> Self - where - F: FnOnce() -> Result + Send + 'static, - { - let object = ComObject::new(Operation(SyncState::new())); - let interface = object.to_interface(); - - spawn(move || { - object.0.spawn(&object.as_interface(), f); - }); - - interface - } -} - -impl IAsyncActionWithProgress

{ - /// Creates an `IAsyncActionWithProgress

` that waits for the closure to execute on the Windows thread pool. - pub fn spawn(f: F) -> Self - where - F: FnOnce() -> Result<()> + Send + 'static, - { - let object = ComObject::new(ActionWithProgress(SyncState::new())); - let interface = object.to_interface(); - - spawn(move || { - object.0.spawn(&object.as_interface(), f); - }); - - interface - } -} - -impl IAsyncOperationWithProgress { - /// Creates an `IAsyncOperationWithProgress` that waits for the closure to execute on the Windows thread pool. - pub fn spawn(f: F) -> Self - where - F: FnOnce() -> Result + Send + 'static, - { - let object = ComObject::new(OperationWithProgress(SyncState::new())); - let interface = object.to_interface(); - - spawn(move || { - object.0.spawn(&object.as_interface(), f); - }); - - interface - } -} - -fn spawn(f: F) { - type PTP_SIMPLE_CALLBACK = unsafe extern "system" fn(instance: *const c_void, context: *const c_void); - windows_link::link!("kernel32.dll" "system" fn TrySubmitThreadpoolCallback(callback: PTP_SIMPLE_CALLBACK, context: *const c_void, environment: *const c_void) -> i32); - - unsafe extern "system" fn callback(_: *const c_void, callback: *const c_void) { - unsafe { - Box::from_raw(callback as *mut F)(); - } - } - - unsafe { - if TrySubmitThreadpoolCallback(callback::, Box::into_raw(Box::new(f)) as _, core::ptr::null()) == 0 { - panic!("allocation failed"); - } - } -} diff --git a/crates/tests/bindgen/src/lib.rs b/crates/tests/bindgen/src/lib.rs index 6d10aa14cf..c9e4aafb54 100644 --- a/crates/tests/bindgen/src/lib.rs +++ b/crates/tests/bindgen/src/lib.rs @@ -70,13 +70,6 @@ pub mod interface_sys_no_core; pub mod multi; pub mod multi_sys; pub mod ref_params; -pub mod reference_async_action; -pub mod reference_async_action_reference_namespace; -pub mod reference_async_action_reference_type; -pub mod reference_async_info_no_status; -pub mod reference_async_info_status_filter; -pub mod reference_async_info_status_reference; -pub mod reference_class_ref_static; pub mod reference_dependency_flat; pub mod reference_dependency_full; pub mod reference_dependency_skip_root; diff --git a/crates/tests/bindgen/src/reference_async_action.rs b/crates/tests/bindgen/src/reference_async_action.rs deleted file mode 100644 index 542ff32be4..0000000000 --- a/crates/tests/bindgen/src/reference_async_action.rs +++ /dev/null @@ -1,245 +0,0 @@ -#![allow( - non_snake_case, - non_upper_case_globals, - non_camel_case_types, - dead_code, - clippy::all -)] - -windows_core::imp::define_interface!( - IAsyncAction, - IAsyncAction_Vtbl, - 0x5a648006_843a_4da9_865b_9d26e5dfad7b -); -impl windows_core::RuntimeType for IAsyncAction { - const SIGNATURE: windows_core::imp::ConstBuffer = - windows_core::imp::ConstBuffer::for_interface::(); -} -windows_core::imp::interface_hierarchy!( - IAsyncAction, - windows_core::IUnknown, - windows_core::IInspectable -); -windows_core::imp::required_hierarchy!(IAsyncAction, IAsyncInfo); -impl IAsyncAction { - pub fn GetResults(&self) -> windows_core::Result<()> { - let this = self; - unsafe { - (windows_core::Interface::vtable(this).GetResults)(windows_core::Interface::as_raw( - this, - )) - .ok() - } - } - pub fn Id(&self) -> windows_core::Result { - let this = &windows_core::Interface::cast::(self)?; - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).Id)( - windows_core::Interface::as_raw(this), - &mut result__, - ) - .map(|| result__) - } - } - pub fn ErrorCode(&self) -> windows_core::Result { - let this = &windows_core::Interface::cast::(self)?; - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).ErrorCode)( - windows_core::Interface::as_raw(this), - &mut result__, - ) - .map(|| result__) - } - } - pub fn Cancel(&self) -> windows_core::Result<()> { - let this = &windows_core::Interface::cast::(self)?; - unsafe { - (windows_core::Interface::vtable(this).Cancel)(windows_core::Interface::as_raw(this)) - .ok() - } - } - pub fn Close(&self) -> windows_core::Result<()> { - let this = &windows_core::Interface::cast::(self)?; - unsafe { - (windows_core::Interface::vtable(this).Close)(windows_core::Interface::as_raw(this)) - .ok() - } - } -} -unsafe impl Send for IAsyncAction {} -unsafe impl Sync for IAsyncAction {} -impl windows_core::RuntimeName for IAsyncAction { - const NAME: &'static str = "Windows.Foundation.IAsyncAction"; -} -pub trait IAsyncAction_Impl: IAsyncInfo_Impl { - fn GetResults(&self) -> windows_core::Result<()>; -} -impl IAsyncAction_Vtbl { - pub const fn new() -> Self { - unsafe extern "system" fn GetResults( - this: *mut core::ffi::c_void, - ) -> windows_core::HRESULT { - unsafe { - let this: &Identity = - &*((this as *const *const ()).offset(OFFSET) as *const Identity); - IAsyncAction_Impl::GetResults(this).into() - } - } - Self { - base__: windows_core::IInspectable_Vtbl::new::(), - SetCompleted: 0, - Completed: 0, - GetResults: GetResults::, - } - } - pub fn matches(iid: &windows_core::GUID) -> bool { - iid == &::IID - } -} -#[repr(C)] -pub struct IAsyncAction_Vtbl { - pub base__: windows_core::IInspectable_Vtbl, - SetCompleted: usize, - Completed: usize, - pub GetResults: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT, -} -windows_core::imp::define_interface!( - IAsyncInfo, - IAsyncInfo_Vtbl, - 0x00000036_0000_0000_c000_000000000046 -); -impl windows_core::RuntimeType for IAsyncInfo { - const SIGNATURE: windows_core::imp::ConstBuffer = - windows_core::imp::ConstBuffer::for_interface::(); -} -windows_core::imp::interface_hierarchy!( - IAsyncInfo, - windows_core::IUnknown, - windows_core::IInspectable -); -impl IAsyncInfo { - pub fn Id(&self) -> windows_core::Result { - let this = self; - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).Id)( - windows_core::Interface::as_raw(this), - &mut result__, - ) - .map(|| result__) - } - } - pub fn ErrorCode(&self) -> windows_core::Result { - let this = self; - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).ErrorCode)( - windows_core::Interface::as_raw(this), - &mut result__, - ) - .map(|| result__) - } - } - pub fn Cancel(&self) -> windows_core::Result<()> { - let this = self; - unsafe { - (windows_core::Interface::vtable(this).Cancel)(windows_core::Interface::as_raw(this)) - .ok() - } - } - pub fn Close(&self) -> windows_core::Result<()> { - let this = self; - unsafe { - (windows_core::Interface::vtable(this).Close)(windows_core::Interface::as_raw(this)) - .ok() - } - } -} -impl windows_core::RuntimeName for IAsyncInfo { - const NAME: &'static str = "Windows.Foundation.IAsyncInfo"; -} -pub trait IAsyncInfo_Impl: windows_core::IUnknownImpl { - fn Id(&self) -> windows_core::Result; - fn ErrorCode(&self) -> windows_core::Result; - fn Cancel(&self) -> windows_core::Result<()>; - fn Close(&self) -> windows_core::Result<()>; -} -impl IAsyncInfo_Vtbl { - pub const fn new() -> Self { - unsafe extern "system" fn Id( - this: *mut core::ffi::c_void, - result__: *mut u32, - ) -> windows_core::HRESULT { - unsafe { - let this: &Identity = - &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IAsyncInfo_Impl::Id(this) { - Ok(ok__) => { - result__.write(core::mem::transmute_copy(&ok__)); - windows_core::HRESULT(0) - } - Err(err) => err.into(), - } - } - } - unsafe extern "system" fn ErrorCode( - this: *mut core::ffi::c_void, - result__: *mut windows_core::HRESULT, - ) -> windows_core::HRESULT { - unsafe { - let this: &Identity = - &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IAsyncInfo_Impl::ErrorCode(this) { - Ok(ok__) => { - result__.write(core::mem::transmute_copy(&ok__)); - windows_core::HRESULT(0) - } - Err(err) => err.into(), - } - } - } - unsafe extern "system" fn Cancel( - this: *mut core::ffi::c_void, - ) -> windows_core::HRESULT { - unsafe { - let this: &Identity = - &*((this as *const *const ()).offset(OFFSET) as *const Identity); - IAsyncInfo_Impl::Cancel(this).into() - } - } - unsafe extern "system" fn Close( - this: *mut core::ffi::c_void, - ) -> windows_core::HRESULT { - unsafe { - let this: &Identity = - &*((this as *const *const ()).offset(OFFSET) as *const Identity); - IAsyncInfo_Impl::Close(this).into() - } - } - Self { - base__: windows_core::IInspectable_Vtbl::new::(), - Id: Id::, - Status: 0, - ErrorCode: ErrorCode::, - Cancel: Cancel::, - Close: Close::, - } - } - pub fn matches(iid: &windows_core::GUID) -> bool { - iid == &::IID - } -} -#[repr(C)] -pub struct IAsyncInfo_Vtbl { - pub base__: windows_core::IInspectable_Vtbl, - pub Id: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, - Status: usize, - pub ErrorCode: unsafe extern "system" fn( - *mut core::ffi::c_void, - *mut windows_core::HRESULT, - ) -> windows_core::HRESULT, - pub Cancel: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT, - pub Close: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT, -} diff --git a/crates/tests/bindgen/src/reference_async_action_reference_namespace.rs b/crates/tests/bindgen/src/reference_async_action_reference_namespace.rs deleted file mode 100644 index 7925f3b5ba..0000000000 --- a/crates/tests/bindgen/src/reference_async_action_reference_namespace.rs +++ /dev/null @@ -1,182 +0,0 @@ -#![allow( - non_snake_case, - non_upper_case_globals, - non_camel_case_types, - dead_code, - clippy::all -)] - -windows_core::imp::define_interface!( - IAsyncAction, - IAsyncAction_Vtbl, - 0x5a648006_843a_4da9_865b_9d26e5dfad7b -); -impl windows_core::RuntimeType for IAsyncAction { - const SIGNATURE: windows_core::imp::ConstBuffer = - windows_core::imp::ConstBuffer::for_interface::(); -} -windows_core::imp::interface_hierarchy!( - IAsyncAction, - windows_core::IUnknown, - windows_core::IInspectable -); -windows_core::imp::required_hierarchy!(IAsyncAction, windows::Foundation::IAsyncInfo); -impl IAsyncAction { - pub fn SetCompleted(&self, handler: P0) -> windows_core::Result<()> - where - P0: windows_core::Param, - { - let this = self; - unsafe { - (windows_core::Interface::vtable(this).SetCompleted)( - windows_core::Interface::as_raw(this), - handler.param().abi(), - ) - .ok() - } - } - pub fn Completed( - &self, - ) -> windows_core::Result { - let this = self; - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).Completed)( - windows_core::Interface::as_raw(this), - &mut result__, - ) - .and_then(|| windows_core::Type::from_abi(result__)) - } - } - pub fn GetResults(&self) -> windows_core::Result<()> { - let this = self; - unsafe { - (windows_core::Interface::vtable(this).GetResults)(windows_core::Interface::as_raw( - this, - )) - .ok() - } - } - pub fn Id(&self) -> windows_core::Result { - let this = &windows_core::Interface::cast::(self)?; - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).Id)( - windows_core::Interface::as_raw(this), - &mut result__, - ) - .map(|| result__) - } - } - pub fn Status(&self) -> windows_core::Result { - let this = &windows_core::Interface::cast::(self)?; - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).Status)( - windows_core::Interface::as_raw(this), - &mut result__, - ) - .map(|| result__) - } - } - pub fn ErrorCode(&self) -> windows_core::Result { - let this = &windows_core::Interface::cast::(self)?; - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).ErrorCode)( - windows_core::Interface::as_raw(this), - &mut result__, - ) - .map(|| result__) - } - } - pub fn Cancel(&self) -> windows_core::Result<()> { - let this = &windows_core::Interface::cast::(self)?; - unsafe { - (windows_core::Interface::vtable(this).Cancel)(windows_core::Interface::as_raw(this)) - .ok() - } - } - pub fn Close(&self) -> windows_core::Result<()> { - let this = &windows_core::Interface::cast::(self)?; - unsafe { - (windows_core::Interface::vtable(this).Close)(windows_core::Interface::as_raw(this)) - .ok() - } - } -} -unsafe impl Send for IAsyncAction {} -unsafe impl Sync for IAsyncAction {} -impl windows_core::RuntimeName for IAsyncAction { - const NAME: &'static str = "Windows.Foundation.IAsyncAction"; -} -pub trait IAsyncAction_Impl: windows::Foundation::IAsyncInfo_Impl { - fn SetCompleted( - &self, - handler: windows_core::Ref<'_, windows::Foundation::AsyncActionCompletedHandler>, - ) -> windows_core::Result<()>; - fn Completed(&self) -> windows_core::Result; - fn GetResults(&self) -> windows_core::Result<()>; -} -impl IAsyncAction_Vtbl { - pub const fn new() -> Self { - unsafe extern "system" fn SetCompleted( - this: *mut core::ffi::c_void, - handler: *mut core::ffi::c_void, - ) -> windows_core::HRESULT { - unsafe { - let this: &Identity = - &*((this as *const *const ()).offset(OFFSET) as *const Identity); - IAsyncAction_Impl::SetCompleted(this, core::mem::transmute_copy(&handler)).into() - } - } - unsafe extern "system" fn Completed( - this: *mut core::ffi::c_void, - result__: *mut *mut core::ffi::c_void, - ) -> windows_core::HRESULT { - unsafe { - let this: &Identity = - &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IAsyncAction_Impl::Completed(this) { - Ok(ok__) => { - result__.write(core::mem::transmute_copy(&ok__)); - core::mem::forget(ok__); - windows_core::HRESULT(0) - } - Err(err) => err.into(), - } - } - } - unsafe extern "system" fn GetResults( - this: *mut core::ffi::c_void, - ) -> windows_core::HRESULT { - unsafe { - let this: &Identity = - &*((this as *const *const ()).offset(OFFSET) as *const Identity); - IAsyncAction_Impl::GetResults(this).into() - } - } - Self { - base__: windows_core::IInspectable_Vtbl::new::(), - SetCompleted: SetCompleted::, - Completed: Completed::, - GetResults: GetResults::, - } - } - pub fn matches(iid: &windows_core::GUID) -> bool { - iid == &::IID - } -} -#[repr(C)] -pub struct IAsyncAction_Vtbl { - pub base__: windows_core::IInspectable_Vtbl, - pub SetCompleted: unsafe extern "system" fn( - *mut core::ffi::c_void, - *mut core::ffi::c_void, - ) -> windows_core::HRESULT, - pub Completed: unsafe extern "system" fn( - *mut core::ffi::c_void, - *mut *mut core::ffi::c_void, - ) -> windows_core::HRESULT, - pub GetResults: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT, -} diff --git a/crates/tests/bindgen/src/reference_async_action_reference_type.rs b/crates/tests/bindgen/src/reference_async_action_reference_type.rs deleted file mode 100644 index ad1602389a..0000000000 --- a/crates/tests/bindgen/src/reference_async_action_reference_type.rs +++ /dev/null @@ -1,107 +0,0 @@ -#![allow( - non_snake_case, - non_upper_case_globals, - non_camel_case_types, - dead_code, - clippy::all -)] - -windows_core::imp::define_interface!( - IAsyncAction, - IAsyncAction_Vtbl, - 0x5a648006_843a_4da9_865b_9d26e5dfad7b -); -impl windows_core::RuntimeType for IAsyncAction { - const SIGNATURE: windows_core::imp::ConstBuffer = - windows_core::imp::ConstBuffer::for_interface::(); -} -windows_core::imp::interface_hierarchy!( - IAsyncAction, - windows_core::IUnknown, - windows_core::IInspectable -); -windows_core::imp::required_hierarchy!(IAsyncAction, windows::Foundation::IAsyncInfo); -impl IAsyncAction { - pub fn GetResults(&self) -> windows_core::Result<()> { - let this = self; - unsafe { - (windows_core::Interface::vtable(this).GetResults)(windows_core::Interface::as_raw( - this, - )) - .ok() - } - } - pub fn Id(&self) -> windows_core::Result { - let this = &windows_core::Interface::cast::(self)?; - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).Id)( - windows_core::Interface::as_raw(this), - &mut result__, - ) - .map(|| result__) - } - } - pub fn ErrorCode(&self) -> windows_core::Result { - let this = &windows_core::Interface::cast::(self)?; - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).ErrorCode)( - windows_core::Interface::as_raw(this), - &mut result__, - ) - .map(|| result__) - } - } - pub fn Cancel(&self) -> windows_core::Result<()> { - let this = &windows_core::Interface::cast::(self)?; - unsafe { - (windows_core::Interface::vtable(this).Cancel)(windows_core::Interface::as_raw(this)) - .ok() - } - } - pub fn Close(&self) -> windows_core::Result<()> { - let this = &windows_core::Interface::cast::(self)?; - unsafe { - (windows_core::Interface::vtable(this).Close)(windows_core::Interface::as_raw(this)) - .ok() - } - } -} -unsafe impl Send for IAsyncAction {} -unsafe impl Sync for IAsyncAction {} -impl windows_core::RuntimeName for IAsyncAction { - const NAME: &'static str = "Windows.Foundation.IAsyncAction"; -} -pub trait IAsyncAction_Impl: windows::Foundation::IAsyncInfo_Impl { - fn GetResults(&self) -> windows_core::Result<()>; -} -impl IAsyncAction_Vtbl { - pub const fn new() -> Self { - unsafe extern "system" fn GetResults( - this: *mut core::ffi::c_void, - ) -> windows_core::HRESULT { - unsafe { - let this: &Identity = - &*((this as *const *const ()).offset(OFFSET) as *const Identity); - IAsyncAction_Impl::GetResults(this).into() - } - } - Self { - base__: windows_core::IInspectable_Vtbl::new::(), - SetCompleted: 0, - Completed: 0, - GetResults: GetResults::, - } - } - pub fn matches(iid: &windows_core::GUID) -> bool { - iid == &::IID - } -} -#[repr(C)] -pub struct IAsyncAction_Vtbl { - pub base__: windows_core::IInspectable_Vtbl, - SetCompleted: usize, - Completed: usize, - pub GetResults: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT, -} diff --git a/crates/tests/bindgen/src/reference_async_info_no_status.rs b/crates/tests/bindgen/src/reference_async_info_no_status.rs deleted file mode 100644 index 9ade187c0b..0000000000 --- a/crates/tests/bindgen/src/reference_async_info_no_status.rs +++ /dev/null @@ -1,146 +0,0 @@ -#![allow( - non_snake_case, - non_upper_case_globals, - non_camel_case_types, - dead_code, - clippy::all -)] - -windows_core::imp::define_interface!( - IAsyncInfo, - IAsyncInfo_Vtbl, - 0x00000036_0000_0000_c000_000000000046 -); -impl windows_core::RuntimeType for IAsyncInfo { - const SIGNATURE: windows_core::imp::ConstBuffer = - windows_core::imp::ConstBuffer::for_interface::(); -} -windows_core::imp::interface_hierarchy!( - IAsyncInfo, - windows_core::IUnknown, - windows_core::IInspectable -); -impl IAsyncInfo { - pub fn Id(&self) -> windows_core::Result { - let this = self; - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).Id)( - windows_core::Interface::as_raw(this), - &mut result__, - ) - .map(|| result__) - } - } - pub fn ErrorCode(&self) -> windows_core::Result { - let this = self; - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).ErrorCode)( - windows_core::Interface::as_raw(this), - &mut result__, - ) - .map(|| result__) - } - } - pub fn Cancel(&self) -> windows_core::Result<()> { - let this = self; - unsafe { - (windows_core::Interface::vtable(this).Cancel)(windows_core::Interface::as_raw(this)) - .ok() - } - } - pub fn Close(&self) -> windows_core::Result<()> { - let this = self; - unsafe { - (windows_core::Interface::vtable(this).Close)(windows_core::Interface::as_raw(this)) - .ok() - } - } -} -impl windows_core::RuntimeName for IAsyncInfo { - const NAME: &'static str = "Windows.Foundation.IAsyncInfo"; -} -pub trait IAsyncInfo_Impl: windows_core::IUnknownImpl { - fn Id(&self) -> windows_core::Result; - fn ErrorCode(&self) -> windows_core::Result; - fn Cancel(&self) -> windows_core::Result<()>; - fn Close(&self) -> windows_core::Result<()>; -} -impl IAsyncInfo_Vtbl { - pub const fn new() -> Self { - unsafe extern "system" fn Id( - this: *mut core::ffi::c_void, - result__: *mut u32, - ) -> windows_core::HRESULT { - unsafe { - let this: &Identity = - &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IAsyncInfo_Impl::Id(this) { - Ok(ok__) => { - result__.write(core::mem::transmute_copy(&ok__)); - windows_core::HRESULT(0) - } - Err(err) => err.into(), - } - } - } - unsafe extern "system" fn ErrorCode( - this: *mut core::ffi::c_void, - result__: *mut windows_core::HRESULT, - ) -> windows_core::HRESULT { - unsafe { - let this: &Identity = - &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IAsyncInfo_Impl::ErrorCode(this) { - Ok(ok__) => { - result__.write(core::mem::transmute_copy(&ok__)); - windows_core::HRESULT(0) - } - Err(err) => err.into(), - } - } - } - unsafe extern "system" fn Cancel( - this: *mut core::ffi::c_void, - ) -> windows_core::HRESULT { - unsafe { - let this: &Identity = - &*((this as *const *const ()).offset(OFFSET) as *const Identity); - IAsyncInfo_Impl::Cancel(this).into() - } - } - unsafe extern "system" fn Close( - this: *mut core::ffi::c_void, - ) -> windows_core::HRESULT { - unsafe { - let this: &Identity = - &*((this as *const *const ()).offset(OFFSET) as *const Identity); - IAsyncInfo_Impl::Close(this).into() - } - } - Self { - base__: windows_core::IInspectable_Vtbl::new::(), - Id: Id::, - Status: 0, - ErrorCode: ErrorCode::, - Cancel: Cancel::, - Close: Close::, - } - } - pub fn matches(iid: &windows_core::GUID) -> bool { - iid == &::IID - } -} -#[repr(C)] -pub struct IAsyncInfo_Vtbl { - pub base__: windows_core::IInspectable_Vtbl, - pub Id: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, - Status: usize, - pub ErrorCode: unsafe extern "system" fn( - *mut core::ffi::c_void, - *mut windows_core::HRESULT, - ) -> windows_core::HRESULT, - pub Cancel: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT, - pub Close: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT, -} diff --git a/crates/tests/bindgen/src/reference_async_info_status_filter.rs b/crates/tests/bindgen/src/reference_async_info_status_filter.rs deleted file mode 100644 index 3e05490b66..0000000000 --- a/crates/tests/bindgen/src/reference_async_info_status_filter.rs +++ /dev/null @@ -1,193 +0,0 @@ -#![allow( - non_snake_case, - non_upper_case_globals, - non_camel_case_types, - dead_code, - clippy::all -)] - -#[repr(transparent)] -#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)] -pub struct AsyncStatus(pub i32); -impl AsyncStatus { - pub const Canceled: Self = Self(2i32); - pub const Completed: Self = Self(1i32); - pub const Error: Self = Self(3i32); - pub const Started: Self = Self(0i32); -} -impl windows_core::TypeKind for AsyncStatus { - type TypeKind = windows_core::CopyType; -} -impl windows_core::RuntimeType for AsyncStatus { - const SIGNATURE: windows_core::imp::ConstBuffer = - windows_core::imp::ConstBuffer::from_slice(b"enum(Windows.Foundation.AsyncStatus;i4)"); -} -windows_core::imp::define_interface!( - IAsyncInfo, - IAsyncInfo_Vtbl, - 0x00000036_0000_0000_c000_000000000046 -); -impl windows_core::RuntimeType for IAsyncInfo { - const SIGNATURE: windows_core::imp::ConstBuffer = - windows_core::imp::ConstBuffer::for_interface::(); -} -windows_core::imp::interface_hierarchy!( - IAsyncInfo, - windows_core::IUnknown, - windows_core::IInspectable -); -impl IAsyncInfo { - pub fn Id(&self) -> windows_core::Result { - let this = self; - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).Id)( - windows_core::Interface::as_raw(this), - &mut result__, - ) - .map(|| result__) - } - } - pub fn Status(&self) -> windows_core::Result { - let this = self; - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).Status)( - windows_core::Interface::as_raw(this), - &mut result__, - ) - .map(|| result__) - } - } - pub fn ErrorCode(&self) -> windows_core::Result { - let this = self; - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).ErrorCode)( - windows_core::Interface::as_raw(this), - &mut result__, - ) - .map(|| result__) - } - } - pub fn Cancel(&self) -> windows_core::Result<()> { - let this = self; - unsafe { - (windows_core::Interface::vtable(this).Cancel)(windows_core::Interface::as_raw(this)) - .ok() - } - } - pub fn Close(&self) -> windows_core::Result<()> { - let this = self; - unsafe { - (windows_core::Interface::vtable(this).Close)(windows_core::Interface::as_raw(this)) - .ok() - } - } -} -impl windows_core::RuntimeName for IAsyncInfo { - const NAME: &'static str = "Windows.Foundation.IAsyncInfo"; -} -pub trait IAsyncInfo_Impl: windows_core::IUnknownImpl { - fn Id(&self) -> windows_core::Result; - fn Status(&self) -> windows_core::Result; - fn ErrorCode(&self) -> windows_core::Result; - fn Cancel(&self) -> windows_core::Result<()>; - fn Close(&self) -> windows_core::Result<()>; -} -impl IAsyncInfo_Vtbl { - pub const fn new() -> Self { - unsafe extern "system" fn Id( - this: *mut core::ffi::c_void, - result__: *mut u32, - ) -> windows_core::HRESULT { - unsafe { - let this: &Identity = - &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IAsyncInfo_Impl::Id(this) { - Ok(ok__) => { - result__.write(core::mem::transmute_copy(&ok__)); - windows_core::HRESULT(0) - } - Err(err) => err.into(), - } - } - } - unsafe extern "system" fn Status( - this: *mut core::ffi::c_void, - result__: *mut AsyncStatus, - ) -> windows_core::HRESULT { - unsafe { - let this: &Identity = - &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IAsyncInfo_Impl::Status(this) { - Ok(ok__) => { - result__.write(core::mem::transmute_copy(&ok__)); - windows_core::HRESULT(0) - } - Err(err) => err.into(), - } - } - } - unsafe extern "system" fn ErrorCode( - this: *mut core::ffi::c_void, - result__: *mut windows_core::HRESULT, - ) -> windows_core::HRESULT { - unsafe { - let this: &Identity = - &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IAsyncInfo_Impl::ErrorCode(this) { - Ok(ok__) => { - result__.write(core::mem::transmute_copy(&ok__)); - windows_core::HRESULT(0) - } - Err(err) => err.into(), - } - } - } - unsafe extern "system" fn Cancel( - this: *mut core::ffi::c_void, - ) -> windows_core::HRESULT { - unsafe { - let this: &Identity = - &*((this as *const *const ()).offset(OFFSET) as *const Identity); - IAsyncInfo_Impl::Cancel(this).into() - } - } - unsafe extern "system" fn Close( - this: *mut core::ffi::c_void, - ) -> windows_core::HRESULT { - unsafe { - let this: &Identity = - &*((this as *const *const ()).offset(OFFSET) as *const Identity); - IAsyncInfo_Impl::Close(this).into() - } - } - Self { - base__: windows_core::IInspectable_Vtbl::new::(), - Id: Id::, - Status: Status::, - ErrorCode: ErrorCode::, - Cancel: Cancel::, - Close: Close::, - } - } - pub fn matches(iid: &windows_core::GUID) -> bool { - iid == &::IID - } -} -#[repr(C)] -pub struct IAsyncInfo_Vtbl { - pub base__: windows_core::IInspectable_Vtbl, - pub Id: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, - pub Status: unsafe extern "system" fn( - *mut core::ffi::c_void, - *mut AsyncStatus, - ) -> windows_core::HRESULT, - pub ErrorCode: unsafe extern "system" fn( - *mut core::ffi::c_void, - *mut windows_core::HRESULT, - ) -> windows_core::HRESULT, - pub Cancel: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT, - pub Close: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT, -} diff --git a/crates/tests/bindgen/src/reference_async_info_status_reference.rs b/crates/tests/bindgen/src/reference_async_info_status_reference.rs deleted file mode 100644 index b464f8a1cf..0000000000 --- a/crates/tests/bindgen/src/reference_async_info_status_reference.rs +++ /dev/null @@ -1,177 +0,0 @@ -#![allow( - non_snake_case, - non_upper_case_globals, - non_camel_case_types, - dead_code, - clippy::all -)] - -windows_core::imp::define_interface!( - IAsyncInfo, - IAsyncInfo_Vtbl, - 0x00000036_0000_0000_c000_000000000046 -); -impl windows_core::RuntimeType for IAsyncInfo { - const SIGNATURE: windows_core::imp::ConstBuffer = - windows_core::imp::ConstBuffer::for_interface::(); -} -windows_core::imp::interface_hierarchy!( - IAsyncInfo, - windows_core::IUnknown, - windows_core::IInspectable -); -impl IAsyncInfo { - pub fn Id(&self) -> windows_core::Result { - let this = self; - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).Id)( - windows_core::Interface::as_raw(this), - &mut result__, - ) - .map(|| result__) - } - } - pub fn Status(&self) -> windows_core::Result { - let this = self; - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).Status)( - windows_core::Interface::as_raw(this), - &mut result__, - ) - .map(|| result__) - } - } - pub fn ErrorCode(&self) -> windows_core::Result { - let this = self; - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).ErrorCode)( - windows_core::Interface::as_raw(this), - &mut result__, - ) - .map(|| result__) - } - } - pub fn Cancel(&self) -> windows_core::Result<()> { - let this = self; - unsafe { - (windows_core::Interface::vtable(this).Cancel)(windows_core::Interface::as_raw(this)) - .ok() - } - } - pub fn Close(&self) -> windows_core::Result<()> { - let this = self; - unsafe { - (windows_core::Interface::vtable(this).Close)(windows_core::Interface::as_raw(this)) - .ok() - } - } -} -impl windows_core::RuntimeName for IAsyncInfo { - const NAME: &'static str = "Windows.Foundation.IAsyncInfo"; -} -pub trait IAsyncInfo_Impl: windows_core::IUnknownImpl { - fn Id(&self) -> windows_core::Result; - fn Status(&self) -> windows_core::Result; - fn ErrorCode(&self) -> windows_core::Result; - fn Cancel(&self) -> windows_core::Result<()>; - fn Close(&self) -> windows_core::Result<()>; -} -impl IAsyncInfo_Vtbl { - pub const fn new() -> Self { - unsafe extern "system" fn Id( - this: *mut core::ffi::c_void, - result__: *mut u32, - ) -> windows_core::HRESULT { - unsafe { - let this: &Identity = - &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IAsyncInfo_Impl::Id(this) { - Ok(ok__) => { - result__.write(core::mem::transmute_copy(&ok__)); - windows_core::HRESULT(0) - } - Err(err) => err.into(), - } - } - } - unsafe extern "system" fn Status( - this: *mut core::ffi::c_void, - result__: *mut windows::Foundation::AsyncStatus, - ) -> windows_core::HRESULT { - unsafe { - let this: &Identity = - &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IAsyncInfo_Impl::Status(this) { - Ok(ok__) => { - result__.write(core::mem::transmute_copy(&ok__)); - windows_core::HRESULT(0) - } - Err(err) => err.into(), - } - } - } - unsafe extern "system" fn ErrorCode( - this: *mut core::ffi::c_void, - result__: *mut windows_core::HRESULT, - ) -> windows_core::HRESULT { - unsafe { - let this: &Identity = - &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IAsyncInfo_Impl::ErrorCode(this) { - Ok(ok__) => { - result__.write(core::mem::transmute_copy(&ok__)); - windows_core::HRESULT(0) - } - Err(err) => err.into(), - } - } - } - unsafe extern "system" fn Cancel( - this: *mut core::ffi::c_void, - ) -> windows_core::HRESULT { - unsafe { - let this: &Identity = - &*((this as *const *const ()).offset(OFFSET) as *const Identity); - IAsyncInfo_Impl::Cancel(this).into() - } - } - unsafe extern "system" fn Close( - this: *mut core::ffi::c_void, - ) -> windows_core::HRESULT { - unsafe { - let this: &Identity = - &*((this as *const *const ()).offset(OFFSET) as *const Identity); - IAsyncInfo_Impl::Close(this).into() - } - } - Self { - base__: windows_core::IInspectable_Vtbl::new::(), - Id: Id::, - Status: Status::, - ErrorCode: ErrorCode::, - Cancel: Cancel::, - Close: Close::, - } - } - pub fn matches(iid: &windows_core::GUID) -> bool { - iid == &::IID - } -} -#[repr(C)] -pub struct IAsyncInfo_Vtbl { - pub base__: windows_core::IInspectable_Vtbl, - pub Id: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, - pub Status: unsafe extern "system" fn( - *mut core::ffi::c_void, - *mut windows::Foundation::AsyncStatus, - ) -> windows_core::HRESULT, - pub ErrorCode: unsafe extern "system" fn( - *mut core::ffi::c_void, - *mut windows_core::HRESULT, - ) -> windows_core::HRESULT, - pub Cancel: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT, - pub Close: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT, -} diff --git a/crates/tests/bindgen/src/reference_class_ref_static.rs b/crates/tests/bindgen/src/reference_class_ref_static.rs deleted file mode 100644 index 406ab32216..0000000000 --- a/crates/tests/bindgen/src/reference_class_ref_static.rs +++ /dev/null @@ -1,334 +0,0 @@ -#![allow( - non_snake_case, - non_upper_case_globals, - non_camel_case_types, - dead_code, - clippy::all -)] - -#[repr(transparent)] -#[derive(Clone, Debug, Eq, PartialEq)] -pub struct Uri(windows_core::IUnknown); -windows_core::imp::interface_hierarchy!(Uri, windows_core::IUnknown, windows_core::IInspectable); -windows_core::imp::required_hierarchy!(Uri, windows::Foundation::IStringable); -impl Uri { - pub fn ToString(&self) -> windows_core::Result { - let this = &windows_core::Interface::cast::(self)?; - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).ToString)( - windows_core::Interface::as_raw(this), - &mut result__, - ) - .map(|| core::mem::transmute(result__)) - } - } - pub fn UnescapeComponent( - tounescape: &windows_core::HSTRING, - ) -> windows_core::Result { - Self::IUriEscapeStatics(|this| unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).UnescapeComponent)( - windows_core::Interface::as_raw(this), - core::mem::transmute_copy(tounescape), - &mut result__, - ) - .map(|| core::mem::transmute(result__)) - }) - } - pub fn EscapeComponent( - toescape: &windows_core::HSTRING, - ) -> windows_core::Result { - Self::IUriEscapeStatics(|this| unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).EscapeComponent)( - windows_core::Interface::as_raw(this), - core::mem::transmute_copy(toescape), - &mut result__, - ) - .map(|| core::mem::transmute(result__)) - }) - } - pub fn AbsoluteUri(&self) -> windows_core::Result { - let this = self; - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).AbsoluteUri)( - windows_core::Interface::as_raw(this), - &mut result__, - ) - .map(|| core::mem::transmute(result__)) - } - } - pub fn DisplayUri(&self) -> windows_core::Result { - let this = self; - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).DisplayUri)( - windows_core::Interface::as_raw(this), - &mut result__, - ) - .map(|| core::mem::transmute(result__)) - } - } - pub fn Domain(&self) -> windows_core::Result { - let this = self; - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).Domain)( - windows_core::Interface::as_raw(this), - &mut result__, - ) - .map(|| core::mem::transmute(result__)) - } - } - pub fn Extension(&self) -> windows_core::Result { - let this = self; - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).Extension)( - windows_core::Interface::as_raw(this), - &mut result__, - ) - .map(|| core::mem::transmute(result__)) - } - } - pub fn Fragment(&self) -> windows_core::Result { - let this = self; - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).Fragment)( - windows_core::Interface::as_raw(this), - &mut result__, - ) - .map(|| core::mem::transmute(result__)) - } - } - pub fn Host(&self) -> windows_core::Result { - let this = self; - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).Host)( - windows_core::Interface::as_raw(this), - &mut result__, - ) - .map(|| core::mem::transmute(result__)) - } - } - pub fn Password(&self) -> windows_core::Result { - let this = self; - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).Password)( - windows_core::Interface::as_raw(this), - &mut result__, - ) - .map(|| core::mem::transmute(result__)) - } - } - pub fn Path(&self) -> windows_core::Result { - let this = self; - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).Path)( - windows_core::Interface::as_raw(this), - &mut result__, - ) - .map(|| core::mem::transmute(result__)) - } - } - pub fn Query(&self) -> windows_core::Result { - let this = self; - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).Query)( - windows_core::Interface::as_raw(this), - &mut result__, - ) - .map(|| core::mem::transmute(result__)) - } - } - pub fn QueryParsed(&self) -> windows_core::Result { - let this = self; - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).QueryParsed)( - windows_core::Interface::as_raw(this), - &mut result__, - ) - .and_then(|| windows_core::Type::from_abi(result__)) - } - } - pub fn RawUri(&self) -> windows_core::Result { - let this = self; - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).RawUri)( - windows_core::Interface::as_raw(this), - &mut result__, - ) - .map(|| core::mem::transmute(result__)) - } - } - pub fn SchemeName(&self) -> windows_core::Result { - let this = self; - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).SchemeName)( - windows_core::Interface::as_raw(this), - &mut result__, - ) - .map(|| core::mem::transmute(result__)) - } - } - pub fn UserName(&self) -> windows_core::Result { - let this = self; - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).UserName)( - windows_core::Interface::as_raw(this), - &mut result__, - ) - .map(|| core::mem::transmute(result__)) - } - } - pub fn Port(&self) -> windows_core::Result { - let this = self; - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).Port)( - windows_core::Interface::as_raw(this), - &mut result__, - ) - .map(|| result__) - } - } - pub fn Suspicious(&self) -> windows_core::Result { - let this = self; - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).Suspicious)( - windows_core::Interface::as_raw(this), - &mut result__, - ) - .map(|| result__) - } - } - pub fn Equals(&self, puri: P0) -> windows_core::Result - where - P0: windows_core::Param, - { - let this = self; - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).Equals)( - windows_core::Interface::as_raw(this), - puri.param().abi(), - &mut result__, - ) - .map(|| result__) - } - } - pub fn CombineUri(&self, relativeuri: &windows_core::HSTRING) -> windows_core::Result { - let this = self; - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).CombineUri)( - windows_core::Interface::as_raw(this), - core::mem::transmute_copy(relativeuri), - &mut result__, - ) - .and_then(|| windows_core::Type::from_abi(result__)) - } - } - pub fn CreateUri(uri: &windows_core::HSTRING) -> windows_core::Result { - Self::IUriRuntimeClassFactory(|this| unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).CreateUri)( - windows_core::Interface::as_raw(this), - core::mem::transmute_copy(uri), - &mut result__, - ) - .and_then(|| windows_core::Type::from_abi(result__)) - }) - } - pub fn CreateWithRelativeUri( - baseuri: &windows_core::HSTRING, - relativeuri: &windows_core::HSTRING, - ) -> windows_core::Result { - Self::IUriRuntimeClassFactory(|this| unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).CreateWithRelativeUri)( - windows_core::Interface::as_raw(this), - core::mem::transmute_copy(baseuri), - core::mem::transmute_copy(relativeuri), - &mut result__, - ) - .and_then(|| windows_core::Type::from_abi(result__)) - }) - } - pub fn AbsoluteCanonicalUri(&self) -> windows_core::Result { - let this = &windows_core::Interface::cast::< - windows::Foundation::IUriRuntimeClassWithAbsoluteCanonicalUri, - >(self)?; - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).AbsoluteCanonicalUri)( - windows_core::Interface::as_raw(this), - &mut result__, - ) - .map(|| core::mem::transmute(result__)) - } - } - pub fn DisplayIri(&self) -> windows_core::Result { - let this = &windows_core::Interface::cast::< - windows::Foundation::IUriRuntimeClassWithAbsoluteCanonicalUri, - >(self)?; - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(this).DisplayIri)( - windows_core::Interface::as_raw(this), - &mut result__, - ) - .map(|| core::mem::transmute(result__)) - } - } - fn IUriEscapeStatics< - R, - F: FnOnce(&windows::Foundation::IUriEscapeStatics) -> windows_core::Result, - >( - callback: F, - ) -> windows_core::Result { - static SHARED: windows_core::imp::FactoryCache< - Uri, - windows::Foundation::IUriEscapeStatics, - > = windows_core::imp::FactoryCache::new(); - SHARED.call(callback) - } - fn IUriRuntimeClassFactory< - R, - F: FnOnce(&windows::Foundation::IUriRuntimeClassFactory) -> windows_core::Result, - >( - callback: F, - ) -> windows_core::Result { - static SHARED: windows_core::imp::FactoryCache< - Uri, - windows::Foundation::IUriRuntimeClassFactory, - > = windows_core::imp::FactoryCache::new(); - SHARED.call(callback) - } -} -impl windows_core::RuntimeType for Uri { - const SIGNATURE: windows_core::imp::ConstBuffer = - windows_core::imp::ConstBuffer::for_class::(); -} -unsafe impl windows_core::Interface for Uri { - type Vtable = ::Vtable; - const IID: windows_core::GUID = - ::IID; -} -impl windows_core::RuntimeName for Uri { - const NAME: &'static str = "Windows.Foundation.Uri"; -} -unsafe impl Send for Uri {} -unsafe impl Sync for Uri {} diff --git a/crates/tests/misc/agile/tests/tests.rs b/crates/tests/misc/agile/tests/tests.rs index 0643fc8be9..6256d0f192 100644 --- a/crates/tests/misc/agile/tests/tests.rs +++ b/crates/tests/misc/agile/tests/tests.rs @@ -10,16 +10,4 @@ fn test() { send(Option::::None); sync(Option::::None); - - send(Option::::None); - sync(Option::::None); - - send(Option::>::None); - sync(Option::>::None); - - send(Option::>::None); - sync(Option::>::None); - - send(Option::>::None); - sync(Option::>::None); } diff --git a/crates/tests/misc/async/Cargo.toml b/crates/tests/misc/async/Cargo.toml index 0a68150898..e278e0a963 100644 --- a/crates/tests/misc/async/Cargo.toml +++ b/crates/tests/misc/async/Cargo.toml @@ -16,5 +16,8 @@ features = [ "Win32_Foundation", ] +[dependencies.windows-async] +workspace = true + [dev-dependencies] futures = "0.3" diff --git a/crates/tests/misc/async/tests/agile.rs b/crates/tests/misc/async/tests/agile.rs new file mode 100644 index 0000000000..755fcc36ad --- /dev/null +++ b/crates/tests/misc/async/tests/agile.rs @@ -0,0 +1,19 @@ +use windows_async::*; + +fn send(_: Option) {} +fn sync(_: Option) {} + +#[test] +fn test() { + send(Option::::None); + sync(Option::::None); + + send(Option::>::None); + sync(Option::>::None); + + send(Option::>::None); + sync(Option::>::None); + + send(Option::>::None); + sync(Option::>::None); +} diff --git a/crates/tests/misc/async/tests/async_info.rs b/crates/tests/misc/async/tests/async_info.rs index da6cd87ece..bcdd2a49db 100644 --- a/crates/tests/misc/async/tests/async_info.rs +++ b/crates/tests/misc/async/tests/async_info.rs @@ -1,7 +1,8 @@ // Tests `IAsyncInfo` for all stock implementations. The only one that really matters is `Status` // but the remaining methods are tested just to confirm stable behavior. -use windows::{core::*, Foundation::*}; +use windows::core::*; +use windows_async::*; #[test] fn test() -> Result<()> { diff --git a/crates/tests/misc/async/tests/completed_finished.rs b/crates/tests/misc/async/tests/completed_finished.rs index 60e13c543c..06e3e2d752 100644 --- a/crates/tests/misc/async/tests/completed_finished.rs +++ b/crates/tests/misc/async/tests/completed_finished.rs @@ -3,7 +3,8 @@ use std::sync::mpsc::channel; use std::thread; -use windows::{core::*, Foundation::*}; +use windows::core::*; +use windows_async::*; #[test] fn action() -> Result<()> { diff --git a/crates/tests/misc/async/tests/completed_get.rs b/crates/tests/misc/async/tests/completed_get.rs index cf3484b8fb..7bf9834ef9 100644 --- a/crates/tests/misc/async/tests/completed_get.rs +++ b/crates/tests/misc/async/tests/completed_get.rs @@ -1,7 +1,8 @@ // All stock implementations of `Completed` return S_OK and a null pointer giving them impression // that they do not store the `Completed` handler for consistency. -use windows::{core::*, Foundation::*}; +use windows::core::*; +use windows_async::*; #[test] fn test() -> Result<()> { diff --git a/crates/tests/misc/async/tests/completed_once.rs b/crates/tests/misc/async/tests/completed_once.rs index cc179afe16..2a28649853 100644 --- a/crates/tests/misc/async/tests/completed_once.rs +++ b/crates/tests/misc/async/tests/completed_once.rs @@ -1,7 +1,8 @@ // Implementations of `SetCompleted` must fail with `E_ILLEGAL_DELEGATE_ASSIGNMENT` if they are called twice. // Also tests that any error from the handler is ignored by the implementation. -use windows::{core::*, Foundation::*, Win32::Foundation::*}; +use windows::{core::*, Win32::Foundation::*}; +use windows_async::*; #[test] fn action_ready() -> Result<()> { diff --git a/crates/tests/misc/async/tests/completed_started.rs b/crates/tests/misc/async/tests/completed_started.rs index 778d15629b..d60a1c6bc4 100644 --- a/crates/tests/misc/async/tests/completed_started.rs +++ b/crates/tests/misc/async/tests/completed_started.rs @@ -3,7 +3,8 @@ use std::sync::mpsc::channel; use std::thread; -use windows::{core::*, Foundation::*}; +use windows::core::*; +use windows_async::*; #[test] fn action() -> Result<()> { diff --git a/crates/tests/misc/async/tests/dropped.rs b/crates/tests/misc/async/tests/dropped.rs index 0e125058d3..32e384652b 100644 --- a/crates/tests/misc/async/tests/dropped.rs +++ b/crates/tests/misc/async/tests/dropped.rs @@ -2,7 +2,8 @@ // so the caller can drop its reference if necessary. use std::sync::mpsc::channel; -use windows::{core::*, Foundation::*}; +use windows::core::*; +use windows_async::*; #[test] fn action() -> Result<()> { diff --git a/crates/tests/misc/async/tests/error.rs b/crates/tests/misc/async/tests/error.rs index 11c41941a8..8a8f97b3a0 100644 --- a/crates/tests/misc/async/tests/error.rs +++ b/crates/tests/misc/async/tests/error.rs @@ -2,7 +2,8 @@ // as that is the normal path for most callers. Older callers may also use `ErrorCode` so that is tested // as well. -use windows::{core::*, Foundation::*, Win32::Foundation::*}; +use windows::{core::*, Win32::Foundation::*}; +use windows_async::*; #[test] fn action_ready() -> Result<()> { diff --git a/crates/tests/misc/async/tests/progress.rs b/crates/tests/misc/async/tests/progress.rs index e5dc032735..0ac99e6644 100644 --- a/crates/tests/misc/async/tests/progress.rs +++ b/crates/tests/misc/async/tests/progress.rs @@ -1,6 +1,7 @@ // All stock implementations don't support progress notifications. -use windows::{core::*, Foundation::*}; +use windows::core::*; +use windows_async::*; #[test] fn test() -> Result<()> { diff --git a/crates/tests/misc/async/tests/started.rs b/crates/tests/misc/async/tests/started.rs index bc76e94d9d..17eaf03b84 100644 --- a/crates/tests/misc/async/tests/started.rs +++ b/crates/tests/misc/async/tests/started.rs @@ -2,7 +2,8 @@ // This tests the `spawn` implementations to confirm that we can observe the `Started` state. // The `GetResults` method may not be called in this state. -use windows::{core::*, Foundation::*, Win32::Foundation::*}; +use windows::{core::*, Win32::Foundation::*}; +use windows_async::*; #[test] fn action() -> Result<()> { diff --git a/crates/tests/misc/implement/Cargo.toml b/crates/tests/misc/implement/Cargo.toml index d68458de10..cb8bedc980 100644 --- a/crates/tests/misc/implement/Cargo.toml +++ b/crates/tests/misc/implement/Cargo.toml @@ -31,5 +31,8 @@ workspace = true [dependencies.windows-collections] workspace = true +[dependencies.windows-async] +workspace = true + [dependencies] static_assertions = "1.1" diff --git a/crates/tests/misc/implement/tests/as_interface_param.rs b/crates/tests/misc/implement/tests/as_interface_param.rs index 6c5784adda..6512690126 100644 --- a/crates/tests/misc/implement/tests/as_interface_param.rs +++ b/crates/tests/misc/implement/tests/as_interface_param.rs @@ -1,4 +1,5 @@ -use windows::{core::*, Foundation::*}; +use windows::core::*; +use windows_async::*; #[implement(IAsyncAction)] struct Async; diff --git a/crates/tests/misc/match/Cargo.toml b/crates/tests/misc/match/Cargo.toml index cc2c9c033c..643d0871c2 100644 --- a/crates/tests/misc/match/Cargo.toml +++ b/crates/tests/misc/match/Cargo.toml @@ -14,3 +14,6 @@ features = [ "Foundation", "Win32_Foundation", ] + +[dependencies.windows-async] +workspace = true diff --git a/crates/tests/misc/match/tests/tests.rs b/crates/tests/misc/match/tests/tests.rs index 874e81dff7..73abe24a19 100644 --- a/crates/tests/misc/match/tests/tests.rs +++ b/crates/tests/misc/match/tests/tests.rs @@ -1,4 +1,5 @@ -use windows::{Foundation::*, Win32::Foundation::*}; +use windows::Win32::Foundation::*; +use windows_async::*; #[test] fn test() { diff --git a/crates/tests/winrt/old/Cargo.toml b/crates/tests/winrt/old/Cargo.toml index f7b9d9f794..cf63b21a5b 100644 --- a/crates/tests/winrt/old/Cargo.toml +++ b/crates/tests/winrt/old/Cargo.toml @@ -14,6 +14,9 @@ workspace = true [dependencies.windows-numerics] workspace = true +[dependencies.windows-async] +workspace = true + [dependencies.windows] workspace = true features = [ diff --git a/crates/tests/winrt/old/tests/delegates.rs b/crates/tests/winrt/old/tests/delegates.rs index d47a7a20f4..719d4293ed 100644 --- a/crates/tests/winrt/old/tests/delegates.rs +++ b/crates/tests/winrt/old/tests/delegates.rs @@ -1,8 +1,8 @@ use core::convert::*; -use windows::{Foundation::Collections::*, Foundation::*}; - use windows::core::Interface; +use windows::{Foundation::Collections::*, Foundation::*}; +use windows_async::*; #[test] fn non_generic() -> windows::core::Result<()> { diff --git a/crates/tests/winrt/old/tests/enum.rs b/crates/tests/winrt/old/tests/enum.rs index 65b204ce6c..b9e797bd42 100644 --- a/crates/tests/winrt/old/tests/enum.rs +++ b/crates/tests/winrt/old/tests/enum.rs @@ -1,4 +1,5 @@ -use windows::{ApplicationModel::Appointments::AppointmentDaysOfWeek, Foundation::AsyncStatus}; +use windows::ApplicationModel::Appointments::AppointmentDaysOfWeek; +use windows_async::*; #[test] fn signed_enum() { diff --git a/crates/tests/winrt/old/tests/generic_guids.rs b/crates/tests/winrt/old/tests/generic_guids.rs index c16651386a..0f7a222a5e 100644 --- a/crates/tests/winrt/old/tests/generic_guids.rs +++ b/crates/tests/winrt/old/tests/generic_guids.rs @@ -1,4 +1,5 @@ use windows::{core::*, Devices::Enumeration::*, Foundation::Collections::*, Foundation::*}; +use windows_async::*; use windows_collections::*; #[test] diff --git a/crates/tests/winrt/old/tests/send_sync.rs b/crates/tests/winrt/old/tests/send_sync.rs index d8ed780889..13ddb0701b 100644 --- a/crates/tests/winrt/old/tests/send_sync.rs +++ b/crates/tests/winrt/old/tests/send_sync.rs @@ -2,6 +2,7 @@ use std::thread; use windows::core::{Interface, HRESULT, HSTRING}; use windows::Foundation::*; use windows::Storage::Streams::*; +use windows_async::*; // Simple test to validate that types with MarshalingType.Agile are marked Send and Sync // (if this compiles it worked) diff --git a/crates/tools/bindgen/src/main.rs b/crates/tools/bindgen/src/main.rs index a282c99962..a14a2ebfc5 100644 --- a/crates/tools/bindgen/src/main.rs +++ b/crates/tools/bindgen/src/main.rs @@ -124,15 +124,6 @@ fn main() { test("--out window_long_set_a_sys.rs --filter SetWindowLongPtrA --sys"); test("--out window_long_set_w_sys.rs --filter SetWindowLongPtrW --sys"); - // Tests for external references e.g. references to other crates - test("--out reference_async_info_no_status.rs --filter IAsyncInfo"); - test("--out reference_async_info_status_filter.rs --filter IAsyncInfo AsyncStatus"); - test("--out reference_async_info_status_reference.rs --filter IAsyncInfo --reference windows,skip-root,Windows"); - test("--out reference_async_action.rs --filter IAsyncAction"); - test("--out reference_async_action_reference_type.rs --filter IAsyncAction --reference windows,skip-root,IAsyncInfo"); - test("--out reference_async_action_reference_namespace.rs --filter IAsyncAction --reference windows,skip-root,Windows"); - test("--out reference_class_ref_static.rs --filter Windows.Foundation.Uri --reference windows,skip-root,Windows"); - // Tests for struct references test("--out reference_struct_filter.rs --filter InkTrailPoint"); test("--out reference_struct_reference_type.rs --filter InkTrailPoint --reference windows,skip-root,Point"); diff --git a/crates/tools/bindings/src/async.txt b/crates/tools/bindings/src/async.txt new file mode 100644 index 0000000000..22a56f5a87 --- /dev/null +++ b/crates/tools/bindings/src/async.txt @@ -0,0 +1,18 @@ +--out crates/libs/async/src/bindings.rs +--flat +--no-comment +--no-allow + +--filter + Windows.Foundation.AsyncActionCompletedHandler + Windows.Foundation.AsyncActionProgressHandler + Windows.Foundation.AsyncActionWithProgressCompletedHandler + Windows.Foundation.AsyncOperationCompletedHandler + Windows.Foundation.AsyncOperationProgressHandler + Windows.Foundation.AsyncOperationWithProgressCompletedHandler + Windows.Foundation.AsyncStatus + Windows.Foundation.IAsyncAction + Windows.Foundation.IAsyncActionWithProgress + Windows.Foundation.IAsyncInfo + Windows.Foundation.IAsyncOperation + Windows.Foundation.IAsyncOperationWithProgress diff --git a/crates/tools/bindings/src/collections.txt b/crates/tools/bindings/src/collections.txt index 10ea988d84..47ddaed4ed 100644 --- a/crates/tools/bindings/src/collections.txt +++ b/crates/tools/bindings/src/collections.txt @@ -3,7 +3,7 @@ --no-comment --filter - IMap - IMapView - IVector - IVectorView + Windows.Foundation.Collections.IMap + Windows.Foundation.Collections.IMapView + Windows.Foundation.Collections.IVector + Windows.Foundation.Collections.IVectorView diff --git a/crates/tools/bindings/src/main.rs b/crates/tools/bindings/src/main.rs index d55bc78e4a..55e39f475a 100644 --- a/crates/tools/bindings/src/main.rs +++ b/crates/tools/bindings/src/main.rs @@ -3,6 +3,7 @@ use windows_bindgen::*; fn main() { let time = std::time::Instant::now(); + bindgen(["--etc", "crates/tools/bindings/src/async.txt"]); bindgen(["--etc", "crates/tools/bindings/src/collections.txt"]); bindgen(["--etc", "crates/tools/bindings/src/core_com.txt"]); bindgen(["--etc", "crates/tools/bindings/src/core.txt"]); diff --git a/crates/tools/bindings/src/numerics.txt b/crates/tools/bindings/src/numerics.txt index bd5f3f1a62..14923cade8 100644 --- a/crates/tools/bindings/src/numerics.txt +++ b/crates/tools/bindings/src/numerics.txt @@ -4,8 +4,8 @@ --no-allow --filter - Matrix3x2 - Matrix4x4 - Vector2 - Vector3 - Vector4 + Windows.Foundation.Numerics.Matrix3x2 + Windows.Foundation.Numerics.Matrix4x4 + Windows.Foundation.Numerics.Vector2 + Windows.Foundation.Numerics.Vector3 + Windows.Foundation.Numerics.Vector4 diff --git a/crates/tools/bindings/src/windows.txt b/crates/tools/bindings/src/windows.txt index e71434122d..d05522e7a9 100644 --- a/crates/tools/bindings/src/windows.txt +++ b/crates/tools/bindings/src/windows.txt @@ -6,25 +6,40 @@ --reference windows_collections,flat,Windows.Foundation.Collections windows_numerics,flat,Windows.Foundation.Numerics + windows_async,flat,Windows.Foundation --filter Windows // Collections - !IIterable - !IIterator - !IKeyValuePair - !IMap - !IMapView - !IVector - !IVectorView + !Windows.Foundation.Collections.IIterable + !Windows.Foundation.Collections.IIterator + !Windows.Foundation.Collections.IKeyValuePair + !Windows.Foundation.Collections.IMap + !Windows.Foundation.Collections.IMapView + !Windows.Foundation.Collections.IVector + !Windows.Foundation.Collections.IVectorView // Numerics - !Matrix3x2 - !Matrix4x4 - !Vector2 - !Vector3 - !Vector4 + !Windows.Foundation.Numerics.Matrix3x2 + !Windows.Foundation.Numerics.Matrix4x4 + !Windows.Foundation.Numerics.Vector2 + !Windows.Foundation.Numerics.Vector3 + !Windows.Foundation.Numerics.Vector4 + +// Async + !Windows.Foundation.AsyncActionCompletedHandler + !Windows.Foundation.AsyncActionProgressHandler + !Windows.Foundation.AsyncActionWithProgressCompletedHandler + !Windows.Foundation.AsyncOperationCompletedHandler + !Windows.Foundation.AsyncOperationProgressHandler + !Windows.Foundation.AsyncOperationWithProgressCompletedHandler + !Windows.Foundation.AsyncStatus + !Windows.Foundation.IAsyncAction + !Windows.Foundation.IAsyncActionWithProgress + !Windows.Foundation.IAsyncInfo + !Windows.Foundation.IAsyncOperation + !Windows.Foundation.IAsyncOperationWithProgress !Windows.AI.MachineLearning.Preview !Windows.ApplicationModel.SocialInfo From 6cde7141fa2ae662717d330a7525b053469084fc Mon Sep 17 00:00:00 2001 From: Kenny Kerr Date: Fri, 14 Feb 2025 09:24:43 -0600 Subject: [PATCH 5/9] no_std --- crates/libs/async/src/async_ready.rs | 1 - crates/libs/async/src/async_spawn.rs | 1 - crates/libs/async/src/bindings_impl.rs | 15 ++++ crates/libs/async/src/{async.rs => future.rs} | 77 ------------------- crates/libs/async/src/get.rs | 73 ++++++++++++++++++ crates/libs/async/src/lib.rs | 14 +++- .../{core/src/imp => async/src}/waiter.rs | 7 +- crates/libs/core/src/imp/windows.rs | 3 - crates/tools/bindings/src/async_impl.txt | 12 +++ crates/tools/bindings/src/main.rs | 1 + 10 files changed, 115 insertions(+), 89 deletions(-) create mode 100644 crates/libs/async/src/bindings_impl.rs rename crates/libs/async/src/{async.rs => future.rs} (76%) create mode 100644 crates/libs/async/src/get.rs rename crates/libs/{core/src/imp => async/src}/waiter.rs (92%) create mode 100644 crates/tools/bindings/src/async_impl.txt diff --git a/crates/libs/async/src/async_ready.rs b/crates/libs/async/src/async_ready.rs index b02836c1bd..be5ac06e65 100644 --- a/crates/libs/async/src/async_ready.rs +++ b/crates/libs/async/src/async_ready.rs @@ -1,6 +1,5 @@ use super::*; use std::sync::atomic::{AtomicBool, Ordering}; -use windows_core::*; struct ReadyState { set_completed: AtomicBool, diff --git a/crates/libs/async/src/async_spawn.rs b/crates/libs/async/src/async_spawn.rs index 3a474bac59..1f624ed470 100644 --- a/crates/libs/async/src/async_spawn.rs +++ b/crates/libs/async/src/async_spawn.rs @@ -1,7 +1,6 @@ use super::*; use std::ffi::c_void; use std::sync::Mutex; -use windows_core::*; struct State { result: Option>, diff --git a/crates/libs/async/src/bindings_impl.rs b/crates/libs/async/src/bindings_impl.rs new file mode 100644 index 0000000000..fa184b8ef5 --- /dev/null +++ b/crates/libs/async/src/bindings_impl.rs @@ -0,0 +1,15 @@ +windows_link::link!("kernel32.dll" "system" fn CloseHandle(hobject : HANDLE) -> BOOL); +windows_link::link!("kernel32.dll" "system" fn CreateEventW(lpeventattributes : *const SECURITY_ATTRIBUTES, bmanualreset : BOOL, binitialstate : BOOL, lpname : PCWSTR) -> HANDLE); +windows_link::link!("kernel32.dll" "system" fn SetEvent(hevent : HANDLE) -> BOOL); +windows_link::link!("kernel32.dll" "system" fn WaitForSingleObject(hhandle : HANDLE, dwmilliseconds : u32) -> WAIT_EVENT); +pub type BOOL = i32; +pub type HANDLE = *mut core::ffi::c_void; +pub type PCWSTR = *const u16; +#[repr(C)] +#[derive(Clone, Copy)] +pub struct SECURITY_ATTRIBUTES { + pub nLength: u32, + pub lpSecurityDescriptor: *mut core::ffi::c_void, + pub bInheritHandle: BOOL, +} +pub type WAIT_EVENT = u32; diff --git a/crates/libs/async/src/async.rs b/crates/libs/async/src/future.rs similarity index 76% rename from crates/libs/async/src/async.rs rename to crates/libs/async/src/future.rs index 4b4edd4fb9..2330b624b6 100644 --- a/crates/libs/async/src/async.rs +++ b/crates/libs/async/src/future.rs @@ -3,7 +3,6 @@ use std::future::{Future, IntoFuture}; use std::pin::Pin; use std::sync::{Arc, Mutex}; use std::task::{Context, Poll, Waker}; -use windows_core::{imp::Waiter, *}; // An `Async` represents a WinRT async execution object or type. There are precisely four such types: // - IAsyncAction @@ -234,79 +233,3 @@ impl IntoFuture for IAsyncOperationWithProgress< AsyncFuture::new(self) } } - -// -// The four `get` implementations for synchronous completion. -// - -impl IAsyncAction { - /// Waits for the `IAsyncAction` to finish. - pub fn get(&self) -> Result<()> { - if self.Status()? == AsyncStatus::Started { - let (_waiter, signaler) = Waiter::new()?; - self.SetCompleted(&AsyncActionCompletedHandler::new(move |_, _| { - // This is safe because the waiter will only be dropped after being signaled. - unsafe { - signaler.signal(); - } - Ok(()) - }))?; - } - self.GetResults() - } -} - -impl IAsyncOperation { - /// Waits for the `IAsyncOperation` to finish. - pub fn get(&self) -> Result { - if self.Status()? == AsyncStatus::Started { - let (_waiter, signaler) = Waiter::new()?; - self.SetCompleted(&AsyncOperationCompletedHandler::new(move |_, _| { - // This is safe because the waiter will only be dropped after being signaled. - unsafe { - signaler.signal(); - } - Ok(()) - }))?; - } - self.GetResults() - } -} - -impl IAsyncActionWithProgress

{ - /// Waits for the `IAsyncActionWithProgress

` to finish. - pub fn get(&self) -> Result<()> { - if self.Status()? == AsyncStatus::Started { - let (_waiter, signaler) = Waiter::new()?; - self.SetCompleted(&AsyncActionWithProgressCompletedHandler::new( - move |_, _| { - // This is safe because the waiter will only be dropped after being signaled. - unsafe { - signaler.signal(); - } - Ok(()) - }, - ))?; - } - self.GetResults() - } -} - -impl IAsyncOperationWithProgress { - /// Waits for the `IAsyncOperationWithProgress` to finish. - pub fn get(&self) -> Result { - if self.Status()? == AsyncStatus::Started { - let (_waiter, signaler) = Waiter::new()?; - self.SetCompleted(&AsyncOperationWithProgressCompletedHandler::new( - move |_, _| { - // This is safe because the waiter will only be dropped after being signaled. - unsafe { - signaler.signal(); - } - Ok(()) - }, - ))?; - } - self.GetResults() - } -} diff --git a/crates/libs/async/src/get.rs b/crates/libs/async/src/get.rs new file mode 100644 index 0000000000..1dfd274db5 --- /dev/null +++ b/crates/libs/async/src/get.rs @@ -0,0 +1,73 @@ +use super::*; + +impl IAsyncAction { + /// Waits for the `IAsyncAction` to finish. + pub fn get(&self) -> Result<()> { + if self.Status()? == AsyncStatus::Started { + let (_waiter, signaler) = Waiter::new()?; + self.SetCompleted(&AsyncActionCompletedHandler::new(move |_, _| { + // This is safe because the waiter will only be dropped after being signaled. + unsafe { + signaler.signal(); + } + Ok(()) + }))?; + } + self.GetResults() + } +} + +impl IAsyncOperation { + /// Waits for the `IAsyncOperation` to finish. + pub fn get(&self) -> Result { + if self.Status()? == AsyncStatus::Started { + let (_waiter, signaler) = Waiter::new()?; + self.SetCompleted(&AsyncOperationCompletedHandler::new(move |_, _| { + // This is safe because the waiter will only be dropped after being signaled. + unsafe { + signaler.signal(); + } + Ok(()) + }))?; + } + self.GetResults() + } +} + +impl IAsyncActionWithProgress

{ + /// Waits for the `IAsyncActionWithProgress

` to finish. + pub fn get(&self) -> Result<()> { + if self.Status()? == AsyncStatus::Started { + let (_waiter, signaler) = Waiter::new()?; + self.SetCompleted(&AsyncActionWithProgressCompletedHandler::new( + move |_, _| { + // This is safe because the waiter will only be dropped after being signaled. + unsafe { + signaler.signal(); + } + Ok(()) + }, + ))?; + } + self.GetResults() + } +} + +impl IAsyncOperationWithProgress { + /// Waits for the `IAsyncOperationWithProgress` to finish. + pub fn get(&self) -> Result { + if self.Status()? == AsyncStatus::Started { + let (_waiter, signaler) = Waiter::new()?; + self.SetCompleted(&AsyncOperationWithProgressCompletedHandler::new( + move |_, _| { + // This is safe because the waiter will only be dropped after being signaled. + unsafe { + signaler.signal(); + } + Ok(()) + }, + ))?; + } + self.GetResults() + } +} diff --git a/crates/libs/async/src/lib.rs b/crates/libs/async/src/lib.rs index d7476d15ad..526cc6a8e6 100644 --- a/crates/libs/async/src/lib.rs +++ b/crates/libs/async/src/lib.rs @@ -9,14 +9,20 @@ #![cfg_attr(all(not(feature = "std")), no_std)] mod bindings; +mod bindings_impl; +mod get; +mod waiter; + pub use bindings::*; +use bindings_impl::*; +use waiter::*; +use windows_core::*; -#[cfg(feature = "std")] -mod r#async; #[cfg(feature = "std")] mod async_ready; #[cfg(feature = "std")] mod async_spawn; - #[cfg(feature = "std")] -pub(crate) use r#async::*; +mod future; +#[cfg(feature = "std")] +use future::*; diff --git a/crates/libs/core/src/imp/waiter.rs b/crates/libs/async/src/waiter.rs similarity index 92% rename from crates/libs/core/src/imp/waiter.rs rename to crates/libs/async/src/waiter.rs index d5e5f09e51..26eb46e951 100644 --- a/crates/libs/core/src/imp/waiter.rs +++ b/crates/libs/async/src/waiter.rs @@ -2,7 +2,6 @@ use super::*; pub struct Waiter(HANDLE); pub struct WaiterSignaler(HANDLE); - unsafe impl Send for WaiterSignaler {} impl Waiter { @@ -24,9 +23,11 @@ impl WaiterSignaler { /// to the lifetime of the `Waiter`. This is not possible in this case because the `Waiter` /// is used to signal a WinRT async completion and the compiler doesn't know that the lifetime /// of the delegate is bounded by the calling function. - pub unsafe fn signal(&self) { + pub unsafe fn signal(&self) { // https://github.com/microsoft/windows-rs/pull/374#discussion_r535313344 - unsafe { SetEvent(self.0); } + unsafe { + SetEvent(self.0); + } } } diff --git a/crates/libs/core/src/imp/windows.rs b/crates/libs/core/src/imp/windows.rs index e1a55ceb4d..ab8ec2418b 100644 --- a/crates/libs/core/src/imp/windows.rs +++ b/crates/libs/core/src/imp/windows.rs @@ -4,8 +4,5 @@ pub use factory_cache::*; mod generic_factory; pub use generic_factory::*; -mod waiter; -pub use waiter::*; - mod bindings; pub use bindings::*; diff --git a/crates/tools/bindings/src/async_impl.txt b/crates/tools/bindings/src/async_impl.txt new file mode 100644 index 0000000000..91713b243d --- /dev/null +++ b/crates/tools/bindings/src/async_impl.txt @@ -0,0 +1,12 @@ +--out crates/libs/async/src/bindings_impl.rs +--flat +--no-comment +--no-allow +--sys +--no-core + +--filter + CloseHandle + CreateEventW + SetEvent + WaitForSingleObject diff --git a/crates/tools/bindings/src/main.rs b/crates/tools/bindings/src/main.rs index 55e39f475a..b5f8384f1e 100644 --- a/crates/tools/bindings/src/main.rs +++ b/crates/tools/bindings/src/main.rs @@ -4,6 +4,7 @@ fn main() { let time = std::time::Instant::now(); bindgen(["--etc", "crates/tools/bindings/src/async.txt"]); + bindgen(["--etc", "crates/tools/bindings/src/async_impl.txt"]); bindgen(["--etc", "crates/tools/bindings/src/collections.txt"]); bindgen(["--etc", "crates/tools/bindings/src/core_com.txt"]); bindgen(["--etc", "crates/tools/bindings/src/core.txt"]); From 2707c71130763764bf80ff57bee9012a1594eefa Mon Sep 17 00:00:00 2001 From: Kenny Kerr Date: Fri, 14 Feb 2025 09:53:39 -0600 Subject: [PATCH 6/9] explicit no_std test --- crates/tests/misc/no_std/Cargo.toml | 4 ++++ crates/tests/misc/no_std/src/lib.rs | 1 + 2 files changed, 5 insertions(+) diff --git a/crates/tests/misc/no_std/Cargo.toml b/crates/tests/misc/no_std/Cargo.toml index 237fc3c565..193ea8cc95 100644 --- a/crates/tests/misc/no_std/Cargo.toml +++ b/crates/tests/misc/no_std/Cargo.toml @@ -41,6 +41,10 @@ default-features = false path = "../../../libs/numerics" default-features = false +[dependencies.windows-async] +path = "../../../libs/async" +default-features = false + [dependencies.windows-version] path = "../../../libs/version" default-features = false diff --git a/crates/tests/misc/no_std/src/lib.rs b/crates/tests/misc/no_std/src/lib.rs index dab6810ca3..4612a45f03 100644 --- a/crates/tests/misc/no_std/src/lib.rs +++ b/crates/tests/misc/no_std/src/lib.rs @@ -24,6 +24,7 @@ fn _test() { let _ = windows_strings::s!("hello"); let _ = windows_strings::w!("hello"); let _: Option> = None; + let _: Option> = None; let _ = windows_numerics::Vector2::new(0.0, 0.0); } From 09534e4753921cd2b1107c1b2bc8071db5bc9d36 Mon Sep 17 00:00:00 2001 From: Kenny Kerr Date: Fri, 14 Feb 2025 09:55:17 -0600 Subject: [PATCH 7/9] msrv tests --- .github/workflows/msrv-windows-async.yml | 27 +++++++++++++++++++++ .github/workflows/msrv-windows-numerics.yml | 27 +++++++++++++++++++++ 2 files changed, 54 insertions(+) create mode 100644 .github/workflows/msrv-windows-async.yml create mode 100644 .github/workflows/msrv-windows-numerics.yml diff --git a/.github/workflows/msrv-windows-async.yml b/.github/workflows/msrv-windows-async.yml new file mode 100644 index 0000000000..2fc88c2570 --- /dev/null +++ b/.github/workflows/msrv-windows-async.yml @@ -0,0 +1,27 @@ +name: windows-async + +on: + pull_request: + paths-ignore: + - '.github/ISSUE_TEMPLATE/**' + - 'web/**' + push: + paths-ignore: + - '.github/ISSUE_TEMPLATE/**' + - 'web/**' + branches: + - master + +jobs: + check: + strategy: + matrix: + rust: [1.74.0, stable, nightly] + runs-on: windows-2022 + steps: + - name: Checkout + uses: actions/checkout@v4 + - name: Prepare + run: rustup update --no-self-update ${{ matrix.rust }} && rustup default ${{ matrix.rust }} + - name: Check + run: cargo check -p windows-async --all-features diff --git a/.github/workflows/msrv-windows-numerics.yml b/.github/workflows/msrv-windows-numerics.yml new file mode 100644 index 0000000000..b35ea37e23 --- /dev/null +++ b/.github/workflows/msrv-windows-numerics.yml @@ -0,0 +1,27 @@ +name: windows-numerics + +on: + pull_request: + paths-ignore: + - '.github/ISSUE_TEMPLATE/**' + - 'web/**' + push: + paths-ignore: + - '.github/ISSUE_TEMPLATE/**' + - 'web/**' + branches: + - master + +jobs: + check: + strategy: + matrix: + rust: [1.74.0, stable, nightly] + runs-on: windows-2022 + steps: + - name: Checkout + uses: actions/checkout@v4 + - name: Prepare + run: rustup update --no-self-update ${{ matrix.rust }} && rustup default ${{ matrix.rust }} + - name: Check + run: cargo check -p windows-numerics --all-features From 3174af017506ed25ff7703af7215e6885f1d7bf0 Mon Sep 17 00:00:00 2001 From: Kenny Kerr Date: Fri, 14 Feb 2025 12:59:18 -0600 Subject: [PATCH 8/9] windows-future --- .github/workflows/clippy.yml | 4 +- .github/workflows/msrv-windows-async.yml | 4 +- .github/workflows/no-default-features.yml | 4 +- .github/workflows/raw-dylib.yml | 4 +- .github/workflows/test.yml | 4 +- Cargo.toml | 2 +- crates/libs/{async => future}/Cargo.toml | 2 +- .../libs/{async => future}/license-apache-2.0 | 0 crates/libs/{async => future}/license-mit | 0 crates/libs/{async => future}/readme.md | 2 +- .../libs/{async => future}/src/async_ready.rs | 0 .../libs/{async => future}/src/async_spawn.rs | 0 crates/libs/{async => future}/src/bindings.rs | 0 .../{async => future}/src/bindings_impl.rs | 0 crates/libs/{async => future}/src/future.rs | 0 crates/libs/{async => future}/src/get.rs | 0 crates/libs/{async => future}/src/lib.rs | 0 crates/libs/{async => future}/src/waiter.rs | 0 crates/libs/windows/Cargo.toml | 4 +- .../src/Windows/AI/MachineLearning/mod.rs | 12 +- .../ApplicationModel/AppExtensions/mod.rs | 8 +- .../ApplicationModel/AppService/mod.rs | 14 +- .../Appointments/DataProvider/mod.rs | 24 +- .../ApplicationModel/Appointments/mod.rs | 138 +++--- .../ApplicationModel/Background/mod.rs | 30 +- .../ApplicationModel/Calls/Provider/mod.rs | 2 +- .../src/Windows/ApplicationModel/Calls/mod.rs | 74 +-- .../src/Windows/ApplicationModel/Chat/mod.rs | 100 ++-- .../CommunicationBlocking/mod.rs | 4 +- .../Contacts/DataProvider/mod.rs | 18 +- .../Windows/ApplicationModel/Contacts/mod.rs | 126 ++--- .../ConversationalAgent/mod.rs | 68 +-- .../src/Windows/ApplicationModel/Core/mod.rs | 8 +- .../DataTransfer/DragDrop/Core/mod.rs | 18 +- .../ApplicationModel/DataTransfer/mod.rs | 30 +- .../Email/DataProvider/mod.rs | 62 +-- .../src/Windows/ApplicationModel/Email/mod.rs | 116 ++--- .../ExtendedExecution/Foreground/mod.rs | 2 +- .../ApplicationModel/ExtendedExecution/mod.rs | 2 +- .../ApplicationModel/PackageExtensions/mod.rs | 8 +- .../ApplicationModel/Payments/Provider/mod.rs | 12 +- .../Windows/ApplicationModel/Payments/mod.rs | 10 +- .../Preview/InkWorkspace/mod.rs | 2 +- .../ApplicationModel/Preview/Notes/mod.rs | 4 +- .../ApplicationModel/Resources/Core/mod.rs | 4 +- .../Resources/Management/mod.rs | 2 +- .../UserActivities/Core/mod.rs | 2 +- .../ApplicationModel/UserActivities/mod.rs | 12 +- .../UserDataAccounts/SystemAccess/mod.rs | 10 +- .../ApplicationModel/UserDataAccounts/mod.rs | 38 +- .../UserDataTasks/DataProvider/mod.rs | 20 +- .../ApplicationModel/UserDataTasks/mod.rs | 34 +- .../ApplicationModel/VoiceCommands/mod.rs | 18 +- .../ApplicationModel/Wallet/System/mod.rs | 10 +- .../Windows/ApplicationModel/Wallet/mod.rs | 24 +- .../src/Windows/ApplicationModel/mod.rs | 42 +- .../libs/windows/src/Windows/Data/Pdf/mod.rs | 14 +- .../libs/windows/src/Windows/Data/Text/mod.rs | 16 +- .../windows/src/Windows/Data/Xml/Dom/mod.rs | 10 +- .../windows/src/Windows/Devices/Adc/mod.rs | 4 +- .../Bluetooth/GenericAttributeProfile/mod.rs | 78 ++-- .../Windows/Devices/Bluetooth/Rfcomm/mod.rs | 10 +- .../src/Windows/Devices/Bluetooth/mod.rs | 38 +- .../windows/src/Windows/Devices/Custom/mod.rs | 6 +- .../src/Windows/Devices/Display/Core/mod.rs | 6 +- .../src/Windows/Devices/Display/mod.rs | 4 +- .../Windows/Devices/Enumeration/Pnp/mod.rs | 6 +- .../src/Windows/Devices/Enumeration/mod.rs | 48 +- .../src/Windows/Devices/Geolocation/mod.rs | 12 +- .../windows/src/Windows/Devices/Gpio/mod.rs | 6 +- .../src/Windows/Devices/Haptics/mod.rs | 8 +- .../Devices/HumanInterfaceDevice/mod.rs | 14 +- .../src/Windows/Devices/I2c/Provider/mod.rs | 4 +- .../windows/src/Windows/Devices/I2c/mod.rs | 10 +- .../src/Windows/Devices/Input/Preview/mod.rs | 2 +- .../windows/src/Windows/Devices/Lights/mod.rs | 10 +- .../windows/src/Windows/Devices/Midi/mod.rs | 8 +- .../Devices/PointOfService/Provider/mod.rs | 84 ++-- .../src/Windows/Devices/PointOfService/mod.rs | 188 ++++---- .../windows/src/Windows/Devices/Power/mod.rs | 2 +- .../src/Windows/Devices/Printers/mod.rs | 8 +- .../windows/src/Windows/Devices/Pwm/mod.rs | 6 +- .../windows/src/Windows/Devices/Radios/mod.rs | 8 +- .../src/Windows/Devices/Scanners/mod.rs | 6 +- .../src/Windows/Devices/Sensors/Custom/mod.rs | 2 +- .../src/Windows/Devices/Sensors/mod.rs | 54 +-- .../Devices/SerialCommunication/mod.rs | 2 +- .../src/Windows/Devices/SmartCards/mod.rs | 98 ++-- .../windows/src/Windows/Devices/Sms/mod.rs | 28 +- .../src/Windows/Devices/Spi/Provider/mod.rs | 4 +- .../windows/src/Windows/Devices/Spi/mod.rs | 10 +- .../windows/src/Windows/Devices/Usb/mod.rs | 20 +- .../windows/src/Windows/Devices/WiFi/mod.rs | 20 +- .../Devices/WiFiDirect/Services/mod.rs | 16 +- .../src/Windows/Devices/WiFiDirect/mod.rs | 4 +- .../Windows/Embedded/DeviceLockdown/mod.rs | 2 +- .../src/Windows/Foundation/Diagnostics/mod.rs | 18 +- .../src/Windows/Gaming/Input/Custom/mod.rs | 2 +- .../Windows/Gaming/Input/ForceFeedback/mod.rs | 10 +- .../Gaming/Preview/GamesEnumeration/mod.rs | 30 +- .../Windows/Gaming/XboxLive/Storage/mod.rs | 28 +- .../src/Windows/Graphics/Capture/mod.rs | 4 +- .../src/Windows/Graphics/Display/Core/mod.rs | 8 +- .../src/Windows/Graphics/Display/mod.rs | 6 +- .../src/Windows/Graphics/Imaging/mod.rs | 96 ++-- .../Graphics/Printing/PrintTicket/mod.rs | 4 +- .../Windows/Graphics/Printing/Workflow/mod.rs | 16 +- .../src/Windows/Graphics/Printing/mod.rs | 2 +- .../src/Windows/Graphics/Printing3D/mod.rs | 26 +- .../src/Windows/Management/Deployment/mod.rs | 80 ++-- .../src/Windows/Management/Setup/mod.rs | 2 +- .../src/Windows/Management/Update/mod.rs | 4 +- .../windows/src/Windows/Management/mod.rs | 6 +- .../src/Windows/Media/AppRecording/mod.rs | 6 +- .../windows/src/Windows/Media/Audio/mod.rs | 36 +- .../src/Windows/Media/Capture/Core/mod.rs | 8 +- .../src/Windows/Media/Capture/Frames/mod.rs | 22 +- .../windows/src/Windows/Media/Capture/mod.rs | 116 ++--- .../windows/src/Windows/Media/Casting/mod.rs | 12 +- .../Windows/Media/ContentRestrictions/mod.rs | 6 +- .../windows/src/Windows/Media/Control/mod.rs | 34 +- .../windows/src/Windows/Media/Core/mod.rs | 8 +- .../windows/src/Windows/Media/Devices/mod.rs | 46 +- .../src/Windows/Media/DialProtocol/mod.rs | 20 +- .../windows/src/Windows/Media/Editing/mod.rs | 20 +- .../src/Windows/Media/FaceAnalysis/mod.rs | 10 +- .../windows/src/Windows/Media/Import/mod.rs | 22 +- .../src/Windows/Media/MediaProperties/mod.rs | 4 +- .../windows/src/Windows/Media/Miracast/mod.rs | 18 +- .../libs/windows/src/Windows/Media/Ocr/mod.rs | 2 +- .../windows/src/Windows/Media/PlayTo/mod.rs | 4 +- .../src/Windows/Media/Playlists/mod.rs | 8 +- .../Windows/Media/Protection/PlayReady/mod.rs | 54 +-- .../src/Windows/Media/Protection/mod.rs | 4 +- .../Windows/Media/SpeechRecognition/mod.rs | 24 +- .../src/Windows/Media/SpeechSynthesis/mod.rs | 12 +- .../Windows/Media/Streaming/Adaptive/mod.rs | 8 +- .../src/Windows/Media/Transcoding/mod.rs | 8 +- crates/libs/windows/src/Windows/Media/mod.rs | 6 +- .../Networking/BackgroundTransfer/mod.rs | 34 +- .../Windows/Networking/Connectivity/mod.rs | 18 +- .../Networking/NetworkOperators/mod.rs | 110 ++--- .../src/Windows/Networking/Proximity/mod.rs | 4 +- .../Networking/PushNotifications/mod.rs | 16 +- .../Networking/ServiceDiscovery/Dnssd/mod.rs | 8 +- .../src/Windows/Networking/Sockets/mod.rs | 60 +-- .../windows/src/Windows/Networking/Vpn/mod.rs | 26 +- .../src/Windows/Networking/XboxLive/mod.rs | 12 +- .../src/Windows/Perception/People/mod.rs | 2 +- .../Perception/Spatial/Surfaces/mod.rs | 6 +- .../src/Windows/Perception/Spatial/mod.rs | 20 +- .../Phone/Management/Deployment/mod.rs | 16 +- .../PersonalInformation/Provisioning/mod.rs | 10 +- .../Windows/Phone/PersonalInformation/mod.rs | 74 +-- .../src/Windows/Phone/StartScreen/mod.rs | 8 +- .../UserProfile/GameServices/Core/mod.rs | 10 +- .../Authentication/Identity/Core/mod.rs | 20 +- .../Security/Authentication/Identity/mod.rs | 2 +- .../Security/Authentication/OnlineId/mod.rs | 6 +- .../Security/Authentication/Web/Core/mod.rs | 30 +- .../Authentication/Web/Provider/mod.rs | 52 +-- .../Security/Authentication/Web/mod.rs | 8 +- .../Authorization/AppCapabilityAccess/mod.rs | 6 +- .../Windows/Security/Credentials/UI/mod.rs | 10 +- .../src/Windows/Security/Credentials/mod.rs | 20 +- .../Security/Cryptography/Certificates/mod.rs | 42 +- .../Windows/Security/Cryptography/Core/mod.rs | 8 +- .../Cryptography/DataProtection/mod.rs | 8 +- .../Windows/Security/DataProtection/mod.rs | 8 +- .../Windows/Security/EnterpriseData/mod.rs | 72 +-- .../ExchangeActiveSyncProvisioning/mod.rs | 2 +- .../src/Windows/Security/Isolation/mod.rs | 34 +- .../Windows/Services/Maps/LocalSearch/mod.rs | 2 +- .../Windows/Services/Maps/OfflineMaps/mod.rs | 8 +- .../windows/src/Windows/Services/Maps/mod.rs | 34 +- .../windows/src/Windows/Services/Store/mod.rs | 100 ++-- .../Windows/Services/TargetedContent/mod.rs | 12 +- .../src/Windows/Storage/AccessCache/mod.rs | 48 +- .../src/Windows/Storage/BulkAccess/mod.rs | 110 ++--- .../src/Windows/Storage/Compression/mod.rs | 8 +- .../src/Windows/Storage/FileProperties/mod.rs | 68 +-- .../src/Windows/Storage/Pickers/mod.rs | 12 +- .../src/Windows/Storage/Provider/mod.rs | 14 +- .../windows/src/Windows/Storage/Search/mod.rs | 78 ++-- .../src/Windows/Storage/Streams/mod.rs | 96 ++-- .../libs/windows/src/Windows/Storage/mod.rs | 434 +++++++++--------- .../src/Windows/System/Diagnostics/mod.rs | 4 +- .../System/Implementation/FileExplorer/mod.rs | 4 +- .../src/Windows/System/Inventory/mod.rs | 2 +- .../windows/src/Windows/System/Profile/mod.rs | 2 +- .../src/Windows/System/RemoteSystems/mod.rs | 22 +- .../src/Windows/System/Threading/Core/mod.rs | 2 +- .../src/Windows/System/Threading/mod.rs | 14 +- .../windows/src/Windows/System/Update/mod.rs | 4 +- .../src/Windows/System/UserProfile/mod.rs | 30 +- crates/libs/windows/src/Windows/System/mod.rs | 108 ++--- .../src/Windows/UI/ApplicationSettings/mod.rs | 8 +- .../src/Windows/UI/Composition/Core/mod.rs | 2 +- .../windows/src/Windows/UI/Composition/mod.rs | 4 +- .../libs/windows/src/Windows/UI/Core/mod.rs | 12 +- .../Windows/UI/Input/Inking/Analysis/mod.rs | 2 +- .../src/Windows/UI/Input/Inking/mod.rs | 28 +- .../src/Windows/UI/Input/Spatial/mod.rs | 4 +- .../UI/Notifications/Management/mod.rs | 4 +- .../src/Windows/UI/Notifications/mod.rs | 14 +- .../libs/windows/src/Windows/UI/Popups/mod.rs | 8 +- .../libs/windows/src/Windows/UI/Shell/mod.rs | 14 +- .../windows/src/Windows/UI/StartScreen/mod.rs | 36 +- .../src/Windows/UI/UIAutomation/Core/mod.rs | 4 +- .../src/Windows/UI/ViewManagement/Core/mod.rs | 2 +- .../src/Windows/UI/ViewManagement/mod.rs | 48 +- .../libs/windows/src/Windows/UI/WebUI/mod.rs | 14 +- .../src/Windows/UI/WindowManagement/mod.rs | 6 +- .../windows/src/Windows/Web/AtomPub/mod.rs | 22 +- .../src/Windows/Web/Http/Filters/mod.rs | 6 +- .../libs/windows/src/Windows/Web/Http/mod.rs | 120 ++--- .../src/Windows/Web/Syndication/mod.rs | 6 +- .../windows/src/Windows/Web/UI/Interop/mod.rs | 8 +- crates/libs/windows/src/Windows/Web/UI/mod.rs | 12 +- crates/libs/windows/src/Windows/Web/mod.rs | 4 +- crates/samples/windows/consent/Cargo.toml | 2 +- crates/samples/windows/consent/src/main.rs | 2 +- crates/tests/misc/async/Cargo.toml | 2 +- crates/tests/misc/async/tests/agile.rs | 2 +- crates/tests/misc/async/tests/async_info.rs | 2 +- .../misc/async/tests/completed_finished.rs | 2 +- .../tests/misc/async/tests/completed_get.rs | 2 +- .../tests/misc/async/tests/completed_once.rs | 2 +- .../misc/async/tests/completed_started.rs | 2 +- crates/tests/misc/async/tests/dropped.rs | 2 +- crates/tests/misc/async/tests/error.rs | 2 +- crates/tests/misc/async/tests/progress.rs | 2 +- crates/tests/misc/async/tests/started.rs | 2 +- crates/tests/misc/implement/Cargo.toml | 2 +- .../implement/tests/as_interface_param.rs | 2 +- crates/tests/misc/match/Cargo.toml | 2 +- crates/tests/misc/match/tests/tests.rs | 2 +- crates/tests/misc/no_std/Cargo.toml | 4 +- crates/tests/misc/no_std/src/lib.rs | 2 +- crates/tests/winrt/old/Cargo.toml | 2 +- crates/tests/winrt/old/tests/delegates.rs | 2 +- crates/tests/winrt/old/tests/enum.rs | 2 +- crates/tests/winrt/old/tests/generic_guids.rs | 2 +- crates/tests/winrt/old/tests/send_sync.rs | 2 +- crates/tools/bindings/src/async.txt | 2 +- crates/tools/bindings/src/async_impl.txt | 2 +- crates/tools/bindings/src/windows.txt | 2 +- 247 files changed, 2648 insertions(+), 2648 deletions(-) rename crates/libs/{async => future}/Cargo.toml (95%) rename crates/libs/{async => future}/license-apache-2.0 (100%) rename crates/libs/{async => future}/license-mit (100%) rename crates/libs/{async => future}/readme.md (66%) rename crates/libs/{async => future}/src/async_ready.rs (100%) rename crates/libs/{async => future}/src/async_spawn.rs (100%) rename crates/libs/{async => future}/src/bindings.rs (100%) rename crates/libs/{async => future}/src/bindings_impl.rs (100%) rename crates/libs/{async => future}/src/future.rs (100%) rename crates/libs/{async => future}/src/get.rs (100%) rename crates/libs/{async => future}/src/lib.rs (100%) rename crates/libs/{async => future}/src/waiter.rs (100%) diff --git a/.github/workflows/clippy.yml b/.github/workflows/clippy.yml index 5fa358a578..ca6292347a 100644 --- a/.github/workflows/clippy.yml +++ b/.github/workflows/clippy.yml @@ -303,14 +303,14 @@ jobs: run: cargo clippy -p tool_yml - name: Clippy windows run: cargo clippy -p windows - - name: Clippy windows-async - run: cargo clippy -p windows-async - name: Clippy windows-bindgen run: cargo clippy -p windows-bindgen - name: Clippy windows-collections run: cargo clippy -p windows-collections - name: Clippy windows-core run: cargo clippy -p windows-core + - name: Clippy windows-future + run: cargo clippy -p windows-future - name: Clippy windows-implement run: cargo clippy -p windows-implement - name: Clippy windows-interface diff --git a/.github/workflows/msrv-windows-async.yml b/.github/workflows/msrv-windows-async.yml index 2fc88c2570..c2c62cce20 100644 --- a/.github/workflows/msrv-windows-async.yml +++ b/.github/workflows/msrv-windows-async.yml @@ -1,4 +1,4 @@ -name: windows-async +name: windows-future on: pull_request: @@ -24,4 +24,4 @@ jobs: - name: Prepare run: rustup update --no-self-update ${{ matrix.rust }} && rustup default ${{ matrix.rust }} - name: Check - run: cargo check -p windows-async --all-features + run: cargo check -p windows-future --all-features diff --git a/.github/workflows/no-default-features.yml b/.github/workflows/no-default-features.yml index 919071e8bc..9a26257bfa 100644 --- a/.github/workflows/no-default-features.yml +++ b/.github/workflows/no-default-features.yml @@ -37,14 +37,14 @@ jobs: run: cargo check -p helpers --no-default-features - name: Check windows run: cargo check -p windows --no-default-features - - name: Check windows-async - run: cargo check -p windows-async --no-default-features - name: Check windows-bindgen run: cargo check -p windows-bindgen --no-default-features - name: Check windows-collections run: cargo check -p windows-collections --no-default-features - name: Check windows-core run: cargo check -p windows-core --no-default-features + - name: Check windows-future + run: cargo check -p windows-future --no-default-features - name: Check windows-implement run: cargo check -p windows-implement --no-default-features - name: Check windows-interface diff --git a/.github/workflows/raw-dylib.yml b/.github/workflows/raw-dylib.yml index 383c2af479..3f2f40afce 100644 --- a/.github/workflows/raw-dylib.yml +++ b/.github/workflows/raw-dylib.yml @@ -334,14 +334,14 @@ jobs: run: cargo test -p tool_yml --target ${{ matrix.target }} ${{ matrix.etc }} - name: Test windows run: cargo test -p windows --target ${{ matrix.target }} ${{ matrix.etc }} - - name: Test windows-async - run: cargo test -p windows-async --target ${{ matrix.target }} ${{ matrix.etc }} - name: Test windows-bindgen run: cargo test -p windows-bindgen --target ${{ matrix.target }} ${{ matrix.etc }} - name: Test windows-collections run: cargo test -p windows-collections --target ${{ matrix.target }} ${{ matrix.etc }} - name: Test windows-core run: cargo test -p windows-core --target ${{ matrix.target }} ${{ matrix.etc }} + - name: Test windows-future + run: cargo test -p windows-future --target ${{ matrix.target }} ${{ matrix.etc }} - name: Test windows-implement run: cargo test -p windows-implement --target ${{ matrix.target }} ${{ matrix.etc }} - name: Test windows-interface diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index 1df4570347..209d074d83 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -331,14 +331,14 @@ jobs: run: cargo test -p tool_yml --target ${{ matrix.target }} ${{ matrix.etc }} - name: Test windows run: cargo test -p windows --target ${{ matrix.target }} ${{ matrix.etc }} - - name: Test windows-async - run: cargo test -p windows-async --target ${{ matrix.target }} ${{ matrix.etc }} - name: Test windows-bindgen run: cargo test -p windows-bindgen --target ${{ matrix.target }} ${{ matrix.etc }} - name: Test windows-collections run: cargo test -p windows-collections --target ${{ matrix.target }} ${{ matrix.etc }} - name: Test windows-core run: cargo test -p windows-core --target ${{ matrix.target }} ${{ matrix.etc }} + - name: Test windows-future + run: cargo test -p windows-future --target ${{ matrix.target }} ${{ matrix.etc }} - name: Test windows-implement run: cargo test -p windows-implement --target ${{ matrix.target }} ${{ matrix.etc }} - name: Test windows-interface diff --git a/Cargo.toml b/Cargo.toml index 9fc27ce764..381762d2e8 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -24,10 +24,10 @@ unexpected_cfgs = { level = "warn", check-cfg = ['cfg(windows_raw_dylib, windows [workspace.dependencies] cppwinrt = { path = "crates/libs/cppwinrt" } windows = { path = "crates/libs/windows" } -windows-async = { path = "crates/libs/async" } windows-bindgen = { path = "crates/libs/bindgen" } windows-collections = { path = "crates/libs/collections" } windows-core = { path = "crates/libs/core" } +windows-future = { path = "crates/libs/future" } windows-link = { path = "crates/libs/link" } windows-numerics = { path = "crates/libs/numerics" } windows-registry = { path = "crates/libs/registry" } diff --git a/crates/libs/async/Cargo.toml b/crates/libs/future/Cargo.toml similarity index 95% rename from crates/libs/async/Cargo.toml rename to crates/libs/future/Cargo.toml index 138e51e1cf..4d1fd0b9ea 100644 --- a/crates/libs/async/Cargo.toml +++ b/crates/libs/future/Cargo.toml @@ -1,5 +1,5 @@ [package] -name = "windows-async" +name = "windows-future" version = "0.1.0" edition = "2021" rust-version = "1.74" diff --git a/crates/libs/async/license-apache-2.0 b/crates/libs/future/license-apache-2.0 similarity index 100% rename from crates/libs/async/license-apache-2.0 rename to crates/libs/future/license-apache-2.0 diff --git a/crates/libs/async/license-mit b/crates/libs/future/license-mit similarity index 100% rename from crates/libs/async/license-mit rename to crates/libs/future/license-mit diff --git a/crates/libs/async/readme.md b/crates/libs/future/readme.md similarity index 66% rename from crates/libs/async/readme.md rename to crates/libs/future/readme.md index 148e193e15..675dbe8a8f 100644 --- a/crates/libs/async/readme.md +++ b/crates/libs/future/readme.md @@ -1,6 +1,6 @@ ## Windows async types -The [windows-async](https://crates.io/crates/windows-async) crate provides stock async support for Windows APIs. +The [windows-future](https://crates.io/crates/windows-future) crate provides stock async support for Windows APIs. * [Getting started](https://kennykerr.ca/rust-getting-started/) * [Samples](https://github.com/microsoft/windows-rs/tree/master/crates/samples) diff --git a/crates/libs/async/src/async_ready.rs b/crates/libs/future/src/async_ready.rs similarity index 100% rename from crates/libs/async/src/async_ready.rs rename to crates/libs/future/src/async_ready.rs diff --git a/crates/libs/async/src/async_spawn.rs b/crates/libs/future/src/async_spawn.rs similarity index 100% rename from crates/libs/async/src/async_spawn.rs rename to crates/libs/future/src/async_spawn.rs diff --git a/crates/libs/async/src/bindings.rs b/crates/libs/future/src/bindings.rs similarity index 100% rename from crates/libs/async/src/bindings.rs rename to crates/libs/future/src/bindings.rs diff --git a/crates/libs/async/src/bindings_impl.rs b/crates/libs/future/src/bindings_impl.rs similarity index 100% rename from crates/libs/async/src/bindings_impl.rs rename to crates/libs/future/src/bindings_impl.rs diff --git a/crates/libs/async/src/future.rs b/crates/libs/future/src/future.rs similarity index 100% rename from crates/libs/async/src/future.rs rename to crates/libs/future/src/future.rs diff --git a/crates/libs/async/src/get.rs b/crates/libs/future/src/get.rs similarity index 100% rename from crates/libs/async/src/get.rs rename to crates/libs/future/src/get.rs diff --git a/crates/libs/async/src/lib.rs b/crates/libs/future/src/lib.rs similarity index 100% rename from crates/libs/async/src/lib.rs rename to crates/libs/future/src/lib.rs diff --git a/crates/libs/async/src/waiter.rs b/crates/libs/future/src/waiter.rs similarity index 100% rename from crates/libs/async/src/waiter.rs rename to crates/libs/future/src/waiter.rs diff --git a/crates/libs/windows/Cargo.toml b/crates/libs/windows/Cargo.toml index 73d0e484a0..649e55976d 100644 --- a/crates/libs/windows/Cargo.toml +++ b/crates/libs/windows/Cargo.toml @@ -45,9 +45,9 @@ version = "0.1.0" path = "../numerics" default-features = false -[dependencies.windows-async] +[dependencies.windows-future] version = "0.1.0" -path = "../async" +path = "../future" default-features = false [features] diff --git a/crates/libs/windows/src/Windows/AI/MachineLearning/mod.rs b/crates/libs/windows/src/Windows/AI/MachineLearning/mod.rs index 6456dc5da7..8f7baeae6f 100644 --- a/crates/libs/windows/src/Windows/AI/MachineLearning/mod.rs +++ b/crates/libs/windows/src/Windows/AI/MachineLearning/mod.rs @@ -1164,7 +1164,7 @@ impl LearningModel { } } #[cfg(feature = "Storage_Streams")] - pub fn LoadFromStorageFileAsync(modelfile: P0) -> windows_core::Result> + pub fn LoadFromStorageFileAsync(modelfile: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1174,7 +1174,7 @@ impl LearningModel { }) } #[cfg(feature = "Storage_Streams")] - pub fn LoadFromStreamAsync(modelstream: P0) -> windows_core::Result> + pub fn LoadFromStreamAsync(modelstream: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1200,7 +1200,7 @@ impl LearningModel { }) } #[cfg(feature = "Storage_Streams")] - pub fn LoadFromStorageFileWithOperatorProviderAsync(modelfile: P0, operatorprovider: P1) -> windows_core::Result> + pub fn LoadFromStorageFileWithOperatorProviderAsync(modelfile: P0, operatorprovider: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -1211,7 +1211,7 @@ impl LearningModel { }) } #[cfg(feature = "Storage_Streams")] - pub fn LoadFromStreamWithOperatorProviderAsync(modelstream: P0, operatorprovider: P1) -> windows_core::Result> + pub fn LoadFromStreamWithOperatorProviderAsync(modelstream: P0, operatorprovider: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -1537,7 +1537,7 @@ impl LearningModelSession { (windows_core::Interface::vtable(this).EvaluationProperties)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn EvaluateAsync(&self, bindings: P0, correlationid: &windows_core::HSTRING) -> windows_core::Result> + pub fn EvaluateAsync(&self, bindings: P0, correlationid: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -1547,7 +1547,7 @@ impl LearningModelSession { (windows_core::Interface::vtable(this).EvaluateAsync)(windows_core::Interface::as_raw(this), bindings.param().abi(), core::mem::transmute_copy(correlationid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn EvaluateFeaturesAsync(&self, features: P0, correlationid: &windows_core::HSTRING) -> windows_core::Result> + pub fn EvaluateFeaturesAsync(&self, features: P0, correlationid: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param>, { diff --git a/crates/libs/windows/src/Windows/ApplicationModel/AppExtensions/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/AppExtensions/mod.rs index 0f8addff10..bf296d821d 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/AppExtensions/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/AppExtensions/mod.rs @@ -39,7 +39,7 @@ impl AppExtension { } } #[cfg(feature = "Foundation_Collections")] - pub fn GetExtensionPropertiesAsync(&self) -> windows_core::Result> { + pub fn GetExtensionPropertiesAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -47,7 +47,7 @@ impl AppExtension { } } #[cfg(feature = "Storage_Search")] - pub fn GetPublicFolderAsync(&self) -> windows_core::Result> { + pub fn GetPublicFolderAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -102,14 +102,14 @@ unsafe impl Sync for AppExtension {} pub struct AppExtensionCatalog(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(AppExtensionCatalog, windows_core::IUnknown, windows_core::IInspectable); impl AppExtensionCatalog { - pub fn FindAllAsync(&self) -> windows_core::Result>> { + pub fn FindAllAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAllAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestRemovePackageAsync(&self, packagefullname: &windows_core::HSTRING) -> windows_core::Result> { + pub fn RequestRemovePackageAsync(&self, packagefullname: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/ApplicationModel/AppService/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/AppService/mod.rs index 6f5eec9758..c0703ebe45 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/AppService/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/AppService/mod.rs @@ -1,6 +1,6 @@ pub struct AppServiceCatalog; impl AppServiceCatalog { - pub fn FindAppServiceProvidersAsync(appservicename: &windows_core::HSTRING) -> windows_core::Result>> { + pub fn FindAppServiceProvidersAsync(appservicename: &windows_core::HSTRING) -> windows_core::Result>> { Self::IAppServiceCatalogStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAppServiceProvidersAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(appservicename), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -89,7 +89,7 @@ impl AppServiceConnection { let this = self; unsafe { (windows_core::Interface::vtable(this).SetPackageFamilyName)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(value)).ok() } } - pub fn OpenAsync(&self) -> windows_core::Result> { + pub fn OpenAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -97,7 +97,7 @@ impl AppServiceConnection { } } #[cfg(feature = "Foundation_Collections")] - pub fn SendMessageAsync(&self, message: P0) -> windows_core::Result> + pub fn SendMessageAsync(&self, message: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -136,7 +136,7 @@ impl AppServiceConnection { unsafe { (windows_core::Interface::vtable(this).RemoveServiceClosed)(windows_core::Interface::as_raw(this), token).ok() } } #[cfg(feature = "System_RemoteSystems")] - pub fn OpenRemoteAsync(&self, remotesystemconnectionrequest: P0) -> windows_core::Result> + pub fn OpenRemoteAsync(&self, remotesystemconnectionrequest: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -163,7 +163,7 @@ impl AppServiceConnection { unsafe { (windows_core::Interface::vtable(this).SetUser)(windows_core::Interface::as_raw(this), value.param().abi()).ok() } } #[cfg(all(feature = "Foundation_Collections", feature = "System_RemoteSystems"))] - pub fn SendStatelessMessageAsync(connection: P0, connectionrequest: P1, message: P2) -> windows_core::Result> + pub fn SendStatelessMessageAsync(connection: P0, connectionrequest: P1, message: P2) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -254,7 +254,7 @@ impl AppServiceRequest { } } #[cfg(feature = "Foundation_Collections")] - pub fn SendResponseAsync(&self, message: P0) -> windows_core::Result> + pub fn SendResponseAsync(&self, message: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -397,7 +397,7 @@ impl AppServiceTriggerDetails { (windows_core::Interface::vtable(this).IsRemoteSystemConnection)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn CheckCallerForCapabilityAsync(&self, capabilityname: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CheckCallerForCapabilityAsync(&self, capabilityname: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/ApplicationModel/Appointments/DataProvider/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/Appointments/DataProvider/mod.rs index d4941b2777..f43e71e595 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/Appointments/DataProvider/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/Appointments/DataProvider/mod.rs @@ -45,14 +45,14 @@ impl AppointmentCalendarCancelMeetingRequest { (windows_core::Interface::vtable(this).NotifyInvitees)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn ReportCompletedAsync(&self) -> windows_core::Result { + pub fn ReportCompletedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -137,7 +137,7 @@ impl AppointmentCalendarCreateOrUpdateAppointmentRequest { (windows_core::Interface::vtable(this).ChangedProperties)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportCompletedAsync(&self, createdorupdatedappointment: P0) -> windows_core::Result + pub fn ReportCompletedAsync(&self, createdorupdatedappointment: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -147,7 +147,7 @@ impl AppointmentCalendarCreateOrUpdateAppointmentRequest { (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), createdorupdatedappointment.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -253,14 +253,14 @@ impl AppointmentCalendarForwardMeetingRequest { (windows_core::Interface::vtable(this).Comment)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn ReportCompletedAsync(&self) -> windows_core::Result { + pub fn ReportCompletedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -366,14 +366,14 @@ impl AppointmentCalendarProposeNewTimeForMeetingRequest { (windows_core::Interface::vtable(this).Comment)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn ReportCompletedAsync(&self) -> windows_core::Result { + pub fn ReportCompletedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -437,14 +437,14 @@ impl AppointmentCalendarSyncManagerSyncRequest { (windows_core::Interface::vtable(this).AppointmentCalendarLocalId)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn ReportCompletedAsync(&self) -> windows_core::Result { + pub fn ReportCompletedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -550,14 +550,14 @@ impl AppointmentCalendarUpdateMeetingResponseRequest { (windows_core::Interface::vtable(this).SendUpdate)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn ReportCompletedAsync(&self) -> windows_core::Result { + pub fn ReportCompletedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/ApplicationModel/Appointments/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/Appointments/mod.rs index 1985556a26..94aa3090a7 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/Appointments/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/Appointments/mod.rs @@ -420,14 +420,14 @@ impl AppointmentCalendar { let this = self; unsafe { (windows_core::Interface::vtable(this).SetSummaryCardView)(windows_core::Interface::as_raw(this), value).ok() } } - pub fn FindAppointmentsAsync(&self, rangestart: super::super::Foundation::DateTime, rangelength: super::super::Foundation::TimeSpan) -> windows_core::Result>> { + pub fn FindAppointmentsAsync(&self, rangestart: super::super::Foundation::DateTime, rangelength: super::super::Foundation::TimeSpan) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAppointmentsAsync)(windows_core::Interface::as_raw(this), rangestart, rangelength, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FindAppointmentsAsyncWithOptions(&self, rangestart: super::super::Foundation::DateTime, rangelength: super::super::Foundation::TimeSpan, options: P2) -> windows_core::Result>> + pub fn FindAppointmentsAsyncWithOptions(&self, rangestart: super::super::Foundation::DateTime, rangelength: super::super::Foundation::TimeSpan, options: P2) -> windows_core::Result>> where P2: windows_core::Param, { @@ -437,21 +437,21 @@ impl AppointmentCalendar { (windows_core::Interface::vtable(this).FindAppointmentsAsyncWithOptions)(windows_core::Interface::as_raw(this), rangestart, rangelength, options.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FindExceptionsFromMasterAsync(&self, masterlocalid: &windows_core::HSTRING) -> windows_core::Result>> { + pub fn FindExceptionsFromMasterAsync(&self, masterlocalid: &windows_core::HSTRING) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindExceptionsFromMasterAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(masterlocalid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FindAllInstancesAsync(&self, masterlocalid: &windows_core::HSTRING, rangestart: super::super::Foundation::DateTime, rangelength: super::super::Foundation::TimeSpan) -> windows_core::Result>> { + pub fn FindAllInstancesAsync(&self, masterlocalid: &windows_core::HSTRING, rangestart: super::super::Foundation::DateTime, rangelength: super::super::Foundation::TimeSpan) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAllInstancesAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(masterlocalid), rangestart, rangelength, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FindAllInstancesAsyncWithOptions(&self, masterlocalid: &windows_core::HSTRING, rangestart: super::super::Foundation::DateTime, rangelength: super::super::Foundation::TimeSpan, poptions: P3) -> windows_core::Result>> + pub fn FindAllInstancesAsyncWithOptions(&self, masterlocalid: &windows_core::HSTRING, rangestart: super::super::Foundation::DateTime, rangelength: super::super::Foundation::TimeSpan, poptions: P3) -> windows_core::Result>> where P3: windows_core::Param, { @@ -461,28 +461,28 @@ impl AppointmentCalendar { (windows_core::Interface::vtable(this).FindAllInstancesAsyncWithOptions)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(masterlocalid), rangestart, rangelength, poptions.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAppointmentAsync(&self, localid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetAppointmentAsync(&self, localid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetAppointmentAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(localid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAppointmentInstanceAsync(&self, localid: &windows_core::HSTRING, instancestarttime: super::super::Foundation::DateTime) -> windows_core::Result> { + pub fn GetAppointmentInstanceAsync(&self, localid: &windows_core::HSTRING, instancestarttime: super::super::Foundation::DateTime) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetAppointmentInstanceAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(localid), instancestarttime, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FindUnexpandedAppointmentsAsync(&self) -> windows_core::Result>> { + pub fn FindUnexpandedAppointmentsAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindUnexpandedAppointmentsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FindUnexpandedAppointmentsAsyncWithOptions(&self, options: P0) -> windows_core::Result>> + pub fn FindUnexpandedAppointmentsAsyncWithOptions(&self, options: P0) -> windows_core::Result>> where P0: windows_core::Param, { @@ -492,35 +492,35 @@ impl AppointmentCalendar { (windows_core::Interface::vtable(this).FindUnexpandedAppointmentsAsyncWithOptions)(windows_core::Interface::as_raw(this), options.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAsync(&self) -> windows_core::Result { + pub fn DeleteAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeleteAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SaveAsync(&self) -> windows_core::Result { + pub fn SaveAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).SaveAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAppointmentAsync(&self, localid: &windows_core::HSTRING) -> windows_core::Result { + pub fn DeleteAppointmentAsync(&self, localid: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeleteAppointmentAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(localid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAppointmentInstanceAsync(&self, localid: &windows_core::HSTRING, instancestarttime: super::super::Foundation::DateTime) -> windows_core::Result { + pub fn DeleteAppointmentInstanceAsync(&self, localid: &windows_core::HSTRING, instancestarttime: super::super::Foundation::DateTime) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeleteAppointmentInstanceAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(localid), instancestarttime, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SaveAppointmentAsync(&self, pappointment: P0) -> windows_core::Result + pub fn SaveAppointmentAsync(&self, pappointment: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -641,7 +641,7 @@ impl AppointmentCalendar { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).SetMustNofityInvitees)(windows_core::Interface::as_raw(this), value).ok() } } - pub fn TryCreateOrUpdateAppointmentAsync(&self, appointment: P0, notifyinvitees: bool) -> windows_core::Result> + pub fn TryCreateOrUpdateAppointmentAsync(&self, appointment: P0, notifyinvitees: bool) -> windows_core::Result> where P0: windows_core::Param, { @@ -651,7 +651,7 @@ impl AppointmentCalendar { (windows_core::Interface::vtable(this).TryCreateOrUpdateAppointmentAsync)(windows_core::Interface::as_raw(this), appointment.param().abi(), notifyinvitees, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryCancelMeetingAsync(&self, meeting: P0, subject: &windows_core::HSTRING, comment: &windows_core::HSTRING, notifyinvitees: bool) -> windows_core::Result> + pub fn TryCancelMeetingAsync(&self, meeting: P0, subject: &windows_core::HSTRING, comment: &windows_core::HSTRING, notifyinvitees: bool) -> windows_core::Result> where P0: windows_core::Param, { @@ -661,7 +661,7 @@ impl AppointmentCalendar { (windows_core::Interface::vtable(this).TryCancelMeetingAsync)(windows_core::Interface::as_raw(this), meeting.param().abi(), core::mem::transmute_copy(subject), core::mem::transmute_copy(comment), notifyinvitees, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryForwardMeetingAsync(&self, meeting: P0, invitees: P1, subject: &windows_core::HSTRING, forwardheader: &windows_core::HSTRING, comment: &windows_core::HSTRING) -> windows_core::Result> + pub fn TryForwardMeetingAsync(&self, meeting: P0, invitees: P1, subject: &windows_core::HSTRING, forwardheader: &windows_core::HSTRING, comment: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param>, @@ -672,7 +672,7 @@ impl AppointmentCalendar { (windows_core::Interface::vtable(this).TryForwardMeetingAsync)(windows_core::Interface::as_raw(this), meeting.param().abi(), invitees.param().abi(), core::mem::transmute_copy(subject), core::mem::transmute_copy(forwardheader), core::mem::transmute_copy(comment), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryProposeNewTimeForMeetingAsync(&self, meeting: P0, newstarttime: super::super::Foundation::DateTime, newduration: super::super::Foundation::TimeSpan, subject: &windows_core::HSTRING, comment: &windows_core::HSTRING) -> windows_core::Result> + pub fn TryProposeNewTimeForMeetingAsync(&self, meeting: P0, newstarttime: super::super::Foundation::DateTime, newduration: super::super::Foundation::TimeSpan, subject: &windows_core::HSTRING, comment: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -682,7 +682,7 @@ impl AppointmentCalendar { (windows_core::Interface::vtable(this).TryProposeNewTimeForMeetingAsync)(windows_core::Interface::as_raw(this), meeting.param().abi(), newstarttime, newduration, core::mem::transmute_copy(subject), core::mem::transmute_copy(comment), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryUpdateMeetingResponseAsync(&self, meeting: P0, response: AppointmentParticipantResponse, subject: &windows_core::HSTRING, comment: &windows_core::HSTRING, sendupdate: bool) -> windows_core::Result> + pub fn TryUpdateMeetingResponseAsync(&self, meeting: P0, response: AppointmentParticipantResponse, subject: &windows_core::HSTRING, comment: &windows_core::HSTRING, sendupdate: bool) -> windows_core::Result> where P0: windows_core::Param, { @@ -692,7 +692,7 @@ impl AppointmentCalendar { (windows_core::Interface::vtable(this).TryUpdateMeetingResponseAsync)(windows_core::Interface::as_raw(this), meeting.param().abi(), response, core::mem::transmute_copy(subject), core::mem::transmute_copy(comment), sendupdate, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RegisterSyncManagerAsync(&self) -> windows_core::Result { + pub fn RegisterSyncManagerAsync(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -767,7 +767,7 @@ impl AppointmentCalendarSyncManager { (windows_core::Interface::vtable(this).LastAttemptedSyncTime)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn SyncAsync(&self) -> windows_core::Result> { + pub fn SyncAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1053,7 +1053,7 @@ unsafe impl Send for AppointmentInvitee {} unsafe impl Sync for AppointmentInvitee {} pub struct AppointmentManager; impl AppointmentManager { - pub fn ShowAddAppointmentAsync(appointment: P0, selection: super::super::Foundation::Rect) -> windows_core::Result> + pub fn ShowAddAppointmentAsync(appointment: P0, selection: super::super::Foundation::Rect) -> windows_core::Result> where P0: windows_core::Param, { @@ -1063,7 +1063,7 @@ impl AppointmentManager { }) } #[cfg(feature = "UI_Popups")] - pub fn ShowAddAppointmentWithPlacementAsync(appointment: P0, selection: super::super::Foundation::Rect, preferredplacement: super::super::UI::Popups::Placement) -> windows_core::Result> + pub fn ShowAddAppointmentWithPlacementAsync(appointment: P0, selection: super::super::Foundation::Rect, preferredplacement: super::super::UI::Popups::Placement) -> windows_core::Result> where P0: windows_core::Param, { @@ -1072,7 +1072,7 @@ impl AppointmentManager { (windows_core::Interface::vtable(this).ShowAddAppointmentWithPlacementAsync)(windows_core::Interface::as_raw(this), appointment.param().abi(), selection, preferredplacement, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn ShowReplaceAppointmentAsync(appointmentid: &windows_core::HSTRING, appointment: P1, selection: super::super::Foundation::Rect) -> windows_core::Result> + pub fn ShowReplaceAppointmentAsync(appointmentid: &windows_core::HSTRING, appointment: P1, selection: super::super::Foundation::Rect) -> windows_core::Result> where P1: windows_core::Param, { @@ -1082,7 +1082,7 @@ impl AppointmentManager { }) } #[cfg(feature = "UI_Popups")] - pub fn ShowReplaceAppointmentWithPlacementAsync(appointmentid: &windows_core::HSTRING, appointment: P1, selection: super::super::Foundation::Rect, preferredplacement: super::super::UI::Popups::Placement) -> windows_core::Result> + pub fn ShowReplaceAppointmentWithPlacementAsync(appointmentid: &windows_core::HSTRING, appointment: P1, selection: super::super::Foundation::Rect, preferredplacement: super::super::UI::Popups::Placement) -> windows_core::Result> where P1: windows_core::Param, { @@ -1092,7 +1092,7 @@ impl AppointmentManager { }) } #[cfg(feature = "UI_Popups")] - pub fn ShowReplaceAppointmentWithPlacementAndDateAsync(appointmentid: &windows_core::HSTRING, appointment: P1, selection: super::super::Foundation::Rect, preferredplacement: super::super::UI::Popups::Placement, instancestartdate: super::super::Foundation::DateTime) -> windows_core::Result> + pub fn ShowReplaceAppointmentWithPlacementAndDateAsync(appointmentid: &windows_core::HSTRING, appointment: P1, selection: super::super::Foundation::Rect, preferredplacement: super::super::UI::Popups::Placement, instancestartdate: super::super::Foundation::DateTime) -> windows_core::Result> where P1: windows_core::Param, { @@ -1101,45 +1101,45 @@ impl AppointmentManager { (windows_core::Interface::vtable(this).ShowReplaceAppointmentWithPlacementAndDateAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(appointmentid), appointment.param().abi(), selection, preferredplacement, instancestartdate, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn ShowRemoveAppointmentAsync(appointmentid: &windows_core::HSTRING, selection: super::super::Foundation::Rect) -> windows_core::Result> { + pub fn ShowRemoveAppointmentAsync(appointmentid: &windows_core::HSTRING, selection: super::super::Foundation::Rect) -> windows_core::Result> { Self::IAppointmentManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ShowRemoveAppointmentAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(appointmentid), selection, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "UI_Popups")] - pub fn ShowRemoveAppointmentWithPlacementAsync(appointmentid: &windows_core::HSTRING, selection: super::super::Foundation::Rect, preferredplacement: super::super::UI::Popups::Placement) -> windows_core::Result> { + pub fn ShowRemoveAppointmentWithPlacementAsync(appointmentid: &windows_core::HSTRING, selection: super::super::Foundation::Rect, preferredplacement: super::super::UI::Popups::Placement) -> windows_core::Result> { Self::IAppointmentManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ShowRemoveAppointmentWithPlacementAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(appointmentid), selection, preferredplacement, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "UI_Popups")] - pub fn ShowRemoveAppointmentWithPlacementAndDateAsync(appointmentid: &windows_core::HSTRING, selection: super::super::Foundation::Rect, preferredplacement: super::super::UI::Popups::Placement, instancestartdate: super::super::Foundation::DateTime) -> windows_core::Result> { + pub fn ShowRemoveAppointmentWithPlacementAndDateAsync(appointmentid: &windows_core::HSTRING, selection: super::super::Foundation::Rect, preferredplacement: super::super::UI::Popups::Placement, instancestartdate: super::super::Foundation::DateTime) -> windows_core::Result> { Self::IAppointmentManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ShowRemoveAppointmentWithPlacementAndDateAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(appointmentid), selection, preferredplacement, instancestartdate, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn ShowTimeFrameAsync(timetoshow: super::super::Foundation::DateTime, duration: super::super::Foundation::TimeSpan) -> windows_core::Result { + pub fn ShowTimeFrameAsync(timetoshow: super::super::Foundation::DateTime, duration: super::super::Foundation::TimeSpan) -> windows_core::Result { Self::IAppointmentManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ShowTimeFrameAsync)(windows_core::Interface::as_raw(this), timetoshow, duration, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn ShowAppointmentDetailsAsync(appointmentid: &windows_core::HSTRING) -> windows_core::Result { + pub fn ShowAppointmentDetailsAsync(appointmentid: &windows_core::HSTRING) -> windows_core::Result { Self::IAppointmentManagerStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ShowAppointmentDetailsAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(appointmentid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn ShowAppointmentDetailsWithDateAsync(appointmentid: &windows_core::HSTRING, instancestartdate: super::super::Foundation::DateTime) -> windows_core::Result { + pub fn ShowAppointmentDetailsWithDateAsync(appointmentid: &windows_core::HSTRING, instancestartdate: super::super::Foundation::DateTime) -> windows_core::Result { Self::IAppointmentManagerStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ShowAppointmentDetailsWithDateAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(appointmentid), instancestartdate, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn ShowEditNewAppointmentAsync(appointment: P0) -> windows_core::Result> + pub fn ShowEditNewAppointmentAsync(appointment: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1148,7 +1148,7 @@ impl AppointmentManager { (windows_core::Interface::vtable(this).ShowEditNewAppointmentAsync)(windows_core::Interface::as_raw(this), appointment.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RequestStoreAsync(options: AppointmentStoreAccessType) -> windows_core::Result> { + pub fn RequestStoreAsync(options: AppointmentStoreAccessType) -> windows_core::Result> { Self::IAppointmentManagerStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestStoreAsync)(windows_core::Interface::as_raw(this), options, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -1185,7 +1185,7 @@ impl windows_core::RuntimeName for AppointmentManager { pub struct AppointmentManagerForUser(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(AppointmentManagerForUser, windows_core::IUnknown, windows_core::IInspectable); impl AppointmentManagerForUser { - pub fn ShowAddAppointmentAsync(&self, appointment: P0, selection: super::super::Foundation::Rect) -> windows_core::Result> + pub fn ShowAddAppointmentAsync(&self, appointment: P0, selection: super::super::Foundation::Rect) -> windows_core::Result> where P0: windows_core::Param, { @@ -1196,7 +1196,7 @@ impl AppointmentManagerForUser { } } #[cfg(feature = "UI_Popups")] - pub fn ShowAddAppointmentWithPlacementAsync(&self, appointment: P0, selection: super::super::Foundation::Rect, preferredplacement: super::super::UI::Popups::Placement) -> windows_core::Result> + pub fn ShowAddAppointmentWithPlacementAsync(&self, appointment: P0, selection: super::super::Foundation::Rect, preferredplacement: super::super::UI::Popups::Placement) -> windows_core::Result> where P0: windows_core::Param, { @@ -1206,7 +1206,7 @@ impl AppointmentManagerForUser { (windows_core::Interface::vtable(this).ShowAddAppointmentWithPlacementAsync)(windows_core::Interface::as_raw(this), appointment.param().abi(), selection, preferredplacement, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ShowReplaceAppointmentAsync(&self, appointmentid: &windows_core::HSTRING, appointment: P1, selection: super::super::Foundation::Rect) -> windows_core::Result> + pub fn ShowReplaceAppointmentAsync(&self, appointmentid: &windows_core::HSTRING, appointment: P1, selection: super::super::Foundation::Rect) -> windows_core::Result> where P1: windows_core::Param, { @@ -1217,7 +1217,7 @@ impl AppointmentManagerForUser { } } #[cfg(feature = "UI_Popups")] - pub fn ShowReplaceAppointmentWithPlacementAsync(&self, appointmentid: &windows_core::HSTRING, appointment: P1, selection: super::super::Foundation::Rect, preferredplacement: super::super::UI::Popups::Placement) -> windows_core::Result> + pub fn ShowReplaceAppointmentWithPlacementAsync(&self, appointmentid: &windows_core::HSTRING, appointment: P1, selection: super::super::Foundation::Rect, preferredplacement: super::super::UI::Popups::Placement) -> windows_core::Result> where P1: windows_core::Param, { @@ -1228,7 +1228,7 @@ impl AppointmentManagerForUser { } } #[cfg(feature = "UI_Popups")] - pub fn ShowReplaceAppointmentWithPlacementAndDateAsync(&self, appointmentid: &windows_core::HSTRING, appointment: P1, selection: super::super::Foundation::Rect, preferredplacement: super::super::UI::Popups::Placement, instancestartdate: super::super::Foundation::DateTime) -> windows_core::Result> + pub fn ShowReplaceAppointmentWithPlacementAndDateAsync(&self, appointmentid: &windows_core::HSTRING, appointment: P1, selection: super::super::Foundation::Rect, preferredplacement: super::super::UI::Popups::Placement, instancestartdate: super::super::Foundation::DateTime) -> windows_core::Result> where P1: windows_core::Param, { @@ -1238,7 +1238,7 @@ impl AppointmentManagerForUser { (windows_core::Interface::vtable(this).ShowReplaceAppointmentWithPlacementAndDateAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(appointmentid), appointment.param().abi(), selection, preferredplacement, instancestartdate, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ShowRemoveAppointmentAsync(&self, appointmentid: &windows_core::HSTRING, selection: super::super::Foundation::Rect) -> windows_core::Result> { + pub fn ShowRemoveAppointmentAsync(&self, appointmentid: &windows_core::HSTRING, selection: super::super::Foundation::Rect) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1246,7 +1246,7 @@ impl AppointmentManagerForUser { } } #[cfg(feature = "UI_Popups")] - pub fn ShowRemoveAppointmentWithPlacementAsync(&self, appointmentid: &windows_core::HSTRING, selection: super::super::Foundation::Rect, preferredplacement: super::super::UI::Popups::Placement) -> windows_core::Result> { + pub fn ShowRemoveAppointmentWithPlacementAsync(&self, appointmentid: &windows_core::HSTRING, selection: super::super::Foundation::Rect, preferredplacement: super::super::UI::Popups::Placement) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1254,35 +1254,35 @@ impl AppointmentManagerForUser { } } #[cfg(feature = "UI_Popups")] - pub fn ShowRemoveAppointmentWithPlacementAndDateAsync(&self, appointmentid: &windows_core::HSTRING, selection: super::super::Foundation::Rect, preferredplacement: super::super::UI::Popups::Placement, instancestartdate: super::super::Foundation::DateTime) -> windows_core::Result> { + pub fn ShowRemoveAppointmentWithPlacementAndDateAsync(&self, appointmentid: &windows_core::HSTRING, selection: super::super::Foundation::Rect, preferredplacement: super::super::UI::Popups::Placement, instancestartdate: super::super::Foundation::DateTime) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ShowRemoveAppointmentWithPlacementAndDateAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(appointmentid), selection, preferredplacement, instancestartdate, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ShowTimeFrameAsync(&self, timetoshow: super::super::Foundation::DateTime, duration: super::super::Foundation::TimeSpan) -> windows_core::Result { + pub fn ShowTimeFrameAsync(&self, timetoshow: super::super::Foundation::DateTime, duration: super::super::Foundation::TimeSpan) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ShowTimeFrameAsync)(windows_core::Interface::as_raw(this), timetoshow, duration, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ShowAppointmentDetailsAsync(&self, appointmentid: &windows_core::HSTRING) -> windows_core::Result { + pub fn ShowAppointmentDetailsAsync(&self, appointmentid: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ShowAppointmentDetailsAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(appointmentid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ShowAppointmentDetailsWithDateAsync(&self, appointmentid: &windows_core::HSTRING, instancestartdate: super::super::Foundation::DateTime) -> windows_core::Result { + pub fn ShowAppointmentDetailsWithDateAsync(&self, appointmentid: &windows_core::HSTRING, instancestartdate: super::super::Foundation::DateTime) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ShowAppointmentDetailsWithDateAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(appointmentid), instancestartdate, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ShowEditNewAppointmentAsync(&self, appointment: P0) -> windows_core::Result> + pub fn ShowEditNewAppointmentAsync(&self, appointment: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1292,7 +1292,7 @@ impl AppointmentManagerForUser { (windows_core::Interface::vtable(this).ShowEditNewAppointmentAsync)(windows_core::Interface::as_raw(this), appointment.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestStoreAsync(&self, options: AppointmentStoreAccessType) -> windows_core::Result> { + pub fn RequestStoreAsync(&self, options: AppointmentStoreAccessType) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1753,56 +1753,56 @@ impl AppointmentStore { (windows_core::Interface::vtable(this).ChangeTracker)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateAppointmentCalendarAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CreateAppointmentCalendarAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreateAppointmentCalendarAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(name), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAppointmentCalendarAsync(&self, calendarid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetAppointmentCalendarAsync(&self, calendarid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetAppointmentCalendarAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(calendarid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAppointmentAsync(&self, localid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetAppointmentAsync(&self, localid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetAppointmentAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(localid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAppointmentInstanceAsync(&self, localid: &windows_core::HSTRING, instancestarttime: super::super::Foundation::DateTime) -> windows_core::Result> { + pub fn GetAppointmentInstanceAsync(&self, localid: &windows_core::HSTRING, instancestarttime: super::super::Foundation::DateTime) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetAppointmentInstanceAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(localid), instancestarttime, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FindAppointmentCalendarsAsync(&self) -> windows_core::Result>> { + pub fn FindAppointmentCalendarsAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAppointmentCalendarsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FindAppointmentCalendarsAsyncWithOptions(&self, options: FindAppointmentCalendarsOptions) -> windows_core::Result>> { + pub fn FindAppointmentCalendarsAsyncWithOptions(&self, options: FindAppointmentCalendarsOptions) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAppointmentCalendarsAsyncWithOptions)(windows_core::Interface::as_raw(this), options, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FindAppointmentsAsync(&self, rangestart: super::super::Foundation::DateTime, rangelength: super::super::Foundation::TimeSpan) -> windows_core::Result>> { + pub fn FindAppointmentsAsync(&self, rangestart: super::super::Foundation::DateTime, rangelength: super::super::Foundation::TimeSpan) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAppointmentsAsync)(windows_core::Interface::as_raw(this), rangestart, rangelength, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FindAppointmentsAsyncWithOptions(&self, rangestart: super::super::Foundation::DateTime, rangelength: super::super::Foundation::TimeSpan, options: P2) -> windows_core::Result>> + pub fn FindAppointmentsAsyncWithOptions(&self, rangestart: super::super::Foundation::DateTime, rangelength: super::super::Foundation::TimeSpan, options: P2) -> windows_core::Result>> where P2: windows_core::Param, { @@ -1812,7 +1812,7 @@ impl AppointmentStore { (windows_core::Interface::vtable(this).FindAppointmentsAsyncWithOptions)(windows_core::Interface::as_raw(this), rangestart, rangelength, options.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FindConflictAsync(&self, appointment: P0) -> windows_core::Result> + pub fn FindConflictAsync(&self, appointment: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1822,7 +1822,7 @@ impl AppointmentStore { (windows_core::Interface::vtable(this).FindConflictAsync)(windows_core::Interface::as_raw(this), appointment.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FindConflictAsyncWithInstanceStart(&self, appointment: P0, instancestarttime: super::super::Foundation::DateTime) -> windows_core::Result> + pub fn FindConflictAsyncWithInstanceStart(&self, appointment: P0, instancestarttime: super::super::Foundation::DateTime) -> windows_core::Result> where P0: windows_core::Param, { @@ -1832,7 +1832,7 @@ impl AppointmentStore { (windows_core::Interface::vtable(this).FindConflictAsyncWithInstanceStart)(windows_core::Interface::as_raw(this), appointment.param().abi(), instancestarttime, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn MoveAppointmentAsync(&self, appointment: P0, destinationcalendar: P1) -> windows_core::Result + pub fn MoveAppointmentAsync(&self, appointment: P0, destinationcalendar: P1) -> windows_core::Result where P0: windows_core::Param, P1: windows_core::Param, @@ -1843,7 +1843,7 @@ impl AppointmentStore { (windows_core::Interface::vtable(this).MoveAppointmentAsync)(windows_core::Interface::as_raw(this), appointment.param().abi(), destinationcalendar.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ShowAddAppointmentAsync(&self, appointment: P0, selection: super::super::Foundation::Rect) -> windows_core::Result> + pub fn ShowAddAppointmentAsync(&self, appointment: P0, selection: super::super::Foundation::Rect) -> windows_core::Result> where P0: windows_core::Param, { @@ -1853,7 +1853,7 @@ impl AppointmentStore { (windows_core::Interface::vtable(this).ShowAddAppointmentAsync)(windows_core::Interface::as_raw(this), appointment.param().abi(), selection, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ShowReplaceAppointmentAsync(&self, localid: &windows_core::HSTRING, appointment: P1, selection: super::super::Foundation::Rect) -> windows_core::Result> + pub fn ShowReplaceAppointmentAsync(&self, localid: &windows_core::HSTRING, appointment: P1, selection: super::super::Foundation::Rect) -> windows_core::Result> where P1: windows_core::Param, { @@ -1864,7 +1864,7 @@ impl AppointmentStore { } } #[cfg(feature = "UI_Popups")] - pub fn ShowReplaceAppointmentWithPlacementAndDateAsync(&self, localid: &windows_core::HSTRING, appointment: P1, selection: super::super::Foundation::Rect, preferredplacement: super::super::UI::Popups::Placement, instancestartdate: super::super::Foundation::DateTime) -> windows_core::Result> + pub fn ShowReplaceAppointmentWithPlacementAndDateAsync(&self, localid: &windows_core::HSTRING, appointment: P1, selection: super::super::Foundation::Rect, preferredplacement: super::super::UI::Popups::Placement, instancestartdate: super::super::Foundation::DateTime) -> windows_core::Result> where P1: windows_core::Param, { @@ -1874,7 +1874,7 @@ impl AppointmentStore { (windows_core::Interface::vtable(this).ShowReplaceAppointmentWithPlacementAndDateAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(localid), appointment.param().abi(), selection, preferredplacement, instancestartdate, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ShowRemoveAppointmentAsync(&self, localid: &windows_core::HSTRING, selection: super::super::Foundation::Rect) -> windows_core::Result> { + pub fn ShowRemoveAppointmentAsync(&self, localid: &windows_core::HSTRING, selection: super::super::Foundation::Rect) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1882,28 +1882,28 @@ impl AppointmentStore { } } #[cfg(feature = "UI_Popups")] - pub fn ShowRemoveAppointmentWithPlacementAndDateAsync(&self, localid: &windows_core::HSTRING, selection: super::super::Foundation::Rect, preferredplacement: super::super::UI::Popups::Placement, instancestartdate: super::super::Foundation::DateTime) -> windows_core::Result> { + pub fn ShowRemoveAppointmentWithPlacementAndDateAsync(&self, localid: &windows_core::HSTRING, selection: super::super::Foundation::Rect, preferredplacement: super::super::UI::Popups::Placement, instancestartdate: super::super::Foundation::DateTime) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ShowRemoveAppointmentWithPlacementAndDateAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(localid), selection, preferredplacement, instancestartdate, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ShowAppointmentDetailsAsync(&self, localid: &windows_core::HSTRING) -> windows_core::Result { + pub fn ShowAppointmentDetailsAsync(&self, localid: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ShowAppointmentDetailsAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(localid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ShowAppointmentDetailsWithDateAsync(&self, localid: &windows_core::HSTRING, instancestartdate: super::super::Foundation::DateTime) -> windows_core::Result { + pub fn ShowAppointmentDetailsWithDateAsync(&self, localid: &windows_core::HSTRING, instancestartdate: super::super::Foundation::DateTime) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ShowAppointmentDetailsWithDateAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(localid), instancestartdate, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ShowEditNewAppointmentAsync(&self, appointment: P0) -> windows_core::Result> + pub fn ShowEditNewAppointmentAsync(&self, appointment: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1913,7 +1913,7 @@ impl AppointmentStore { (windows_core::Interface::vtable(this).ShowEditNewAppointmentAsync)(windows_core::Interface::as_raw(this), appointment.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FindLocalIdsFromRoamingIdAsync(&self, roamingid: &windows_core::HSTRING) -> windows_core::Result>> { + pub fn FindLocalIdsFromRoamingIdAsync(&self, roamingid: &windows_core::HSTRING) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1934,7 +1934,7 @@ impl AppointmentStore { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).RemoveStoreChanged)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn CreateAppointmentCalendarInAccountAsync(&self, name: &windows_core::HSTRING, userdataaccountid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CreateAppointmentCalendarInAccountAsync(&self, name: &windows_core::HSTRING, userdataaccountid: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -2019,7 +2019,7 @@ unsafe impl Sync for AppointmentStoreChange {} pub struct AppointmentStoreChangeReader(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(AppointmentStoreChangeReader, windows_core::IUnknown, windows_core::IInspectable); impl AppointmentStoreChangeReader { - pub fn ReadBatchAsync(&self) -> windows_core::Result>> { + pub fn ReadBatchAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/ApplicationModel/Background/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/Background/mod.rs index b2c0f57c76..b0f5ffccae 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/Background/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/Background/mod.rs @@ -74,7 +74,7 @@ impl windows_core::RuntimeType for AlarmAccessStatus { } pub struct AlarmApplicationManager; impl AlarmApplicationManager { - pub fn RequestAccessAsync() -> windows_core::Result> { + pub fn RequestAccessAsync() -> windows_core::Result> { Self::IAlarmApplicationManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestAccessAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -234,7 +234,7 @@ impl ApplicationTrigger { static SHARED: windows_core::imp::FactoryCache = windows_core::imp::FactoryCache::new(); SHARED.call(callback) } - pub fn RequestAsync(&self) -> windows_core::Result> { + pub fn RequestAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -242,7 +242,7 @@ impl ApplicationTrigger { } } #[cfg(feature = "Foundation_Collections")] - pub fn RequestAsyncWithArguments(&self, arguments: P0) -> windows_core::Result> + pub fn RequestAsyncWithArguments(&self, arguments: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -366,13 +366,13 @@ impl windows_core::RuntimeType for BackgroundAccessStatus { } pub struct BackgroundExecutionManager; impl BackgroundExecutionManager { - pub fn RequestAccessAsync() -> windows_core::Result> { + pub fn RequestAccessAsync() -> windows_core::Result> { Self::IBackgroundExecutionManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestAccessAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RequestAccessForApplicationAsync(applicationid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn RequestAccessForApplicationAsync(applicationid: &windows_core::HSTRING) -> windows_core::Result> { Self::IBackgroundExecutionManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestAccessForApplicationAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(applicationid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -396,13 +396,13 @@ impl BackgroundExecutionManager { (windows_core::Interface::vtable(this).GetAccessStatusForApplication)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(applicationid), &mut result__).map(|| result__) }) } - pub fn RequestAccessKindAsync(requestedaccess: BackgroundAccessRequestKind, reason: &windows_core::HSTRING) -> windows_core::Result> { + pub fn RequestAccessKindAsync(requestedaccess: BackgroundAccessRequestKind, reason: &windows_core::HSTRING) -> windows_core::Result> { Self::IBackgroundExecutionManagerStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestAccessKindAsync)(windows_core::Interface::as_raw(this), requestedaccess, core::mem::transmute_copy(reason), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RequestAccessKindForModernStandbyAsync(requestedaccess: BackgroundAccessRequestKind, reason: &windows_core::HSTRING) -> windows_core::Result> { + pub fn RequestAccessKindForModernStandbyAsync(requestedaccess: BackgroundAccessRequestKind, reason: &windows_core::HSTRING) -> windows_core::Result> { Self::IBackgroundExecutionManagerStatics3(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestAccessKindForModernStandbyAsync)(windows_core::Interface::as_raw(this), requestedaccess, core::mem::transmute_copy(reason), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -1642,7 +1642,7 @@ impl DeviceConnectionChangeTrigger { let this = self; unsafe { (windows_core::Interface::vtable(this).SetMaintainConnection)(windows_core::Interface::as_raw(this), value).ok() } } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IDeviceConnectionChangeTriggerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -1726,14 +1726,14 @@ impl DeviceServicingTrigger { static SHARED: windows_core::imp::FactoryCache = windows_core::imp::FactoryCache::new(); SHARED.call(callback) } - pub fn RequestAsyncSimple(&self, deviceid: &windows_core::HSTRING, expectedduration: super::super::Foundation::TimeSpan) -> windows_core::Result> { + pub fn RequestAsyncSimple(&self, deviceid: &windows_core::HSTRING, expectedduration: super::super::Foundation::TimeSpan) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestAsyncSimple)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), expectedduration, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestAsyncWithArguments(&self, deviceid: &windows_core::HSTRING, expectedduration: super::super::Foundation::TimeSpan, arguments: &windows_core::HSTRING) -> windows_core::Result> { + pub fn RequestAsyncWithArguments(&self, deviceid: &windows_core::HSTRING, expectedduration: super::super::Foundation::TimeSpan, arguments: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1781,14 +1781,14 @@ impl DeviceUseTrigger { static SHARED: windows_core::imp::FactoryCache = windows_core::imp::FactoryCache::new(); SHARED.call(callback) } - pub fn RequestAsyncSimple(&self, deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn RequestAsyncSimple(&self, deviceid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestAsyncSimple)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestAsyncWithArguments(&self, deviceid: &windows_core::HSTRING, arguments: &windows_core::HSTRING) -> windows_core::Result> { + pub fn RequestAsyncWithArguments(&self, deviceid: &windows_core::HSTRING, arguments: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1965,7 +1965,7 @@ impl GattServiceProviderTrigger { (windows_core::Interface::vtable(this).AdvertisingParameters)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateAsync(triggerid: &windows_core::HSTRING, serviceuuid: windows_core::GUID) -> windows_core::Result> { + pub fn CreateAsync(triggerid: &windows_core::HSTRING, serviceuuid: windows_core::GUID) -> windows_core::Result> { Self::IGattServiceProviderTriggerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreateAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(triggerid), serviceuuid, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -4045,7 +4045,7 @@ impl MediaProcessingTrigger { static SHARED: windows_core::imp::FactoryCache = windows_core::imp::FactoryCache::new(); SHARED.call(callback) } - pub fn RequestAsync(&self) -> windows_core::Result> { + pub fn RequestAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -4053,7 +4053,7 @@ impl MediaProcessingTrigger { } } #[cfg(feature = "Foundation_Collections")] - pub fn RequestAsyncWithArguments(&self, arguments: P0) -> windows_core::Result> + pub fn RequestAsyncWithArguments(&self, arguments: P0) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/ApplicationModel/Calls/Provider/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/Calls/Provider/mod.rs index 4f6ca2e551..5abdd7f549 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/Calls/Provider/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/Calls/Provider/mod.rs @@ -197,7 +197,7 @@ impl PhoneCallOriginManager { { Self::IPhoneCallOriginManagerStatics(|this| unsafe { (windows_core::Interface::vtable(this).SetCallOrigin)(windows_core::Interface::as_raw(this), requestid, callorigin.param().abi()).ok() }) } - pub fn RequestSetAsActiveCallOriginAppAsync() -> windows_core::Result> { + pub fn RequestSetAsActiveCallOriginAppAsync() -> windows_core::Result> { Self::IPhoneCallOriginManagerStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestSetAsActiveCallOriginAppAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/ApplicationModel/Calls/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/Calls/mod.rs index e6d78f4d01..3c1ce887bd 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/Calls/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/Calls/mod.rs @@ -1670,7 +1670,7 @@ impl PhoneCall { (windows_core::Interface::vtable(this).GetPhoneCallInfo)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetPhoneCallInfoAsync(&self) -> windows_core::Result> { + pub fn GetPhoneCallInfoAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1684,7 +1684,7 @@ impl PhoneCall { (windows_core::Interface::vtable(this).End)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn EndAsync(&self) -> windows_core::Result> { + pub fn EndAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1698,7 +1698,7 @@ impl PhoneCall { (windows_core::Interface::vtable(this).SendDtmfKey)(windows_core::Interface::as_raw(this), key, dtmftoneaudioplayback, &mut result__).map(|| result__) } } - pub fn SendDtmfKeyAsync(&self, key: DtmfKey, dtmftoneaudioplayback: DtmfToneAudioPlayback) -> windows_core::Result> { + pub fn SendDtmfKeyAsync(&self, key: DtmfKey, dtmftoneaudioplayback: DtmfToneAudioPlayback) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1712,7 +1712,7 @@ impl PhoneCall { (windows_core::Interface::vtable(this).AcceptIncoming)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn AcceptIncomingAsync(&self) -> windows_core::Result> { + pub fn AcceptIncomingAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1726,7 +1726,7 @@ impl PhoneCall { (windows_core::Interface::vtable(this).Hold)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn HoldAsync(&self) -> windows_core::Result> { + pub fn HoldAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1740,7 +1740,7 @@ impl PhoneCall { (windows_core::Interface::vtable(this).ResumeFromHold)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn ResumeFromHoldAsync(&self) -> windows_core::Result> { + pub fn ResumeFromHoldAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1754,7 +1754,7 @@ impl PhoneCall { (windows_core::Interface::vtable(this).Mute)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn MuteAsync(&self) -> windows_core::Result> { + pub fn MuteAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1768,7 +1768,7 @@ impl PhoneCall { (windows_core::Interface::vtable(this).Unmute)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn UnmuteAsync(&self) -> windows_core::Result> { + pub fn UnmuteAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1782,7 +1782,7 @@ impl PhoneCall { (windows_core::Interface::vtable(this).RejectIncoming)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn RejectIncomingAsync(&self) -> windows_core::Result> { + pub fn RejectIncomingAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1796,7 +1796,7 @@ impl PhoneCall { (windows_core::Interface::vtable(this).ChangeAudioDevice)(windows_core::Interface::as_raw(this), endpoint, &mut result__).map(|| result__) } } - pub fn ChangeAudioDeviceAsync(&self, endpoint: PhoneCallAudioDevice) -> windows_core::Result> { + pub fn ChangeAudioDeviceAsync(&self, endpoint: PhoneCallAudioDevice) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1860,7 +1860,7 @@ impl PhoneCallBlocking { pub fn SetBlockPrivateNumbers(value: bool) -> windows_core::Result<()> { Self::IPhoneCallBlockingStatics(|this| unsafe { (windows_core::Interface::vtable(this).SetBlockPrivateNumbers)(windows_core::Interface::as_raw(this), value).ok() }) } - pub fn SetCallBlockingListAsync(phonenumberlist: P0) -> windows_core::Result> + pub fn SetCallBlockingListAsync(phonenumberlist: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -2326,7 +2326,7 @@ impl windows_core::RuntimeType for PhoneCallHistoryEntryRawAddressKind { pub struct PhoneCallHistoryEntryReader(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(PhoneCallHistoryEntryReader, windows_core::IUnknown, windows_core::IInspectable); impl PhoneCallHistoryEntryReader { - pub fn ReadBatchAsync(&self) -> windows_core::Result>> { + pub fn ReadBatchAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2348,7 +2348,7 @@ unsafe impl Send for PhoneCallHistoryEntryReader {} unsafe impl Sync for PhoneCallHistoryEntryReader {} pub struct PhoneCallHistoryManager; impl PhoneCallHistoryManager { - pub fn RequestStoreAsync(accesstype: PhoneCallHistoryStoreAccessType) -> windows_core::Result> { + pub fn RequestStoreAsync(accesstype: PhoneCallHistoryStoreAccessType) -> windows_core::Result> { Self::IPhoneCallHistoryManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestStoreAsync)(windows_core::Interface::as_raw(this), accesstype, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -2381,7 +2381,7 @@ impl windows_core::RuntimeName for PhoneCallHistoryManager { pub struct PhoneCallHistoryManagerForUser(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(PhoneCallHistoryManagerForUser, windows_core::IUnknown, windows_core::IInspectable); impl PhoneCallHistoryManagerForUser { - pub fn RequestStoreAsync(&self, accesstype: PhoneCallHistoryStoreAccessType) -> windows_core::Result> { + pub fn RequestStoreAsync(&self, accesstype: PhoneCallHistoryStoreAccessType) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2427,7 +2427,7 @@ impl windows_core::RuntimeType for PhoneCallHistorySourceIdKind { pub struct PhoneCallHistoryStore(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(PhoneCallHistoryStore, windows_core::IUnknown, windows_core::IInspectable); impl PhoneCallHistoryStore { - pub fn GetEntryAsync(&self, callhistoryentryid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetEntryAsync(&self, callhistoryentryid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2451,7 +2451,7 @@ impl PhoneCallHistoryStore { (windows_core::Interface::vtable(this).GetEntryReaderWithOptions)(windows_core::Interface::as_raw(this), queryoptions.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SaveEntryAsync(&self, callhistoryentry: P0) -> windows_core::Result + pub fn SaveEntryAsync(&self, callhistoryentry: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -2461,7 +2461,7 @@ impl PhoneCallHistoryStore { (windows_core::Interface::vtable(this).SaveEntryAsync)(windows_core::Interface::as_raw(this), callhistoryentry.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteEntryAsync(&self, callhistoryentry: P0) -> windows_core::Result + pub fn DeleteEntryAsync(&self, callhistoryentry: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -2471,7 +2471,7 @@ impl PhoneCallHistoryStore { (windows_core::Interface::vtable(this).DeleteEntryAsync)(windows_core::Interface::as_raw(this), callhistoryentry.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteEntriesAsync(&self, callhistoryentries: P0) -> windows_core::Result + pub fn DeleteEntriesAsync(&self, callhistoryentries: P0) -> windows_core::Result where P0: windows_core::Param>, { @@ -2481,7 +2481,7 @@ impl PhoneCallHistoryStore { (windows_core::Interface::vtable(this).DeleteEntriesAsync)(windows_core::Interface::as_raw(this), callhistoryentries.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn MarkEntryAsSeenAsync(&self, callhistoryentry: P0) -> windows_core::Result + pub fn MarkEntryAsSeenAsync(&self, callhistoryentry: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -2491,7 +2491,7 @@ impl PhoneCallHistoryStore { (windows_core::Interface::vtable(this).MarkEntryAsSeenAsync)(windows_core::Interface::as_raw(this), callhistoryentry.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn MarkEntriesAsSeenAsync(&self, callhistoryentries: P0) -> windows_core::Result + pub fn MarkEntriesAsSeenAsync(&self, callhistoryentries: P0) -> windows_core::Result where P0: windows_core::Param>, { @@ -2501,21 +2501,21 @@ impl PhoneCallHistoryStore { (windows_core::Interface::vtable(this).MarkEntriesAsSeenAsync)(windows_core::Interface::as_raw(this), callhistoryentries.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetUnseenCountAsync(&self) -> windows_core::Result> { + pub fn GetUnseenCountAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetUnseenCountAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn MarkAllAsSeenAsync(&self) -> windows_core::Result { + pub fn MarkAllAsSeenAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).MarkAllAsSeenAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetSourcesUnseenCountAsync(&self, sourceids: P0) -> windows_core::Result> + pub fn GetSourcesUnseenCountAsync(&self, sourceids: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -2525,7 +2525,7 @@ impl PhoneCallHistoryStore { (windows_core::Interface::vtable(this).GetSourcesUnseenCountAsync)(windows_core::Interface::as_raw(this), sourceids.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn MarkSourcesAsSeenAsync(&self, sourceids: P0) -> windows_core::Result + pub fn MarkSourcesAsSeenAsync(&self, sourceids: P0) -> windows_core::Result where P0: windows_core::Param>, { @@ -2654,7 +2654,7 @@ impl PhoneCallManager { pub fn ShowPhoneCallSettingsUI() -> windows_core::Result<()> { Self::IPhoneCallManagerStatics2(|this| unsafe { (windows_core::Interface::vtable(this).ShowPhoneCallSettingsUI)(windows_core::Interface::as_raw(this)).ok() }) } - pub fn RequestStoreAsync() -> windows_core::Result> { + pub fn RequestStoreAsync() -> windows_core::Result> { Self::IPhoneCallManagerStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestStoreAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -2724,14 +2724,14 @@ impl windows_core::RuntimeType for PhoneCallStatus { pub struct PhoneCallStore(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(PhoneCallStore, windows_core::IUnknown, windows_core::IInspectable); impl PhoneCallStore { - pub fn IsEmergencyPhoneNumberAsync(&self, number: &windows_core::HSTRING) -> windows_core::Result> { + pub fn IsEmergencyPhoneNumberAsync(&self, number: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).IsEmergencyPhoneNumberAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(number), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetDefaultLineAsync(&self) -> windows_core::Result> { + pub fn GetDefaultLineAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2785,7 +2785,7 @@ unsafe impl Send for PhoneCallVideoCapabilities {} unsafe impl Sync for PhoneCallVideoCapabilities {} pub struct PhoneCallVideoCapabilitiesManager; impl PhoneCallVideoCapabilitiesManager { - pub fn GetCapabilitiesAsync(phonenumber: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetCapabilitiesAsync(phonenumber: &windows_core::HSTRING) -> windows_core::Result> { Self::IPhoneCallVideoCapabilitiesManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetCapabilitiesAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(phonenumber), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -3036,7 +3036,7 @@ impl PhoneLine { (windows_core::Interface::vtable(this).LineConfiguration)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn IsImmediateDialNumberAsync(&self, number: &windows_core::HSTRING) -> windows_core::Result> { + pub fn IsImmediateDialNumberAsync(&self, number: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -3073,7 +3073,7 @@ impl PhoneLine { (windows_core::Interface::vtable(this).DialWithResult)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(number), core::mem::transmute_copy(displayname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DialWithResultAsync(&self, number: &windows_core::HSTRING, displayname: &windows_core::HSTRING) -> windows_core::Result> { + pub fn DialWithResultAsync(&self, number: &windows_core::HSTRING, displayname: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -3087,14 +3087,14 @@ impl PhoneLine { (windows_core::Interface::vtable(this).GetAllActivePhoneCalls)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAllActivePhoneCallsAsync(&self) -> windows_core::Result> { + pub fn GetAllActivePhoneCallsAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetAllActivePhoneCallsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FromIdAsync(lineid: windows_core::GUID) -> windows_core::Result> { + pub fn FromIdAsync(lineid: windows_core::GUID) -> windows_core::Result> { Self::IPhoneLineStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), lineid, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -3299,7 +3299,7 @@ impl PhoneLineTransportDevice { } } #[cfg(feature = "Devices_Enumeration")] - pub fn RequestAccessAsync(&self) -> windows_core::Result> { + pub fn RequestAccessAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -3344,7 +3344,7 @@ impl PhoneLineTransportDevice { (windows_core::Interface::vtable(this).Connect)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn ConnectAsync(&self) -> windows_core::Result> { + pub fn ConnectAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -3635,7 +3635,7 @@ impl PhoneVoicemail { (windows_core::Interface::vtable(this).Type)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn DialVoicemailAsync(&self) -> windows_core::Result { + pub fn DialVoicemailAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -3701,7 +3701,7 @@ impl windows_core::RuntimeType for VoipCallControlDeviceKind { pub struct VoipCallCoordinator(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(VoipCallCoordinator, windows_core::IUnknown, windows_core::IInspectable); impl VoipCallCoordinator { - pub fn ReserveCallResourcesAsync(&self, taskentrypoint: &windows_core::HSTRING) -> windows_core::Result> { + pub fn ReserveCallResourcesAsync(&self, taskentrypoint: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -3802,7 +3802,7 @@ impl VoipCallCoordinator { (windows_core::Interface::vtable(this).RequestNewIncomingCallWithContactRemoteId)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(context), core::mem::transmute_copy(contactname), core::mem::transmute_copy(contactnumber), contactimage.param().abi(), core::mem::transmute_copy(servicename), brandingimage.param().abi(), core::mem::transmute_copy(calldetails), ringtone.param().abi(), media, ringtimeout, core::mem::transmute_copy(contactremoteid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReserveOneProcessCallResourcesAsync(&self) -> windows_core::Result> { + pub fn ReserveOneProcessCallResourcesAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/ApplicationModel/Chat/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/Chat/mod.rs index f41360e3a8..c4a7d966e8 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/Chat/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/Chat/mod.rs @@ -53,25 +53,25 @@ unsafe impl Send for ChatCapabilities {} unsafe impl Sync for ChatCapabilities {} pub struct ChatCapabilitiesManager; impl ChatCapabilitiesManager { - pub fn GetCachedCapabilitiesAsync(address: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetCachedCapabilitiesAsync(address: &windows_core::HSTRING) -> windows_core::Result> { Self::IChatCapabilitiesManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetCachedCapabilitiesAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(address), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetCapabilitiesFromNetworkAsync(address: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetCapabilitiesFromNetworkAsync(address: &windows_core::HSTRING) -> windows_core::Result> { Self::IChatCapabilitiesManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetCapabilitiesFromNetworkAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(address), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetCachedCapabilitiesForTransportAsync(address: &windows_core::HSTRING, transportid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetCachedCapabilitiesForTransportAsync(address: &windows_core::HSTRING, transportid: &windows_core::HSTRING) -> windows_core::Result> { Self::IChatCapabilitiesManagerStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetCachedCapabilitiesForTransportAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(address), core::mem::transmute_copy(transportid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetCapabilitiesFromNetworkForTransportAsync(address: &windows_core::HSTRING, transportid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetCapabilitiesFromNetworkForTransportAsync(address: &windows_core::HSTRING, transportid: &windows_core::HSTRING) -> windows_core::Result> { Self::IChatCapabilitiesManagerStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetCapabilitiesFromNetworkForTransportAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(address), core::mem::transmute_copy(transportid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -152,7 +152,7 @@ impl ChatConversation { (windows_core::Interface::vtable(this).ThreadingInfo)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAsync(&self) -> windows_core::Result { + pub fn DeleteAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -166,21 +166,21 @@ impl ChatConversation { (windows_core::Interface::vtable(this).GetMessageReader)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn MarkAllMessagesAsReadAsync(&self) -> windows_core::Result { + pub fn MarkAllMessagesAsReadAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).MarkAllMessagesAsReadAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn MarkMessagesAsReadAsync(&self, value: super::super::Foundation::DateTime) -> windows_core::Result { + pub fn MarkMessagesAsReadAsync(&self, value: super::super::Foundation::DateTime) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).MarkMessagesAsReadAsync)(windows_core::Interface::as_raw(this), value, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SaveAsync(&self) -> windows_core::Result { + pub fn SaveAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -245,14 +245,14 @@ unsafe impl Sync for ChatConversation {} pub struct ChatConversationReader(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(ChatConversationReader, windows_core::IUnknown, windows_core::IInspectable); impl ChatConversationReader { - pub fn ReadBatchAsync(&self) -> windows_core::Result>> { + pub fn ReadBatchAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReadBatchAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReadBatchWithCountAsync(&self, count: i32) -> windows_core::Result>> { + pub fn ReadBatchWithCountAsync(&self, count: i32) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -809,7 +809,7 @@ unsafe impl Send for ChatMessageAttachment {} unsafe impl Sync for ChatMessageAttachment {} pub struct ChatMessageBlocking; impl ChatMessageBlocking { - pub fn MarkMessageAsBlockedAsync(localchatmessageid: &windows_core::HSTRING, blocked: bool) -> windows_core::Result { + pub fn MarkMessageAsBlockedAsync(localchatmessageid: &windows_core::HSTRING, blocked: bool) -> windows_core::Result { Self::IChatMessageBlockingStatic(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).MarkMessageAsBlockedAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(localchatmessageid), blocked, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -871,7 +871,7 @@ impl ChatMessageChangeReader { let this = self; unsafe { (windows_core::Interface::vtable(this).AcceptChangesThrough)(windows_core::Interface::as_raw(this), lastchangetoacknowledge.param().abi()).ok() } } - pub fn ReadBatchAsync(&self) -> windows_core::Result>> { + pub fn ReadBatchAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1006,31 +1006,31 @@ impl windows_core::RuntimeType for ChatMessageKind { } pub struct ChatMessageManager; impl ChatMessageManager { - pub fn RegisterTransportAsync() -> windows_core::Result> { + pub fn RegisterTransportAsync() -> windows_core::Result> { Self::IChatMessageManager2Statics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RegisterTransportAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetTransportAsync(transportid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetTransportAsync(transportid: &windows_core::HSTRING) -> windows_core::Result> { Self::IChatMessageManager2Statics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetTransportAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(transportid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetTransportsAsync() -> windows_core::Result>> { + pub fn GetTransportsAsync() -> windows_core::Result>> { Self::IChatMessageManagerStatic(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetTransportsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RequestStoreAsync() -> windows_core::Result> { + pub fn RequestStoreAsync() -> windows_core::Result> { Self::IChatMessageManagerStatic(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestStoreAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn ShowComposeSmsMessageAsync(message: P0) -> windows_core::Result + pub fn ShowComposeSmsMessageAsync(message: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -1042,7 +1042,7 @@ impl ChatMessageManager { pub fn ShowSmsSettings() -> windows_core::Result<()> { Self::IChatMessageManagerStatic(|this| unsafe { (windows_core::Interface::vtable(this).ShowSmsSettings)(windows_core::Interface::as_raw(this)).ok() }) } - pub fn RequestSyncManagerAsync() -> windows_core::Result> { + pub fn RequestSyncManagerAsync() -> windows_core::Result> { Self::IChatMessageManagerStatics3(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestSyncManagerAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -1137,14 +1137,14 @@ impl windows_core::RuntimeType for ChatMessageOperatorKind { pub struct ChatMessageReader(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(ChatMessageReader, windows_core::IUnknown, windows_core::IInspectable); impl ChatMessageReader { - pub fn ReadBatchAsync(&self) -> windows_core::Result>> { + pub fn ReadBatchAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReadBatchAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReadBatchWithCountAsync(&self, count: i32) -> windows_core::Result>> { + pub fn ReadBatchWithCountAsync(&self, count: i32) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1201,21 +1201,21 @@ impl ChatMessageStore { (windows_core::Interface::vtable(this).ChangeTracker)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteMessageAsync(&self, localmessageid: &windows_core::HSTRING) -> windows_core::Result { + pub fn DeleteMessageAsync(&self, localmessageid: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeleteMessageAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(localmessageid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DownloadMessageAsync(&self, localchatmessageid: &windows_core::HSTRING) -> windows_core::Result { + pub fn DownloadMessageAsync(&self, localchatmessageid: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DownloadMessageAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(localchatmessageid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetMessageAsync(&self, localchatmessageid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetMessageAsync(&self, localchatmessageid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1236,21 +1236,21 @@ impl ChatMessageStore { (windows_core::Interface::vtable(this).GetMessageReader2)(windows_core::Interface::as_raw(this), recenttimelimit, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn MarkMessageReadAsync(&self, localchatmessageid: &windows_core::HSTRING) -> windows_core::Result { + pub fn MarkMessageReadAsync(&self, localchatmessageid: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).MarkMessageReadAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(localchatmessageid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RetrySendMessageAsync(&self, localchatmessageid: &windows_core::HSTRING) -> windows_core::Result { + pub fn RetrySendMessageAsync(&self, localchatmessageid: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RetrySendMessageAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(localchatmessageid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SendMessageAsync(&self, chatmessage: P0) -> windows_core::Result + pub fn SendMessageAsync(&self, chatmessage: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -1284,7 +1284,7 @@ impl ChatMessageStore { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveMessageChanged)(windows_core::Interface::as_raw(this), value).ok() } } - pub fn ForwardMessageAsync(&self, localchatmessageid: &windows_core::HSTRING, addresses: P1) -> windows_core::Result> + pub fn ForwardMessageAsync(&self, localchatmessageid: &windows_core::HSTRING, addresses: P1) -> windows_core::Result> where P1: windows_core::Param>, { @@ -1294,14 +1294,14 @@ impl ChatMessageStore { (windows_core::Interface::vtable(this).ForwardMessageAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(localchatmessageid), addresses.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetConversationAsync(&self, conversationid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetConversationAsync(&self, conversationid: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetConversationAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(conversationid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetConversationForTransportsAsync(&self, conversationid: &windows_core::HSTRING, transportids: P1) -> windows_core::Result> + pub fn GetConversationForTransportsAsync(&self, conversationid: &windows_core::HSTRING, transportids: P1) -> windows_core::Result> where P1: windows_core::Param>, { @@ -1311,7 +1311,7 @@ impl ChatMessageStore { (windows_core::Interface::vtable(this).GetConversationForTransportsAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(conversationid), transportids.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetConversationFromThreadingInfoAsync(&self, threadinginfo: P0) -> windows_core::Result> + pub fn GetConversationFromThreadingInfoAsync(&self, threadinginfo: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1338,21 +1338,21 @@ impl ChatMessageStore { (windows_core::Interface::vtable(this).GetConversationForTransportsReader)(windows_core::Interface::as_raw(this), transportids.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetMessageByRemoteIdAsync(&self, transportid: &windows_core::HSTRING, remoteid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetMessageByRemoteIdAsync(&self, transportid: &windows_core::HSTRING, remoteid: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetMessageByRemoteIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(transportid), core::mem::transmute_copy(remoteid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetUnseenCountAsync(&self) -> windows_core::Result> { + pub fn GetUnseenCountAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetUnseenCountAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetUnseenCountForTransportsReaderAsync(&self, transportids: P0) -> windows_core::Result> + pub fn GetUnseenCountForTransportsReaderAsync(&self, transportids: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -1362,14 +1362,14 @@ impl ChatMessageStore { (windows_core::Interface::vtable(this).GetUnseenCountForTransportsReaderAsync)(windows_core::Interface::as_raw(this), transportids.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn MarkAsSeenAsync(&self) -> windows_core::Result { + pub fn MarkAsSeenAsync(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).MarkAsSeenAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn MarkAsSeenForTransportsAsync(&self, transportids: P0) -> windows_core::Result + pub fn MarkAsSeenForTransportsAsync(&self, transportids: P0) -> windows_core::Result where P0: windows_core::Param>, { @@ -1389,7 +1389,7 @@ impl ChatMessageStore { (windows_core::Interface::vtable(this).GetSearchReader)(windows_core::Interface::as_raw(this), value.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SaveMessageAsync(&self, chatmessage: P0) -> windows_core::Result + pub fn SaveMessageAsync(&self, chatmessage: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -1399,14 +1399,14 @@ impl ChatMessageStore { (windows_core::Interface::vtable(this).SaveMessageAsync)(windows_core::Interface::as_raw(this), chatmessage.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryCancelDownloadMessageAsync(&self, localchatmessageid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn TryCancelDownloadMessageAsync(&self, localchatmessageid: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryCancelDownloadMessageAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(localchatmessageid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryCancelSendMessageAsync(&self, localchatmessageid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn TryCancelSendMessageAsync(&self, localchatmessageid: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1427,7 +1427,7 @@ impl ChatMessageStore { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).RemoveStoreChanged)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn GetMessageBySyncIdAsync(&self, syncid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetMessageBySyncIdAsync(&self, syncid: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1512,7 +1512,7 @@ impl ChatMessageTransport { (windows_core::Interface::vtable(this).TransportId)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn RequestSetAsNotificationProviderAsync(&self) -> windows_core::Result { + pub fn RequestSetAsNotificationProviderAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1840,14 +1840,14 @@ impl windows_core::RuntimeType for ChatRestoreHistorySpan { pub struct ChatSearchReader(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(ChatSearchReader, windows_core::IUnknown, windows_core::IInspectable); impl ChatSearchReader { - pub fn ReadBatchAsync(&self) -> windows_core::Result>> { + pub fn ReadBatchAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReadBatchAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReadBatchWithCountAsync(&self, count: i32) -> windows_core::Result>> { + pub fn ReadBatchWithCountAsync(&self, count: i32) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1939,7 +1939,7 @@ impl ChatSyncManager { } } #[cfg(feature = "Security_Credentials")] - pub fn AssociateAccountAsync(&self, webaccount: P0) -> windows_core::Result + pub fn AssociateAccountAsync(&self, webaccount: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -1949,7 +1949,7 @@ impl ChatSyncManager { (windows_core::Interface::vtable(this).AssociateAccountAsync)(windows_core::Interface::as_raw(this), webaccount.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn UnassociateAccountAsync(&self) -> windows_core::Result { + pub fn UnassociateAccountAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1971,7 +1971,7 @@ impl ChatSyncManager { let this = self; unsafe { (windows_core::Interface::vtable(this).StartSync)(windows_core::Interface::as_raw(this)).ok() } } - pub fn SetConfigurationAsync(&self, configuration: P0) -> windows_core::Result + pub fn SetConfigurationAsync(&self, configuration: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -2783,7 +2783,7 @@ impl RcsEndUserMessage { (windows_core::Interface::vtable(this).Actions)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SendResponseAsync(&self, action: P0) -> windows_core::Result + pub fn SendResponseAsync(&self, action: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -2793,7 +2793,7 @@ impl RcsEndUserMessage { (windows_core::Interface::vtable(this).SendResponseAsync)(windows_core::Interface::as_raw(this), action.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SendResponseWithPinAsync(&self, action: P0, pin: &windows_core::HSTRING) -> windows_core::Result + pub fn SendResponseWithPinAsync(&self, action: P0, pin: &windows_core::HSTRING) -> windows_core::Result where P0: windows_core::Param, { @@ -2945,19 +2945,19 @@ impl RcsManager { (windows_core::Interface::vtable(this).GetEndUserMessageManager)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetTransportsAsync() -> windows_core::Result>> { + pub fn GetTransportsAsync() -> windows_core::Result>> { Self::IRcsManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetTransportsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetTransportAsync(transportid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetTransportAsync(transportid: &windows_core::HSTRING) -> windows_core::Result> { Self::IRcsManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetTransportAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(transportid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn LeaveConversationAsync(conversation: P0) -> windows_core::Result + pub fn LeaveConversationAsync(conversation: P0) -> windows_core::Result where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/ApplicationModel/CommunicationBlocking/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/CommunicationBlocking/mod.rs index 88291d029a..f8db3e16a6 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/CommunicationBlocking/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/CommunicationBlocking/mod.rs @@ -6,7 +6,7 @@ impl CommunicationBlockingAccessManager { (windows_core::Interface::vtable(this).IsBlockingActive)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) }) } - pub fn IsBlockedNumberAsync(number: &windows_core::HSTRING) -> windows_core::Result> { + pub fn IsBlockedNumberAsync(number: &windows_core::HSTRING) -> windows_core::Result> { Self::ICommunicationBlockingAccessManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).IsBlockedNumberAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(number), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -55,7 +55,7 @@ impl CommunicationBlockingAppManager { pub fn ShowCommunicationBlockingSettingsUI() -> windows_core::Result<()> { Self::ICommunicationBlockingAppManagerStatics(|this| unsafe { (windows_core::Interface::vtable(this).ShowCommunicationBlockingSettingsUI)(windows_core::Interface::as_raw(this)).ok() }) } - pub fn RequestSetAsActiveBlockingAppAsync() -> windows_core::Result> { + pub fn RequestSetAsActiveBlockingAppAsync() -> windows_core::Result> { Self::ICommunicationBlockingAppManagerStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestSetAsActiveBlockingAppAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/ApplicationModel/Contacts/DataProvider/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/Contacts/DataProvider/mod.rs index 0697b3ea9d..d2bed4da94 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/Contacts/DataProvider/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/Contacts/DataProvider/mod.rs @@ -120,7 +120,7 @@ impl ContactListCreateOrUpdateContactRequest { (windows_core::Interface::vtable(this).Contact)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportCompletedAsync(&self, createdorupdatedcontact: P0) -> windows_core::Result + pub fn ReportCompletedAsync(&self, createdorupdatedcontact: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -130,7 +130,7 @@ impl ContactListCreateOrUpdateContactRequest { (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), createdorupdatedcontact.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -201,14 +201,14 @@ impl ContactListDeleteContactRequest { (windows_core::Interface::vtable(this).ContactId)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn ReportCompletedAsync(&self) -> windows_core::Result { + pub fn ReportCompletedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -293,7 +293,7 @@ impl ContactListServerSearchReadBatchRequest { (windows_core::Interface::vtable(this).SuggestedBatchSize)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn SaveContactAsync(&self, contact: P0) -> windows_core::Result + pub fn SaveContactAsync(&self, contact: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -303,14 +303,14 @@ impl ContactListServerSearchReadBatchRequest { (windows_core::Interface::vtable(this).SaveContactAsync)(windows_core::Interface::as_raw(this), contact.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportCompletedAsync(&self) -> windows_core::Result { + pub fn ReportCompletedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self, batchstatus: super::ContactBatchStatus) -> windows_core::Result { + pub fn ReportFailedAsync(&self, batchstatus: super::ContactBatchStatus) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -374,14 +374,14 @@ impl ContactListSyncManagerSyncRequest { (windows_core::Interface::vtable(this).ContactListId)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn ReportCompletedAsync(&self) -> windows_core::Result { + pub fn ReportCompletedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/ApplicationModel/Contacts/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/Contacts/mod.rs index 180ea7caed..3608755037 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/Contacts/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/Contacts/mod.rs @@ -7,7 +7,7 @@ pub mod Provider; pub struct AggregateContactManager(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(AggregateContactManager, windows_core::IUnknown, windows_core::IInspectable); impl AggregateContactManager { - pub fn FindRawContactsAsync(&self, contact: P0) -> windows_core::Result>> + pub fn FindRawContactsAsync(&self, contact: P0) -> windows_core::Result>> where P0: windows_core::Param, { @@ -17,7 +17,7 @@ impl AggregateContactManager { (windows_core::Interface::vtable(this).FindRawContactsAsync)(windows_core::Interface::as_raw(this), contact.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryLinkContactsAsync(&self, primarycontact: P0, secondarycontact: P1) -> windows_core::Result> + pub fn TryLinkContactsAsync(&self, primarycontact: P0, secondarycontact: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -28,7 +28,7 @@ impl AggregateContactManager { (windows_core::Interface::vtable(this).TryLinkContactsAsync)(windows_core::Interface::as_raw(this), primarycontact.param().abi(), secondarycontact.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn UnlinkRawContactAsync(&self, contact: P0) -> windows_core::Result + pub fn UnlinkRawContactAsync(&self, contact: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -38,7 +38,7 @@ impl AggregateContactManager { (windows_core::Interface::vtable(this).UnlinkRawContactAsync)(windows_core::Interface::as_raw(this), contact.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TrySetPreferredSourceForPictureAsync(&self, aggregatecontact: P0, rawcontact: P1) -> windows_core::Result> + pub fn TrySetPreferredSourceForPictureAsync(&self, aggregatecontact: P0, rawcontact: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -49,7 +49,7 @@ impl AggregateContactManager { (windows_core::Interface::vtable(this).TrySetPreferredSourceForPictureAsync)(windows_core::Interface::as_raw(this), aggregatecontact.param().abi(), rawcontact.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SetRemoteIdentificationInformationAsync(&self, contactlistid: &windows_core::HSTRING, remotesourceid: &windows_core::HSTRING, accountid: &windows_core::HSTRING) -> windows_core::Result { + pub fn SetRemoteIdentificationInformationAsync(&self, contactlistid: &windows_core::HSTRING, remotesourceid: &windows_core::HSTRING, accountid: &windows_core::HSTRING) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -699,14 +699,14 @@ impl ContactAnnotationList { (windows_core::Interface::vtable(this).UserDataAccountId)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn DeleteAsync(&self) -> windows_core::Result { + pub fn DeleteAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeleteAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TrySaveAnnotationAsync(&self, annotation: P0) -> windows_core::Result> + pub fn TrySaveAnnotationAsync(&self, annotation: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -716,28 +716,28 @@ impl ContactAnnotationList { (windows_core::Interface::vtable(this).TrySaveAnnotationAsync)(windows_core::Interface::as_raw(this), annotation.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAnnotationAsync(&self, annotationid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetAnnotationAsync(&self, annotationid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetAnnotationAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(annotationid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FindAnnotationsByRemoteIdAsync(&self, remoteid: &windows_core::HSTRING) -> windows_core::Result>> { + pub fn FindAnnotationsByRemoteIdAsync(&self, remoteid: &windows_core::HSTRING) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAnnotationsByRemoteIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(remoteid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FindAnnotationsAsync(&self) -> windows_core::Result>> { + pub fn FindAnnotationsAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAnnotationsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAnnotationAsync(&self, annotation: P0) -> windows_core::Result + pub fn DeleteAnnotationAsync(&self, annotation: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -816,21 +816,21 @@ impl core::ops::Not for ContactAnnotationOperations { pub struct ContactAnnotationStore(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(ContactAnnotationStore, windows_core::IUnknown, windows_core::IInspectable); impl ContactAnnotationStore { - pub fn FindContactIdsByEmailAsync(&self, emailaddress: &windows_core::HSTRING) -> windows_core::Result>> { + pub fn FindContactIdsByEmailAsync(&self, emailaddress: &windows_core::HSTRING) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindContactIdsByEmailAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(emailaddress), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FindContactIdsByPhoneNumberAsync(&self, phonenumber: &windows_core::HSTRING) -> windows_core::Result>> { + pub fn FindContactIdsByPhoneNumberAsync(&self, phonenumber: &windows_core::HSTRING) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindContactIdsByPhoneNumberAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(phonenumber), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FindAnnotationsForContactAsync(&self, contact: P0) -> windows_core::Result>> + pub fn FindAnnotationsForContactAsync(&self, contact: P0) -> windows_core::Result>> where P0: windows_core::Param, { @@ -840,7 +840,7 @@ impl ContactAnnotationStore { (windows_core::Interface::vtable(this).FindAnnotationsForContactAsync)(windows_core::Interface::as_raw(this), contact.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DisableAnnotationAsync(&self, annotation: P0) -> windows_core::Result + pub fn DisableAnnotationAsync(&self, annotation: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -850,35 +850,35 @@ impl ContactAnnotationStore { (windows_core::Interface::vtable(this).DisableAnnotationAsync)(windows_core::Interface::as_raw(this), annotation.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateAnnotationListAsync(&self) -> windows_core::Result> { + pub fn CreateAnnotationListAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreateAnnotationListAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateAnnotationListInAccountAsync(&self, userdataaccountid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CreateAnnotationListInAccountAsync(&self, userdataaccountid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreateAnnotationListInAccountAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(userdataaccountid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAnnotationListAsync(&self, annotationlistid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetAnnotationListAsync(&self, annotationlistid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetAnnotationListAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(annotationlistid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FindAnnotationListsAsync(&self) -> windows_core::Result>> { + pub fn FindAnnotationListsAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAnnotationListsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FindAnnotationsForContactListAsync(&self, contactlistid: &windows_core::HSTRING) -> windows_core::Result>> { + pub fn FindAnnotationsForContactListAsync(&self, contactlistid: &windows_core::HSTRING) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1120,7 +1120,7 @@ impl ContactChangeReader { let this = self; unsafe { (windows_core::Interface::vtable(this).AcceptChangesThrough)(windows_core::Interface::as_raw(this), lastchangetoaccept.param().abi()).ok() } } - pub fn ReadBatchAsync(&self) -> windows_core::Result>> { + pub fn ReadBatchAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1694,7 +1694,7 @@ impl ContactInformation { } } #[cfg(feature = "Storage_Streams")] - pub fn GetThumbnailAsync(&self) -> windows_core::Result> { + pub fn GetThumbnailAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2112,28 +2112,28 @@ impl ContactList { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveContactChanged)(windows_core::Interface::as_raw(this), value).ok() } } - pub fn SaveAsync(&self) -> windows_core::Result { + pub fn SaveAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).SaveAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAsync(&self) -> windows_core::Result { + pub fn DeleteAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeleteAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetContactFromRemoteIdAsync(&self, remoteid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetContactFromRemoteIdAsync(&self, remoteid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetContactFromRemoteIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(remoteid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetMeContactAsync(&self) -> windows_core::Result> { + pub fn GetMeContactAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2157,7 +2157,7 @@ impl ContactList { (windows_core::Interface::vtable(this).GetContactReaderWithOptions)(windows_core::Interface::as_raw(this), options.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SaveContactAsync(&self, contact: P0) -> windows_core::Result + pub fn SaveContactAsync(&self, contact: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -2167,7 +2167,7 @@ impl ContactList { (windows_core::Interface::vtable(this).SaveContactAsync)(windows_core::Interface::as_raw(this), contact.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteContactAsync(&self, contact: P0) -> windows_core::Result + pub fn DeleteContactAsync(&self, contact: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -2177,14 +2177,14 @@ impl ContactList { (windows_core::Interface::vtable(this).DeleteContactAsync)(windows_core::Interface::as_raw(this), contact.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetContactAsync(&self, contactid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetContactAsync(&self, contactid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetContactAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(contactid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RegisterSyncManagerAsync(&self) -> windows_core::Result { + pub fn RegisterSyncManagerAsync(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -2234,7 +2234,7 @@ unsafe impl Sync for ContactList {} pub struct ContactListLimitedWriteOperations(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(ContactListLimitedWriteOperations, windows_core::IUnknown, windows_core::IInspectable); impl ContactListLimitedWriteOperations { - pub fn TryCreateOrUpdateContactAsync(&self, contact: P0) -> windows_core::Result> + pub fn TryCreateOrUpdateContactAsync(&self, contact: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2244,7 +2244,7 @@ impl ContactListLimitedWriteOperations { (windows_core::Interface::vtable(this).TryCreateOrUpdateContactAsync)(windows_core::Interface::as_raw(this), contact.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryDeleteContactAsync(&self, contactid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn TryDeleteContactAsync(&self, contactid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2726,7 +2726,7 @@ impl ContactListSyncManager { (windows_core::Interface::vtable(this).LastAttemptedSyncTime)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn SyncAsync(&self) -> windows_core::Result> { + pub fn SyncAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2926,14 +2926,14 @@ impl ContactManager { (windows_core::Interface::vtable(this).ShowDelayLoadedContactCard)(windows_core::Interface::as_raw(this), contact.param().abi(), selection, preferredplacement, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RequestStoreAsync() -> windows_core::Result> { + pub fn RequestStoreAsync() -> windows_core::Result> { Self::IContactManagerStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestStoreAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "Storage_Streams")] - pub fn ConvertContactToVCardAsync(contact: P0) -> windows_core::Result> + pub fn ConvertContactToVCardAsync(contact: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2943,7 +2943,7 @@ impl ContactManager { }) } #[cfg(feature = "Storage_Streams")] - pub fn ConvertContactToVCardAsyncWithMaxBytes(contact: P0, maxbytes: u32) -> windows_core::Result> + pub fn ConvertContactToVCardAsyncWithMaxBytes(contact: P0, maxbytes: u32) -> windows_core::Result> where P0: windows_core::Param, { @@ -2953,7 +2953,7 @@ impl ContactManager { }) } #[cfg(feature = "Storage_Streams")] - pub fn ConvertVCardToContactAsync(vcard: P0) -> windows_core::Result> + pub fn ConvertVCardToContactAsync(vcard: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2962,13 +2962,13 @@ impl ContactManager { (windows_core::Interface::vtable(this).ConvertVCardToContactAsync)(windows_core::Interface::as_raw(this), vcard.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RequestStoreAsyncWithAccessType(accesstype: ContactStoreAccessType) -> windows_core::Result> { + pub fn RequestStoreAsyncWithAccessType(accesstype: ContactStoreAccessType) -> windows_core::Result> { Self::IContactManagerStatics3(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestStoreAsyncWithAccessType)(windows_core::Interface::as_raw(this), accesstype, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RequestAnnotationStoreAsync(accesstype: ContactAnnotationStoreAccessType) -> windows_core::Result> { + pub fn RequestAnnotationStoreAsync(accesstype: ContactAnnotationStoreAccessType) -> windows_core::Result> { Self::IContactManagerStatics3(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestAnnotationStoreAsync)(windows_core::Interface::as_raw(this), accesstype, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -3040,7 +3040,7 @@ impl ContactManager { (windows_core::Interface::vtable(this).GetForUser)(windows_core::Interface::as_raw(this), user.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn IsShowFullContactCardSupportedAsync() -> windows_core::Result> { + pub fn IsShowFullContactCardSupportedAsync() -> windows_core::Result> { Self::IContactManagerStatics5(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).IsShowFullContactCardSupportedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -3085,7 +3085,7 @@ pub struct ContactManagerForUser(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(ContactManagerForUser, windows_core::IUnknown, windows_core::IInspectable); impl ContactManagerForUser { #[cfg(feature = "Storage_Streams")] - pub fn ConvertContactToVCardAsync(&self, contact: P0) -> windows_core::Result> + pub fn ConvertContactToVCardAsync(&self, contact: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -3096,7 +3096,7 @@ impl ContactManagerForUser { } } #[cfg(feature = "Storage_Streams")] - pub fn ConvertContactToVCardAsyncWithMaxBytes(&self, contact: P0, maxbytes: u32) -> windows_core::Result> + pub fn ConvertContactToVCardAsyncWithMaxBytes(&self, contact: P0, maxbytes: u32) -> windows_core::Result> where P0: windows_core::Param, { @@ -3107,7 +3107,7 @@ impl ContactManagerForUser { } } #[cfg(feature = "Storage_Streams")] - pub fn ConvertVCardToContactAsync(&self, vcard: P0) -> windows_core::Result> + pub fn ConvertVCardToContactAsync(&self, vcard: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -3117,14 +3117,14 @@ impl ContactManagerForUser { (windows_core::Interface::vtable(this).ConvertVCardToContactAsync)(windows_core::Interface::as_raw(this), vcard.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestStoreAsync(&self, accesstype: ContactStoreAccessType) -> windows_core::Result> { + pub fn RequestStoreAsync(&self, accesstype: ContactStoreAccessType) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestStoreAsync)(windows_core::Interface::as_raw(this), accesstype, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestAnnotationStoreAsync(&self, accesstype: ContactAnnotationStoreAccessType) -> windows_core::Result> { + pub fn RequestAnnotationStoreAsync(&self, accesstype: ContactAnnotationStoreAccessType) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -3492,14 +3492,14 @@ impl ContactPicker { (windows_core::Interface::vtable(this).DesiredFields)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn PickSingleContactAsync(&self) -> windows_core::Result> { + pub fn PickSingleContactAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).PickSingleContactAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn PickMultipleContactsAsync(&self) -> windows_core::Result>> { + pub fn PickMultipleContactsAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -3513,14 +3513,14 @@ impl ContactPicker { (windows_core::Interface::vtable(this).DesiredFieldsWithContactFieldType)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn PickContactAsync(&self) -> windows_core::Result> { + pub fn PickContactAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).PickContactAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn PickContactsAsync(&self) -> windows_core::Result>> { + pub fn PickContactsAsync(&self) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -3545,7 +3545,7 @@ impl ContactPicker { (windows_core::Interface::vtable(this).CreateForUser)(windows_core::Interface::as_raw(this), user.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn IsSupportedAsync() -> windows_core::Result> { + pub fn IsSupportedAsync() -> windows_core::Result> { Self::IContactPickerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).IsSupportedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -3827,7 +3827,7 @@ unsafe impl Sync for ContactQueryTextSearch {} pub struct ContactReader(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(ContactReader, windows_core::IUnknown, windows_core::IInspectable); impl ContactReader { - pub fn ReadBatchAsync(&self) -> windows_core::Result> { + pub fn ReadBatchAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -3950,21 +3950,21 @@ unsafe impl Sync for ContactSignificantOther {} pub struct ContactStore(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(ContactStore, windows_core::IUnknown, windows_core::IInspectable); impl ContactStore { - pub fn FindContactsAsync(&self) -> windows_core::Result>> { + pub fn FindContactsAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindContactsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FindContactsWithSearchTextAsync(&self, searchtext: &windows_core::HSTRING) -> windows_core::Result>> { + pub fn FindContactsWithSearchTextAsync(&self, searchtext: &windows_core::HSTRING) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindContactsWithSearchTextAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(searchtext), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetContactAsync(&self, contactid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetContactAsync(&self, contactid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -3999,28 +3999,28 @@ impl ContactStore { (windows_core::Interface::vtable(this).AggregateContactManager)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FindContactListsAsync(&self) -> windows_core::Result>> { + pub fn FindContactListsAsync(&self) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindContactListsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetContactListAsync(&self, contactlistid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetContactListAsync(&self, contactlistid: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetContactListAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(contactlistid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateContactListAsync(&self, displayname: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CreateContactListAsync(&self, displayname: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreateContactListAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(displayname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetMeContactAsync(&self) -> windows_core::Result> { + pub fn GetMeContactAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -4044,7 +4044,7 @@ impl ContactStore { (windows_core::Interface::vtable(this).GetContactReaderWithOptions)(windows_core::Interface::as_raw(this), options.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateContactListInAccountAsync(&self, displayname: &windows_core::HSTRING, userdataaccountid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CreateContactListInAccountAsync(&self, displayname: &windows_core::HSTRING, userdataaccountid: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -5783,7 +5783,7 @@ impl PinnedContactManager { (windows_core::Interface::vtable(this).IsContactPinned)(windows_core::Interface::as_raw(this), contact.param().abi(), surface, &mut result__).map(|| result__) } } - pub fn RequestPinContactAsync(&self, contact: P0, surface: PinnedContactSurface) -> windows_core::Result> + pub fn RequestPinContactAsync(&self, contact: P0, surface: PinnedContactSurface) -> windows_core::Result> where P0: windows_core::Param, { @@ -5793,7 +5793,7 @@ impl PinnedContactManager { (windows_core::Interface::vtable(this).RequestPinContactAsync)(windows_core::Interface::as_raw(this), contact.param().abi(), surface, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestPinContactsAsync(&self, contacts: P0, surface: PinnedContactSurface) -> windows_core::Result> + pub fn RequestPinContactsAsync(&self, contacts: P0, surface: PinnedContactSurface) -> windows_core::Result> where P0: windows_core::Param>, { @@ -5803,7 +5803,7 @@ impl PinnedContactManager { (windows_core::Interface::vtable(this).RequestPinContactsAsync)(windows_core::Interface::as_raw(this), contacts.param().abi(), surface, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestUnpinContactAsync(&self, contact: P0, surface: PinnedContactSurface) -> windows_core::Result> + pub fn RequestUnpinContactAsync(&self, contact: P0, surface: PinnedContactSurface) -> windows_core::Result> where P0: windows_core::Param, { @@ -5820,7 +5820,7 @@ impl PinnedContactManager { let this = self; unsafe { (windows_core::Interface::vtable(this).SignalContactActivity)(windows_core::Interface::as_raw(this), contact.param().abi()).ok() } } - pub fn GetPinnedContactIdsAsync(&self) -> windows_core::Result> { + pub fn GetPinnedContactIdsAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/ApplicationModel/ConversationalAgent/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/ConversationalAgent/mod.rs index a2da6bd310..89d570058f 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/ConversationalAgent/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/ConversationalAgent/mod.rs @@ -36,7 +36,7 @@ impl ActivationSignalDetectionConfiguration { let this = self; unsafe { (windows_core::Interface::vtable(this).SetEnabled)(windows_core::Interface::as_raw(this), value).ok() } } - pub fn SetEnabledAsync(&self, value: bool) -> windows_core::Result { + pub fn SetEnabledAsync(&self, value: bool) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -73,7 +73,7 @@ impl ActivationSignalDetectionConfiguration { unsafe { (windows_core::Interface::vtable(this).SetModelData)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(datatype), data.param().abi()).ok() } } #[cfg(feature = "Storage_Streams")] - pub fn SetModelDataAsync(&self, datatype: &windows_core::HSTRING, data: P1) -> windows_core::Result + pub fn SetModelDataAsync(&self, datatype: &windows_core::HSTRING, data: P1) -> windows_core::Result where P1: windows_core::Param, { @@ -90,7 +90,7 @@ impl ActivationSignalDetectionConfiguration { (windows_core::Interface::vtable(this).GetModelDataType)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn GetModelDataTypeAsync(&self) -> windows_core::Result> { + pub fn GetModelDataTypeAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -106,7 +106,7 @@ impl ActivationSignalDetectionConfiguration { } } #[cfg(feature = "Storage_Streams")] - pub fn GetModelDataAsync(&self) -> windows_core::Result> { + pub fn GetModelDataAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -117,7 +117,7 @@ impl ActivationSignalDetectionConfiguration { let this = self; unsafe { (windows_core::Interface::vtable(this).ClearModelData)(windows_core::Interface::as_raw(this)).ok() } } - pub fn ClearModelDataAsync(&self) -> windows_core::Result { + pub fn ClearModelDataAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -157,7 +157,7 @@ impl ActivationSignalDetectionConfiguration { } } #[cfg(feature = "Storage_Streams")] - pub fn ApplyTrainingDataAsync(&self, trainingdataformat: ActivationSignalDetectionTrainingDataFormat, trainingdata: P1) -> windows_core::Result> + pub fn ApplyTrainingDataAsync(&self, trainingdataformat: ActivationSignalDetectionTrainingDataFormat, trainingdata: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -171,7 +171,7 @@ impl ActivationSignalDetectionConfiguration { let this = self; unsafe { (windows_core::Interface::vtable(this).ClearTrainingData)(windows_core::Interface::as_raw(this)).ok() } } - pub fn ClearTrainingDataAsync(&self) -> windows_core::Result { + pub fn ClearTrainingDataAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -190,7 +190,7 @@ impl ActivationSignalDetectionConfiguration { } } #[cfg(feature = "Storage_Streams")] - pub fn SetModelDataWithResultAsync(&self, datatype: &windows_core::HSTRING, data: P1) -> windows_core::Result> + pub fn SetModelDataWithResultAsync(&self, datatype: &windows_core::HSTRING, data: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -200,7 +200,7 @@ impl ActivationSignalDetectionConfiguration { (windows_core::Interface::vtable(this).SetModelDataWithResultAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(datatype), data.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SetEnabledWithResultAsync(&self, value: bool) -> windows_core::Result> { + pub fn SetEnabledWithResultAsync(&self, value: bool) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -413,7 +413,7 @@ impl ActivationSignalDetector { (windows_core::Interface::vtable(this).GetSupportedModelIdsForSignalId)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(signalid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetSupportedModelIdsForSignalIdAsync(&self, signalid: &windows_core::HSTRING) -> windows_core::Result>> { + pub fn GetSupportedModelIdsForSignalIdAsync(&self, signalid: &windows_core::HSTRING) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -424,7 +424,7 @@ impl ActivationSignalDetector { let this = self; unsafe { (windows_core::Interface::vtable(this).CreateConfiguration)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(signalid), core::mem::transmute_copy(modelid), core::mem::transmute_copy(displayname)).ok() } } - pub fn CreateConfigurationAsync(&self, signalid: &windows_core::HSTRING, modelid: &windows_core::HSTRING, displayname: &windows_core::HSTRING) -> windows_core::Result { + pub fn CreateConfigurationAsync(&self, signalid: &windows_core::HSTRING, modelid: &windows_core::HSTRING, displayname: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -438,7 +438,7 @@ impl ActivationSignalDetector { (windows_core::Interface::vtable(this).GetConfigurations)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetConfigurationsAsync(&self) -> windows_core::Result>> { + pub fn GetConfigurationsAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -452,7 +452,7 @@ impl ActivationSignalDetector { (windows_core::Interface::vtable(this).GetConfiguration)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(signalid), core::mem::transmute_copy(modelid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetConfigurationAsync(&self, signalid: &windows_core::HSTRING, modelid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetConfigurationAsync(&self, signalid: &windows_core::HSTRING, modelid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -463,14 +463,14 @@ impl ActivationSignalDetector { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveConfiguration)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(signalid), core::mem::transmute_copy(modelid)).ok() } } - pub fn RemoveConfigurationAsync(&self, signalid: &windows_core::HSTRING, modelid: &windows_core::HSTRING) -> windows_core::Result { + pub fn RemoveConfigurationAsync(&self, signalid: &windows_core::HSTRING, modelid: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RemoveConfigurationAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(signalid), core::mem::transmute_copy(modelid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAvailableModelIdsForSignalIdAsync(&self, signalid: &windows_core::HSTRING) -> windows_core::Result>> { + pub fn GetAvailableModelIdsForSignalIdAsync(&self, signalid: &windows_core::HSTRING) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -484,7 +484,7 @@ impl ActivationSignalDetector { (windows_core::Interface::vtable(this).GetAvailableModelIdsForSignalId)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(signalid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateConfigurationWithResultAsync(&self, signalid: &windows_core::HSTRING, modelid: &windows_core::HSTRING, displayname: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CreateConfigurationWithResultAsync(&self, signalid: &windows_core::HSTRING, modelid: &windows_core::HSTRING, displayname: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -498,7 +498,7 @@ impl ActivationSignalDetector { (windows_core::Interface::vtable(this).CreateConfigurationWithResult)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(signalid), core::mem::transmute_copy(modelid), core::mem::transmute_copy(displayname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RemoveConfigurationWithResultAsync(&self, signalid: &windows_core::HSTRING, modelid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn RemoveConfigurationWithResultAsync(&self, signalid: &windows_core::HSTRING, modelid: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -600,7 +600,7 @@ impl ConversationalAgentDetectorManager { (windows_core::Interface::vtable(this).GetAllActivationSignalDetectors)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAllActivationSignalDetectorsAsync(&self) -> windows_core::Result>> { + pub fn GetAllActivationSignalDetectorsAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -614,7 +614,7 @@ impl ConversationalAgentDetectorManager { (windows_core::Interface::vtable(this).GetActivationSignalDetectors)(windows_core::Interface::as_raw(this), kind, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetActivationSignalDetectorsAsync(&self, kind: ActivationSignalDetectorKind) -> windows_core::Result>> { + pub fn GetActivationSignalDetectorsAsync(&self, kind: ActivationSignalDetectorKind) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -628,7 +628,7 @@ impl ConversationalAgentDetectorManager { (windows_core::Interface::vtable(this).GetActivationSignalDetectorFromId)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(detectorid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetActivationSignalDetectorFromIdAsync(&self, detectorid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetActivationSignalDetectorFromIdAsync(&self, detectorid: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -766,7 +766,7 @@ impl ConversationalAgentSession { (windows_core::Interface::vtable(this).IsInterrupted)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn RequestInterruptibleAsync(&self, interruptible: bool) -> windows_core::Result> { + pub fn RequestInterruptibleAsync(&self, interruptible: bool) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -780,7 +780,7 @@ impl ConversationalAgentSession { (windows_core::Interface::vtable(this).RequestInterruptible)(windows_core::Interface::as_raw(this), interruptible, &mut result__).map(|| result__) } } - pub fn RequestAgentStateChangeAsync(&self, state: ConversationalAgentState) -> windows_core::Result> { + pub fn RequestAgentStateChangeAsync(&self, state: ConversationalAgentState) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -794,7 +794,7 @@ impl ConversationalAgentSession { (windows_core::Interface::vtable(this).RequestAgentStateChange)(windows_core::Interface::as_raw(this), state, &mut result__).map(|| result__) } } - pub fn RequestForegroundActivationAsync(&self) -> windows_core::Result> { + pub fn RequestForegroundActivationAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -808,7 +808,7 @@ impl ConversationalAgentSession { (windows_core::Interface::vtable(this).RequestForegroundActivation)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn GetAudioClientAsync(&self) -> windows_core::Result> { + pub fn GetAudioClientAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -823,7 +823,7 @@ impl ConversationalAgentSession { } } #[cfg(feature = "Media_Audio")] - pub fn CreateAudioDeviceInputNodeAsync(&self, graph: P0) -> windows_core::Result> + pub fn CreateAudioDeviceInputNodeAsync(&self, graph: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -844,7 +844,7 @@ impl ConversationalAgentSession { (windows_core::Interface::vtable(this).CreateAudioDeviceInputNode)(windows_core::Interface::as_raw(this), graph.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAudioCaptureDeviceIdAsync(&self) -> windows_core::Result> { + pub fn GetAudioCaptureDeviceIdAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -858,7 +858,7 @@ impl ConversationalAgentSession { (windows_core::Interface::vtable(this).GetAudioCaptureDeviceId)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn GetAudioRenderDeviceIdAsync(&self) -> windows_core::Result> { + pub fn GetAudioRenderDeviceIdAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -872,7 +872,7 @@ impl ConversationalAgentSession { (windows_core::Interface::vtable(this).GetAudioRenderDeviceId)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn GetSignalModelIdAsync(&self) -> windows_core::Result> { + pub fn GetSignalModelIdAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -886,7 +886,7 @@ impl ConversationalAgentSession { (windows_core::Interface::vtable(this).GetSignalModelId)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn SetSignalModelIdAsync(&self, signalmodelid: u32) -> windows_core::Result> { + pub fn SetSignalModelIdAsync(&self, signalmodelid: u32) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -900,7 +900,7 @@ impl ConversationalAgentSession { (windows_core::Interface::vtable(this).SetSignalModelId)(windows_core::Interface::as_raw(this), signalmodelid, &mut result__).map(|| result__) } } - pub fn GetSupportedSignalModelIdsAsync(&self) -> windows_core::Result>> { + pub fn GetSupportedSignalModelIdsAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -914,7 +914,7 @@ impl ConversationalAgentSession { (windows_core::Interface::vtable(this).GetSupportedSignalModelIds)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestActivationAsync(&self, activationkind: ConversationalAgentActivationKind) -> windows_core::Result> { + pub fn RequestActivationAsync(&self, activationkind: ConversationalAgentActivationKind) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -928,7 +928,7 @@ impl ConversationalAgentSession { (windows_core::Interface::vtable(this).RequestActivation)(windows_core::Interface::as_raw(this), activationkind, &mut result__).map(|| result__) } } - pub fn SetSupportLockScreenActivationAsync(&self, lockscreenactivationsupported: bool) -> windows_core::Result { + pub fn SetSupportLockScreenActivationAsync(&self, lockscreenactivationsupported: bool) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -946,14 +946,14 @@ impl ConversationalAgentSession { (windows_core::Interface::vtable(this).GetMissingPrerequisites)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetMissingPrerequisitesAsync(&self) -> windows_core::Result>> { + pub fn GetMissingPrerequisitesAsync(&self) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetMissingPrerequisitesAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetCurrentSessionAsync() -> windows_core::Result> { + pub fn GetCurrentSessionAsync() -> windows_core::Result> { Self::IConversationalAgentSessionStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetCurrentSessionAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/ApplicationModel/Core/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/Core/mod.rs index 689f727d85..078f111e7c 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/Core/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/Core/mod.rs @@ -10,7 +10,7 @@ impl AppListEntry { (windows_core::Interface::vtable(this).DisplayInfo)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn LaunchAsync(&self) -> windows_core::Result> { + pub fn LaunchAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -25,7 +25,7 @@ impl AppListEntry { } } #[cfg(feature = "System")] - pub fn LaunchForUserAsync(&self, user: P0) -> windows_core::Result> + pub fn LaunchForUserAsync(&self, user: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -167,14 +167,14 @@ impl CoreApplication { pub fn EnablePrelaunch(value: bool) -> windows_core::Result<()> { Self::ICoreApplication2(|this| unsafe { (windows_core::Interface::vtable(this).EnablePrelaunch)(windows_core::Interface::as_raw(this), value).ok() }) } - pub fn RequestRestartAsync(launcharguments: &windows_core::HSTRING) -> windows_core::Result> { + pub fn RequestRestartAsync(launcharguments: &windows_core::HSTRING) -> windows_core::Result> { Self::ICoreApplication3(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestRestartAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(launcharguments), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "System")] - pub fn RequestRestartForUserAsync(user: P0, launcharguments: &windows_core::HSTRING) -> windows_core::Result> + pub fn RequestRestartForUserAsync(user: P0, launcharguments: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/ApplicationModel/DataTransfer/DragDrop/Core/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/DataTransfer/DragDrop/Core/mod.rs index 09601c948c..11ea623248 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/DataTransfer/DragDrop/Core/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/DataTransfer/DragDrop/Core/mod.rs @@ -147,7 +147,7 @@ impl CoreDragOperation { let this = self; unsafe { (windows_core::Interface::vtable(this).SetDragUIContentMode)(windows_core::Interface::as_raw(this), value).ok() } } - pub fn StartAsync(&self) -> windows_core::Result> { + pub fn StartAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -434,7 +434,7 @@ impl windows_core::RuntimeType for ICoreDropOperationTarget { } windows_core::imp::interface_hierarchy!(ICoreDropOperationTarget, windows_core::IUnknown, windows_core::IInspectable); impl ICoreDropOperationTarget { - pub fn EnterAsync(&self, draginfo: P0, draguioverride: P1) -> windows_core::Result> + pub fn EnterAsync(&self, draginfo: P0, draguioverride: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -445,7 +445,7 @@ impl ICoreDropOperationTarget { (windows_core::Interface::vtable(this).EnterAsync)(windows_core::Interface::as_raw(this), draginfo.param().abi(), draguioverride.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn OverAsync(&self, draginfo: P0, draguioverride: P1) -> windows_core::Result> + pub fn OverAsync(&self, draginfo: P0, draguioverride: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -456,7 +456,7 @@ impl ICoreDropOperationTarget { (windows_core::Interface::vtable(this).OverAsync)(windows_core::Interface::as_raw(this), draginfo.param().abi(), draguioverride.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn LeaveAsync(&self, draginfo: P0) -> windows_core::Result + pub fn LeaveAsync(&self, draginfo: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -466,7 +466,7 @@ impl ICoreDropOperationTarget { (windows_core::Interface::vtable(this).LeaveAsync)(windows_core::Interface::as_raw(this), draginfo.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DropAsync(&self, draginfo: P0) -> windows_core::Result> + pub fn DropAsync(&self, draginfo: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -481,10 +481,10 @@ impl windows_core::RuntimeName for ICoreDropOperationTarget { const NAME: &'static str = "Windows.ApplicationModel.DataTransfer.DragDrop.Core.ICoreDropOperationTarget"; } pub trait ICoreDropOperationTarget_Impl: windows_core::IUnknownImpl { - fn EnterAsync(&self, dragInfo: windows_core::Ref<'_, CoreDragInfo>, dragUIOverride: windows_core::Ref<'_, CoreDragUIOverride>) -> windows_core::Result>; - fn OverAsync(&self, dragInfo: windows_core::Ref<'_, CoreDragInfo>, dragUIOverride: windows_core::Ref<'_, CoreDragUIOverride>) -> windows_core::Result>; - fn LeaveAsync(&self, dragInfo: windows_core::Ref<'_, CoreDragInfo>) -> windows_core::Result; - fn DropAsync(&self, dragInfo: windows_core::Ref<'_, CoreDragInfo>) -> windows_core::Result>; + fn EnterAsync(&self, dragInfo: windows_core::Ref<'_, CoreDragInfo>, dragUIOverride: windows_core::Ref<'_, CoreDragUIOverride>) -> windows_core::Result>; + fn OverAsync(&self, dragInfo: windows_core::Ref<'_, CoreDragInfo>, dragUIOverride: windows_core::Ref<'_, CoreDragUIOverride>) -> windows_core::Result>; + fn LeaveAsync(&self, dragInfo: windows_core::Ref<'_, CoreDragInfo>) -> windows_core::Result; + fn DropAsync(&self, dragInfo: windows_core::Ref<'_, CoreDragInfo>) -> windows_core::Result>; } impl ICoreDropOperationTarget_Vtbl { pub const fn new() -> Self { diff --git a/crates/libs/windows/src/Windows/ApplicationModel/DataTransfer/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/DataTransfer/mod.rs index cf4430f3db..adf8d4462e 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/DataTransfer/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/DataTransfer/mod.rs @@ -34,7 +34,7 @@ impl Clipboard { pub fn RemoveContentChanged(token: i64) -> windows_core::Result<()> { Self::IClipboardStatics(|this| unsafe { (windows_core::Interface::vtable(this).RemoveContentChanged)(windows_core::Interface::as_raw(this), token).ok() }) } - pub fn GetHistoryItemsAsync() -> windows_core::Result> { + pub fn GetHistoryItemsAsync() -> windows_core::Result> { Self::IClipboardStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetHistoryItemsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -980,21 +980,21 @@ impl DataPackageView { (windows_core::Interface::vtable(this).Contains)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(formatid), &mut result__).map(|| result__) } } - pub fn GetDataAsync(&self, formatid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetDataAsync(&self, formatid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetDataAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(formatid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetTextAsync(&self) -> windows_core::Result> { + pub fn GetTextAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetTextAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetCustomTextAsync(&self, formatid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetCustomTextAsync(&self, formatid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1002,14 +1002,14 @@ impl DataPackageView { } } #[cfg(feature = "deprecated")] - pub fn GetUriAsync(&self) -> windows_core::Result> { + pub fn GetUriAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetUriAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetHtmlFormatAsync(&self) -> windows_core::Result> { + pub fn GetHtmlFormatAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1017,14 +1017,14 @@ impl DataPackageView { } } #[cfg(feature = "Storage_Streams")] - pub fn GetResourceMapAsync(&self) -> windows_core::Result>> { + pub fn GetResourceMapAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetResourceMapAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetRtfAsync(&self) -> windows_core::Result> { + pub fn GetRtfAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1032,7 +1032,7 @@ impl DataPackageView { } } #[cfg(feature = "Storage_Streams")] - pub fn GetBitmapAsync(&self) -> windows_core::Result> { + pub fn GetBitmapAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1040,21 +1040,21 @@ impl DataPackageView { } } #[cfg(feature = "Storage")] - pub fn GetStorageItemsAsync(&self) -> windows_core::Result>> { + pub fn GetStorageItemsAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetStorageItemsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetApplicationLinkAsync(&self) -> windows_core::Result> { + pub fn GetApplicationLinkAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetApplicationLinkAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetWebLinkAsync(&self) -> windows_core::Result> { + pub fn GetWebLinkAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1062,7 +1062,7 @@ impl DataPackageView { } } #[cfg(feature = "Security_EnterpriseData")] - pub fn RequestAccessAsync(&self) -> windows_core::Result> { + pub fn RequestAccessAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1070,7 +1070,7 @@ impl DataPackageView { } } #[cfg(feature = "Security_EnterpriseData")] - pub fn RequestAccessWithEnterpriseIdAsync(&self, enterpriseid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn RequestAccessWithEnterpriseIdAsync(&self, enterpriseid: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -2477,7 +2477,7 @@ impl SharedStorageAccessManager { }) } #[cfg(feature = "Storage_Streams")] - pub fn RedeemTokenForFileAsync(token: &windows_core::HSTRING) -> windows_core::Result> { + pub fn RedeemTokenForFileAsync(token: &windows_core::HSTRING) -> windows_core::Result> { Self::ISharedStorageAccessManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RedeemTokenForFileAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(token), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/ApplicationModel/Email/DataProvider/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/Email/DataProvider/mod.rs index 210c39d884..169a5415f4 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/Email/DataProvider/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/Email/DataProvider/mod.rs @@ -281,7 +281,7 @@ impl EmailMailboxCreateFolderRequest { (windows_core::Interface::vtable(this).Name)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn ReportCompletedAsync(&self, folder: P0) -> windows_core::Result + pub fn ReportCompletedAsync(&self, folder: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -291,7 +291,7 @@ impl EmailMailboxCreateFolderRequest { (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), folder.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self, status: super::EmailMailboxCreateFolderStatus) -> windows_core::Result { + pub fn ReportFailedAsync(&self, status: super::EmailMailboxCreateFolderStatus) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -362,14 +362,14 @@ impl EmailMailboxDeleteFolderRequest { (windows_core::Interface::vtable(this).EmailFolderId)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn ReportCompletedAsync(&self) -> windows_core::Result { + pub fn ReportCompletedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self, status: super::EmailMailboxDeleteFolderStatus) -> windows_core::Result { + pub fn ReportFailedAsync(&self, status: super::EmailMailboxDeleteFolderStatus) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -447,14 +447,14 @@ impl EmailMailboxDownloadAttachmentRequest { (windows_core::Interface::vtable(this).EmailAttachmentId)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn ReportCompletedAsync(&self) -> windows_core::Result { + pub fn ReportCompletedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -525,14 +525,14 @@ impl EmailMailboxDownloadMessageRequest { (windows_core::Interface::vtable(this).EmailMessageId)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn ReportCompletedAsync(&self) -> windows_core::Result { + pub fn ReportCompletedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -603,14 +603,14 @@ impl EmailMailboxEmptyFolderRequest { (windows_core::Interface::vtable(this).EmailFolderId)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn ReportCompletedAsync(&self) -> windows_core::Result { + pub fn ReportCompletedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self, status: super::EmailMailboxEmptyFolderStatus) -> windows_core::Result { + pub fn ReportFailedAsync(&self, status: super::EmailMailboxEmptyFolderStatus) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -716,14 +716,14 @@ impl EmailMailboxForwardMeetingRequest { (windows_core::Interface::vtable(this).Comment)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn ReportCompletedAsync(&self) -> windows_core::Result { + pub fn ReportCompletedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -794,7 +794,7 @@ impl EmailMailboxGetAutoReplySettingsRequest { (windows_core::Interface::vtable(this).RequestedFormat)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn ReportCompletedAsync(&self, autoreplysettings: P0) -> windows_core::Result + pub fn ReportCompletedAsync(&self, autoreplysettings: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -804,7 +804,7 @@ impl EmailMailboxGetAutoReplySettingsRequest { (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), autoreplysettings.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -889,14 +889,14 @@ impl EmailMailboxMoveFolderRequest { (windows_core::Interface::vtable(this).NewFolderName)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn ReportCompletedAsync(&self) -> windows_core::Result { + pub fn ReportCompletedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -995,14 +995,14 @@ impl EmailMailboxProposeNewTimeForMeetingRequest { (windows_core::Interface::vtable(this).Comment)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn ReportCompletedAsync(&self) -> windows_core::Result { + pub fn ReportCompletedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1073,7 +1073,7 @@ impl EmailMailboxResolveRecipientsRequest { (windows_core::Interface::vtable(this).Recipients)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportCompletedAsync(&self, resolutionresults: P0) -> windows_core::Result + pub fn ReportCompletedAsync(&self, resolutionresults: P0) -> windows_core::Result where P0: windows_core::Param>, { @@ -1083,7 +1083,7 @@ impl EmailMailboxResolveRecipientsRequest { (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), resolutionresults.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1175,7 +1175,7 @@ impl EmailMailboxServerSearchReadBatchRequest { (windows_core::Interface::vtable(this).SuggestedBatchSize)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn SaveMessageAsync(&self, message: P0) -> windows_core::Result + pub fn SaveMessageAsync(&self, message: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -1185,14 +1185,14 @@ impl EmailMailboxServerSearchReadBatchRequest { (windows_core::Interface::vtable(this).SaveMessageAsync)(windows_core::Interface::as_raw(this), message.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportCompletedAsync(&self) -> windows_core::Result { + pub fn ReportCompletedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self, batchstatus: super::EmailBatchStatus) -> windows_core::Result { + pub fn ReportFailedAsync(&self, batchstatus: super::EmailBatchStatus) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1263,14 +1263,14 @@ impl EmailMailboxSetAutoReplySettingsRequest { (windows_core::Interface::vtable(this).AutoReplySettings)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportCompletedAsync(&self) -> windows_core::Result { + pub fn ReportCompletedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1334,14 +1334,14 @@ impl EmailMailboxSyncManagerSyncRequest { (windows_core::Interface::vtable(this).EmailMailboxId)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn ReportCompletedAsync(&self) -> windows_core::Result { + pub fn ReportCompletedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1440,14 +1440,14 @@ impl EmailMailboxUpdateMeetingResponseRequest { (windows_core::Interface::vtable(this).SendUpdate)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn ReportCompletedAsync(&self) -> windows_core::Result { + pub fn ReportCompletedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1519,7 +1519,7 @@ impl EmailMailboxValidateCertificatesRequest { (windows_core::Interface::vtable(this).Certificates)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportCompletedAsync(&self, validationstatuses: P0) -> windows_core::Result + pub fn ReportCompletedAsync(&self, validationstatuses: P0) -> windows_core::Result where P0: windows_core::Param>, { @@ -1529,7 +1529,7 @@ impl EmailMailboxValidateCertificatesRequest { (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), validationstatuses.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/ApplicationModel/Email/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/Email/mod.rs index 17114bd04a..d8f54fe575 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/Email/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/Email/mod.rs @@ -307,14 +307,14 @@ impl EmailConversation { (windows_core::Interface::vtable(this).UnreadMessageCount)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn FindMessagesAsync(&self) -> windows_core::Result>> { + pub fn FindMessagesAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindMessagesAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FindMessagesWithCountAsync(&self, count: u32) -> windows_core::Result>> { + pub fn FindMessagesWithCountAsync(&self, count: u32) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -371,7 +371,7 @@ unsafe impl Sync for EmailConversationBatch {} pub struct EmailConversationReader(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(EmailConversationReader, windows_core::IUnknown, windows_core::IInspectable); impl EmailConversationReader { - pub fn ReadBatchAsync(&self) -> windows_core::Result> { + pub fn ReadBatchAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -483,21 +483,21 @@ impl EmailFolder { (windows_core::Interface::vtable(this).Kind)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn CreateFolderAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CreateFolderAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreateFolderAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(name), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAsync(&self) -> windows_core::Result { + pub fn DeleteAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeleteAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FindChildFoldersAsync(&self) -> windows_core::Result>> { + pub fn FindChildFoldersAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -521,7 +521,7 @@ impl EmailFolder { (windows_core::Interface::vtable(this).GetConversationReaderWithOptions)(windows_core::Interface::as_raw(this), options.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetMessageAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetMessageAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -545,14 +545,14 @@ impl EmailFolder { (windows_core::Interface::vtable(this).GetMessageReaderWithOptions)(windows_core::Interface::as_raw(this), options.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetMessageCountsAsync(&self) -> windows_core::Result> { + pub fn GetMessageCountsAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetMessageCountsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryMoveAsync(&self, newparentfolder: P0) -> windows_core::Result> + pub fn TryMoveAsync(&self, newparentfolder: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -562,7 +562,7 @@ impl EmailFolder { (windows_core::Interface::vtable(this).TryMoveAsync)(windows_core::Interface::as_raw(this), newparentfolder.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryMoveWithNewNameAsync(&self, newparentfolder: P0, newfoldername: &windows_core::HSTRING) -> windows_core::Result> + pub fn TryMoveWithNewNameAsync(&self, newparentfolder: P0, newfoldername: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -572,14 +572,14 @@ impl EmailFolder { (windows_core::Interface::vtable(this).TryMoveWithNewNameAsync)(windows_core::Interface::as_raw(this), newparentfolder.param().abi(), core::mem::transmute_copy(newfoldername), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TrySaveAsync(&self) -> windows_core::Result> { + pub fn TrySaveAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TrySaveAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SaveMessageAsync(&self, message: P0) -> windows_core::Result + pub fn SaveMessageAsync(&self, message: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -1056,112 +1056,112 @@ impl EmailMailbox { (windows_core::Interface::vtable(this).GetMessageReaderWithOptions)(windows_core::Interface::as_raw(this), options.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAsync(&self) -> windows_core::Result { + pub fn DeleteAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeleteAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetConversationAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetConversationAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetConversationAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(id), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetFolderAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetFolderAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFolderAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(id), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetMessageAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetMessageAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetMessageAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(id), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetSpecialFolderAsync(&self, foldertype: EmailSpecialFolderKind) -> windows_core::Result> { + pub fn GetSpecialFolderAsync(&self, foldertype: EmailSpecialFolderKind) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetSpecialFolderAsync)(windows_core::Interface::as_raw(this), foldertype, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SaveAsync(&self) -> windows_core::Result { + pub fn SaveAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).SaveAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn MarkMessageAsSeenAsync(&self, messageid: &windows_core::HSTRING) -> windows_core::Result { + pub fn MarkMessageAsSeenAsync(&self, messageid: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).MarkMessageAsSeenAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(messageid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn MarkFolderAsSeenAsync(&self, folderid: &windows_core::HSTRING) -> windows_core::Result { + pub fn MarkFolderAsSeenAsync(&self, folderid: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).MarkFolderAsSeenAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(folderid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn MarkMessageReadAsync(&self, messageid: &windows_core::HSTRING, isread: bool) -> windows_core::Result { + pub fn MarkMessageReadAsync(&self, messageid: &windows_core::HSTRING, isread: bool) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).MarkMessageReadAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(messageid), isread, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ChangeMessageFlagStateAsync(&self, messageid: &windows_core::HSTRING, flagstate: EmailFlagState) -> windows_core::Result { + pub fn ChangeMessageFlagStateAsync(&self, messageid: &windows_core::HSTRING, flagstate: EmailFlagState) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ChangeMessageFlagStateAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(messageid), flagstate, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryMoveMessageAsync(&self, messageid: &windows_core::HSTRING, newparentfolderid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn TryMoveMessageAsync(&self, messageid: &windows_core::HSTRING, newparentfolderid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryMoveMessageAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(messageid), core::mem::transmute_copy(newparentfolderid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryMoveFolderAsync(&self, folderid: &windows_core::HSTRING, newparentfolderid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn TryMoveFolderAsync(&self, folderid: &windows_core::HSTRING, newparentfolderid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryMoveFolderAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(folderid), core::mem::transmute_copy(newparentfolderid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryMoveFolderWithNewNameAsync(&self, folderid: &windows_core::HSTRING, newparentfolderid: &windows_core::HSTRING, newfoldername: &windows_core::HSTRING) -> windows_core::Result> { + pub fn TryMoveFolderWithNewNameAsync(&self, folderid: &windows_core::HSTRING, newparentfolderid: &windows_core::HSTRING, newfoldername: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryMoveFolderWithNewNameAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(folderid), core::mem::transmute_copy(newparentfolderid), core::mem::transmute_copy(newfoldername), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteMessageAsync(&self, messageid: &windows_core::HSTRING) -> windows_core::Result { + pub fn DeleteMessageAsync(&self, messageid: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeleteMessageAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(messageid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn MarkFolderSyncEnabledAsync(&self, folderid: &windows_core::HSTRING, issyncenabled: bool) -> windows_core::Result { + pub fn MarkFolderSyncEnabledAsync(&self, folderid: &windows_core::HSTRING, issyncenabled: bool) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).MarkFolderSyncEnabledAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(folderid), issyncenabled, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SendMessageAsync(&self, message: P0) -> windows_core::Result + pub fn SendMessageAsync(&self, message: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -1171,7 +1171,7 @@ impl EmailMailbox { (windows_core::Interface::vtable(this).SendMessageAsync)(windows_core::Interface::as_raw(this), message.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SaveDraftAsync(&self, message: P0) -> windows_core::Result + pub fn SaveDraftAsync(&self, message: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -1181,28 +1181,28 @@ impl EmailMailbox { (windows_core::Interface::vtable(this).SaveDraftAsync)(windows_core::Interface::as_raw(this), message.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DownloadMessageAsync(&self, messageid: &windows_core::HSTRING) -> windows_core::Result { + pub fn DownloadMessageAsync(&self, messageid: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DownloadMessageAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(messageid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DownloadAttachmentAsync(&self, attachmentid: &windows_core::HSTRING) -> windows_core::Result { + pub fn DownloadAttachmentAsync(&self, attachmentid: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DownloadAttachmentAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(attachmentid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateResponseMessageAsync(&self, messageid: &windows_core::HSTRING, responsetype: EmailMessageResponseKind, subject: &windows_core::HSTRING, responseheadertype: EmailMessageBodyKind, responseheader: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CreateResponseMessageAsync(&self, messageid: &windows_core::HSTRING, responsetype: EmailMessageResponseKind, subject: &windows_core::HSTRING, responseheadertype: EmailMessageBodyKind, responseheader: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreateResponseMessageAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(messageid), responsetype, core::mem::transmute_copy(subject), responseheadertype, core::mem::transmute_copy(responseheader), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryUpdateMeetingResponseAsync(&self, meeting: P0, response: EmailMeetingResponseType, subject: &windows_core::HSTRING, comment: &windows_core::HSTRING, sendupdate: bool) -> windows_core::Result> + pub fn TryUpdateMeetingResponseAsync(&self, meeting: P0, response: EmailMeetingResponseType, subject: &windows_core::HSTRING, comment: &windows_core::HSTRING, sendupdate: bool) -> windows_core::Result> where P0: windows_core::Param, { @@ -1212,7 +1212,7 @@ impl EmailMailbox { (windows_core::Interface::vtable(this).TryUpdateMeetingResponseAsync)(windows_core::Interface::as_raw(this), meeting.param().abi(), response, core::mem::transmute_copy(subject), core::mem::transmute_copy(comment), sendupdate, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryForwardMeetingAsync(&self, meeting: P0, recipients: P1, subject: &windows_core::HSTRING, forwardheadertype: EmailMessageBodyKind, forwardheader: &windows_core::HSTRING, comment: &windows_core::HSTRING) -> windows_core::Result> + pub fn TryForwardMeetingAsync(&self, meeting: P0, recipients: P1, subject: &windows_core::HSTRING, forwardheadertype: EmailMessageBodyKind, forwardheader: &windows_core::HSTRING, comment: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param>, @@ -1223,7 +1223,7 @@ impl EmailMailbox { (windows_core::Interface::vtable(this).TryForwardMeetingAsync)(windows_core::Interface::as_raw(this), meeting.param().abi(), recipients.param().abi(), core::mem::transmute_copy(subject), forwardheadertype, core::mem::transmute_copy(forwardheader), core::mem::transmute_copy(comment), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryProposeNewTimeForMeetingAsync(&self, meeting: P0, newstarttime: super::super::Foundation::DateTime, newduration: super::super::Foundation::TimeSpan, subject: &windows_core::HSTRING, comment: &windows_core::HSTRING) -> windows_core::Result> + pub fn TryProposeNewTimeForMeetingAsync(&self, meeting: P0, newstarttime: super::super::Foundation::DateTime, newduration: super::super::Foundation::TimeSpan, subject: &windows_core::HSTRING, comment: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -1247,7 +1247,7 @@ impl EmailMailbox { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveMailboxChanged)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn SmartSendMessageAsync(&self, message: P0, smartsend: bool) -> windows_core::Result + pub fn SmartSendMessageAsync(&self, message: P0, smartsend: bool) -> windows_core::Result where P0: windows_core::Param, { @@ -1257,7 +1257,7 @@ impl EmailMailbox { (windows_core::Interface::vtable(this).SmartSendMessageAsync)(windows_core::Interface::as_raw(this), message.param().abi(), smartsend, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TrySetAutoReplySettingsAsync(&self, autoreplysettings: P0) -> windows_core::Result> + pub fn TrySetAutoReplySettingsAsync(&self, autoreplysettings: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1267,7 +1267,7 @@ impl EmailMailbox { (windows_core::Interface::vtable(this).TrySetAutoReplySettingsAsync)(windows_core::Interface::as_raw(this), autoreplysettings.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryGetAutoReplySettingsAsync(&self, requestedformat: EmailMailboxAutoReplyMessageResponseKind) -> windows_core::Result> { + pub fn TryGetAutoReplySettingsAsync(&self, requestedformat: EmailMailboxAutoReplyMessageResponseKind) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1295,7 +1295,7 @@ impl EmailMailbox { (windows_core::Interface::vtable(this).NetworkId)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn ResolveRecipientsAsync(&self, recipients: P0) -> windows_core::Result>> + pub fn ResolveRecipientsAsync(&self, recipients: P0) -> windows_core::Result>> where P0: windows_core::Param>, { @@ -1306,7 +1306,7 @@ impl EmailMailbox { } } #[cfg(feature = "Security_Cryptography_Certificates")] - pub fn ValidateCertificatesAsync(&self, certificates: P0) -> windows_core::Result>> + pub fn ValidateCertificatesAsync(&self, certificates: P0) -> windows_core::Result>> where P0: windows_core::Param>, { @@ -1316,28 +1316,28 @@ impl EmailMailbox { (windows_core::Interface::vtable(this).ValidateCertificatesAsync)(windows_core::Interface::as_raw(this), certificates.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryEmptyFolderAsync(&self, folderid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn TryEmptyFolderAsync(&self, folderid: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryEmptyFolderAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(folderid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryCreateFolderAsync(&self, parentfolderid: &windows_core::HSTRING, name: &windows_core::HSTRING) -> windows_core::Result> { + pub fn TryCreateFolderAsync(&self, parentfolderid: &windows_core::HSTRING, name: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryCreateFolderAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(parentfolderid), core::mem::transmute_copy(name), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryDeleteFolderAsync(&self, folderid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn TryDeleteFolderAsync(&self, folderid: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryDeleteFolderAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(folderid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RegisterSyncManagerAsync(&self) -> windows_core::Result { + pub fn RegisterSyncManagerAsync(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1815,7 +1815,7 @@ impl EmailMailboxChangeReader { let this = self; unsafe { (windows_core::Interface::vtable(this).AcceptChangesThrough)(windows_core::Interface::as_raw(this), lastchangetoacknowledge.param().abi()).ok() } } - pub fn ReadBatchAsync(&self) -> windows_core::Result>> { + pub fn ReadBatchAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2198,7 +2198,7 @@ impl EmailMailboxSyncManager { (windows_core::Interface::vtable(this).LastAttemptedSyncTime)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn SyncAsync(&self) -> windows_core::Result> { + pub fn SyncAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2264,7 +2264,7 @@ impl windows_core::RuntimeType for EmailMailboxSyncStatus { } pub struct EmailManager; impl EmailManager { - pub fn ShowComposeNewEmailAsync(message: P0) -> windows_core::Result + pub fn ShowComposeNewEmailAsync(message: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -2273,7 +2273,7 @@ impl EmailManager { (windows_core::Interface::vtable(this).ShowComposeNewEmailAsync)(windows_core::Interface::as_raw(this), message.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RequestStoreAsync(accesstype: EmailStoreAccessType) -> windows_core::Result> { + pub fn RequestStoreAsync(accesstype: EmailStoreAccessType) -> windows_core::Result> { Self::IEmailManagerStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestStoreAsync)(windows_core::Interface::as_raw(this), accesstype, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -2310,7 +2310,7 @@ impl windows_core::RuntimeName for EmailManager { pub struct EmailManagerForUser(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(EmailManagerForUser, windows_core::IUnknown, windows_core::IInspectable); impl EmailManagerForUser { - pub fn ShowComposeNewEmailAsync(&self, message: P0) -> windows_core::Result + pub fn ShowComposeNewEmailAsync(&self, message: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -2320,7 +2320,7 @@ impl EmailManagerForUser { (windows_core::Interface::vtable(this).ShowComposeNewEmailAsync)(windows_core::Interface::as_raw(this), message.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestStoreAsync(&self, accesstype: EmailStoreAccessType) -> windows_core::Result> { + pub fn RequestStoreAsync(&self, accesstype: EmailStoreAccessType) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -3023,7 +3023,7 @@ impl windows_core::RuntimeType for EmailMessageDownloadState { pub struct EmailMessageReader(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(EmailMessageReader, windows_core::IUnknown, windows_core::IInspectable); impl EmailMessageReader { - pub fn ReadBatchAsync(&self) -> windows_core::Result> { + pub fn ReadBatchAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -3474,7 +3474,7 @@ impl windows_core::RuntimeType for EmailSpecialFolderKind { pub struct EmailStore(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(EmailStore, windows_core::IUnknown, windows_core::IInspectable); impl EmailStore { - pub fn FindMailboxesAsync(&self) -> windows_core::Result>> { + pub fn FindMailboxesAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -3515,42 +3515,42 @@ impl EmailStore { (windows_core::Interface::vtable(this).GetMessageReaderWithOptions)(windows_core::Interface::as_raw(this), options.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetMailboxAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetMailboxAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetMailboxAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(id), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetConversationAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetConversationAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetConversationAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(id), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetFolderAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetFolderAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFolderAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(id), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetMessageAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetMessageAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetMessageAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(id), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateMailboxAsync(&self, accountname: &windows_core::HSTRING, accountaddress: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CreateMailboxAsync(&self, accountname: &windows_core::HSTRING, accountaddress: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreateMailboxAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(accountname), core::mem::transmute_copy(accountaddress), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateMailboxInAccountAsync(&self, accountname: &windows_core::HSTRING, accountaddress: &windows_core::HSTRING, userdataaccountid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CreateMailboxInAccountAsync(&self, accountname: &windows_core::HSTRING, accountaddress: &windows_core::HSTRING, userdataaccountid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/ApplicationModel/ExtendedExecution/Foreground/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/ExtendedExecution/Foreground/mod.rs index 71e98857e2..23bd4a8210 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/ExtendedExecution/Foreground/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/ExtendedExecution/Foreground/mod.rs @@ -106,7 +106,7 @@ impl ExtendedExecutionForegroundSession { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveRevoked)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn RequestExtensionAsync(&self) -> windows_core::Result> { + pub fn RequestExtensionAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/ApplicationModel/ExtendedExecution/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/ExtendedExecution/mod.rs index c9a49aa5a5..072af0fa81 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/ExtendedExecution/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/ExtendedExecution/mod.rs @@ -129,7 +129,7 @@ impl ExtendedExecutionSession { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveRevoked)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn RequestExtensionAsync(&self) -> windows_core::Result> { + pub fn RequestExtensionAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/ApplicationModel/PackageExtensions/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/PackageExtensions/mod.rs index d665ec1307..436d48d419 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/PackageExtensions/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/PackageExtensions/mod.rs @@ -151,7 +151,7 @@ impl PackageExtension { } } #[cfg(feature = "Foundation_Collections")] - pub fn GetExtensionPropertiesAsync(&self) -> windows_core::Result> { + pub fn GetExtensionPropertiesAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -174,7 +174,7 @@ impl PackageExtension { } } #[cfg(feature = "Storage_Search")] - pub fn GetPublicFolderAsync(&self) -> windows_core::Result> { + pub fn GetPublicFolderAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -206,14 +206,14 @@ impl PackageExtensionCatalog { (windows_core::Interface::vtable(this).FindAll)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FindAllAsync(&self) -> windows_core::Result>> { + pub fn FindAllAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAllAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestRemovePackageAsync(&self, packagefullname: &windows_core::HSTRING) -> windows_core::Result> { + pub fn RequestRemovePackageAsync(&self, packagefullname: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/ApplicationModel/Payments/Provider/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/Payments/Provider/mod.rs index 9c6ea6ef18..80be2990a8 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/Payments/Provider/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/Payments/Provider/mod.rs @@ -101,7 +101,7 @@ unsafe impl Sync for PaymentAppCanMakePaymentTriggerDetails {} pub struct PaymentAppManager(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(PaymentAppManager, windows_core::IUnknown, windows_core::IInspectable); impl PaymentAppManager { - pub fn RegisterAsync(&self, supportedpaymentmethodids: P0) -> windows_core::Result + pub fn RegisterAsync(&self, supportedpaymentmethodids: P0) -> windows_core::Result where P0: windows_core::Param>, { @@ -111,7 +111,7 @@ impl PaymentAppManager { (windows_core::Interface::vtable(this).RegisterAsync)(windows_core::Interface::as_raw(this), supportedpaymentmethodids.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn UnregisterAsync(&self) -> windows_core::Result { + pub fn UnregisterAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -186,7 +186,7 @@ impl PaymentTransaction { let this = self; unsafe { (windows_core::Interface::vtable(this).SetPayerPhoneNumber)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(value)).ok() } } - pub fn UpdateShippingAddressAsync(&self, shippingaddress: P0) -> windows_core::Result> + pub fn UpdateShippingAddressAsync(&self, shippingaddress: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -196,7 +196,7 @@ impl PaymentTransaction { (windows_core::Interface::vtable(this).UpdateShippingAddressAsync)(windows_core::Interface::as_raw(this), shippingaddress.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn UpdateSelectedShippingOptionAsync(&self, selectedshippingoption: P0) -> windows_core::Result> + pub fn UpdateSelectedShippingOptionAsync(&self, selectedshippingoption: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -206,7 +206,7 @@ impl PaymentTransaction { (windows_core::Interface::vtable(this).UpdateSelectedShippingOptionAsync)(windows_core::Interface::as_raw(this), selectedshippingoption.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn AcceptAsync(&self, paymenttoken: P0) -> windows_core::Result> + pub fn AcceptAsync(&self, paymenttoken: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -220,7 +220,7 @@ impl PaymentTransaction { let this = self; unsafe { (windows_core::Interface::vtable(this).Reject)(windows_core::Interface::as_raw(this)).ok() } } - pub fn FromIdAsync(id: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(id: &windows_core::HSTRING) -> windows_core::Result> { Self::IPaymentTransactionStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(id), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/ApplicationModel/Payments/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/Payments/mod.rs index 399d5a23aa..60c1bc57f6 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/Payments/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/Payments/mod.rs @@ -916,14 +916,14 @@ impl PaymentMediator { static SHARED: windows_core::imp::FactoryCache = windows_core::imp::FactoryCache::new(); SHARED.call(callback) } - pub fn GetSupportedMethodIdsAsync(&self) -> windows_core::Result>> { + pub fn GetSupportedMethodIdsAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetSupportedMethodIdsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SubmitPaymentRequestAsync(&self, paymentrequest: P0) -> windows_core::Result> + pub fn SubmitPaymentRequestAsync(&self, paymentrequest: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -933,7 +933,7 @@ impl PaymentMediator { (windows_core::Interface::vtable(this).SubmitPaymentRequestAsync)(windows_core::Interface::as_raw(this), paymentrequest.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SubmitPaymentRequestWithChangeHandlerAsync(&self, paymentrequest: P0, changehandler: P1) -> windows_core::Result> + pub fn SubmitPaymentRequestWithChangeHandlerAsync(&self, paymentrequest: P0, changehandler: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -944,7 +944,7 @@ impl PaymentMediator { (windows_core::Interface::vtable(this).SubmitPaymentRequestWithChangeHandlerAsync)(windows_core::Interface::as_raw(this), paymentrequest.param().abi(), changehandler.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CanMakePaymentAsync(&self, paymentrequest: P0) -> windows_core::Result> + pub fn CanMakePaymentAsync(&self, paymentrequest: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1581,7 +1581,7 @@ impl PaymentResponse { (windows_core::Interface::vtable(this).PayerPhoneNumber)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn CompleteAsync(&self, status: PaymentRequestCompletionStatus) -> windows_core::Result { + pub fn CompleteAsync(&self, status: PaymentRequestCompletionStatus) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/ApplicationModel/Preview/InkWorkspace/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/Preview/InkWorkspace/mod.rs index 16d96eb32a..aff45f078c 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/Preview/InkWorkspace/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/Preview/InkWorkspace/mod.rs @@ -25,7 +25,7 @@ pub struct InkWorkspaceHostedAppManager(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(InkWorkspaceHostedAppManager, windows_core::IUnknown, windows_core::IInspectable); impl InkWorkspaceHostedAppManager { #[cfg(feature = "Graphics_Imaging")] - pub fn SetThumbnailAsync(&self, bitmap: P0) -> windows_core::Result + pub fn SetThumbnailAsync(&self, bitmap: P0) -> windows_core::Result where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/ApplicationModel/Preview/Notes/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/Preview/Notes/mod.rs index 8a9e69601a..bf6c8f8a28 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/Preview/Notes/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/Preview/Notes/mod.rs @@ -195,7 +195,7 @@ impl NotesWindowManagerPreview { unsafe { (windows_core::Interface::vtable(this).SetFocusToNextView)(windows_core::Interface::as_raw(this)).ok() } } #[cfg(feature = "Storage_Streams")] - pub fn SetNotesThumbnailAsync(&self, thumbnail: P0) -> windows_core::Result + pub fn SetNotesThumbnailAsync(&self, thumbnail: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -268,7 +268,7 @@ impl NotesWindowManagerPreview { unsafe { (windows_core::Interface::vtable(this).SetFocusToPreviousView)(windows_core::Interface::as_raw(this)).ok() } } #[cfg(feature = "Graphics_Imaging")] - pub fn SetThumbnailImageForTaskSwitcherAsync(&self, bitmap: P0) -> windows_core::Result + pub fn SetThumbnailImageForTaskSwitcherAsync(&self, bitmap: P0) -> windows_core::Result where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/ApplicationModel/Resources/Core/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/Resources/Core/mod.rs index 072b37c523..1c2d4e0507 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/Resources/Core/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/Resources/Core/mod.rs @@ -283,7 +283,7 @@ impl ResourceCandidate { } } #[cfg(feature = "Storage_Streams")] - pub fn GetValueAsFileAsync(&self) -> windows_core::Result> { + pub fn GetValueAsFileAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -298,7 +298,7 @@ impl ResourceCandidate { } } #[cfg(feature = "Storage_Streams")] - pub fn GetValueAsStreamAsync(&self) -> windows_core::Result> { + pub fn GetValueAsStreamAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/ApplicationModel/Resources/Management/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/Resources/Management/mod.rs index d00b8d9d32..c7506b5380 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/Resources/Management/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/Resources/Management/mod.rs @@ -183,7 +183,7 @@ impl ResourceIndexer { (windows_core::Interface::vtable(this).IndexFilePath)(windows_core::Interface::as_raw(this), filepath.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn IndexFileContentsAsync(&self, file: P0) -> windows_core::Result>> + pub fn IndexFileContentsAsync(&self, file: P0) -> windows_core::Result>> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/ApplicationModel/UserActivities/Core/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/UserActivities/Core/mod.rs index dbcba434cd..941a9ed3c5 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/UserActivities/Core/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/UserActivities/Core/mod.rs @@ -9,7 +9,7 @@ impl CoreUserActivityManager { (windows_core::Interface::vtable(this).CreateUserActivitySessionInBackground)(windows_core::Interface::as_raw(this), activity.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn DeleteUserActivitySessionsInTimeRangeAsync(channel: P0, starttime: super::super::super::Foundation::DateTime, endtime: super::super::super::Foundation::DateTime) -> windows_core::Result + pub fn DeleteUserActivitySessionsInTimeRangeAsync(channel: P0, starttime: super::super::super::Foundation::DateTime, endtime: super::super::super::Foundation::DateTime) -> windows_core::Result where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/ApplicationModel/UserActivities/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/UserActivities/mod.rs index 50d5627307..2692960e24 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/UserActivities/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/UserActivities/mod.rs @@ -386,7 +386,7 @@ impl UserActivity { let this = self; unsafe { (windows_core::Interface::vtable(this).SetContentInfo)(windows_core::Interface::as_raw(this), value.param().abi()).ok() } } - pub fn SaveAsync(&self) -> windows_core::Result { + pub fn SaveAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -545,35 +545,35 @@ unsafe impl Sync for UserActivityAttribution {} pub struct UserActivityChannel(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(UserActivityChannel, windows_core::IUnknown, windows_core::IInspectable); impl UserActivityChannel { - pub fn GetOrCreateUserActivityAsync(&self, activityid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetOrCreateUserActivityAsync(&self, activityid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetOrCreateUserActivityAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(activityid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteActivityAsync(&self, activityid: &windows_core::HSTRING) -> windows_core::Result { + pub fn DeleteActivityAsync(&self, activityid: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeleteActivityAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(activityid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAllActivitiesAsync(&self) -> windows_core::Result { + pub fn DeleteAllActivitiesAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeleteAllActivitiesAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetRecentUserActivitiesAsync(&self, maxuniqueactivities: i32) -> windows_core::Result>> { + pub fn GetRecentUserActivitiesAsync(&self, maxuniqueactivities: i32) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetRecentUserActivitiesAsync)(windows_core::Interface::as_raw(this), maxuniqueactivities, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetSessionHistoryItemsForUserActivityAsync(&self, activityid: &windows_core::HSTRING, starttime: super::super::Foundation::DateTime) -> windows_core::Result>> { + pub fn GetSessionHistoryItemsForUserActivityAsync(&self, activityid: &windows_core::HSTRING, starttime: super::super::Foundation::DateTime) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/ApplicationModel/UserDataAccounts/SystemAccess/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/UserDataAccounts/SystemAccess/mod.rs index 4ff59b0e92..9106b617c5 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/UserDataAccounts/SystemAccess/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/UserDataAccounts/SystemAccess/mod.rs @@ -744,7 +744,7 @@ pub struct IUserDataAccountSystemAccessManagerStatics2_Vtbl { } pub struct UserDataAccountSystemAccessManager; impl UserDataAccountSystemAccessManager { - pub fn AddAndShowDeviceAccountsAsync(accounts: P0) -> windows_core::Result>> + pub fn AddAndShowDeviceAccountsAsync(accounts: P0) -> windows_core::Result>> where P0: windows_core::Param>, { @@ -753,13 +753,13 @@ impl UserDataAccountSystemAccessManager { (windows_core::Interface::vtable(this).AddAndShowDeviceAccountsAsync)(windows_core::Interface::as_raw(this), accounts.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn SuppressLocalAccountWithAccountAsync(userdataaccountid: &windows_core::HSTRING) -> windows_core::Result { + pub fn SuppressLocalAccountWithAccountAsync(userdataaccountid: &windows_core::HSTRING) -> windows_core::Result { Self::IUserDataAccountSystemAccessManagerStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).SuppressLocalAccountWithAccountAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(userdataaccountid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn CreateDeviceAccountAsync(account: P0) -> windows_core::Result> + pub fn CreateDeviceAccountAsync(account: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -768,13 +768,13 @@ impl UserDataAccountSystemAccessManager { (windows_core::Interface::vtable(this).CreateDeviceAccountAsync)(windows_core::Interface::as_raw(this), account.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn DeleteDeviceAccountAsync(accountid: &windows_core::HSTRING) -> windows_core::Result { + pub fn DeleteDeviceAccountAsync(accountid: &windows_core::HSTRING) -> windows_core::Result { Self::IUserDataAccountSystemAccessManagerStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeleteDeviceAccountAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(accountid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetDeviceAccountConfigurationAsync(accountid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetDeviceAccountConfigurationAsync(accountid: &windows_core::HSTRING) -> windows_core::Result> { Self::IUserDataAccountSystemAccessManagerStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetDeviceAccountConfigurationAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(accountid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/ApplicationModel/UserDataAccounts/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/UserDataAccounts/mod.rs index 6714cae3fc..7382349611 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/UserDataAccounts/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/UserDataAccounts/mod.rs @@ -221,14 +221,14 @@ impl UserDataAccount { (windows_core::Interface::vtable(this).PackageFamilyName)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn SaveAsync(&self) -> windows_core::Result { + pub fn SaveAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).SaveAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAsync(&self) -> windows_core::Result { + pub fn DeleteAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -236,7 +236,7 @@ impl UserDataAccount { } } #[cfg(feature = "ApplicationModel_Appointments")] - pub fn FindAppointmentCalendarsAsync(&self) -> windows_core::Result>> { + pub fn FindAppointmentCalendarsAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -244,7 +244,7 @@ impl UserDataAccount { } } #[cfg(feature = "ApplicationModel_Email")] - pub fn FindEmailMailboxesAsync(&self) -> windows_core::Result>> { + pub fn FindEmailMailboxesAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -252,7 +252,7 @@ impl UserDataAccount { } } #[cfg(feature = "ApplicationModel_Contacts")] - pub fn FindContactListsAsync(&self) -> windows_core::Result>> { + pub fn FindContactListsAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -260,7 +260,7 @@ impl UserDataAccount { } } #[cfg(feature = "ApplicationModel_Contacts")] - pub fn FindContactAnnotationListsAsync(&self) -> windows_core::Result>> { + pub fn FindContactAnnotationListsAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -319,7 +319,7 @@ impl UserDataAccount { } } #[cfg(feature = "ApplicationModel_UserDataTasks")] - pub fn FindUserDataTaskListsAsync(&self) -> windows_core::Result>> { + pub fn FindUserDataTaskListsAsync(&self) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -327,14 +327,14 @@ impl UserDataAccount { } } #[cfg(feature = "ApplicationModel_Contacts")] - pub fn FindContactGroupsAsync(&self) -> windows_core::Result>> { + pub fn FindContactGroupsAsync(&self) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindContactGroupsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryShowCreateContactGroupAsync(&self) -> windows_core::Result> { + pub fn TryShowCreateContactGroupAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -415,25 +415,25 @@ impl core::ops::Not for UserDataAccountContentKinds { } pub struct UserDataAccountManager; impl UserDataAccountManager { - pub fn RequestStoreAsync(storeaccesstype: UserDataAccountStoreAccessType) -> windows_core::Result> { + pub fn RequestStoreAsync(storeaccesstype: UserDataAccountStoreAccessType) -> windows_core::Result> { Self::IUserDataAccountManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestStoreAsync)(windows_core::Interface::as_raw(this), storeaccesstype, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn ShowAddAccountAsync(contentkinds: UserDataAccountContentKinds) -> windows_core::Result> { + pub fn ShowAddAccountAsync(contentkinds: UserDataAccountContentKinds) -> windows_core::Result> { Self::IUserDataAccountManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ShowAddAccountAsync)(windows_core::Interface::as_raw(this), contentkinds, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn ShowAccountSettingsAsync(id: &windows_core::HSTRING) -> windows_core::Result { + pub fn ShowAccountSettingsAsync(id: &windows_core::HSTRING) -> windows_core::Result { Self::IUserDataAccountManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ShowAccountSettingsAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(id), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn ShowAccountErrorResolverAsync(id: &windows_core::HSTRING) -> windows_core::Result { + pub fn ShowAccountErrorResolverAsync(id: &windows_core::HSTRING) -> windows_core::Result { Self::IUserDataAccountManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ShowAccountErrorResolverAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(id), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -466,7 +466,7 @@ impl windows_core::RuntimeName for UserDataAccountManager { pub struct UserDataAccountManagerForUser(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(UserDataAccountManagerForUser, windows_core::IUnknown, windows_core::IInspectable); impl UserDataAccountManagerForUser { - pub fn RequestStoreAsync(&self, storeaccesstype: UserDataAccountStoreAccessType) -> windows_core::Result> { + pub fn RequestStoreAsync(&self, storeaccesstype: UserDataAccountStoreAccessType) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -513,28 +513,28 @@ impl windows_core::RuntimeType for UserDataAccountOtherAppReadAccess { pub struct UserDataAccountStore(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(UserDataAccountStore, windows_core::IUnknown, windows_core::IInspectable); impl UserDataAccountStore { - pub fn FindAccountsAsync(&self) -> windows_core::Result>> { + pub fn FindAccountsAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAccountsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAccountAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetAccountAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetAccountAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(id), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateAccountAsync(&self, userdisplayname: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CreateAccountAsync(&self, userdisplayname: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreateAccountAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(userdisplayname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateAccountWithPackageRelativeAppIdAsync(&self, userdisplayname: &windows_core::HSTRING, packagerelativeappid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CreateAccountWithPackageRelativeAppIdAsync(&self, userdisplayname: &windows_core::HSTRING, packagerelativeappid: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -555,7 +555,7 @@ impl UserDataAccountStore { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).RemoveStoreChanged)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn CreateAccountWithPackageRelativeAppIdAndEnterpriseIdAsync(&self, userdisplayname: &windows_core::HSTRING, packagerelativeappid: &windows_core::HSTRING, enterpriseid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CreateAccountWithPackageRelativeAppIdAndEnterpriseIdAsync(&self, userdisplayname: &windows_core::HSTRING, packagerelativeappid: &windows_core::HSTRING, enterpriseid: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/ApplicationModel/UserDataTasks/DataProvider/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/UserDataTasks/DataProvider/mod.rs index c8dbd1afcc..5a2f7f86e3 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/UserDataTasks/DataProvider/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/UserDataTasks/DataProvider/mod.rs @@ -271,14 +271,14 @@ impl UserDataTaskListCompleteTaskRequest { (windows_core::Interface::vtable(this).TaskId)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn ReportCompletedAsync(&self, completedtaskid: &windows_core::HSTRING) -> windows_core::Result { + pub fn ReportCompletedAsync(&self, completedtaskid: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(completedtaskid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -349,7 +349,7 @@ impl UserDataTaskListCreateOrUpdateTaskRequest { (windows_core::Interface::vtable(this).Task)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportCompletedAsync(&self, createdorupdateduserdatatask: P0) -> windows_core::Result + pub fn ReportCompletedAsync(&self, createdorupdateduserdatatask: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -359,7 +359,7 @@ impl UserDataTaskListCreateOrUpdateTaskRequest { (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), createdorupdateduserdatatask.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -430,14 +430,14 @@ impl UserDataTaskListDeleteTaskRequest { (windows_core::Interface::vtable(this).TaskId)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn ReportCompletedAsync(&self) -> windows_core::Result { + pub fn ReportCompletedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -508,14 +508,14 @@ impl UserDataTaskListSkipOccurrenceRequest { (windows_core::Interface::vtable(this).TaskId)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn ReportCompletedAsync(&self) -> windows_core::Result { + pub fn ReportCompletedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -579,14 +579,14 @@ impl UserDataTaskListSyncManagerSyncRequest { (windows_core::Interface::vtable(this).TaskListId)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn ReportCompletedAsync(&self) -> windows_core::Result { + pub fn ReportCompletedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/ApplicationModel/UserDataTasks/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/UserDataTasks/mod.rs index 00728b4633..05a18ab43a 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/UserDataTasks/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/UserDataTasks/mod.rs @@ -572,7 +572,7 @@ impl UserDataTaskList { (windows_core::Interface::vtable(this).SyncManager)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RegisterSyncManagerAsync(&self) -> windows_core::Result { + pub fn RegisterSyncManagerAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -596,14 +596,14 @@ impl UserDataTaskList { (windows_core::Interface::vtable(this).GetTaskReaderWithOptions)(windows_core::Interface::as_raw(this), options.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetTaskAsync(&self, userdatatask: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetTaskAsync(&self, userdatatask: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetTaskAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(userdatatask), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SaveTaskAsync(&self, userdatatask: P0) -> windows_core::Result + pub fn SaveTaskAsync(&self, userdatatask: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -613,21 +613,21 @@ impl UserDataTaskList { (windows_core::Interface::vtable(this).SaveTaskAsync)(windows_core::Interface::as_raw(this), userdatatask.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteTaskAsync(&self, userdatataskid: &windows_core::HSTRING) -> windows_core::Result { + pub fn DeleteTaskAsync(&self, userdatataskid: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeleteTaskAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(userdatataskid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAsync(&self) -> windows_core::Result { + pub fn DeleteAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeleteAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SaveAsync(&self) -> windows_core::Result { + pub fn SaveAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -652,14 +652,14 @@ unsafe impl Sync for UserDataTaskList {} pub struct UserDataTaskListLimitedWriteOperations(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(UserDataTaskListLimitedWriteOperations, windows_core::IUnknown, windows_core::IInspectable); impl UserDataTaskListLimitedWriteOperations { - pub fn TryCompleteTaskAsync(&self, userdatataskid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn TryCompleteTaskAsync(&self, userdatataskid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryCompleteTaskAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(userdatataskid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryCreateOrUpdateTaskAsync(&self, userdatatask: P0) -> windows_core::Result> + pub fn TryCreateOrUpdateTaskAsync(&self, userdatatask: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -669,14 +669,14 @@ impl UserDataTaskListLimitedWriteOperations { (windows_core::Interface::vtable(this).TryCreateOrUpdateTaskAsync)(windows_core::Interface::as_raw(this), userdatatask.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryDeleteTaskAsync(&self, userdatataskid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn TryDeleteTaskAsync(&self, userdatataskid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryDeleteTaskAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(userdatataskid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TrySkipOccurrenceAsync(&self, userdatataskid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn TrySkipOccurrenceAsync(&self, userdatataskid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -761,7 +761,7 @@ impl UserDataTaskListSyncManager { let this = self; unsafe { (windows_core::Interface::vtable(this).SetStatus)(windows_core::Interface::as_raw(this), value).ok() } } - pub fn SyncAsync(&self) -> windows_core::Result> { + pub fn SyncAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -817,7 +817,7 @@ impl windows_core::RuntimeType for UserDataTaskListSyncStatus { pub struct UserDataTaskManager(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(UserDataTaskManager, windows_core::IUnknown, windows_core::IInspectable); impl UserDataTaskManager { - pub fn RequestStoreAsync(&self, accesstype: UserDataTaskStoreAccessType) -> windows_core::Result> { + pub fn RequestStoreAsync(&self, accesstype: UserDataTaskStoreAccessType) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -957,7 +957,7 @@ impl windows_core::RuntimeType for UserDataTaskQuerySortProperty { pub struct UserDataTaskReader(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(UserDataTaskReader, windows_core::IUnknown, windows_core::IInspectable); impl UserDataTaskReader { - pub fn ReadBatchAsync(&self) -> windows_core::Result> { + pub fn ReadBatchAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1233,28 +1233,28 @@ impl windows_core::RuntimeType for UserDataTaskSensitivity { pub struct UserDataTaskStore(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(UserDataTaskStore, windows_core::IUnknown, windows_core::IInspectable); impl UserDataTaskStore { - pub fn CreateListAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CreateListAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreateListAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(name), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateListInAccountAsync(&self, name: &windows_core::HSTRING, userdataaccountid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CreateListInAccountAsync(&self, name: &windows_core::HSTRING, userdataaccountid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreateListInAccountAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(name), core::mem::transmute_copy(userdataaccountid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FindListsAsync(&self) -> windows_core::Result>> { + pub fn FindListsAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindListsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetListAsync(&self, tasklistid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetListAsync(&self, tasklistid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/ApplicationModel/VoiceCommands/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/VoiceCommands/mod.rs index c24e5984ed..039ca1801d 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/VoiceCommands/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/VoiceCommands/mod.rs @@ -433,7 +433,7 @@ impl VoiceCommandDefinition { (windows_core::Interface::vtable(this).Name)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn SetPhraseListAsync(&self, phraselistname: &windows_core::HSTRING, phraselist: P1) -> windows_core::Result + pub fn SetPhraseListAsync(&self, phraselistname: &windows_core::HSTRING, phraselist: P1) -> windows_core::Result where P1: windows_core::Param>, { @@ -459,7 +459,7 @@ unsafe impl Sync for VoiceCommandDefinition {} pub struct VoiceCommandDefinitionManager; impl VoiceCommandDefinitionManager { #[cfg(feature = "Storage_Streams")] - pub fn InstallCommandDefinitionsFromStorageFileAsync(file: P0) -> windows_core::Result + pub fn InstallCommandDefinitionsFromStorageFileAsync(file: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -626,14 +626,14 @@ unsafe impl Sync for VoiceCommandResponse {} pub struct VoiceCommandServiceConnection(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(VoiceCommandServiceConnection, windows_core::IUnknown, windows_core::IInspectable); impl VoiceCommandServiceConnection { - pub fn GetVoiceCommandAsync(&self) -> windows_core::Result> { + pub fn GetVoiceCommandAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetVoiceCommandAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestConfirmationAsync(&self, response: P0) -> windows_core::Result> + pub fn RequestConfirmationAsync(&self, response: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -643,7 +643,7 @@ impl VoiceCommandServiceConnection { (windows_core::Interface::vtable(this).RequestConfirmationAsync)(windows_core::Interface::as_raw(this), response.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestDisambiguationAsync(&self, response: P0) -> windows_core::Result> + pub fn RequestDisambiguationAsync(&self, response: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -653,7 +653,7 @@ impl VoiceCommandServiceConnection { (windows_core::Interface::vtable(this).RequestDisambiguationAsync)(windows_core::Interface::as_raw(this), response.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportProgressAsync(&self, response: P0) -> windows_core::Result + pub fn ReportProgressAsync(&self, response: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -663,7 +663,7 @@ impl VoiceCommandServiceConnection { (windows_core::Interface::vtable(this).ReportProgressAsync)(windows_core::Interface::as_raw(this), response.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportSuccessAsync(&self, response: P0) -> windows_core::Result + pub fn ReportSuccessAsync(&self, response: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -673,7 +673,7 @@ impl VoiceCommandServiceConnection { (windows_core::Interface::vtable(this).ReportSuccessAsync)(windows_core::Interface::as_raw(this), response.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailureAsync(&self, response: P0) -> windows_core::Result + pub fn ReportFailureAsync(&self, response: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -683,7 +683,7 @@ impl VoiceCommandServiceConnection { (windows_core::Interface::vtable(this).ReportFailureAsync)(windows_core::Interface::as_raw(this), response.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestAppLaunchAsync(&self, response: P0) -> windows_core::Result + pub fn RequestAppLaunchAsync(&self, response: P0) -> windows_core::Result where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/ApplicationModel/Wallet/System/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/Wallet/System/mod.rs index 4dd3fde841..46a05d7fba 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/Wallet/System/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/Wallet/System/mod.rs @@ -64,14 +64,14 @@ pub struct WalletItemSystemStore(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(WalletItemSystemStore, windows_core::IUnknown, windows_core::IInspectable); #[cfg(feature = "deprecated")] impl WalletItemSystemStore { - pub fn GetItemsAsync(&self) -> windows_core::Result>> { + pub fn GetItemsAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetItemsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAsync(&self, item: P0) -> windows_core::Result + pub fn DeleteAsync(&self, item: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -82,7 +82,7 @@ impl WalletItemSystemStore { } } #[cfg(feature = "Storage_Streams")] - pub fn ImportItemAsync(&self, stream: P0) -> windows_core::Result> + pub fn ImportItemAsync(&self, stream: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -102,7 +102,7 @@ impl WalletItemSystemStore { (windows_core::Interface::vtable(this).GetAppStatusForItem)(windows_core::Interface::as_raw(this), item.param().abi(), &mut result__).map(|| result__) } } - pub fn LaunchAppForItemAsync(&self, item: P0) -> windows_core::Result> + pub fn LaunchAppForItemAsync(&self, item: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -148,7 +148,7 @@ unsafe impl Sync for WalletItemSystemStore {} pub struct WalletManagerSystem; #[cfg(feature = "deprecated")] impl WalletManagerSystem { - pub fn RequestStoreAsync() -> windows_core::Result> { + pub fn RequestStoreAsync() -> windows_core::Result> { Self::IWalletManagerSystemStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestStoreAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/ApplicationModel/Wallet/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/Wallet/mod.rs index f02b781aa1..d5ba615857 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/Wallet/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/Wallet/mod.rs @@ -364,7 +364,7 @@ impl WalletBarcode { } } #[cfg(feature = "Storage_Streams")] - pub fn GetImageAsync(&self) -> windows_core::Result> { + pub fn GetImageAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -961,7 +961,7 @@ pub struct WalletItemStore(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(WalletItemStore, windows_core::IUnknown, windows_core::IInspectable); #[cfg(feature = "deprecated")] impl WalletItemStore { - pub fn AddAsync(&self, id: &windows_core::HSTRING, item: P1) -> windows_core::Result + pub fn AddAsync(&self, id: &windows_core::HSTRING, item: P1) -> windows_core::Result where P1: windows_core::Param, { @@ -971,28 +971,28 @@ impl WalletItemStore { (windows_core::Interface::vtable(this).AddAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(id), item.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ClearAsync(&self) -> windows_core::Result { + pub fn ClearAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ClearAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetWalletItemAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetWalletItemAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetWalletItemAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(id), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetItemsAsync(&self) -> windows_core::Result>> { + pub fn GetItemsAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetItemsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetItemsWithKindAsync(&self, kind: WalletItemKind) -> windows_core::Result>> { + pub fn GetItemsWithKindAsync(&self, kind: WalletItemKind) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1000,7 +1000,7 @@ impl WalletItemStore { } } #[cfg(feature = "Storage_Streams")] - pub fn ImportItemAsync(&self, stream: P0) -> windows_core::Result> + pub fn ImportItemAsync(&self, stream: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1010,28 +1010,28 @@ impl WalletItemStore { (windows_core::Interface::vtable(this).ImportItemAsync)(windows_core::Interface::as_raw(this), stream.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result { + pub fn DeleteAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeleteAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(id), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ShowAsync(&self) -> windows_core::Result { + pub fn ShowAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ShowAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ShowItemAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result { + pub fn ShowItemAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ShowItemAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(id), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn UpdateAsync(&self, item: P0) -> windows_core::Result + pub fn UpdateAsync(&self, item: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -1063,7 +1063,7 @@ unsafe impl Sync for WalletItemStore {} pub struct WalletManager; #[cfg(feature = "deprecated")] impl WalletManager { - pub fn RequestStoreAsync() -> windows_core::Result> { + pub fn RequestStoreAsync() -> windows_core::Result> { Self::IWalletManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestStoreAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/ApplicationModel/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/mod.rs index 5c003cafa1..19dfba567b 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/mod.rs @@ -651,37 +651,37 @@ unsafe impl Send for FullTrustProcessLaunchResult {} unsafe impl Sync for FullTrustProcessLaunchResult {} pub struct FullTrustProcessLauncher; impl FullTrustProcessLauncher { - pub fn LaunchFullTrustProcessForCurrentAppAsync() -> windows_core::Result { + pub fn LaunchFullTrustProcessForCurrentAppAsync() -> windows_core::Result { Self::IFullTrustProcessLauncherStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).LaunchFullTrustProcessForCurrentAppAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn LaunchFullTrustProcessForCurrentAppWithParametersAsync(parametergroupid: &windows_core::HSTRING) -> windows_core::Result { + pub fn LaunchFullTrustProcessForCurrentAppWithParametersAsync(parametergroupid: &windows_core::HSTRING) -> windows_core::Result { Self::IFullTrustProcessLauncherStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).LaunchFullTrustProcessForCurrentAppWithParametersAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(parametergroupid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn LaunchFullTrustProcessForAppAsync(fulltrustpackagerelativeappid: &windows_core::HSTRING) -> windows_core::Result { + pub fn LaunchFullTrustProcessForAppAsync(fulltrustpackagerelativeappid: &windows_core::HSTRING) -> windows_core::Result { Self::IFullTrustProcessLauncherStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).LaunchFullTrustProcessForAppAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(fulltrustpackagerelativeappid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn LaunchFullTrustProcessForAppWithParametersAsync(fulltrustpackagerelativeappid: &windows_core::HSTRING, parametergroupid: &windows_core::HSTRING) -> windows_core::Result { + pub fn LaunchFullTrustProcessForAppWithParametersAsync(fulltrustpackagerelativeappid: &windows_core::HSTRING, parametergroupid: &windows_core::HSTRING) -> windows_core::Result { Self::IFullTrustProcessLauncherStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).LaunchFullTrustProcessForAppWithParametersAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(fulltrustpackagerelativeappid), core::mem::transmute_copy(parametergroupid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn LaunchFullTrustProcessForCurrentAppWithArgumentsAsync(commandline: &windows_core::HSTRING) -> windows_core::Result> { + pub fn LaunchFullTrustProcessForCurrentAppWithArgumentsAsync(commandline: &windows_core::HSTRING) -> windows_core::Result> { Self::IFullTrustProcessLauncherStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).LaunchFullTrustProcessForCurrentAppWithArgumentsAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(commandline), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn LaunchFullTrustProcessForAppWithArgumentsAsync(fulltrustpackagerelativeappid: &windows_core::HSTRING, commandline: &windows_core::HSTRING) -> windows_core::Result> { + pub fn LaunchFullTrustProcessForAppWithArgumentsAsync(fulltrustpackagerelativeappid: &windows_core::HSTRING, commandline: &windows_core::HSTRING) -> windows_core::Result> { Self::IFullTrustProcessLauncherStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).LaunchFullTrustProcessForAppWithArgumentsAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(fulltrustpackagerelativeappid), core::mem::transmute_copy(commandline), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -1870,7 +1870,7 @@ impl Package { } } #[cfg(feature = "ApplicationModel_Core")] - pub fn GetAppListEntriesAsync(&self) -> windows_core::Result>> { + pub fn GetAppListEntriesAsync(&self) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1891,28 +1891,28 @@ impl Package { (windows_core::Interface::vtable(this).IsOptional)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn VerifyContentIntegrityAsync(&self) -> windows_core::Result> { + pub fn VerifyContentIntegrityAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).VerifyContentIntegrityAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetContentGroupsAsync(&self) -> windows_core::Result>> { + pub fn GetContentGroupsAsync(&self) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetContentGroupsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetContentGroupAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetContentGroupAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetContentGroupAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(name), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StageContentGroupsAsync(&self, names: P0) -> windows_core::Result>> + pub fn StageContentGroupsAsync(&self, names: P0) -> windows_core::Result>> where P0: windows_core::Param>, { @@ -1922,7 +1922,7 @@ impl Package { (windows_core::Interface::vtable(this).StageContentGroupsAsync)(windows_core::Interface::as_raw(this), names.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StageContentGroupsWithPriorityAsync(&self, names: P0, movetoheadofqueue: bool) -> windows_core::Result>> + pub fn StageContentGroupsWithPriorityAsync(&self, names: P0, movetoheadofqueue: bool) -> windows_core::Result>> where P0: windows_core::Param>, { @@ -1932,7 +1932,7 @@ impl Package { (windows_core::Interface::vtable(this).StageContentGroupsWithPriorityAsync)(windows_core::Interface::as_raw(this), names.param().abi(), movetoheadofqueue, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SetInUseAsync(&self, inuse: bool) -> windows_core::Result> { + pub fn SetInUseAsync(&self, inuse: bool) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1946,7 +1946,7 @@ impl Package { (windows_core::Interface::vtable(this).GetAppInstallerInfo)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CheckUpdateAvailabilityAsync(&self) -> windows_core::Result> { + pub fn CheckUpdateAvailabilityAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -2207,14 +2207,14 @@ impl PackageCatalog { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).RemovePackageContentGroupStaging)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn AddOptionalPackageAsync(&self, optionalpackagefamilyname: &windows_core::HSTRING) -> windows_core::Result> { + pub fn AddOptionalPackageAsync(&self, optionalpackagefamilyname: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).AddOptionalPackageAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(optionalpackagefamilyname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RemoveOptionalPackagesAsync(&self, optionalpackagefamilynames: P0) -> windows_core::Result> + pub fn RemoveOptionalPackagesAsync(&self, optionalpackagefamilynames: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -2224,14 +2224,14 @@ impl PackageCatalog { (windows_core::Interface::vtable(this).RemoveOptionalPackagesAsync)(windows_core::Interface::as_raw(this), optionalpackagefamilynames.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn AddResourcePackageAsync(&self, resourcepackagefamilyname: &windows_core::HSTRING, resourceid: &windows_core::HSTRING, options: AddResourcePackageOptions) -> windows_core::Result> { + pub fn AddResourcePackageAsync(&self, resourcepackagefamilyname: &windows_core::HSTRING, resourceid: &windows_core::HSTRING, options: AddResourcePackageOptions) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).AddResourcePackageAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(resourcepackagefamilyname), core::mem::transmute_copy(resourceid), options, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RemoveResourcePackagesAsync(&self, resourcepackages: P0) -> windows_core::Result> + pub fn RemoveResourcePackagesAsync(&self, resourcepackages: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -3100,7 +3100,7 @@ impl windows_core::RuntimeType for PackageVersion { pub struct StartupTask(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(StartupTask, windows_core::IUnknown, windows_core::IInspectable); impl StartupTask { - pub fn RequestEnableAsync(&self) -> windows_core::Result> { + pub fn RequestEnableAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -3125,13 +3125,13 @@ impl StartupTask { (windows_core::Interface::vtable(this).TaskId)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn GetForCurrentPackageAsync() -> windows_core::Result>> { + pub fn GetForCurrentPackageAsync() -> windows_core::Result>> { Self::IStartupTaskStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetForCurrentPackageAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetAsync(taskid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetAsync(taskid: &windows_core::HSTRING) -> windows_core::Result> { Self::IStartupTaskStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(taskid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/Data/Pdf/mod.rs b/crates/libs/windows/src/Windows/Data/Pdf/mod.rs index c9bfe2483d..28d9f10f83 100644 --- a/crates/libs/windows/src/Windows/Data/Pdf/mod.rs +++ b/crates/libs/windows/src/Windows/Data/Pdf/mod.rs @@ -121,7 +121,7 @@ impl PdfDocument { } } #[cfg(feature = "Storage_Streams")] - pub fn LoadFromFileAsync(file: P0) -> windows_core::Result> + pub fn LoadFromFileAsync(file: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -131,7 +131,7 @@ impl PdfDocument { }) } #[cfg(feature = "Storage_Streams")] - pub fn LoadFromFileWithPasswordAsync(file: P0, password: &windows_core::HSTRING) -> windows_core::Result> + pub fn LoadFromFileWithPasswordAsync(file: P0, password: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -141,7 +141,7 @@ impl PdfDocument { }) } #[cfg(feature = "Storage_Streams")] - pub fn LoadFromStreamAsync(inputstream: P0) -> windows_core::Result> + pub fn LoadFromStreamAsync(inputstream: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -151,7 +151,7 @@ impl PdfDocument { }) } #[cfg(feature = "Storage_Streams")] - pub fn LoadFromStreamWithPasswordAsync(inputstream: P0, password: &windows_core::HSTRING) -> windows_core::Result> + pub fn LoadFromStreamWithPasswordAsync(inputstream: P0, password: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -188,7 +188,7 @@ impl PdfPage { unsafe { (windows_core::Interface::vtable(this).Close)(windows_core::Interface::as_raw(this)).ok() } } #[cfg(feature = "Storage_Streams")] - pub fn RenderToStreamAsync(&self, outputstream: P0) -> windows_core::Result + pub fn RenderToStreamAsync(&self, outputstream: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -199,7 +199,7 @@ impl PdfPage { } } #[cfg(feature = "Storage_Streams")] - pub fn RenderWithOptionsToStreamAsync(&self, outputstream: P0, options: P1) -> windows_core::Result + pub fn RenderWithOptionsToStreamAsync(&self, outputstream: P0, options: P1) -> windows_core::Result where P0: windows_core::Param, P1: windows_core::Param, @@ -210,7 +210,7 @@ impl PdfPage { (windows_core::Interface::vtable(this).RenderWithOptionsToStreamAsync)(windows_core::Interface::as_raw(this), outputstream.param().abi(), options.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn PreparePageAsync(&self) -> windows_core::Result { + pub fn PreparePageAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Data/Text/mod.rs b/crates/libs/windows/src/Windows/Data/Text/mod.rs index f3396548ab..f5a2755c03 100644 --- a/crates/libs/windows/src/Windows/Data/Text/mod.rs +++ b/crates/libs/windows/src/Windows/Data/Text/mod.rs @@ -495,14 +495,14 @@ impl TextConversionGenerator { (windows_core::Interface::vtable(this).LanguageAvailableButNotInstalled)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn GetCandidatesAsync(&self, input: &windows_core::HSTRING) -> windows_core::Result>> { + pub fn GetCandidatesAsync(&self, input: &windows_core::HSTRING) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetCandidatesAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(input), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetCandidatesWithMaxCountAsync(&self, input: &windows_core::HSTRING, maxcandidates: u32) -> windows_core::Result>> { + pub fn GetCandidatesWithMaxCountAsync(&self, input: &windows_core::HSTRING, maxcandidates: u32) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -583,21 +583,21 @@ impl TextPredictionGenerator { (windows_core::Interface::vtable(this).LanguageAvailableButNotInstalled)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn GetCandidatesAsync(&self, input: &windows_core::HSTRING) -> windows_core::Result>> { + pub fn GetCandidatesAsync(&self, input: &windows_core::HSTRING) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetCandidatesAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(input), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetCandidatesWithMaxCountAsync(&self, input: &windows_core::HSTRING, maxcandidates: u32) -> windows_core::Result>> { + pub fn GetCandidatesWithMaxCountAsync(&self, input: &windows_core::HSTRING, maxcandidates: u32) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetCandidatesWithMaxCountAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(input), maxcandidates, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetCandidatesWithParametersAsync(&self, input: &windows_core::HSTRING, maxcandidates: u32, predictionoptions: TextPredictionOptions, previousstrings: P3) -> windows_core::Result>> + pub fn GetCandidatesWithParametersAsync(&self, input: &windows_core::HSTRING, maxcandidates: u32, predictionoptions: TextPredictionOptions, previousstrings: P3) -> windows_core::Result>> where P3: windows_core::Param>, { @@ -607,7 +607,7 @@ impl TextPredictionGenerator { (windows_core::Interface::vtable(this).GetCandidatesWithParametersAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(input), maxcandidates, predictionoptions, previousstrings.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetNextWordCandidatesAsync(&self, maxcandidates: u32, previousstrings: P1) -> windows_core::Result>> + pub fn GetNextWordCandidatesAsync(&self, maxcandidates: u32, previousstrings: P1) -> windows_core::Result>> where P1: windows_core::Param>, { @@ -719,14 +719,14 @@ impl TextReverseConversionGenerator { (windows_core::Interface::vtable(this).LanguageAvailableButNotInstalled)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn ConvertBackAsync(&self, input: &windows_core::HSTRING) -> windows_core::Result> { + pub fn ConvertBackAsync(&self, input: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ConvertBackAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(input), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetPhonemesAsync(&self, input: &windows_core::HSTRING) -> windows_core::Result>> { + pub fn GetPhonemesAsync(&self, input: &windows_core::HSTRING) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Data/Xml/Dom/mod.rs b/crates/libs/windows/src/Windows/Data/Xml/Dom/mod.rs index 45f9fd8347..30c2c931f2 100644 --- a/crates/libs/windows/src/Windows/Data/Xml/Dom/mod.rs +++ b/crates/libs/windows/src/Windows/Data/Xml/Dom/mod.rs @@ -3274,7 +3274,7 @@ impl XmlDocument { unsafe { (windows_core::Interface::vtable(this).LoadXmlWithSettings)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(xml), loadsettings.param().abi()).ok() } } #[cfg(feature = "Storage_Streams")] - pub fn SaveToFileAsync(&self, file: P0) -> windows_core::Result + pub fn SaveToFileAsync(&self, file: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -3301,7 +3301,7 @@ impl XmlDocument { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).LoadXmlFromBufferWithSettings)(windows_core::Interface::as_raw(this), buffer.param().abi(), loadsettings.param().abi()).ok() } } - pub fn LoadFromUriAsync(uri: P0) -> windows_core::Result> + pub fn LoadFromUriAsync(uri: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -3310,7 +3310,7 @@ impl XmlDocument { (windows_core::Interface::vtable(this).LoadFromUriAsync)(windows_core::Interface::as_raw(this), uri.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn LoadFromUriWithSettingsAsync(uri: P0, loadsettings: P1) -> windows_core::Result> + pub fn LoadFromUriWithSettingsAsync(uri: P0, loadsettings: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -3321,7 +3321,7 @@ impl XmlDocument { }) } #[cfg(feature = "Storage_Streams")] - pub fn LoadFromFileAsync(file: P0) -> windows_core::Result> + pub fn LoadFromFileAsync(file: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -3331,7 +3331,7 @@ impl XmlDocument { }) } #[cfg(feature = "Storage_Streams")] - pub fn LoadFromFileWithSettingsAsync(file: P0, loadsettings: P1) -> windows_core::Result> + pub fn LoadFromFileWithSettingsAsync(file: P0, loadsettings: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, diff --git a/crates/libs/windows/src/Windows/Devices/Adc/mod.rs b/crates/libs/windows/src/Windows/Devices/Adc/mod.rs index 95213c2bfc..dac86d2578 100644 --- a/crates/libs/windows/src/Windows/Devices/Adc/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/Adc/mod.rs @@ -116,7 +116,7 @@ impl AdcController { } } #[cfg(feature = "Devices_Adc_Provider")] - pub fn GetControllersAsync(provider: P0) -> windows_core::Result>> + pub fn GetControllersAsync(provider: P0) -> windows_core::Result>> where P0: windows_core::Param, { @@ -125,7 +125,7 @@ impl AdcController { (windows_core::Interface::vtable(this).GetControllersAsync)(windows_core::Interface::as_raw(this), provider.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetDefaultAsync() -> windows_core::Result> { + pub fn GetDefaultAsync() -> windows_core::Result> { Self::IAdcControllerStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetDefaultAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/Devices/Bluetooth/GenericAttributeProfile/mod.rs b/crates/libs/windows/src/Windows/Devices/Bluetooth/GenericAttributeProfile/mod.rs index 432137f2e8..69c649924f 100644 --- a/crates/libs/windows/src/Windows/Devices/Bluetooth/GenericAttributeProfile/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/Bluetooth/GenericAttributeProfile/mod.rs @@ -57,14 +57,14 @@ impl GattCharacteristic { (windows_core::Interface::vtable(this).PresentationFormats)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReadValueAsync(&self) -> windows_core::Result> { + pub fn ReadValueAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReadValueAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReadValueWithCacheModeAsync(&self, cachemode: super::BluetoothCacheMode) -> windows_core::Result> { + pub fn ReadValueWithCacheModeAsync(&self, cachemode: super::BluetoothCacheMode) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -72,7 +72,7 @@ impl GattCharacteristic { } } #[cfg(feature = "Storage_Streams")] - pub fn WriteValueAsync(&self, value: P0) -> windows_core::Result> + pub fn WriteValueAsync(&self, value: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -83,7 +83,7 @@ impl GattCharacteristic { } } #[cfg(feature = "Storage_Streams")] - pub fn WriteValueWithOptionAsync(&self, value: P0, writeoption: GattWriteOption) -> windows_core::Result> + pub fn WriteValueWithOptionAsync(&self, value: P0, writeoption: GattWriteOption) -> windows_core::Result> where P0: windows_core::Param, { @@ -93,14 +93,14 @@ impl GattCharacteristic { (windows_core::Interface::vtable(this).WriteValueWithOptionAsync)(windows_core::Interface::as_raw(this), value.param().abi(), writeoption, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReadClientCharacteristicConfigurationDescriptorAsync(&self) -> windows_core::Result> { + pub fn ReadClientCharacteristicConfigurationDescriptorAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReadClientCharacteristicConfigurationDescriptorAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn WriteClientCharacteristicConfigurationDescriptorAsync(&self, clientcharacteristicconfigurationdescriptorvalue: GattClientCharacteristicConfigurationDescriptorValue) -> windows_core::Result> { + pub fn WriteClientCharacteristicConfigurationDescriptorAsync(&self, clientcharacteristicconfigurationdescriptorvalue: GattClientCharacteristicConfigurationDescriptorValue) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -136,28 +136,28 @@ impl GattCharacteristic { (windows_core::Interface::vtable(this).GetAllDescriptors)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetDescriptorsAsync(&self) -> windows_core::Result> { + pub fn GetDescriptorsAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetDescriptorsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetDescriptorsWithCacheModeAsync(&self, cachemode: super::BluetoothCacheMode) -> windows_core::Result> { + pub fn GetDescriptorsWithCacheModeAsync(&self, cachemode: super::BluetoothCacheMode) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetDescriptorsWithCacheModeAsync)(windows_core::Interface::as_raw(this), cachemode, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetDescriptorsForUuidAsync(&self, descriptoruuid: windows_core::GUID) -> windows_core::Result> { + pub fn GetDescriptorsForUuidAsync(&self, descriptoruuid: windows_core::GUID) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetDescriptorsForUuidAsync)(windows_core::Interface::as_raw(this), descriptoruuid, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetDescriptorsForUuidWithCacheModeAsync(&self, descriptoruuid: windows_core::GUID, cachemode: super::BluetoothCacheMode) -> windows_core::Result> { + pub fn GetDescriptorsForUuidWithCacheModeAsync(&self, descriptoruuid: windows_core::GUID, cachemode: super::BluetoothCacheMode) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -165,7 +165,7 @@ impl GattCharacteristic { } } #[cfg(feature = "Storage_Streams")] - pub fn WriteValueWithResultAsync(&self, value: P0) -> windows_core::Result> + pub fn WriteValueWithResultAsync(&self, value: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -176,7 +176,7 @@ impl GattCharacteristic { } } #[cfg(feature = "Storage_Streams")] - pub fn WriteValueWithResultAndOptionAsync(&self, value: P0, writeoption: GattWriteOption) -> windows_core::Result> + pub fn WriteValueWithResultAndOptionAsync(&self, value: P0, writeoption: GattWriteOption) -> windows_core::Result> where P0: windows_core::Param, { @@ -186,7 +186,7 @@ impl GattCharacteristic { (windows_core::Interface::vtable(this).WriteValueWithResultAndOptionAsync)(windows_core::Interface::as_raw(this), value.param().abi(), writeoption, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn WriteClientCharacteristicConfigurationDescriptorWithResultAsync(&self, clientcharacteristicconfigurationdescriptorvalue: GattClientCharacteristicConfigurationDescriptorValue) -> windows_core::Result> { + pub fn WriteClientCharacteristicConfigurationDescriptorWithResultAsync(&self, clientcharacteristicconfigurationdescriptorvalue: GattClientCharacteristicConfigurationDescriptorValue) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -916,14 +916,14 @@ impl GattDescriptor { (windows_core::Interface::vtable(this).AttributeHandle)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn ReadValueAsync(&self) -> windows_core::Result> { + pub fn ReadValueAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReadValueAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReadValueWithCacheModeAsync(&self, cachemode: super::BluetoothCacheMode) -> windows_core::Result> { + pub fn ReadValueWithCacheModeAsync(&self, cachemode: super::BluetoothCacheMode) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -931,7 +931,7 @@ impl GattDescriptor { } } #[cfg(feature = "Storage_Streams")] - pub fn WriteValueAsync(&self, value: P0) -> windows_core::Result> + pub fn WriteValueAsync(&self, value: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -942,7 +942,7 @@ impl GattDescriptor { } } #[cfg(feature = "Storage_Streams")] - pub fn WriteValueWithResultAsync(&self, value: P0) -> windows_core::Result> + pub fn WriteValueWithResultAsync(&self, value: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1163,77 +1163,77 @@ impl GattDeviceService { } } #[cfg(feature = "Devices_Enumeration")] - pub fn RequestAccessAsync(&self) -> windows_core::Result> { + pub fn RequestAccessAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestAccessAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn OpenAsync(&self, sharingmode: GattSharingMode) -> windows_core::Result> { + pub fn OpenAsync(&self, sharingmode: GattSharingMode) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).OpenAsync)(windows_core::Interface::as_raw(this), sharingmode, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetCharacteristicsAsync(&self) -> windows_core::Result> { + pub fn GetCharacteristicsAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetCharacteristicsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetCharacteristicsWithCacheModeAsync(&self, cachemode: super::BluetoothCacheMode) -> windows_core::Result> { + pub fn GetCharacteristicsWithCacheModeAsync(&self, cachemode: super::BluetoothCacheMode) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetCharacteristicsWithCacheModeAsync)(windows_core::Interface::as_raw(this), cachemode, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetCharacteristicsForUuidAsync(&self, characteristicuuid: windows_core::GUID) -> windows_core::Result> { + pub fn GetCharacteristicsForUuidAsync(&self, characteristicuuid: windows_core::GUID) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetCharacteristicsForUuidAsync)(windows_core::Interface::as_raw(this), characteristicuuid, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetCharacteristicsForUuidWithCacheModeAsync(&self, characteristicuuid: windows_core::GUID, cachemode: super::BluetoothCacheMode) -> windows_core::Result> { + pub fn GetCharacteristicsForUuidWithCacheModeAsync(&self, characteristicuuid: windows_core::GUID, cachemode: super::BluetoothCacheMode) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetCharacteristicsForUuidWithCacheModeAsync)(windows_core::Interface::as_raw(this), characteristicuuid, cachemode, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetIncludedServicesAsync(&self) -> windows_core::Result> { + pub fn GetIncludedServicesAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetIncludedServicesAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetIncludedServicesWithCacheModeAsync(&self, cachemode: super::BluetoothCacheMode) -> windows_core::Result> { + pub fn GetIncludedServicesWithCacheModeAsync(&self, cachemode: super::BluetoothCacheMode) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetIncludedServicesWithCacheModeAsync)(windows_core::Interface::as_raw(this), cachemode, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetIncludedServicesForUuidAsync(&self, serviceuuid: windows_core::GUID) -> windows_core::Result> { + pub fn GetIncludedServicesForUuidAsync(&self, serviceuuid: windows_core::GUID) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetIncludedServicesForUuidAsync)(windows_core::Interface::as_raw(this), serviceuuid, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetIncludedServicesForUuidWithCacheModeAsync(&self, serviceuuid: windows_core::GUID, cachemode: super::BluetoothCacheMode) -> windows_core::Result> { + pub fn GetIncludedServicesForUuidWithCacheModeAsync(&self, serviceuuid: windows_core::GUID, cachemode: super::BluetoothCacheMode) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetIncludedServicesForUuidWithCacheModeAsync)(windows_core::Interface::as_raw(this), serviceuuid, cachemode, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IGattDeviceServiceStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -1259,7 +1259,7 @@ impl GattDeviceService { (windows_core::Interface::vtable(this).ConvertShortIdToUuid)(windows_core::Interface::as_raw(this), shortid, &mut result__).map(|| result__) }) } - pub fn FromIdWithSharingModeAsync(deviceid: &windows_core::HSTRING, sharingmode: GattSharingMode) -> windows_core::Result> { + pub fn FromIdWithSharingModeAsync(deviceid: &windows_core::HSTRING, sharingmode: GattSharingMode) -> windows_core::Result> { Self::IGattDeviceServiceStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdWithSharingModeAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), sharingmode, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -1402,7 +1402,7 @@ impl GattLocalCharacteristic { (windows_core::Interface::vtable(this).WriteProtectionLevel)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn CreateDescriptorAsync(&self, descriptoruuid: windows_core::GUID, parameters: P1) -> windows_core::Result> + pub fn CreateDescriptorAsync(&self, descriptoruuid: windows_core::GUID, parameters: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -1483,7 +1483,7 @@ impl GattLocalCharacteristic { unsafe { (windows_core::Interface::vtable(this).RemoveWriteRequested)(windows_core::Interface::as_raw(this), token).ok() } } #[cfg(feature = "Storage_Streams")] - pub fn NotifyValueAsync(&self, value: P0) -> windows_core::Result>> + pub fn NotifyValueAsync(&self, value: P0) -> windows_core::Result>> where P0: windows_core::Param, { @@ -1494,7 +1494,7 @@ impl GattLocalCharacteristic { } } #[cfg(feature = "Storage_Streams")] - pub fn NotifyValueForSubscribedClientAsync(&self, value: P0, subscribedclient: P1) -> windows_core::Result> + pub fn NotifyValueForSubscribedClientAsync(&self, value: P0, subscribedclient: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -1824,7 +1824,7 @@ impl GattLocalService { (windows_core::Interface::vtable(this).Uuid)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn CreateCharacteristicAsync(&self, characteristicuuid: windows_core::GUID, parameters: P1) -> windows_core::Result> + pub fn CreateCharacteristicAsync(&self, characteristicuuid: windows_core::GUID, parameters: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -2366,7 +2366,7 @@ impl GattReadRequestedEventArgs { (windows_core::Interface::vtable(this).GetDeferral)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetRequestAsync(&self) -> windows_core::Result> { + pub fn GetRequestAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2447,14 +2447,14 @@ impl GattReliableWriteTransaction { let this = self; unsafe { (windows_core::Interface::vtable(this).WriteValue)(windows_core::Interface::as_raw(this), characteristic.param().abi(), value.param().abi()).ok() } } - pub fn CommitAsync(&self) -> windows_core::Result> { + pub fn CommitAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CommitAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CommitWithResultAsync(&self) -> windows_core::Result> { + pub fn CommitWithResultAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -2568,7 +2568,7 @@ impl GattServiceProvider { let this = self; unsafe { (windows_core::Interface::vtable(this).StopAdvertising)(windows_core::Interface::as_raw(this)).ok() } } - pub fn CreateAsync(serviceuuid: windows_core::GUID) -> windows_core::Result> { + pub fn CreateAsync(serviceuuid: windows_core::GUID) -> windows_core::Result> { Self::IGattServiceProviderStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreateAsync)(windows_core::Interface::as_raw(this), serviceuuid, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -2957,7 +2957,7 @@ impl GattSession { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveSessionStatusChanged)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn FromDeviceIdAsync(deviceid: P0) -> windows_core::Result> + pub fn FromDeviceIdAsync(deviceid: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -3223,7 +3223,7 @@ impl GattWriteRequestedEventArgs { (windows_core::Interface::vtable(this).GetDeferral)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetRequestAsync(&self) -> windows_core::Result> { + pub fn GetRequestAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Devices/Bluetooth/Rfcomm/mod.rs b/crates/libs/windows/src/Windows/Devices/Bluetooth/Rfcomm/mod.rs index d4a6994134..1f0e9c9433 100644 --- a/crates/libs/windows/src/Windows/Devices/Bluetooth/Rfcomm/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/Bluetooth/Rfcomm/mod.rs @@ -200,7 +200,7 @@ impl RfcommDeviceService { } } #[cfg(feature = "Storage_Streams")] - pub fn GetSdpRawAttributesAsync(&self) -> windows_core::Result>> { + pub fn GetSdpRawAttributesAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -208,7 +208,7 @@ impl RfcommDeviceService { } } #[cfg(feature = "Storage_Streams")] - pub fn GetSdpRawAttributesWithCacheModeAsync(&self, cachemode: super::BluetoothCacheMode) -> windows_core::Result>> { + pub fn GetSdpRawAttributesWithCacheModeAsync(&self, cachemode: super::BluetoothCacheMode) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -231,14 +231,14 @@ impl RfcommDeviceService { } } #[cfg(feature = "Devices_Enumeration")] - pub fn RequestAccessAsync(&self) -> windows_core::Result> { + pub fn RequestAccessAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestAccessAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IRfcommDeviceServiceStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -475,7 +475,7 @@ impl RfcommServiceProvider { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).StartAdvertisingWithRadioDiscoverability)(windows_core::Interface::as_raw(this), listener.param().abi(), radiodiscoverable).ok() } } - pub fn CreateAsync(serviceid: P0) -> windows_core::Result> + pub fn CreateAsync(serviceid: P0) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Devices/Bluetooth/mod.rs b/crates/libs/windows/src/Windows/Devices/Bluetooth/mod.rs index fc426428fa..dadd36f547 100644 --- a/crates/libs/windows/src/Windows/Devices/Bluetooth/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/Bluetooth/mod.rs @@ -61,7 +61,7 @@ impl BluetoothAdapter { } } #[cfg(feature = "Devices_Radios")] - pub fn GetRadioAsync(&self) -> windows_core::Result> { + pub fn GetRadioAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -102,13 +102,13 @@ impl BluetoothAdapter { (windows_core::Interface::vtable(this).GetDeviceSelector)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IBluetoothAdapterStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetDefaultAsync() -> windows_core::Result> { + pub fn GetDefaultAsync() -> windows_core::Result> { Self::IBluetoothAdapterStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetDefaultAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -357,7 +357,7 @@ impl BluetoothDevice { } } #[cfg(feature = "Devices_Enumeration")] - pub fn RequestAccessAsync(&self) -> windows_core::Result> { + pub fn RequestAccessAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -365,7 +365,7 @@ impl BluetoothDevice { } } #[cfg(feature = "Devices_Bluetooth_Rfcomm")] - pub fn GetRfcommServicesAsync(&self) -> windows_core::Result> { + pub fn GetRfcommServicesAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -373,7 +373,7 @@ impl BluetoothDevice { } } #[cfg(feature = "Devices_Bluetooth_Rfcomm")] - pub fn GetRfcommServicesWithCacheModeAsync(&self, cachemode: BluetoothCacheMode) -> windows_core::Result> { + pub fn GetRfcommServicesWithCacheModeAsync(&self, cachemode: BluetoothCacheMode) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -381,7 +381,7 @@ impl BluetoothDevice { } } #[cfg(feature = "Devices_Bluetooth_Rfcomm")] - pub fn GetRfcommServicesForIdAsync(&self, serviceid: P0) -> windows_core::Result> + pub fn GetRfcommServicesForIdAsync(&self, serviceid: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -392,7 +392,7 @@ impl BluetoothDevice { } } #[cfg(feature = "Devices_Bluetooth_Rfcomm")] - pub fn GetRfcommServicesForIdWithCacheModeAsync(&self, serviceid: P0, cachemode: BluetoothCacheMode) -> windows_core::Result> + pub fn GetRfcommServicesForIdWithCacheModeAsync(&self, serviceid: P0, cachemode: BluetoothCacheMode) -> windows_core::Result> where P0: windows_core::Param, { @@ -416,14 +416,14 @@ impl BluetoothDevice { (windows_core::Interface::vtable(this).WasSecureConnectionUsedForPairing)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IBluetoothDeviceStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "Networking")] - pub fn FromHostNameAsync(hostname: P0) -> windows_core::Result> + pub fn FromHostNameAsync(hostname: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -432,7 +432,7 @@ impl BluetoothDevice { (windows_core::Interface::vtable(this).FromHostNameAsync)(windows_core::Interface::as_raw(this), hostname.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn FromBluetoothAddressAsync(address: u64) -> windows_core::Result> { + pub fn FromBluetoothAddressAsync(address: u64) -> windows_core::Result> { Self::IBluetoothDeviceStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromBluetoothAddressAsync)(windows_core::Interface::as_raw(this), address, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -1180,7 +1180,7 @@ impl BluetoothLEDevice { } } #[cfg(feature = "Devices_Enumeration")] - pub fn RequestAccessAsync(&self) -> windows_core::Result> { + pub fn RequestAccessAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1188,7 +1188,7 @@ impl BluetoothLEDevice { } } #[cfg(feature = "Devices_Bluetooth_GenericAttributeProfile")] - pub fn GetGattServicesAsync(&self) -> windows_core::Result> { + pub fn GetGattServicesAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1196,7 +1196,7 @@ impl BluetoothLEDevice { } } #[cfg(feature = "Devices_Bluetooth_GenericAttributeProfile")] - pub fn GetGattServicesWithCacheModeAsync(&self, cachemode: BluetoothCacheMode) -> windows_core::Result> { + pub fn GetGattServicesWithCacheModeAsync(&self, cachemode: BluetoothCacheMode) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1204,7 +1204,7 @@ impl BluetoothLEDevice { } } #[cfg(feature = "Devices_Bluetooth_GenericAttributeProfile")] - pub fn GetGattServicesForUuidAsync(&self, serviceuuid: windows_core::GUID) -> windows_core::Result> { + pub fn GetGattServicesForUuidAsync(&self, serviceuuid: windows_core::GUID) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1212,7 +1212,7 @@ impl BluetoothLEDevice { } } #[cfg(feature = "Devices_Bluetooth_GenericAttributeProfile")] - pub fn GetGattServicesForUuidWithCacheModeAsync(&self, serviceuuid: windows_core::GUID, cachemode: BluetoothCacheMode) -> windows_core::Result> { + pub fn GetGattServicesForUuidWithCacheModeAsync(&self, serviceuuid: windows_core::GUID, cachemode: BluetoothCacheMode) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1285,13 +1285,13 @@ impl BluetoothLEDevice { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).RemoveConnectionPhyChanged)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IBluetoothLEDeviceStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn FromBluetoothAddressAsync(bluetoothaddress: u64) -> windows_core::Result> { + pub fn FromBluetoothAddressAsync(bluetoothaddress: u64) -> windows_core::Result> { Self::IBluetoothLEDeviceStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromBluetoothAddressAsync)(windows_core::Interface::as_raw(this), bluetoothaddress, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -1342,7 +1342,7 @@ impl BluetoothLEDevice { (windows_core::Interface::vtable(this).GetDeviceSelectorFromAppearance)(windows_core::Interface::as_raw(this), appearance.param().abi(), &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn FromBluetoothAddressWithBluetoothAddressTypeAsync(bluetoothaddress: u64, bluetoothaddresstype: BluetoothAddressType) -> windows_core::Result> { + pub fn FromBluetoothAddressWithBluetoothAddressTypeAsync(bluetoothaddress: u64, bluetoothaddresstype: BluetoothAddressType) -> windows_core::Result> { Self::IBluetoothLEDeviceStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromBluetoothAddressWithBluetoothAddressTypeAsync)(windows_core::Interface::as_raw(this), bluetoothaddress, bluetoothaddresstype, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/Devices/Custom/mod.rs b/crates/libs/windows/src/Windows/Devices/Custom/mod.rs index 4b2aa6f756..67bf23d9bd 100644 --- a/crates/libs/windows/src/Windows/Devices/Custom/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/Custom/mod.rs @@ -20,7 +20,7 @@ impl CustomDevice { } } #[cfg(feature = "Storage_Streams")] - pub fn SendIOControlAsync(&self, iocontrolcode: P0, inputbuffer: P1, outputbuffer: P2) -> windows_core::Result> + pub fn SendIOControlAsync(&self, iocontrolcode: P0, inputbuffer: P1, outputbuffer: P2) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -33,7 +33,7 @@ impl CustomDevice { } } #[cfg(feature = "Storage_Streams")] - pub fn TrySendIOControlAsync(&self, iocontrolcode: P0, inputbuffer: P1, outputbuffer: P2) -> windows_core::Result> + pub fn TrySendIOControlAsync(&self, iocontrolcode: P0, inputbuffer: P1, outputbuffer: P2) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -51,7 +51,7 @@ impl CustomDevice { (windows_core::Interface::vtable(this).GetDeviceSelector)(windows_core::Interface::as_raw(this), classguid, &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING, desiredaccess: DeviceAccessMode, sharingmode: DeviceSharingMode) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING, desiredaccess: DeviceAccessMode, sharingmode: DeviceSharingMode) -> windows_core::Result> { Self::ICustomDeviceStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), desiredaccess, sharingmode, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/Devices/Display/Core/mod.rs b/crates/libs/windows/src/Windows/Devices/Display/Core/mod.rs index 06e9ef068b..6fe8f91d3e 100644 --- a/crates/libs/windows/src/Windows/Devices/Display/Core/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/Display/Core/mod.rs @@ -914,7 +914,7 @@ impl DisplayMuxDevice { (windows_core::Interface::vtable(this).IsAutomaticTargetSwitchingEnabled)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn SetPreferredTarget(&self, target: P0) -> windows_core::Result + pub fn SetPreferredTarget(&self, target: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -924,7 +924,7 @@ impl DisplayMuxDevice { (windows_core::Interface::vtable(this).SetPreferredTarget)(windows_core::Interface::as_raw(this), target.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SetAutomaticTargetSwitching(&self) -> windows_core::Result { + pub fn SetAutomaticTargetSwitching(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -951,7 +951,7 @@ impl DisplayMuxDevice { (windows_core::Interface::vtable(this).GetDeviceSelector)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn FromIdAsync(deviceinterfaceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceinterfaceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IDisplayMuxDeviceStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceinterfaceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/Devices/Display/mod.rs b/crates/libs/windows/src/Windows/Devices/Display/mod.rs index 29cc689e46..6de4a0c079 100644 --- a/crates/libs/windows/src/Windows/Devices/Display/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/Display/mod.rs @@ -160,13 +160,13 @@ impl DisplayMonitor { (windows_core::Interface::vtable(this).GetDeviceSelector)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IDisplayMonitorStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn FromInterfaceIdAsync(deviceinterfaceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromInterfaceIdAsync(deviceinterfaceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IDisplayMonitorStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromInterfaceIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceinterfaceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/Devices/Enumeration/Pnp/mod.rs b/crates/libs/windows/src/Windows/Devices/Enumeration/Pnp/mod.rs index 5517801bb4..cd633a4deb 100644 --- a/crates/libs/windows/src/Windows/Devices/Enumeration/Pnp/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/Enumeration/Pnp/mod.rs @@ -88,7 +88,7 @@ impl PnpObject { let this = self; unsafe { (windows_core::Interface::vtable(this).Update)(windows_core::Interface::as_raw(this), updateinfo.param().abi()).ok() } } - pub fn CreateFromIdAsync(r#type: PnpObjectType, id: &windows_core::HSTRING, requestedproperties: P2) -> windows_core::Result> + pub fn CreateFromIdAsync(r#type: PnpObjectType, id: &windows_core::HSTRING, requestedproperties: P2) -> windows_core::Result> where P2: windows_core::Param>, { @@ -97,7 +97,7 @@ impl PnpObject { (windows_core::Interface::vtable(this).CreateFromIdAsync)(windows_core::Interface::as_raw(this), r#type, core::mem::transmute_copy(id), requestedproperties.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn FindAllAsync(r#type: PnpObjectType, requestedproperties: P1) -> windows_core::Result> + pub fn FindAllAsync(r#type: PnpObjectType, requestedproperties: P1) -> windows_core::Result> where P1: windows_core::Param>, { @@ -106,7 +106,7 @@ impl PnpObject { (windows_core::Interface::vtable(this).FindAllAsync)(windows_core::Interface::as_raw(this), r#type, requestedproperties.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn FindAllAsyncAqsFilter(r#type: PnpObjectType, requestedproperties: P1, aqsfilter: &windows_core::HSTRING) -> windows_core::Result> + pub fn FindAllAsyncAqsFilter(r#type: PnpObjectType, requestedproperties: P1, aqsfilter: &windows_core::HSTRING) -> windows_core::Result> where P1: windows_core::Param>, { diff --git a/crates/libs/windows/src/Windows/Devices/Enumeration/mod.rs b/crates/libs/windows/src/Windows/Devices/Enumeration/mod.rs index ffd5a8280a..612e72d387 100644 --- a/crates/libs/windows/src/Windows/Devices/Enumeration/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/Enumeration/mod.rs @@ -245,7 +245,7 @@ impl DeviceInformation { unsafe { (windows_core::Interface::vtable(this).Update)(windows_core::Interface::as_raw(this), updateinfo.param().abi()).ok() } } #[cfg(feature = "Storage_Streams")] - pub fn GetThumbnailAsync(&self) -> windows_core::Result> { + pub fn GetThumbnailAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -253,7 +253,7 @@ impl DeviceInformation { } } #[cfg(feature = "Storage_Streams")] - pub fn GetGlyphThumbnailAsync(&self) -> windows_core::Result> { + pub fn GetGlyphThumbnailAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -274,13 +274,13 @@ impl DeviceInformation { (windows_core::Interface::vtable(this).Pairing)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateFromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CreateFromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IDeviceInformationStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreateFromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn CreateFromIdAsyncAdditionalProperties(deviceid: &windows_core::HSTRING, additionalproperties: P1) -> windows_core::Result> + pub fn CreateFromIdAsyncAdditionalProperties(deviceid: &windows_core::HSTRING, additionalproperties: P1) -> windows_core::Result> where P1: windows_core::Param>, { @@ -289,25 +289,25 @@ impl DeviceInformation { (windows_core::Interface::vtable(this).CreateFromIdAsyncAdditionalProperties)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), additionalproperties.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn FindAllAsync() -> windows_core::Result> { + pub fn FindAllAsync() -> windows_core::Result> { Self::IDeviceInformationStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAllAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn FindAllAsyncDeviceClass(deviceclass: DeviceClass) -> windows_core::Result> { + pub fn FindAllAsyncDeviceClass(deviceclass: DeviceClass) -> windows_core::Result> { Self::IDeviceInformationStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAllAsyncDeviceClass)(windows_core::Interface::as_raw(this), deviceclass, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn FindAllAsyncAqsFilter(aqsfilter: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FindAllAsyncAqsFilter(aqsfilter: &windows_core::HSTRING) -> windows_core::Result> { Self::IDeviceInformationStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAllAsyncAqsFilter)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(aqsfilter), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn FindAllAsyncAqsFilterAndAdditionalProperties(aqsfilter: &windows_core::HSTRING, additionalproperties: P1) -> windows_core::Result> + pub fn FindAllAsyncAqsFilterAndAdditionalProperties(aqsfilter: &windows_core::HSTRING, additionalproperties: P1) -> windows_core::Result> where P1: windows_core::Param>, { @@ -349,7 +349,7 @@ impl DeviceInformation { (windows_core::Interface::vtable(this).GetAqsFilterFromDeviceClass)(windows_core::Interface::as_raw(this), deviceclass, &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn CreateFromIdAsyncWithKindAndAdditionalProperties(deviceid: &windows_core::HSTRING, additionalproperties: P1, kind: DeviceInformationKind) -> windows_core::Result> + pub fn CreateFromIdAsyncWithKindAndAdditionalProperties(deviceid: &windows_core::HSTRING, additionalproperties: P1, kind: DeviceInformationKind) -> windows_core::Result> where P1: windows_core::Param>, { @@ -358,7 +358,7 @@ impl DeviceInformation { (windows_core::Interface::vtable(this).CreateFromIdAsyncWithKindAndAdditionalProperties)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), additionalproperties.param().abi(), kind, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn FindAllAsyncWithKindAqsFilterAndAdditionalProperties(aqsfilter: &windows_core::HSTRING, additionalproperties: P1, kind: DeviceInformationKind) -> windows_core::Result> + pub fn FindAllAsyncWithKindAqsFilterAndAdditionalProperties(aqsfilter: &windows_core::HSTRING, additionalproperties: P1, kind: DeviceInformationKind) -> windows_core::Result> where P1: windows_core::Param>, { @@ -376,7 +376,7 @@ impl DeviceInformation { (windows_core::Interface::vtable(this).CreateWatcherWithKindAqsFilterAndAdditionalProperties)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(aqsfilter), additionalproperties.param().abi(), kind, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn CreateFromIdAsyncWithAdditionalPropertiesKindAndSettings(deviceid: &windows_core::HSTRING, additionalproperties: P1, kind: DeviceInformationKind, settings: P3) -> windows_core::Result> + pub fn CreateFromIdAsyncWithAdditionalPropertiesKindAndSettings(deviceid: &windows_core::HSTRING, additionalproperties: P1, kind: DeviceInformationKind, settings: P3) -> windows_core::Result> where P1: windows_core::Param>, P3: windows_core::Param, @@ -386,7 +386,7 @@ impl DeviceInformation { (windows_core::Interface::vtable(this).CreateFromIdAsyncWithAdditionalPropertiesKindAndSettings)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), additionalproperties.param().abi(), kind, settings.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn FindAllAsyncWithAqsFilterAdditionalPropertiesKindAndSettings(aqsfilter: &windows_core::HSTRING, additionalproperties: P1, kind: DeviceInformationKind, settings: P3) -> windows_core::Result> + pub fn FindAllAsyncWithAqsFilterAdditionalPropertiesKindAndSettings(aqsfilter: &windows_core::HSTRING, additionalproperties: P1, kind: DeviceInformationKind, settings: P3) -> windows_core::Result> where P1: windows_core::Param>, P3: windows_core::Param, @@ -507,21 +507,21 @@ impl IntoIterator for &DeviceInformationCollection { pub struct DeviceInformationCustomPairing(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(DeviceInformationCustomPairing, windows_core::IUnknown, windows_core::IInspectable); impl DeviceInformationCustomPairing { - pub fn PairAsync(&self, pairingkindssupported: DevicePairingKinds) -> windows_core::Result> { + pub fn PairAsync(&self, pairingkindssupported: DevicePairingKinds) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).PairAsync)(windows_core::Interface::as_raw(this), pairingkindssupported, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn PairWithProtectionLevelAsync(&self, pairingkindssupported: DevicePairingKinds, minprotectionlevel: DevicePairingProtectionLevel) -> windows_core::Result> { + pub fn PairWithProtectionLevelAsync(&self, pairingkindssupported: DevicePairingKinds, minprotectionlevel: DevicePairingProtectionLevel) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).PairWithProtectionLevelAsync)(windows_core::Interface::as_raw(this), pairingkindssupported, minprotectionlevel, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn PairWithProtectionLevelAndSettingsAsync(&self, pairingkindssupported: DevicePairingKinds, minprotectionlevel: DevicePairingProtectionLevel, devicepairingsettings: P2) -> windows_core::Result> + pub fn PairWithProtectionLevelAndSettingsAsync(&self, pairingkindssupported: DevicePairingKinds, minprotectionlevel: DevicePairingProtectionLevel, devicepairingsettings: P2) -> windows_core::Result> where P2: windows_core::Param, { @@ -619,14 +619,14 @@ impl DeviceInformationPairing { (windows_core::Interface::vtable(this).CanPair)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn PairAsync(&self) -> windows_core::Result> { + pub fn PairAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).PairAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn PairWithProtectionLevelAsync(&self, minprotectionlevel: DevicePairingProtectionLevel) -> windows_core::Result> { + pub fn PairWithProtectionLevelAsync(&self, minprotectionlevel: DevicePairingProtectionLevel) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -647,7 +647,7 @@ impl DeviceInformationPairing { (windows_core::Interface::vtable(this).Custom)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn PairWithProtectionLevelAndSettingsAsync(&self, minprotectionlevel: DevicePairingProtectionLevel, devicepairingsettings: P1) -> windows_core::Result> + pub fn PairWithProtectionLevelAndSettingsAsync(&self, minprotectionlevel: DevicePairingProtectionLevel, devicepairingsettings: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -657,7 +657,7 @@ impl DeviceInformationPairing { (windows_core::Interface::vtable(this).PairWithProtectionLevelAndSettingsAsync)(windows_core::Interface::as_raw(this), minprotectionlevel, devicepairingsettings.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn UnpairAsync(&self) -> windows_core::Result> { + pub fn UnpairAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1071,7 +1071,7 @@ impl DevicePicker { let this = self; unsafe { (windows_core::Interface::vtable(this).ShowWithPlacement)(windows_core::Interface::as_raw(this), selection, placement).ok() } } - pub fn PickSingleDeviceAsync(&self, selection: super::super::Foundation::Rect) -> windows_core::Result> { + pub fn PickSingleDeviceAsync(&self, selection: super::super::Foundation::Rect) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1079,7 +1079,7 @@ impl DevicePicker { } } #[cfg(feature = "UI_Popups")] - pub fn PickSingleDeviceAsyncWithPlacement(&self, selection: super::super::Foundation::Rect, placement: super::super::UI::Popups::Placement) -> windows_core::Result> { + pub fn PickSingleDeviceAsyncWithPlacement(&self, selection: super::super::Foundation::Rect, placement: super::super::UI::Popups::Placement) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1343,7 +1343,7 @@ impl DeviceThumbnail { (windows_core::Interface::vtable(this).ContentType)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn ReadAsync(&self, buffer: P0, count: u32, options: super::super::Storage::Streams::InputStreamOptions) -> windows_core::Result> + pub fn ReadAsync(&self, buffer: P0, count: u32, options: super::super::Storage::Streams::InputStreamOptions) -> windows_core::Result> where P0: windows_core::Param, { @@ -1353,7 +1353,7 @@ impl DeviceThumbnail { (windows_core::Interface::vtable(this).ReadAsync)(windows_core::Interface::as_raw(this), buffer.param().abi(), count, options, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn WriteAsync(&self, buffer: P0) -> windows_core::Result> + pub fn WriteAsync(&self, buffer: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1363,7 +1363,7 @@ impl DeviceThumbnail { (windows_core::Interface::vtable(this).WriteAsync)(windows_core::Interface::as_raw(this), buffer.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FlushAsync(&self) -> windows_core::Result> { + pub fn FlushAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Devices/Geolocation/mod.rs b/crates/libs/windows/src/Windows/Devices/Geolocation/mod.rs index 477c8bcda6..6b1e2dbe98 100644 --- a/crates/libs/windows/src/Windows/Devices/Geolocation/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/Geolocation/mod.rs @@ -519,14 +519,14 @@ impl Geolocator { (windows_core::Interface::vtable(this).LocationStatus)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn GetGeopositionAsync(&self) -> windows_core::Result> { + pub fn GetGeopositionAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetGeopositionAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetGeopositionAsyncWithAgeAndTimeout(&self, maximumage: super::super::Foundation::TimeSpan, timeout: super::super::Foundation::TimeSpan) -> windows_core::Result> { + pub fn GetGeopositionAsyncWithAgeAndTimeout(&self, maximumage: super::super::Foundation::TimeSpan, timeout: super::super::Foundation::TimeSpan) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -565,19 +565,19 @@ impl Geolocator { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).AllowFallbackToConsentlessPositions)(windows_core::Interface::as_raw(this)).ok() } } - pub fn RequestAccessAsync() -> windows_core::Result> { + pub fn RequestAccessAsync() -> windows_core::Result> { Self::IGeolocatorStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestAccessAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetGeopositionHistoryAsync(starttime: super::super::Foundation::DateTime) -> windows_core::Result>> { + pub fn GetGeopositionHistoryAsync(starttime: super::super::Foundation::DateTime) -> windows_core::Result>> { Self::IGeolocatorStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetGeopositionHistoryAsync)(windows_core::Interface::as_raw(this), starttime, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetGeopositionHistoryWithDurationAsync(starttime: super::super::Foundation::DateTime, duration: super::super::Foundation::TimeSpan) -> windows_core::Result>> { + pub fn GetGeopositionHistoryWithDurationAsync(starttime: super::super::Foundation::DateTime, duration: super::super::Foundation::TimeSpan) -> windows_core::Result>> { Self::IGeolocatorStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetGeopositionHistoryWithDurationAsync)(windows_core::Interface::as_raw(this), starttime, duration, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -917,7 +917,7 @@ impl GeovisitMonitor { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveVisitStateChanged)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn GetLastReportAsync() -> windows_core::Result> { + pub fn GetLastReportAsync() -> windows_core::Result> { Self::IGeovisitMonitorStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetLastReportAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/Devices/Gpio/mod.rs b/crates/libs/windows/src/Windows/Devices/Gpio/mod.rs index c5740e5b02..57291e700e 100644 --- a/crates/libs/windows/src/Windows/Devices/Gpio/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/Gpio/mod.rs @@ -191,7 +191,7 @@ impl GpioChangeReader { (windows_core::Interface::vtable(this).GetAllItems)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn WaitForItemsAsync(&self, count: i32) -> windows_core::Result { + pub fn WaitForItemsAsync(&self, count: i32) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -285,7 +285,7 @@ impl GpioController { }) } #[cfg(feature = "Devices_Gpio_Provider")] - pub fn GetControllersAsync(provider: P0) -> windows_core::Result>> + pub fn GetControllersAsync(provider: P0) -> windows_core::Result>> where P0: windows_core::Param, { @@ -294,7 +294,7 @@ impl GpioController { (windows_core::Interface::vtable(this).GetControllersAsync)(windows_core::Interface::as_raw(this), provider.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetDefaultAsync() -> windows_core::Result> { + pub fn GetDefaultAsync() -> windows_core::Result> { Self::IGpioControllerStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetDefaultAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/Devices/Haptics/mod.rs b/crates/libs/windows/src/Windows/Devices/Haptics/mod.rs index e9f678c165..210bc31e3d 100644 --- a/crates/libs/windows/src/Windows/Devices/Haptics/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/Haptics/mod.rs @@ -343,7 +343,7 @@ impl VibrationDevice { (windows_core::Interface::vtable(this).SimpleHapticsController)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestAccessAsync() -> windows_core::Result> { + pub fn RequestAccessAsync() -> windows_core::Result> { Self::IVibrationDeviceStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestAccessAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -355,19 +355,19 @@ impl VibrationDevice { (windows_core::Interface::vtable(this).GetDeviceSelector)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IVibrationDeviceStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetDefaultAsync() -> windows_core::Result> { + pub fn GetDefaultAsync() -> windows_core::Result> { Self::IVibrationDeviceStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetDefaultAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn FindAllAsync() -> windows_core::Result>> { + pub fn FindAllAsync() -> windows_core::Result>> { Self::IVibrationDeviceStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAllAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/Devices/HumanInterfaceDevice/mod.rs b/crates/libs/windows/src/Windows/Devices/HumanInterfaceDevice/mod.rs index 15b75992b6..65fef72173 100644 --- a/crates/libs/windows/src/Windows/Devices/HumanInterfaceDevice/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/HumanInterfaceDevice/mod.rs @@ -232,28 +232,28 @@ impl HidDevice { (windows_core::Interface::vtable(this).UsageId)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn GetInputReportAsync(&self) -> windows_core::Result> { + pub fn GetInputReportAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetInputReportAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetInputReportByIdAsync(&self, reportid: u16) -> windows_core::Result> { + pub fn GetInputReportByIdAsync(&self, reportid: u16) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetInputReportByIdAsync)(windows_core::Interface::as_raw(this), reportid, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetFeatureReportAsync(&self) -> windows_core::Result> { + pub fn GetFeatureReportAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFeatureReportAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetFeatureReportByIdAsync(&self, reportid: u16) -> windows_core::Result> { + pub fn GetFeatureReportByIdAsync(&self, reportid: u16) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -288,7 +288,7 @@ impl HidDevice { (windows_core::Interface::vtable(this).CreateFeatureReportById)(windows_core::Interface::as_raw(this), reportid, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SendOutputReportAsync(&self, outputreport: P0) -> windows_core::Result> + pub fn SendOutputReportAsync(&self, outputreport: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -298,7 +298,7 @@ impl HidDevice { (windows_core::Interface::vtable(this).SendOutputReportAsync)(windows_core::Interface::as_raw(this), outputreport.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SendFeatureReportAsync(&self, featurereport: P0) -> windows_core::Result> + pub fn SendFeatureReportAsync(&self, featurereport: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -349,7 +349,7 @@ impl HidDevice { }) } #[cfg(feature = "Storage")] - pub fn FromIdAsync(deviceid: &windows_core::HSTRING, accessmode: super::super::Storage::FileAccessMode) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING, accessmode: super::super::Storage::FileAccessMode) -> windows_core::Result> { Self::IHidDeviceStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), accessmode, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/Devices/I2c/Provider/mod.rs b/crates/libs/windows/src/Windows/Devices/I2c/Provider/mod.rs index d9cd392908..4f5c6b4c09 100644 --- a/crates/libs/windows/src/Windows/Devices/I2c/Provider/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/I2c/Provider/mod.rs @@ -215,7 +215,7 @@ impl windows_core::RuntimeType for II2cProvider { } windows_core::imp::interface_hierarchy!(II2cProvider, windows_core::IUnknown, windows_core::IInspectable); impl II2cProvider { - pub fn GetControllersAsync(&self) -> windows_core::Result>> { + pub fn GetControllersAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -227,7 +227,7 @@ impl windows_core::RuntimeName for II2cProvider { const NAME: &'static str = "Windows.Devices.I2c.Provider.II2cProvider"; } pub trait II2cProvider_Impl: windows_core::IUnknownImpl { - fn GetControllersAsync(&self) -> windows_core::Result>>; + fn GetControllersAsync(&self) -> windows_core::Result>>; } impl II2cProvider_Vtbl { pub const fn new() -> Self { diff --git a/crates/libs/windows/src/Windows/Devices/I2c/mod.rs b/crates/libs/windows/src/Windows/Devices/I2c/mod.rs index 4a7a1aaa9c..516bac8b6e 100644 --- a/crates/libs/windows/src/Windows/Devices/I2c/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/I2c/mod.rs @@ -90,7 +90,7 @@ impl I2cController { } } #[cfg(feature = "Devices_I2c_Provider")] - pub fn GetControllersAsync(provider: P0) -> windows_core::Result>> + pub fn GetControllersAsync(provider: P0) -> windows_core::Result>> where P0: windows_core::Param, { @@ -99,7 +99,7 @@ impl I2cController { (windows_core::Interface::vtable(this).GetControllersAsync)(windows_core::Interface::as_raw(this), provider.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetDefaultAsync() -> windows_core::Result> { + pub fn GetDefaultAsync() -> windows_core::Result> { Self::II2cControllerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetDefaultAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -191,7 +191,7 @@ impl I2cDevice { (windows_core::Interface::vtable(this).GetDeviceSelectorFromFriendlyName)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(friendlyname), &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING, settings: P1) -> windows_core::Result> + pub fn FromIdAsync(deviceid: &windows_core::HSTRING, settings: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -339,7 +339,7 @@ impl II2cDeviceStatics { (windows_core::Interface::vtable(this).GetDeviceSelectorFromFriendlyName)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(friendlyname), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn FromIdAsync(&self, deviceid: &windows_core::HSTRING, settings: P1) -> windows_core::Result> + pub fn FromIdAsync(&self, deviceid: &windows_core::HSTRING, settings: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -356,7 +356,7 @@ impl windows_core::RuntimeName for II2cDeviceStatics { pub trait II2cDeviceStatics_Impl: windows_core::IUnknownImpl { fn GetDeviceSelector(&self) -> windows_core::Result; fn GetDeviceSelectorFromFriendlyName(&self, friendlyName: &windows_core::HSTRING) -> windows_core::Result; - fn FromIdAsync(&self, deviceId: &windows_core::HSTRING, settings: windows_core::Ref<'_, I2cConnectionSettings>) -> windows_core::Result>; + fn FromIdAsync(&self, deviceId: &windows_core::HSTRING, settings: windows_core::Ref<'_, I2cConnectionSettings>) -> windows_core::Result>; } impl II2cDeviceStatics_Vtbl { pub const fn new() -> Self { diff --git a/crates/libs/windows/src/Windows/Devices/Input/Preview/mod.rs b/crates/libs/windows/src/Windows/Devices/Input/Preview/mod.rs index ce313faf11..714b777fc1 100644 --- a/crates/libs/windows/src/Windows/Devices/Input/Preview/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/Input/Preview/mod.rs @@ -47,7 +47,7 @@ impl GazeDevicePreview { (windows_core::Interface::vtable(this).ConfigurationState)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn RequestCalibrationAsync(&self) -> windows_core::Result> { + pub fn RequestCalibrationAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Devices/Lights/mod.rs b/crates/libs/windows/src/Windows/Devices/Lights/mod.rs index 82ed3b71ff..13a56739a2 100644 --- a/crates/libs/windows/src/Windows/Devices/Lights/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/Lights/mod.rs @@ -232,13 +232,13 @@ impl Lamp { (windows_core::Interface::vtable(this).GetDeviceSelector)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::ILampStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetDefaultAsync() -> windows_core::Result> { + pub fn GetDefaultAsync() -> windows_core::Result> { Self::ILampStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetDefaultAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -416,7 +416,7 @@ impl LampArray { unsafe { (windows_core::Interface::vtable(this).SetColorsForPurposes)(windows_core::Interface::as_raw(this), desiredcolor, purposes).ok() } } #[cfg(feature = "Storage_Streams")] - pub fn SendMessageAsync(&self, messageid: i32, message: P1) -> windows_core::Result + pub fn SendMessageAsync(&self, messageid: i32, message: P1) -> windows_core::Result where P1: windows_core::Param, { @@ -427,7 +427,7 @@ impl LampArray { } } #[cfg(feature = "Storage_Streams")] - pub fn RequestMessageAsync(&self, messageid: i32) -> windows_core::Result> { + pub fn RequestMessageAsync(&self, messageid: i32) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -461,7 +461,7 @@ impl LampArray { (windows_core::Interface::vtable(this).GetDeviceSelector)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::ILampArrayStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/Devices/Midi/mod.rs b/crates/libs/windows/src/Windows/Devices/Midi/mod.rs index 3063a5f1a1..924e40c707 100644 --- a/crates/libs/windows/src/Windows/Devices/Midi/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/Midi/mod.rs @@ -728,7 +728,7 @@ impl MidiInPort { (windows_core::Interface::vtable(this).DeviceId)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IMidiInPortStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -989,7 +989,7 @@ impl MidiOutPort { (windows_core::Interface::vtable(this).DeviceId)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IMidiOutPortStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -1481,14 +1481,14 @@ impl MidiSynthesizer { let this = self; unsafe { (windows_core::Interface::vtable(this).SetVolume)(windows_core::Interface::as_raw(this), value).ok() } } - pub fn CreateAsync() -> windows_core::Result> { + pub fn CreateAsync() -> windows_core::Result> { Self::IMidiSynthesizerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreateAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "Devices_Enumeration")] - pub fn CreateFromAudioDeviceAsync(audiodevice: P0) -> windows_core::Result> + pub fn CreateFromAudioDeviceAsync(audiodevice: P0) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Devices/PointOfService/Provider/mod.rs b/crates/libs/windows/src/Windows/Devices/PointOfService/Provider/mod.rs index 6f48d62aa1..a6620fec7f 100644 --- a/crates/libs/windows/src/Windows/Devices/PointOfService/Provider/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/PointOfService/Provider/mod.rs @@ -3,28 +3,28 @@ pub struct BarcodeScannerDisableScannerRequest(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(BarcodeScannerDisableScannerRequest, windows_core::IUnknown, windows_core::IInspectable); impl BarcodeScannerDisableScannerRequest { - pub fn ReportCompletedAsync(&self) -> windows_core::Result { + pub fn ReportCompletedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportFailedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedWithFailedReasonAsync(&self, reason: i32) -> windows_core::Result { + pub fn ReportFailedWithFailedReasonAsync(&self, reason: i32) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportFailedWithFailedReasonAsync)(windows_core::Interface::as_raw(this), reason, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedWithFailedReasonAndDescriptionAsync(&self, reason: i32, failedreasondescription: &windows_core::HSTRING) -> windows_core::Result { + pub fn ReportFailedWithFailedReasonAndDescriptionAsync(&self, reason: i32, failedreasondescription: &windows_core::HSTRING) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -81,28 +81,28 @@ unsafe impl Sync for BarcodeScannerDisableScannerRequestEventArgs {} pub struct BarcodeScannerEnableScannerRequest(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(BarcodeScannerEnableScannerRequest, windows_core::IUnknown, windows_core::IInspectable); impl BarcodeScannerEnableScannerRequest { - pub fn ReportCompletedAsync(&self) -> windows_core::Result { + pub fn ReportCompletedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportFailedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedWithFailedReasonAsync(&self, reason: i32) -> windows_core::Result { + pub fn ReportFailedWithFailedReasonAsync(&self, reason: i32) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportFailedWithFailedReasonAsync)(windows_core::Interface::as_raw(this), reason, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedWithFailedReasonAndDescriptionAsync(&self, reason: i32, failedreasondescription: &windows_core::HSTRING) -> windows_core::Result { + pub fn ReportFailedWithFailedReasonAndDescriptionAsync(&self, reason: i32, failedreasondescription: &windows_core::HSTRING) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -160,21 +160,21 @@ pub struct BarcodeScannerFrameReader(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(BarcodeScannerFrameReader, windows_core::IUnknown, windows_core::IInspectable); windows_core::imp::required_hierarchy!(BarcodeScannerFrameReader, super::super::super::Foundation::IClosable); impl BarcodeScannerFrameReader { - pub fn StartAsync(&self) -> windows_core::Result> { + pub fn StartAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).StartAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StopAsync(&self) -> windows_core::Result { + pub fn StopAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).StopAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryAcquireLatestFrameAsync(&self) -> windows_core::Result> { + pub fn TryAcquireLatestFrameAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -256,7 +256,7 @@ impl BarcodeScannerGetSymbologyAttributesRequest { (windows_core::Interface::vtable(this).Symbology)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn ReportCompletedAsync(&self, attributes: P0) -> windows_core::Result + pub fn ReportCompletedAsync(&self, attributes: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -266,21 +266,21 @@ impl BarcodeScannerGetSymbologyAttributesRequest { (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), attributes.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportFailedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedWithFailedReasonAsync(&self, reason: i32) -> windows_core::Result { + pub fn ReportFailedWithFailedReasonAsync(&self, reason: i32) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportFailedWithFailedReasonAsync)(windows_core::Interface::as_raw(this), reason, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedWithFailedReasonAndDescriptionAsync(&self, reason: i32, failedreasondescription: &windows_core::HSTRING) -> windows_core::Result { + pub fn ReportFailedWithFailedReasonAndDescriptionAsync(&self, reason: i32, failedreasondescription: &windows_core::HSTRING) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -337,28 +337,28 @@ unsafe impl Sync for BarcodeScannerGetSymbologyAttributesRequestEventArgs {} pub struct BarcodeScannerHideVideoPreviewRequest(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(BarcodeScannerHideVideoPreviewRequest, windows_core::IUnknown, windows_core::IInspectable); impl BarcodeScannerHideVideoPreviewRequest { - pub fn ReportCompletedAsync(&self) -> windows_core::Result { + pub fn ReportCompletedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportFailedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedWithFailedReasonAsync(&self, reason: i32) -> windows_core::Result { + pub fn ReportFailedWithFailedReasonAsync(&self, reason: i32) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportFailedWithFailedReasonAsync)(windows_core::Interface::as_raw(this), reason, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedWithFailedReasonAndDescriptionAsync(&self, reason: i32, failedreasondescription: &windows_core::HSTRING) -> windows_core::Result { + pub fn ReportFailedWithFailedReasonAndDescriptionAsync(&self, reason: i32, failedreasondescription: &windows_core::HSTRING) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -474,7 +474,7 @@ impl BarcodeScannerProviderConnection { let this = self; unsafe { (windows_core::Interface::vtable(this).Start)(windows_core::Interface::as_raw(this)).ok() } } - pub fn ReportScannedDataAsync(&self, report: P0) -> windows_core::Result + pub fn ReportScannedDataAsync(&self, report: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -484,14 +484,14 @@ impl BarcodeScannerProviderConnection { (windows_core::Interface::vtable(this).ReportScannedDataAsync)(windows_core::Interface::as_raw(this), report.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportTriggerStateAsync(&self, state: BarcodeScannerTriggerState) -> windows_core::Result { + pub fn ReportTriggerStateAsync(&self, state: BarcodeScannerTriggerState) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportTriggerStateAsync)(windows_core::Interface::as_raw(this), state, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportErrorAsync(&self, errordata: P0) -> windows_core::Result + pub fn ReportErrorAsync(&self, errordata: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -501,7 +501,7 @@ impl BarcodeScannerProviderConnection { (windows_core::Interface::vtable(this).ReportErrorAsync)(windows_core::Interface::as_raw(this), errordata.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportErrorAsyncWithScanReport(&self, errordata: P0, isretriable: bool, scanreport: P2) -> windows_core::Result + pub fn ReportErrorAsyncWithScanReport(&self, errordata: P0, isretriable: bool, scanreport: P2) -> windows_core::Result where P0: windows_core::Param, P2: windows_core::Param, @@ -624,7 +624,7 @@ impl BarcodeScannerProviderConnection { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveHideVideoPreviewRequested)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn CreateFrameReaderAsync(&self) -> windows_core::Result> { + pub fn CreateFrameReaderAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -632,7 +632,7 @@ impl BarcodeScannerProviderConnection { } } #[cfg(feature = "Graphics_Imaging")] - pub fn CreateFrameReaderWithFormatAsync(&self, preferredformat: super::super::super::Graphics::Imaging::BitmapPixelFormat) -> windows_core::Result> { + pub fn CreateFrameReaderWithFormatAsync(&self, preferredformat: super::super::super::Graphics::Imaging::BitmapPixelFormat) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -640,7 +640,7 @@ impl BarcodeScannerProviderConnection { } } #[cfg(feature = "Graphics_Imaging")] - pub fn CreateFrameReaderWithFormatAndSizeAsync(&self, preferredformat: super::super::super::Graphics::Imaging::BitmapPixelFormat, preferredsize: super::super::super::Graphics::Imaging::BitmapSize) -> windows_core::Result> { + pub fn CreateFrameReaderWithFormatAndSizeAsync(&self, preferredformat: super::super::super::Graphics::Imaging::BitmapPixelFormat, preferredsize: super::super::super::Graphics::Imaging::BitmapSize) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -701,28 +701,28 @@ impl BarcodeScannerSetActiveSymbologiesRequest { (windows_core::Interface::vtable(this).Symbologies)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportCompletedAsync(&self) -> windows_core::Result { + pub fn ReportCompletedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportFailedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedWithFailedReasonAsync(&self, reason: i32) -> windows_core::Result { + pub fn ReportFailedWithFailedReasonAsync(&self, reason: i32) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportFailedWithFailedReasonAsync)(windows_core::Interface::as_raw(this), reason, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedWithFailedReasonAndDescriptionAsync(&self, reason: i32, failedreasondescription: &windows_core::HSTRING) -> windows_core::Result { + pub fn ReportFailedWithFailedReasonAndDescriptionAsync(&self, reason: i32, failedreasondescription: &windows_core::HSTRING) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -793,28 +793,28 @@ impl BarcodeScannerSetSymbologyAttributesRequest { (windows_core::Interface::vtable(this).Attributes)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportCompletedAsync(&self) -> windows_core::Result { + pub fn ReportCompletedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportFailedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedWithFailedReasonAsync(&self, reason: i32) -> windows_core::Result { + pub fn ReportFailedWithFailedReasonAsync(&self, reason: i32) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportFailedWithFailedReasonAsync)(windows_core::Interface::as_raw(this), reason, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedWithFailedReasonAndDescriptionAsync(&self, reason: i32, failedreasondescription: &windows_core::HSTRING) -> windows_core::Result { + pub fn ReportFailedWithFailedReasonAndDescriptionAsync(&self, reason: i32, failedreasondescription: &windows_core::HSTRING) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -871,28 +871,28 @@ unsafe impl Sync for BarcodeScannerSetSymbologyAttributesRequestEventArgs {} pub struct BarcodeScannerStartSoftwareTriggerRequest(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(BarcodeScannerStartSoftwareTriggerRequest, windows_core::IUnknown, windows_core::IInspectable); impl BarcodeScannerStartSoftwareTriggerRequest { - pub fn ReportCompletedAsync(&self) -> windows_core::Result { + pub fn ReportCompletedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportFailedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedWithFailedReasonAsync(&self, reason: i32) -> windows_core::Result { + pub fn ReportFailedWithFailedReasonAsync(&self, reason: i32) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportFailedWithFailedReasonAsync)(windows_core::Interface::as_raw(this), reason, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedWithFailedReasonAndDescriptionAsync(&self, reason: i32, failedreasondescription: &windows_core::HSTRING) -> windows_core::Result { + pub fn ReportFailedWithFailedReasonAndDescriptionAsync(&self, reason: i32, failedreasondescription: &windows_core::HSTRING) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -949,28 +949,28 @@ unsafe impl Sync for BarcodeScannerStartSoftwareTriggerRequestEventArgs {} pub struct BarcodeScannerStopSoftwareTriggerRequest(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(BarcodeScannerStopSoftwareTriggerRequest, windows_core::IUnknown, windows_core::IInspectable); impl BarcodeScannerStopSoftwareTriggerRequest { - pub fn ReportCompletedAsync(&self) -> windows_core::Result { + pub fn ReportCompletedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportCompletedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedAsync(&self) -> windows_core::Result { + pub fn ReportFailedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportFailedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedWithFailedReasonAsync(&self, reason: i32) -> windows_core::Result { + pub fn ReportFailedWithFailedReasonAsync(&self, reason: i32) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportFailedWithFailedReasonAsync)(windows_core::Interface::as_raw(this), reason, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportFailedWithFailedReasonAndDescriptionAsync(&self, reason: i32, failedreasondescription: &windows_core::HSTRING) -> windows_core::Result { + pub fn ReportFailedWithFailedReasonAndDescriptionAsync(&self, reason: i32, failedreasondescription: &windows_core::HSTRING) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Devices/PointOfService/mod.rs b/crates/libs/windows/src/Windows/Devices/PointOfService/mod.rs index bad7bb3e7b..88ce535d8b 100644 --- a/crates/libs/windows/src/Windows/Devices/PointOfService/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/PointOfService/mod.rs @@ -20,28 +20,28 @@ impl BarcodeScanner { (windows_core::Interface::vtable(this).Capabilities)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ClaimScannerAsync(&self) -> windows_core::Result> { + pub fn ClaimScannerAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ClaimScannerAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CheckHealthAsync(&self, level: UnifiedPosHealthCheckLevel) -> windows_core::Result> { + pub fn CheckHealthAsync(&self, level: UnifiedPosHealthCheckLevel) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CheckHealthAsync)(windows_core::Interface::as_raw(this), level, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetSupportedSymbologiesAsync(&self) -> windows_core::Result>> { + pub fn GetSupportedSymbologiesAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetSupportedSymbologiesAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn IsSymbologySupportedAsync(&self, barcodesymbology: u32) -> windows_core::Result> { + pub fn IsSymbologySupportedAsync(&self, barcodesymbology: u32) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -49,7 +49,7 @@ impl BarcodeScanner { } } #[cfg(feature = "Storage_Streams")] - pub fn RetrieveStatisticsAsync(&self, statisticscategories: P0) -> windows_core::Result> + pub fn RetrieveStatisticsAsync(&self, statisticscategories: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -94,13 +94,13 @@ impl BarcodeScanner { (windows_core::Interface::vtable(this).VideoDeviceId)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn GetDefaultAsync() -> windows_core::Result> { + pub fn GetDefaultAsync() -> windows_core::Result> { Self::IBarcodeScannerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetDefaultAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IBarcodeScannerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -1130,21 +1130,21 @@ impl CashDrawer { (windows_core::Interface::vtable(this).DrawerEventSource)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ClaimDrawerAsync(&self) -> windows_core::Result> { + pub fn ClaimDrawerAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ClaimDrawerAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CheckHealthAsync(&self, level: UnifiedPosHealthCheckLevel) -> windows_core::Result> { + pub fn CheckHealthAsync(&self, level: UnifiedPosHealthCheckLevel) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CheckHealthAsync)(windows_core::Interface::as_raw(this), level, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetStatisticsAsync(&self, statisticscategories: P0) -> windows_core::Result> + pub fn GetStatisticsAsync(&self, statisticscategories: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -1168,13 +1168,13 @@ impl CashDrawer { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveStatusUpdated)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn GetDefaultAsync() -> windows_core::Result> { + pub fn GetDefaultAsync() -> windows_core::Result> { Self::ICashDrawerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetDefaultAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::ICashDrawerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -1340,7 +1340,7 @@ impl CashDrawerCloseAlarm { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveAlarmTimeoutExpired)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn StartAsync(&self) -> windows_core::Result> { + pub fn StartAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1571,14 +1571,14 @@ impl ClaimedBarcodeScanner { (windows_core::Interface::vtable(this).IsDecodeDataEnabled)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn EnableAsync(&self) -> windows_core::Result { + pub fn EnableAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).EnableAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DisableAsync(&self) -> windows_core::Result { + pub fn DisableAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1589,7 +1589,7 @@ impl ClaimedBarcodeScanner { let this = self; unsafe { (windows_core::Interface::vtable(this).RetainDevice)(windows_core::Interface::as_raw(this)).ok() } } - pub fn SetActiveSymbologiesAsync(&self, symbologies: P0) -> windows_core::Result + pub fn SetActiveSymbologiesAsync(&self, symbologies: P0) -> windows_core::Result where P0: windows_core::Param>, { @@ -1599,7 +1599,7 @@ impl ClaimedBarcodeScanner { (windows_core::Interface::vtable(this).SetActiveSymbologiesAsync)(windows_core::Interface::as_raw(this), symbologies.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ResetStatisticsAsync(&self, statisticscategories: P0) -> windows_core::Result + pub fn ResetStatisticsAsync(&self, statisticscategories: P0) -> windows_core::Result where P0: windows_core::Param>, { @@ -1609,7 +1609,7 @@ impl ClaimedBarcodeScanner { (windows_core::Interface::vtable(this).ResetStatisticsAsync)(windows_core::Interface::as_raw(this), statisticscategories.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn UpdateStatisticsAsync(&self, statistics: P0) -> windows_core::Result + pub fn UpdateStatisticsAsync(&self, statistics: P0) -> windows_core::Result where P0: windows_core::Param>>, { @@ -1619,7 +1619,7 @@ impl ClaimedBarcodeScanner { (windows_core::Interface::vtable(this).UpdateStatisticsAsync)(windows_core::Interface::as_raw(this), statistics.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SetActiveProfileAsync(&self, profile: &windows_core::HSTRING) -> windows_core::Result { + pub fn SetActiveProfileAsync(&self, profile: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1710,28 +1710,28 @@ impl ClaimedBarcodeScanner { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveErrorOccurred)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn StartSoftwareTriggerAsync(&self) -> windows_core::Result { + pub fn StartSoftwareTriggerAsync(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).StartSoftwareTriggerAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StopSoftwareTriggerAsync(&self) -> windows_core::Result { + pub fn StopSoftwareTriggerAsync(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).StopSoftwareTriggerAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetSymbologyAttributesAsync(&self, barcodesymbology: u32) -> windows_core::Result> { + pub fn GetSymbologyAttributesAsync(&self, barcodesymbology: u32) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetSymbologyAttributesAsync)(windows_core::Interface::as_raw(this), barcodesymbology, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SetSymbologyAttributesAsync(&self, barcodesymbology: u32, attributes: P1) -> windows_core::Result> + pub fn SetSymbologyAttributesAsync(&self, barcodesymbology: u32, attributes: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -1741,7 +1741,7 @@ impl ClaimedBarcodeScanner { (windows_core::Interface::vtable(this).SetSymbologyAttributesAsync)(windows_core::Interface::as_raw(this), barcodesymbology, attributes.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ShowVideoPreviewAsync(&self) -> windows_core::Result> { + pub fn ShowVideoPreviewAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1845,35 +1845,35 @@ impl ClaimedCashDrawer { (windows_core::Interface::vtable(this).CloseAlarm)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn OpenDrawerAsync(&self) -> windows_core::Result> { + pub fn OpenDrawerAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).OpenDrawerAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn EnableAsync(&self) -> windows_core::Result> { + pub fn EnableAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).EnableAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DisableAsync(&self) -> windows_core::Result> { + pub fn DisableAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DisableAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RetainDeviceAsync(&self) -> windows_core::Result> { + pub fn RetainDeviceAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RetainDeviceAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ResetStatisticsAsync(&self, statisticscategories: P0) -> windows_core::Result> + pub fn ResetStatisticsAsync(&self, statisticscategories: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -1883,7 +1883,7 @@ impl ClaimedCashDrawer { (windows_core::Interface::vtable(this).ResetStatisticsAsync)(windows_core::Interface::as_raw(this), statisticscategories.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn UpdateStatisticsAsync(&self, statistics: P0) -> windows_core::Result> + pub fn UpdateStatisticsAsync(&self, statistics: P0) -> windows_core::Result> where P0: windows_core::Param>>, { @@ -2179,7 +2179,7 @@ impl ClaimedLineDisplay { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveReleaseDeviceRequested)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn GetStatisticsAsync(&self, statisticscategories: P0) -> windows_core::Result> + pub fn GetStatisticsAsync(&self, statisticscategories: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -2189,14 +2189,14 @@ impl ClaimedLineDisplay { (windows_core::Interface::vtable(this).GetStatisticsAsync)(windows_core::Interface::as_raw(this), statisticscategories.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CheckHealthAsync(&self, level: UnifiedPosHealthCheckLevel) -> windows_core::Result> { + pub fn CheckHealthAsync(&self, level: UnifiedPosHealthCheckLevel) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CheckHealthAsync)(windows_core::Interface::as_raw(this), level, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CheckPowerStatusAsync(&self) -> windows_core::Result> { + pub fn CheckPowerStatusAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -2252,7 +2252,7 @@ impl ClaimedLineDisplay { (windows_core::Interface::vtable(this).GetAttributes)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryUpdateAttributesAsync(&self, attributes: P0) -> windows_core::Result> + pub fn TryUpdateAttributesAsync(&self, attributes: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2262,21 +2262,21 @@ impl ClaimedLineDisplay { (windows_core::Interface::vtable(this).TryUpdateAttributesAsync)(windows_core::Interface::as_raw(this), attributes.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TrySetDescriptorAsync(&self, descriptor: u32, descriptorstate: LineDisplayDescriptorState) -> windows_core::Result> { + pub fn TrySetDescriptorAsync(&self, descriptor: u32, descriptorstate: LineDisplayDescriptorState) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TrySetDescriptorAsync)(windows_core::Interface::as_raw(this), descriptor, descriptorstate, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryClearDescriptorsAsync(&self) -> windows_core::Result> { + pub fn TryClearDescriptorsAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryClearDescriptorsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryCreateWindowAsync(&self, viewport: super::super::Foundation::Rect, windowsize: super::super::Foundation::Size) -> windows_core::Result> { + pub fn TryCreateWindowAsync(&self, viewport: super::super::Foundation::Rect, windowsize: super::super::Foundation::Size) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -2284,7 +2284,7 @@ impl ClaimedLineDisplay { } } #[cfg(feature = "Storage_Streams")] - pub fn TryStoreStorageFileBitmapAsync(&self, bitmap: P0) -> windows_core::Result> + pub fn TryStoreStorageFileBitmapAsync(&self, bitmap: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2295,7 +2295,7 @@ impl ClaimedLineDisplay { } } #[cfg(feature = "Storage_Streams")] - pub fn TryStoreStorageFileBitmapWithAlignmentAsync(&self, bitmap: P0, horizontalalignment: LineDisplayHorizontalAlignment, verticalalignment: LineDisplayVerticalAlignment) -> windows_core::Result> + pub fn TryStoreStorageFileBitmapWithAlignmentAsync(&self, bitmap: P0, horizontalalignment: LineDisplayHorizontalAlignment, verticalalignment: LineDisplayVerticalAlignment) -> windows_core::Result> where P0: windows_core::Param, { @@ -2306,7 +2306,7 @@ impl ClaimedLineDisplay { } } #[cfg(feature = "Storage_Streams")] - pub fn TryStoreStorageFileBitmapWithAlignmentAndWidthAsync(&self, bitmap: P0, horizontalalignment: LineDisplayHorizontalAlignment, verticalalignment: LineDisplayVerticalAlignment, widthinpixels: i32) -> windows_core::Result> + pub fn TryStoreStorageFileBitmapWithAlignmentAndWidthAsync(&self, bitmap: P0, horizontalalignment: LineDisplayHorizontalAlignment, verticalalignment: LineDisplayVerticalAlignment, widthinpixels: i32) -> windows_core::Result> where P0: windows_core::Param, { @@ -2330,7 +2330,7 @@ impl ClaimedLineDisplay { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).RemoveClosed)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IClaimedLineDisplayStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -2468,14 +2468,14 @@ impl ClaimedMagneticStripeReader { (windows_core::Interface::vtable(this).IsTransmitSentinelsEnabled)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn EnableAsync(&self) -> windows_core::Result { + pub fn EnableAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).EnableAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DisableAsync(&self) -> windows_core::Result { + pub fn DisableAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2491,35 +2491,35 @@ impl ClaimedMagneticStripeReader { unsafe { (windows_core::Interface::vtable(this).SetErrorReportingType)(windows_core::Interface::as_raw(this), value).ok() } } #[cfg(feature = "Storage_Streams")] - pub fn RetrieveDeviceAuthenticationDataAsync(&self) -> windows_core::Result> { + pub fn RetrieveDeviceAuthenticationDataAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RetrieveDeviceAuthenticationDataAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn AuthenticateDeviceAsync(&self, responsetoken: &[u8]) -> windows_core::Result { + pub fn AuthenticateDeviceAsync(&self, responsetoken: &[u8]) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).AuthenticateDeviceAsync)(windows_core::Interface::as_raw(this), responsetoken.len().try_into().unwrap(), responsetoken.as_ptr(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeAuthenticateDeviceAsync(&self, responsetoken: &[u8]) -> windows_core::Result { + pub fn DeAuthenticateDeviceAsync(&self, responsetoken: &[u8]) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeAuthenticateDeviceAsync)(windows_core::Interface::as_raw(this), responsetoken.len().try_into().unwrap(), responsetoken.as_ptr(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn UpdateKeyAsync(&self, key: &windows_core::HSTRING, keyname: &windows_core::HSTRING) -> windows_core::Result { + pub fn UpdateKeyAsync(&self, key: &windows_core::HSTRING, keyname: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).UpdateKeyAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(key), core::mem::transmute_copy(keyname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ResetStatisticsAsync(&self, statisticscategories: P0) -> windows_core::Result + pub fn ResetStatisticsAsync(&self, statisticscategories: P0) -> windows_core::Result where P0: windows_core::Param>, { @@ -2529,7 +2529,7 @@ impl ClaimedMagneticStripeReader { (windows_core::Interface::vtable(this).ResetStatisticsAsync)(windows_core::Interface::as_raw(this), statisticscategories.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn UpdateStatisticsAsync(&self, statistics: P0) -> windows_core::Result + pub fn UpdateStatisticsAsync(&self, statistics: P0) -> windows_core::Result where P0: windows_core::Param>>, { @@ -2738,28 +2738,28 @@ impl ClaimedPosPrinter { (windows_core::Interface::vtable(this).Journal)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn EnableAsync(&self) -> windows_core::Result> { + pub fn EnableAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).EnableAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DisableAsync(&self) -> windows_core::Result> { + pub fn DisableAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DisableAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RetainDeviceAsync(&self) -> windows_core::Result> { + pub fn RetainDeviceAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RetainDeviceAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ResetStatisticsAsync(&self, statisticscategories: P0) -> windows_core::Result> + pub fn ResetStatisticsAsync(&self, statisticscategories: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -2769,7 +2769,7 @@ impl ClaimedPosPrinter { (windows_core::Interface::vtable(this).ResetStatisticsAsync)(windows_core::Interface::as_raw(this), statisticscategories.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn UpdateStatisticsAsync(&self, statistics: P0) -> windows_core::Result> + pub fn UpdateStatisticsAsync(&self, statistics: P0) -> windows_core::Result> where P0: windows_core::Param>>, { @@ -3083,14 +3083,14 @@ impl ClaimedSlipPrinter { let this = self; unsafe { (windows_core::Interface::vtable(this).CloseJaws)(windows_core::Interface::as_raw(this)).ok() } } - pub fn InsertSlipAsync(&self, timeout: super::super::Foundation::TimeSpan) -> windows_core::Result> { + pub fn InsertSlipAsync(&self, timeout: super::super::Foundation::TimeSpan) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).InsertSlipAsync)(windows_core::Interface::as_raw(this), timeout, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RemoveSlipAsync(&self, timeout: super::super::Foundation::TimeSpan) -> windows_core::Result> { + pub fn RemoveSlipAsync(&self, timeout: super::super::Foundation::TimeSpan) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -5613,7 +5613,7 @@ impl IPosPrinterJob { let this = self; unsafe { (windows_core::Interface::vtable(this).PrintNewline)(windows_core::Interface::as_raw(this)).ok() } } - pub fn ExecuteAsync(&self) -> windows_core::Result> { + pub fn ExecuteAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -5628,7 +5628,7 @@ pub trait IPosPrinterJob_Impl: windows_core::IUnknownImpl { fn Print(&self, data: &windows_core::HSTRING) -> windows_core::Result<()>; fn PrintLine(&self, data: &windows_core::HSTRING) -> windows_core::Result<()>; fn PrintNewline(&self) -> windows_core::Result<()>; - fn ExecuteAsync(&self) -> windows_core::Result>; + fn ExecuteAsync(&self) -> windows_core::Result>; } impl IPosPrinterJob_Vtbl { pub const fn new() -> Self { @@ -5875,7 +5875,7 @@ impl IReceiptOrSlipJob { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).PrintNewline)(windows_core::Interface::as_raw(this)).ok() } } - pub fn ExecuteAsync(&self) -> windows_core::Result> { + pub fn ExecuteAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -6200,7 +6200,7 @@ impl JournalPrintJob { let this = self; unsafe { (windows_core::Interface::vtable(this).PrintNewline)(windows_core::Interface::as_raw(this)).ok() } } - pub fn ExecuteAsync(&self) -> windows_core::Result> { + pub fn ExecuteAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -6431,27 +6431,27 @@ impl LineDisplay { (windows_core::Interface::vtable(this).DeviceServiceVersion)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn ClaimAsync(&self) -> windows_core::Result> { + pub fn ClaimAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ClaimAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CheckPowerStatusAsync(&self) -> windows_core::Result> { + pub fn CheckPowerStatusAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CheckPowerStatusAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::ILineDisplayStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetDefaultAsync() -> windows_core::Result> { + pub fn GetDefaultAsync() -> windows_core::Result> { Self::ILineDisplayStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetDefaultAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -6799,7 +6799,7 @@ impl LineDisplayCursor { (windows_core::Interface::vtable(this).GetAttributes)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryUpdateAttributesAsync(&self, attributes: P0) -> windows_core::Result> + pub fn TryUpdateAttributesAsync(&self, attributes: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -6921,7 +6921,7 @@ impl LineDisplayCustomGlyphs { } } #[cfg(feature = "Storage_Streams")] - pub fn TryRedefineAsync(&self, glyphcode: u32, glyphdata: P1) -> windows_core::Result> + pub fn TryRedefineAsync(&self, glyphcode: u32, glyphdata: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -7010,14 +7010,14 @@ impl LineDisplayMarquee { let this = self; unsafe { (windows_core::Interface::vtable(this).SetScrollWaitInterval)(windows_core::Interface::as_raw(this), value).ok() } } - pub fn TryStartScrollingAsync(&self, direction: LineDisplayScrollDirection) -> windows_core::Result> { + pub fn TryStartScrollingAsync(&self, direction: LineDisplayScrollDirection) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryStartScrollingAsync)(windows_core::Interface::as_raw(this), direction, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryStopScrollingAsync(&self) -> windows_core::Result> { + pub fn TryStopScrollingAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -7158,7 +7158,7 @@ impl LineDisplayStoredBitmap { (windows_core::Interface::vtable(this).EscapeSequence)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn TryDeleteAsync(&self) -> windows_core::Result> { + pub fn TryDeleteAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -7249,42 +7249,42 @@ impl LineDisplayWindow { let this = self; unsafe { (windows_core::Interface::vtable(this).SetInterCharacterWaitInterval)(windows_core::Interface::as_raw(this), value).ok() } } - pub fn TryRefreshAsync(&self) -> windows_core::Result> { + pub fn TryRefreshAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryRefreshAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryDisplayTextAsync(&self, text: &windows_core::HSTRING, displayattribute: LineDisplayTextAttribute) -> windows_core::Result> { + pub fn TryDisplayTextAsync(&self, text: &windows_core::HSTRING, displayattribute: LineDisplayTextAttribute) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryDisplayTextAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(text), displayattribute, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryDisplayTextAtPositionAsync(&self, text: &windows_core::HSTRING, displayattribute: LineDisplayTextAttribute, startposition: super::super::Foundation::Point) -> windows_core::Result> { + pub fn TryDisplayTextAtPositionAsync(&self, text: &windows_core::HSTRING, displayattribute: LineDisplayTextAttribute, startposition: super::super::Foundation::Point) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryDisplayTextAtPositionAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(text), displayattribute, startposition, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryDisplayTextNormalAsync(&self, text: &windows_core::HSTRING) -> windows_core::Result> { + pub fn TryDisplayTextNormalAsync(&self, text: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryDisplayTextNormalAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(text), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryScrollTextAsync(&self, direction: LineDisplayScrollDirection, numberofcolumnsorrows: u32) -> windows_core::Result> { + pub fn TryScrollTextAsync(&self, direction: LineDisplayScrollDirection, numberofcolumnsorrows: u32) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryScrollTextAsync)(windows_core::Interface::as_raw(this), direction, numberofcolumnsorrows, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryClearTextAsync(&self) -> windows_core::Result> { + pub fn TryClearTextAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -7305,14 +7305,14 @@ impl LineDisplayWindow { (windows_core::Interface::vtable(this).Marquee)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReadCharacterAtCursorAsync(&self) -> windows_core::Result> { + pub fn ReadCharacterAtCursorAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReadCharacterAtCursorAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryDisplayStoredBitmapAtCursorAsync(&self, bitmap: P0) -> windows_core::Result> + pub fn TryDisplayStoredBitmapAtCursorAsync(&self, bitmap: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -7323,7 +7323,7 @@ impl LineDisplayWindow { } } #[cfg(feature = "Storage_Streams")] - pub fn TryDisplayStorageFileBitmapAtCursorAsync(&self, bitmap: P0) -> windows_core::Result> + pub fn TryDisplayStorageFileBitmapAtCursorAsync(&self, bitmap: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -7334,7 +7334,7 @@ impl LineDisplayWindow { } } #[cfg(feature = "Storage_Streams")] - pub fn TryDisplayStorageFileBitmapAtCursorWithAlignmentAsync(&self, bitmap: P0, horizontalalignment: LineDisplayHorizontalAlignment, verticalalignment: LineDisplayVerticalAlignment) -> windows_core::Result> + pub fn TryDisplayStorageFileBitmapAtCursorWithAlignmentAsync(&self, bitmap: P0, horizontalalignment: LineDisplayHorizontalAlignment, verticalalignment: LineDisplayVerticalAlignment) -> windows_core::Result> where P0: windows_core::Param, { @@ -7345,7 +7345,7 @@ impl LineDisplayWindow { } } #[cfg(feature = "Storage_Streams")] - pub fn TryDisplayStorageFileBitmapAtCursorWithAlignmentAndWidthAsync(&self, bitmap: P0, horizontalalignment: LineDisplayHorizontalAlignment, verticalalignment: LineDisplayVerticalAlignment, widthinpixels: i32) -> windows_core::Result> + pub fn TryDisplayStorageFileBitmapAtCursorWithAlignmentAndWidthAsync(&self, bitmap: P0, horizontalalignment: LineDisplayHorizontalAlignment, verticalalignment: LineDisplayVerticalAlignment, widthinpixels: i32) -> windows_core::Result> where P0: windows_core::Param, { @@ -7356,7 +7356,7 @@ impl LineDisplayWindow { } } #[cfg(feature = "Storage_Streams")] - pub fn TryDisplayStorageFileBitmapAtPointAsync(&self, bitmap: P0, offsetinpixels: super::super::Foundation::Point) -> windows_core::Result> + pub fn TryDisplayStorageFileBitmapAtPointAsync(&self, bitmap: P0, offsetinpixels: super::super::Foundation::Point) -> windows_core::Result> where P0: windows_core::Param, { @@ -7367,7 +7367,7 @@ impl LineDisplayWindow { } } #[cfg(feature = "Storage_Streams")] - pub fn TryDisplayStorageFileBitmapAtPointWithWidthAsync(&self, bitmap: P0, offsetinpixels: super::super::Foundation::Point, widthinpixels: i32) -> windows_core::Result> + pub fn TryDisplayStorageFileBitmapAtPointWithWidthAsync(&self, bitmap: P0, offsetinpixels: super::super::Foundation::Point, widthinpixels: i32) -> windows_core::Result> where P0: windows_core::Param, { @@ -7428,14 +7428,14 @@ impl MagneticStripeReader { (windows_core::Interface::vtable(this).DeviceAuthenticationProtocol)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn CheckHealthAsync(&self, level: UnifiedPosHealthCheckLevel) -> windows_core::Result> { + pub fn CheckHealthAsync(&self, level: UnifiedPosHealthCheckLevel) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CheckHealthAsync)(windows_core::Interface::as_raw(this), level, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ClaimReaderAsync(&self) -> windows_core::Result> { + pub fn ClaimReaderAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -7443,7 +7443,7 @@ impl MagneticStripeReader { } } #[cfg(feature = "Storage_Streams")] - pub fn RetrieveStatisticsAsync(&self, statisticscategories: P0) -> windows_core::Result> + pub fn RetrieveStatisticsAsync(&self, statisticscategories: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -7474,13 +7474,13 @@ impl MagneticStripeReader { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveStatusUpdated)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn GetDefaultAsync() -> windows_core::Result> { + pub fn GetDefaultAsync() -> windows_core::Result> { Self::IMagneticStripeReaderStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetDefaultAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IMagneticStripeReaderStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -8330,21 +8330,21 @@ impl PosPrinter { (windows_core::Interface::vtable(this).Status)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ClaimPrinterAsync(&self) -> windows_core::Result> { + pub fn ClaimPrinterAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ClaimPrinterAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CheckHealthAsync(&self, level: UnifiedPosHealthCheckLevel) -> windows_core::Result> { + pub fn CheckHealthAsync(&self, level: UnifiedPosHealthCheckLevel) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CheckHealthAsync)(windows_core::Interface::as_raw(this), level, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetStatisticsAsync(&self, statisticscategories: P0) -> windows_core::Result> + pub fn GetStatisticsAsync(&self, statisticscategories: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -8382,13 +8382,13 @@ impl PosPrinter { (windows_core::Interface::vtable(this).GetFontProperty)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(typeface), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetDefaultAsync() -> windows_core::Result> { + pub fn GetDefaultAsync() -> windows_core::Result> { Self::IPosPrinterStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetDefaultAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IPosPrinterStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -9196,7 +9196,7 @@ impl ReceiptPrintJob { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).PrintNewline)(windows_core::Interface::as_raw(this)).ok() } } - pub fn ExecuteAsync(&self) -> windows_core::Result> { + pub fn ExecuteAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -9605,7 +9605,7 @@ impl SlipPrintJob { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).PrintNewline)(windows_core::Interface::as_raw(this)).ok() } } - pub fn ExecuteAsync(&self) -> windows_core::Result> { + pub fn ExecuteAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Devices/Power/mod.rs b/crates/libs/windows/src/Windows/Devices/Power/mod.rs index 4923bdff59..29fb8465d9 100644 --- a/crates/libs/windows/src/Windows/Devices/Power/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/Power/mod.rs @@ -37,7 +37,7 @@ impl Battery { (windows_core::Interface::vtable(this).AggregateBattery)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IBatteryStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/Devices/Printers/mod.rs b/crates/libs/windows/src/Windows/Devices/Printers/mod.rs index 5c80976f7e..4de3462281 100644 --- a/crates/libs/windows/src/Windows/Devices/Printers/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/Printers/mod.rs @@ -1404,7 +1404,7 @@ impl Print3DDevice { (windows_core::Interface::vtable(this).PrintSchema)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IPrint3DDeviceStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -1439,7 +1439,7 @@ pub struct PrintSchema(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(PrintSchema, windows_core::IUnknown, windows_core::IInspectable); impl PrintSchema { #[cfg(feature = "Storage_Streams")] - pub fn GetDefaultPrintTicketAsync(&self) -> windows_core::Result> { + pub fn GetDefaultPrintTicketAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1447,7 +1447,7 @@ impl PrintSchema { } } #[cfg(feature = "Storage_Streams")] - pub fn GetCapabilitiesAsync(&self, constrainticket: P0) -> windows_core::Result> + pub fn GetCapabilitiesAsync(&self, constrainticket: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1458,7 +1458,7 @@ impl PrintSchema { } } #[cfg(feature = "Storage_Streams")] - pub fn MergeAndValidateWithDefaultPrintTicketAsync(&self, deltaticket: P0) -> windows_core::Result> + pub fn MergeAndValidateWithDefaultPrintTicketAsync(&self, deltaticket: P0) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Devices/Pwm/mod.rs b/crates/libs/windows/src/Windows/Devices/Pwm/mod.rs index 0266520bf6..d271144560 100644 --- a/crates/libs/windows/src/Windows/Devices/Pwm/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/Pwm/mod.rs @@ -110,7 +110,7 @@ impl PwmController { } } #[cfg(feature = "Devices_Pwm_Provider")] - pub fn GetControllersAsync(provider: P0) -> windows_core::Result>> + pub fn GetControllersAsync(provider: P0) -> windows_core::Result>> where P0: windows_core::Param, { @@ -119,7 +119,7 @@ impl PwmController { (windows_core::Interface::vtable(this).GetControllersAsync)(windows_core::Interface::as_raw(this), provider.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetDefaultAsync() -> windows_core::Result> { + pub fn GetDefaultAsync() -> windows_core::Result> { Self::IPwmControllerStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetDefaultAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -137,7 +137,7 @@ impl PwmController { (windows_core::Interface::vtable(this).GetDeviceSelectorFromFriendlyName)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(friendlyname), &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IPwmControllerStatics3(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/Devices/Radios/mod.rs b/crates/libs/windows/src/Windows/Devices/Radios/mod.rs index b166100d9f..9662ee32e9 100644 --- a/crates/libs/windows/src/Windows/Devices/Radios/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/Radios/mod.rs @@ -29,7 +29,7 @@ pub struct IRadioStatics_Vtbl { pub struct Radio(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(Radio, windows_core::IUnknown, windows_core::IInspectable); impl Radio { - pub fn SetStateAsync(&self, value: RadioState) -> windows_core::Result> { + pub fn SetStateAsync(&self, value: RadioState) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -71,7 +71,7 @@ impl Radio { (windows_core::Interface::vtable(this).Kind)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn GetRadiosAsync() -> windows_core::Result>> { + pub fn GetRadiosAsync() -> windows_core::Result>> { Self::IRadioStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetRadiosAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -83,13 +83,13 @@ impl Radio { (windows_core::Interface::vtable(this).GetDeviceSelector)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IRadioStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RequestAccessAsync() -> windows_core::Result> { + pub fn RequestAccessAsync() -> windows_core::Result> { Self::IRadioStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestAccessAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/Devices/Scanners/mod.rs b/crates/libs/windows/src/Windows/Devices/Scanners/mod.rs index 678625d392..5b0f26b6e0 100644 --- a/crates/libs/windows/src/Windows/Devices/Scanners/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/Scanners/mod.rs @@ -889,7 +889,7 @@ impl ImageScanner { } } #[cfg(feature = "Storage_Streams")] - pub fn ScanPreviewToStreamAsync(&self, scansource: ImageScannerScanSource, targetstream: P1) -> windows_core::Result> + pub fn ScanPreviewToStreamAsync(&self, scansource: ImageScannerScanSource, targetstream: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -900,7 +900,7 @@ impl ImageScanner { } } #[cfg(feature = "Storage_Search")] - pub fn ScanFilesToFolderAsync(&self, scansource: ImageScannerScanSource, storagefolder: P1) -> windows_core::Result> + pub fn ScanFilesToFolderAsync(&self, scansource: ImageScannerScanSource, storagefolder: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -910,7 +910,7 @@ impl ImageScanner { (windows_core::Interface::vtable(this).ScanFilesToFolderAsync)(windows_core::Interface::as_raw(this), scansource, storagefolder.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IImageScannerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/Devices/Sensors/Custom/mod.rs b/crates/libs/windows/src/Windows/Devices/Sensors/Custom/mod.rs index 71310ca650..fdbd4b653b 100644 --- a/crates/libs/windows/src/Windows/Devices/Sensors/Custom/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/Sensors/Custom/mod.rs @@ -73,7 +73,7 @@ impl CustomSensor { (windows_core::Interface::vtable(this).GetDeviceSelector)(windows_core::Interface::as_raw(this), interfaceid, &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn FromIdAsync(sensorid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(sensorid: &windows_core::HSTRING) -> windows_core::Result> { Self::ICustomSensorStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(sensorid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/Devices/Sensors/mod.rs b/crates/libs/windows/src/Windows/Devices/Sensors/mod.rs index e24e1761e5..7fcf048732 100644 --- a/crates/libs/windows/src/Windows/Devices/Sensors/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/Sensors/mod.rs @@ -122,7 +122,7 @@ impl Accelerometer { (windows_core::Interface::vtable(this).GetDefaultWithAccelerometerReadingType)(windows_core::Interface::as_raw(this), readingtype, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IAccelerometerStatics3(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -339,7 +339,7 @@ unsafe impl Sync for AccelerometerShakenEventArgs {} pub struct ActivitySensor(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(ActivitySensor, windows_core::IUnknown, windows_core::IInspectable); impl ActivitySensor { - pub fn GetCurrentReadingAsync(&self) -> windows_core::Result> { + pub fn GetCurrentReadingAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -395,7 +395,7 @@ impl ActivitySensor { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveReadingChanged)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn GetDefaultAsync() -> windows_core::Result> { + pub fn GetDefaultAsync() -> windows_core::Result> { Self::IActivitySensorStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetDefaultAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -407,19 +407,19 @@ impl ActivitySensor { (windows_core::Interface::vtable(this).GetDeviceSelector)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IActivitySensorStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetSystemHistoryAsync(fromtime: super::super::Foundation::DateTime) -> windows_core::Result>> { + pub fn GetSystemHistoryAsync(fromtime: super::super::Foundation::DateTime) -> windows_core::Result>> { Self::IActivitySensorStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetSystemHistoryAsync)(windows_core::Interface::as_raw(this), fromtime, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetSystemHistoryWithDurationAsync(fromtime: super::super::Foundation::DateTime, duration: super::super::Foundation::TimeSpan) -> windows_core::Result>> { + pub fn GetSystemHistoryWithDurationAsync(fromtime: super::super::Foundation::DateTime, duration: super::super::Foundation::TimeSpan) -> windows_core::Result>> { Self::IActivitySensorStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetSystemHistoryWithDurationAsync)(windows_core::Interface::as_raw(this), fromtime, duration, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -862,7 +862,7 @@ impl Barometer { (windows_core::Interface::vtable(this).GetDefault)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IBarometerStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -1096,7 +1096,7 @@ impl Compass { (windows_core::Interface::vtable(this).GetDeviceSelector)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::ICompassStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -1391,7 +1391,7 @@ impl Gyrometer { (windows_core::Interface::vtable(this).GetDeviceSelector)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IGyrometerStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -1669,7 +1669,7 @@ unsafe impl Sync for HingeAngleReading {} pub struct HingeAngleSensor(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(HingeAngleSensor, windows_core::IUnknown, windows_core::IInspectable); impl HingeAngleSensor { - pub fn GetCurrentReadingAsync(&self) -> windows_core::Result> { + pub fn GetCurrentReadingAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1721,19 +1721,19 @@ impl HingeAngleSensor { (windows_core::Interface::vtable(this).GetDeviceSelector)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn GetDefaultAsync() -> windows_core::Result> { + pub fn GetDefaultAsync() -> windows_core::Result> { Self::IHingeAngleSensorStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetDefaultAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetRelatedToAdjacentPanelsAsync(firstpanelid: &windows_core::HSTRING, secondpanelid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetRelatedToAdjacentPanelsAsync(firstpanelid: &windows_core::HSTRING, secondpanelid: &windows_core::HSTRING) -> windows_core::Result> { Self::IHingeAngleSensorStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetRelatedToAdjacentPanelsAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(firstpanelid), core::mem::transmute_copy(secondpanelid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IHingeAngleSensorStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -1972,13 +1972,13 @@ impl HumanPresenceSensor { (windows_core::Interface::vtable(this).GetDeviceSelector)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn FromIdAsync(sensorid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(sensorid: &windows_core::HSTRING) -> windows_core::Result> { Self::IHumanPresenceSensorStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(sensorid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetDefaultAsync() -> windows_core::Result> { + pub fn GetDefaultAsync() -> windows_core::Result> { Self::IHumanPresenceSensorStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetDefaultAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -2312,7 +2312,7 @@ impl HumanPresenceSettings { (windows_core::Interface::vtable(this).LockOptions)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetCurrentSettingsAsync() -> windows_core::Result> { + pub fn GetCurrentSettingsAsync() -> windows_core::Result> { Self::IHumanPresenceSettingsStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetCurrentSettingsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -2324,7 +2324,7 @@ impl HumanPresenceSettings { (windows_core::Interface::vtable(this).GetCurrentSettings)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn UpdateSettingsAsync(settings: P0) -> windows_core::Result + pub fn UpdateSettingsAsync(settings: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -2339,7 +2339,7 @@ impl HumanPresenceSettings { { Self::IHumanPresenceSettingsStatics(|this| unsafe { (windows_core::Interface::vtable(this).UpdateSettings)(windows_core::Interface::as_raw(this), settings.param().abi()).ok() }) } - pub fn GetSupportedFeaturesForSensorIdAsync(sensorid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetSupportedFeaturesForSensorIdAsync(sensorid: &windows_core::HSTRING) -> windows_core::Result> { Self::IHumanPresenceSettingsStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetSupportedFeaturesForSensorIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(sensorid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -4346,7 +4346,7 @@ impl Inclinometer { (windows_core::Interface::vtable(this).GetDeviceSelector)(windows_core::Interface::as_raw(this), readingtype, &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IInclinometerStatics4(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -4612,7 +4612,7 @@ impl LightSensor { (windows_core::Interface::vtable(this).GetDeviceSelector)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::ILightSensorStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -4880,7 +4880,7 @@ impl Magnetometer { (windows_core::Interface::vtable(this).GetDeviceSelector)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IMagnetometerStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -5190,7 +5190,7 @@ impl OrientationSensor { (windows_core::Interface::vtable(this).GetDeviceSelectorWithSensorReadingTypeAndSensorOptimizationGoal)(windows_core::Interface::as_raw(this), readingtype, optimizationgoal, &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IOrientationSensorStatics4(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -5368,13 +5368,13 @@ impl Pedometer { (windows_core::Interface::vtable(this).GetCurrentReadings)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IPedometerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetDefaultAsync() -> windows_core::Result> { + pub fn GetDefaultAsync() -> windows_core::Result> { Self::IPedometerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetDefaultAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -5386,13 +5386,13 @@ impl Pedometer { (windows_core::Interface::vtable(this).GetDeviceSelector)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn GetSystemHistoryAsync(fromtime: super::super::Foundation::DateTime) -> windows_core::Result>> { + pub fn GetSystemHistoryAsync(fromtime: super::super::Foundation::DateTime) -> windows_core::Result>> { Self::IPedometerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetSystemHistoryAsync)(windows_core::Interface::as_raw(this), fromtime, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetSystemHistoryWithDurationAsync(fromtime: super::super::Foundation::DateTime, duration: super::super::Foundation::TimeSpan) -> windows_core::Result>> { + pub fn GetSystemHistoryWithDurationAsync(fromtime: super::super::Foundation::DateTime, duration: super::super::Foundation::TimeSpan) -> windows_core::Result>> { Self::IPedometerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetSystemHistoryWithDurationAsync)(windows_core::Interface::as_raw(this), fromtime, duration, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -6042,7 +6042,7 @@ impl SimpleOrientationSensor { (windows_core::Interface::vtable(this).GetDeviceSelector)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::ISimpleOrientationSensorStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/Devices/SerialCommunication/mod.rs b/crates/libs/windows/src/Windows/Devices/SerialCommunication/mod.rs index 23c6adca2a..3659193184 100644 --- a/crates/libs/windows/src/Windows/Devices/SerialCommunication/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/SerialCommunication/mod.rs @@ -356,7 +356,7 @@ impl SerialDevice { (windows_core::Interface::vtable(this).GetDeviceSelectorFromUsbVidPid)(windows_core::Interface::as_raw(this), vendorid, productid, &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::ISerialDeviceStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/Devices/SmartCards/mod.rs b/crates/libs/windows/src/Windows/Devices/SmartCards/mod.rs index 6b96589001..67ed5365d1 100644 --- a/crates/libs/windows/src/Windows/Devices/SmartCards/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/SmartCards/mod.rs @@ -851,7 +851,7 @@ impl SmartCard { (windows_core::Interface::vtable(this).Reader)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetStatusAsync(&self) -> windows_core::Result> { + pub fn GetStatusAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -859,14 +859,14 @@ impl SmartCard { } } #[cfg(feature = "Storage_Streams")] - pub fn GetAnswerToResetAsync(&self) -> windows_core::Result> { + pub fn GetAnswerToResetAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetAnswerToResetAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ConnectAsync(&self) -> windows_core::Result> { + pub fn ConnectAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1079,7 +1079,7 @@ impl SmartCardAppletIdGroupRegistration { (windows_core::Interface::vtable(this).AppletIdGroup)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestActivationPolicyChangeAsync(&self, policy: SmartCardAppletIdGroupActivationPolicy) -> windows_core::Result> { + pub fn RequestActivationPolicyChangeAsync(&self, policy: SmartCardAppletIdGroupActivationPolicy) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1093,7 +1093,7 @@ impl SmartCardAppletIdGroupRegistration { (windows_core::Interface::vtable(this).Id)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn SetAutomaticResponseApdusAsync(&self, apdus: P0) -> windows_core::Result + pub fn SetAutomaticResponseApdusAsync(&self, apdus: P0) -> windows_core::Result where P0: windows_core::Param>, { @@ -1111,7 +1111,7 @@ impl SmartCardAppletIdGroupRegistration { } } #[cfg(feature = "Foundation_Collections")] - pub fn SetPropertiesAsync(&self, props: P0) -> windows_core::Result + pub fn SetPropertiesAsync(&self, props: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -1314,7 +1314,7 @@ impl SmartCardChallengeContext { } } #[cfg(feature = "Storage_Streams")] - pub fn VerifyResponseAsync(&self, response: P0) -> windows_core::Result> + pub fn VerifyResponseAsync(&self, response: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1325,7 +1325,7 @@ impl SmartCardChallengeContext { } } #[cfg(feature = "Storage_Streams")] - pub fn ProvisionAsync(&self, response: P0, formatcard: bool) -> windows_core::Result + pub fn ProvisionAsync(&self, response: P0, formatcard: bool) -> windows_core::Result where P0: windows_core::Param, { @@ -1336,7 +1336,7 @@ impl SmartCardChallengeContext { } } #[cfg(feature = "Storage_Streams")] - pub fn ProvisionAsyncWithNewCardId(&self, response: P0, formatcard: bool, newcardid: windows_core::GUID) -> windows_core::Result + pub fn ProvisionAsyncWithNewCardId(&self, response: P0, formatcard: bool, newcardid: windows_core::GUID) -> windows_core::Result where P0: windows_core::Param, { @@ -1347,7 +1347,7 @@ impl SmartCardChallengeContext { } } #[cfg(feature = "Storage_Streams")] - pub fn ChangeAdministrativeKeyAsync(&self, response: P0, newadministrativekey: P1) -> windows_core::Result + pub fn ChangeAdministrativeKeyAsync(&self, response: P0, newadministrativekey: P1) -> windows_core::Result where P0: windows_core::Param, P1: windows_core::Param, @@ -1382,7 +1382,7 @@ impl SmartCardConnection { unsafe { (windows_core::Interface::vtable(this).Close)(windows_core::Interface::as_raw(this)).ok() } } #[cfg(feature = "Storage_Streams")] - pub fn TransmitAsync(&self, command: P0) -> windows_core::Result> + pub fn TransmitAsync(&self, command: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1465,14 +1465,14 @@ impl SmartCardCryptogramGenerator { (windows_core::Interface::vtable(this).SupportedSmartCardCryptogramStorageKeyCapabilities)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteCryptogramMaterialStorageKeyAsync(&self, storagekeyname: &windows_core::HSTRING) -> windows_core::Result> { + pub fn DeleteCryptogramMaterialStorageKeyAsync(&self, storagekeyname: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeleteCryptogramMaterialStorageKeyAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(storagekeyname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateCryptogramMaterialStorageKeyAsync(&self, promptingbehavior: SmartCardUnlockPromptingBehavior, storagekeyname: &windows_core::HSTRING, algorithm: SmartCardCryptogramStorageKeyAlgorithm, capabilities: SmartCardCryptogramStorageKeyCapabilities) -> windows_core::Result> { + pub fn CreateCryptogramMaterialStorageKeyAsync(&self, promptingbehavior: SmartCardUnlockPromptingBehavior, storagekeyname: &windows_core::HSTRING, algorithm: SmartCardCryptogramStorageKeyAlgorithm, capabilities: SmartCardCryptogramStorageKeyCapabilities) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1480,7 +1480,7 @@ impl SmartCardCryptogramGenerator { } } #[cfg(feature = "Security_Cryptography_Core")] - pub fn RequestCryptogramMaterialStorageKeyInfoAsync(&self, promptingbehavior: SmartCardUnlockPromptingBehavior, storagekeyname: &windows_core::HSTRING, format: super::super::Security::Cryptography::Core::CryptographicPublicKeyBlobType) -> windows_core::Result> { + pub fn RequestCryptogramMaterialStorageKeyInfoAsync(&self, promptingbehavior: SmartCardUnlockPromptingBehavior, storagekeyname: &windows_core::HSTRING, format: super::super::Security::Cryptography::Core::CryptographicPublicKeyBlobType) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1488,7 +1488,7 @@ impl SmartCardCryptogramGenerator { } } #[cfg(feature = "Storage_Streams")] - pub fn ImportCryptogramMaterialPackageAsync(&self, format: SmartCardCryptogramMaterialPackageFormat, storagekeyname: &windows_core::HSTRING, materialpackagename: &windows_core::HSTRING, cryptogrammaterialpackage: P3) -> windows_core::Result> + pub fn ImportCryptogramMaterialPackageAsync(&self, format: SmartCardCryptogramMaterialPackageFormat, storagekeyname: &windows_core::HSTRING, materialpackagename: &windows_core::HSTRING, cryptogrammaterialpackage: P3) -> windows_core::Result> where P3: windows_core::Param, { @@ -1499,7 +1499,7 @@ impl SmartCardCryptogramGenerator { } } #[cfg(feature = "Storage_Streams")] - pub fn TryProvePossessionOfCryptogramMaterialPackageAsync(&self, promptingbehavior: SmartCardUnlockPromptingBehavior, responseformat: SmartCardCryptogramMaterialPackageConfirmationResponseFormat, materialpackagename: &windows_core::HSTRING, materialname: &windows_core::HSTRING, challenge: P4) -> windows_core::Result> + pub fn TryProvePossessionOfCryptogramMaterialPackageAsync(&self, promptingbehavior: SmartCardUnlockPromptingBehavior, responseformat: SmartCardCryptogramMaterialPackageConfirmationResponseFormat, materialpackagename: &windows_core::HSTRING, materialname: &windows_core::HSTRING, challenge: P4) -> windows_core::Result> where P4: windows_core::Param, { @@ -1509,14 +1509,14 @@ impl SmartCardCryptogramGenerator { (windows_core::Interface::vtable(this).TryProvePossessionOfCryptogramMaterialPackageAsync)(windows_core::Interface::as_raw(this), promptingbehavior, responseformat, core::mem::transmute_copy(materialpackagename), core::mem::transmute_copy(materialname), challenge.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestUnlockCryptogramMaterialForUseAsync(&self, promptingbehavior: SmartCardUnlockPromptingBehavior) -> windows_core::Result> { + pub fn RequestUnlockCryptogramMaterialForUseAsync(&self, promptingbehavior: SmartCardUnlockPromptingBehavior) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestUnlockCryptogramMaterialForUseAsync)(windows_core::Interface::as_raw(this), promptingbehavior, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteCryptogramMaterialPackageAsync(&self, materialpackagename: &windows_core::HSTRING) -> windows_core::Result> { + pub fn DeleteCryptogramMaterialPackageAsync(&self, materialpackagename: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1524,7 +1524,7 @@ impl SmartCardCryptogramGenerator { } } #[cfg(feature = "Storage_Streams")] - pub fn ValidateRequestApduAsync(&self, promptingbehavior: SmartCardUnlockPromptingBehavior, apdutovalidate: P1, cryptogramplacementsteps: P2) -> windows_core::Result> + pub fn ValidateRequestApduAsync(&self, promptingbehavior: SmartCardUnlockPromptingBehavior, apdutovalidate: P1, cryptogramplacementsteps: P2) -> windows_core::Result> where P1: windows_core::Param, P2: windows_core::Param>, @@ -1535,35 +1535,35 @@ impl SmartCardCryptogramGenerator { (windows_core::Interface::vtable(this).ValidateRequestApduAsync)(windows_core::Interface::as_raw(this), promptingbehavior, apdutovalidate.param().abi(), cryptogramplacementsteps.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAllCryptogramStorageKeyCharacteristicsAsync(&self) -> windows_core::Result> { + pub fn GetAllCryptogramStorageKeyCharacteristicsAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetAllCryptogramStorageKeyCharacteristicsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAllCryptogramMaterialPackageCharacteristicsAsync(&self) -> windows_core::Result> { + pub fn GetAllCryptogramMaterialPackageCharacteristicsAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetAllCryptogramMaterialPackageCharacteristicsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAllCryptogramMaterialPackageCharacteristicsWithStorageKeyAsync(&self, storagekeyname: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetAllCryptogramMaterialPackageCharacteristicsWithStorageKeyAsync(&self, storagekeyname: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetAllCryptogramMaterialPackageCharacteristicsWithStorageKeyAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(storagekeyname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAllCryptogramMaterialCharacteristicsAsync(&self, promptingbehavior: SmartCardUnlockPromptingBehavior, materialpackagename: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetAllCryptogramMaterialCharacteristicsAsync(&self, promptingbehavior: SmartCardUnlockPromptingBehavior, materialpackagename: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetAllCryptogramMaterialCharacteristicsAsync)(windows_core::Interface::as_raw(this), promptingbehavior, core::mem::transmute_copy(materialpackagename), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetSmartCardCryptogramGeneratorAsync() -> windows_core::Result> { + pub fn GetSmartCardCryptogramGeneratorAsync() -> windows_core::Result> { Self::ISmartCardCryptogramGeneratorStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetSmartCardCryptogramGeneratorAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -2427,19 +2427,19 @@ impl SmartCardEmulator { (windows_core::Interface::vtable(this).IsHostCardEmulationSupported)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn GetDefaultAsync() -> windows_core::Result> { + pub fn GetDefaultAsync() -> windows_core::Result> { Self::ISmartCardEmulatorStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetDefaultAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetAppletIdGroupRegistrationsAsync() -> windows_core::Result>> { + pub fn GetAppletIdGroupRegistrationsAsync() -> windows_core::Result>> { Self::ISmartCardEmulatorStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetAppletIdGroupRegistrationsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RegisterAppletIdGroupAsync(appletidgroup: P0) -> windows_core::Result> + pub fn RegisterAppletIdGroupAsync(appletidgroup: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2448,7 +2448,7 @@ impl SmartCardEmulator { (windows_core::Interface::vtable(this).RegisterAppletIdGroupAsync)(windows_core::Interface::as_raw(this), appletidgroup.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn UnregisterAppletIdGroupAsync(registration: P0) -> windows_core::Result + pub fn UnregisterAppletIdGroupAsync(registration: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -2515,7 +2515,7 @@ impl SmartCardEmulatorApduReceivedEventArgs { } } #[cfg(feature = "Storage_Streams")] - pub fn TryRespondAsync(&self, responseapdu: P0) -> windows_core::Result> + pub fn TryRespondAsync(&self, responseapdu: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2540,7 +2540,7 @@ impl SmartCardEmulatorApduReceivedEventArgs { } } #[cfg(feature = "Storage_Streams")] - pub fn TryRespondWithStateAsync(&self, responseapdu: P0, nextstate: P1) -> windows_core::Result> + pub fn TryRespondWithStateAsync(&self, responseapdu: P0, nextstate: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param>, @@ -2552,7 +2552,7 @@ impl SmartCardEmulatorApduReceivedEventArgs { } } #[cfg(feature = "Storage_Streams")] - pub fn TryRespondWithCryptogramsAsync(&self, responsetemplate: P0, cryptogramplacementsteps: P1) -> windows_core::Result> + pub fn TryRespondWithCryptogramsAsync(&self, responsetemplate: P0, cryptogramplacementsteps: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param>, @@ -2564,7 +2564,7 @@ impl SmartCardEmulatorApduReceivedEventArgs { } } #[cfg(feature = "Storage_Streams")] - pub fn TryRespondWithCryptogramsAndStateAsync(&self, responsetemplate: P0, cryptogramplacementsteps: P1, nextstate: P2) -> windows_core::Result> + pub fn TryRespondWithCryptogramsAndStateAsync(&self, responsetemplate: P0, cryptogramplacementsteps: P1, nextstate: P2) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param>, @@ -2963,35 +2963,35 @@ impl SmartCardProvisioning { (windows_core::Interface::vtable(this).SmartCard)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetIdAsync(&self) -> windows_core::Result> { + pub fn GetIdAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetIdAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetNameAsync(&self) -> windows_core::Result> { + pub fn GetNameAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetNameAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetChallengeContextAsync(&self) -> windows_core::Result> { + pub fn GetChallengeContextAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetChallengeContextAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestPinChangeAsync(&self) -> windows_core::Result> { + pub fn RequestPinChangeAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestPinChangeAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestPinResetAsync(&self, handler: P0) -> windows_core::Result> + pub fn RequestPinResetAsync(&self, handler: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -3001,14 +3001,14 @@ impl SmartCardProvisioning { (windows_core::Interface::vtable(this).RequestPinResetAsync)(windows_core::Interface::as_raw(this), handler.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAuthorityKeyContainerNameAsync(&self) -> windows_core::Result> { + pub fn GetAuthorityKeyContainerNameAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetAuthorityKeyContainerNameAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FromSmartCardAsync(card: P0) -> windows_core::Result> + pub fn FromSmartCardAsync(card: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -3018,7 +3018,7 @@ impl SmartCardProvisioning { }) } #[cfg(feature = "Storage_Streams")] - pub fn RequestVirtualSmartCardCreationAsync(friendlyname: &windows_core::HSTRING, administrativekey: P1, pinpolicy: P2) -> windows_core::Result> + pub fn RequestVirtualSmartCardCreationAsync(friendlyname: &windows_core::HSTRING, administrativekey: P1, pinpolicy: P2) -> windows_core::Result> where P1: windows_core::Param, P2: windows_core::Param, @@ -3029,7 +3029,7 @@ impl SmartCardProvisioning { }) } #[cfg(feature = "Storage_Streams")] - pub fn RequestVirtualSmartCardCreationAsyncWithCardId(friendlyname: &windows_core::HSTRING, administrativekey: P1, pinpolicy: P2, cardid: windows_core::GUID) -> windows_core::Result> + pub fn RequestVirtualSmartCardCreationAsyncWithCardId(friendlyname: &windows_core::HSTRING, administrativekey: P1, pinpolicy: P2, cardid: windows_core::GUID) -> windows_core::Result> where P1: windows_core::Param, P2: windows_core::Param, @@ -3039,7 +3039,7 @@ impl SmartCardProvisioning { (windows_core::Interface::vtable(this).RequestVirtualSmartCardCreationAsyncWithCardId)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(friendlyname), administrativekey.param().abi(), pinpolicy.param().abi(), cardid, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RequestVirtualSmartCardDeletionAsync(card: P0) -> windows_core::Result> + pub fn RequestVirtualSmartCardDeletionAsync(card: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -3049,7 +3049,7 @@ impl SmartCardProvisioning { }) } #[cfg(feature = "Storage_Streams")] - pub fn RequestAttestedVirtualSmartCardCreationAsync(friendlyname: &windows_core::HSTRING, administrativekey: P1, pinpolicy: P2) -> windows_core::Result> + pub fn RequestAttestedVirtualSmartCardCreationAsync(friendlyname: &windows_core::HSTRING, administrativekey: P1, pinpolicy: P2) -> windows_core::Result> where P1: windows_core::Param, P2: windows_core::Param, @@ -3060,7 +3060,7 @@ impl SmartCardProvisioning { }) } #[cfg(feature = "Storage_Streams")] - pub fn RequestAttestedVirtualSmartCardCreationAsyncWithCardId(friendlyname: &windows_core::HSTRING, administrativekey: P1, pinpolicy: P2, cardid: windows_core::GUID) -> windows_core::Result> + pub fn RequestAttestedVirtualSmartCardCreationAsyncWithCardId(friendlyname: &windows_core::HSTRING, administrativekey: P1, pinpolicy: P2, cardid: windows_core::GUID) -> windows_core::Result> where P1: windows_core::Param, P2: windows_core::Param, @@ -3117,14 +3117,14 @@ impl SmartCardReader { (windows_core::Interface::vtable(this).Kind)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn GetStatusAsync(&self) -> windows_core::Result> { + pub fn GetStatusAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetStatusAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FindAllCardsAsync(&self) -> windows_core::Result>> { + pub fn FindAllCardsAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -3171,7 +3171,7 @@ impl SmartCardReader { (windows_core::Interface::vtable(this).GetDeviceSelectorWithKind)(windows_core::Interface::as_raw(this), kind, &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::ISmartCardReaderStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -3276,14 +3276,14 @@ impl SmartCardTriggerDetails { (windows_core::Interface::vtable(this).Emulator)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryLaunchCurrentAppAsync(&self, arguments: &windows_core::HSTRING) -> windows_core::Result> { + pub fn TryLaunchCurrentAppAsync(&self, arguments: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryLaunchCurrentAppAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(arguments), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryLaunchCurrentAppWithBehaviorAsync(&self, arguments: &windows_core::HSTRING, behavior: SmartCardLaunchBehavior) -> windows_core::Result> { + pub fn TryLaunchCurrentAppWithBehaviorAsync(&self, arguments: &windows_core::HSTRING, behavior: SmartCardLaunchBehavior) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Devices/Sms/mod.rs b/crates/libs/windows/src/Windows/Devices/Sms/mod.rs index b231ac1ac3..3a5b38671a 100644 --- a/crates/libs/windows/src/Windows/Devices/Sms/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/Sms/mod.rs @@ -13,15 +13,15 @@ impl windows_core::RuntimeType for CellularClass { const SIGNATURE: windows_core::imp::ConstBuffer = windows_core::imp::ConstBuffer::from_slice(b"enum(Windows.Devices.Sms.CellularClass;i4)"); } #[cfg(feature = "deprecated")] -pub type DeleteSmsMessageOperation = windows_async::IAsyncAction; +pub type DeleteSmsMessageOperation = windows_future::IAsyncAction; #[cfg(feature = "deprecated")] -pub type DeleteSmsMessagesOperation = windows_async::IAsyncAction; +pub type DeleteSmsMessagesOperation = windows_future::IAsyncAction; #[cfg(feature = "deprecated")] -pub type GetSmsDeviceOperation = windows_async::IAsyncOperation; +pub type GetSmsDeviceOperation = windows_future::IAsyncOperation; #[cfg(feature = "deprecated")] -pub type GetSmsMessageOperation = windows_async::IAsyncOperation; +pub type GetSmsMessageOperation = windows_future::IAsyncOperation; #[cfg(feature = "deprecated")] -pub type GetSmsMessagesOperation = windows_async::IAsyncOperationWithProgress, i32>; +pub type GetSmsMessagesOperation = windows_future::IAsyncOperationWithProgress, i32>; windows_core::imp::define_interface!(ISmsAppMessage, ISmsAppMessage_Vtbl, 0xe8bb8494_d3a0_4a0a_86d7_291033a8cf54); impl windows_core::RuntimeType for ISmsAppMessage { const SIGNATURE: windows_core::imp::ConstBuffer = windows_core::imp::ConstBuffer::for_interface::(); @@ -1260,7 +1260,7 @@ pub struct ISmsWapMessage_Vtbl { pub Headers: unsafe extern "system" fn(*mut core::ffi::c_void, *mut *mut core::ffi::c_void) -> windows_core::HRESULT, } #[cfg(feature = "deprecated")] -pub type SendSmsMessageOperation = windows_async::IAsyncAction; +pub type SendSmsMessageOperation = windows_future::IAsyncAction; #[repr(transparent)] #[derive(Clone, Debug, Eq, PartialEq)] pub struct SmsAppMessage(windows_core::IUnknown); @@ -1778,19 +1778,19 @@ impl SmsDevice { (windows_core::Interface::vtable(this).GetDeviceSelector)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::ISmsDeviceStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetDefaultAsync() -> windows_core::Result> { + pub fn GetDefaultAsync() -> windows_core::Result> { Self::ISmsDeviceStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetDefaultAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn FromNetworkAccountIdAsync(networkaccountid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromNetworkAccountIdAsync(networkaccountid: &windows_core::HSTRING) -> windows_core::Result> { Self::ISmsDeviceStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromNetworkAccountIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(networkaccountid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -1879,7 +1879,7 @@ impl SmsDevice2 { (windows_core::Interface::vtable(this).CalculateLength)(windows_core::Interface::as_raw(this), message.param().abi(), &mut result__).map(|| result__) } } - pub fn SendMessageAndGetResultAsync(&self, message: P0) -> windows_core::Result> + pub fn SendMessageAndGetResultAsync(&self, message: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1950,28 +1950,28 @@ pub struct SmsDeviceMessageStore(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(SmsDeviceMessageStore, windows_core::IUnknown, windows_core::IInspectable); #[cfg(feature = "deprecated")] impl SmsDeviceMessageStore { - pub fn DeleteMessageAsync(&self, messageid: u32) -> windows_core::Result { + pub fn DeleteMessageAsync(&self, messageid: u32) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeleteMessageAsync)(windows_core::Interface::as_raw(this), messageid, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteMessagesAsync(&self, messagefilter: SmsMessageFilter) -> windows_core::Result { + pub fn DeleteMessagesAsync(&self, messagefilter: SmsMessageFilter) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeleteMessagesAsync)(windows_core::Interface::as_raw(this), messagefilter, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetMessageAsync(&self, messageid: u32) -> windows_core::Result> { + pub fn GetMessageAsync(&self, messageid: u32) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetMessageAsync)(windows_core::Interface::as_raw(this), messageid, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetMessagesAsync(&self, messagefilter: SmsMessageFilter) -> windows_core::Result, i32>> { + pub fn GetMessagesAsync(&self, messagefilter: SmsMessageFilter) -> windows_core::Result, i32>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Devices/Spi/Provider/mod.rs b/crates/libs/windows/src/Windows/Devices/Spi/Provider/mod.rs index 1f37ec7589..2d863f5e3b 100644 --- a/crates/libs/windows/src/Windows/Devices/Spi/Provider/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/Spi/Provider/mod.rs @@ -212,7 +212,7 @@ impl windows_core::RuntimeType for ISpiProvider { } windows_core::imp::interface_hierarchy!(ISpiProvider, windows_core::IUnknown, windows_core::IInspectable); impl ISpiProvider { - pub fn GetControllersAsync(&self) -> windows_core::Result>> { + pub fn GetControllersAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -224,7 +224,7 @@ impl windows_core::RuntimeName for ISpiProvider { const NAME: &'static str = "Windows.Devices.Spi.Provider.ISpiProvider"; } pub trait ISpiProvider_Impl: windows_core::IUnknownImpl { - fn GetControllersAsync(&self) -> windows_core::Result>>; + fn GetControllersAsync(&self) -> windows_core::Result>>; } impl ISpiProvider_Vtbl { pub const fn new() -> Self { diff --git a/crates/libs/windows/src/Windows/Devices/Spi/mod.rs b/crates/libs/windows/src/Windows/Devices/Spi/mod.rs index 0565deef2d..a5f74b6619 100644 --- a/crates/libs/windows/src/Windows/Devices/Spi/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/Spi/mod.rs @@ -102,7 +102,7 @@ impl ISpiDeviceStatics { (windows_core::Interface::vtable(this).GetBusInfo)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(busid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FromIdAsync(&self, busid: &windows_core::HSTRING, settings: P1) -> windows_core::Result> + pub fn FromIdAsync(&self, busid: &windows_core::HSTRING, settings: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -120,7 +120,7 @@ pub trait ISpiDeviceStatics_Impl: windows_core::IUnknownImpl { fn GetDeviceSelector(&self) -> windows_core::Result; fn GetDeviceSelectorFromFriendlyName(&self, friendlyName: &windows_core::HSTRING) -> windows_core::Result; fn GetBusInfo(&self, busId: &windows_core::HSTRING) -> windows_core::Result; - fn FromIdAsync(&self, busId: &windows_core::HSTRING, settings: windows_core::Ref<'_, SpiConnectionSettings>) -> windows_core::Result>; + fn FromIdAsync(&self, busId: &windows_core::HSTRING, settings: windows_core::Ref<'_, SpiConnectionSettings>) -> windows_core::Result>; } impl ISpiDeviceStatics_Vtbl { pub const fn new() -> Self { @@ -340,14 +340,14 @@ impl SpiController { (windows_core::Interface::vtable(this).GetDevice)(windows_core::Interface::as_raw(this), settings.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetDefaultAsync() -> windows_core::Result> { + pub fn GetDefaultAsync() -> windows_core::Result> { Self::ISpiControllerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetDefaultAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "Devices_Spi_Provider")] - pub fn GetControllersAsync(provider: P0) -> windows_core::Result>> + pub fn GetControllersAsync(provider: P0) -> windows_core::Result>> where P0: windows_core::Param, { @@ -431,7 +431,7 @@ impl SpiDevice { (windows_core::Interface::vtable(this).GetBusInfo)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(busid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn FromIdAsync(busid: &windows_core::HSTRING, settings: P1) -> windows_core::Result> + pub fn FromIdAsync(busid: &windows_core::HSTRING, settings: P1) -> windows_core::Result> where P1: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Devices/Usb/mod.rs b/crates/libs/windows/src/Windows/Devices/Usb/mod.rs index b0ce88e395..b9a4f899fc 100644 --- a/crates/libs/windows/src/Windows/Devices/Usb/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/Usb/mod.rs @@ -438,7 +438,7 @@ impl UsbBulkInPipe { (windows_core::Interface::vtable(this).EndpointDescriptor)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ClearStallAsync(&self) -> windows_core::Result { + pub fn ClearStallAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -532,7 +532,7 @@ impl UsbBulkOutPipe { (windows_core::Interface::vtable(this).EndpointDescriptor)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ClearStallAsync(&self) -> windows_core::Result { + pub fn ClearStallAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -828,7 +828,7 @@ impl UsbDevice { unsafe { (windows_core::Interface::vtable(this).Close)(windows_core::Interface::as_raw(this)).ok() } } #[cfg(feature = "Storage_Streams")] - pub fn SendControlOutTransferAsync(&self, setuppacket: P0, buffer: P1) -> windows_core::Result> + pub fn SendControlOutTransferAsync(&self, setuppacket: P0, buffer: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -839,7 +839,7 @@ impl UsbDevice { (windows_core::Interface::vtable(this).SendControlOutTransferAsync)(windows_core::Interface::as_raw(this), setuppacket.param().abi(), buffer.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SendControlOutTransferAsyncNoBuffer(&self, setuppacket: P0) -> windows_core::Result> + pub fn SendControlOutTransferAsyncNoBuffer(&self, setuppacket: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -850,7 +850,7 @@ impl UsbDevice { } } #[cfg(feature = "Storage_Streams")] - pub fn SendControlInTransferAsync(&self, setuppacket: P0, buffer: P1) -> windows_core::Result> + pub fn SendControlInTransferAsync(&self, setuppacket: P0, buffer: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -862,7 +862,7 @@ impl UsbDevice { } } #[cfg(feature = "Storage_Streams")] - pub fn SendControlInTransferAsyncNoBuffer(&self, setuppacket: P0) -> windows_core::Result> + pub fn SendControlInTransferAsyncNoBuffer(&self, setuppacket: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -920,7 +920,7 @@ impl UsbDevice { (windows_core::Interface::vtable(this).GetDeviceClassSelector)(windows_core::Interface::as_raw(this), usbclass.param().abi(), &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IUsbDeviceStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -1429,7 +1429,7 @@ impl UsbInterfaceSetting { (windows_core::Interface::vtable(this).Selected)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn SelectSettingAsync(&self) -> windows_core::Result { + pub fn SelectSettingAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1547,7 +1547,7 @@ impl UsbInterruptInPipe { (windows_core::Interface::vtable(this).EndpointDescriptor)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ClearStallAsync(&self) -> windows_core::Result { + pub fn ClearStallAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1639,7 +1639,7 @@ impl UsbInterruptOutPipe { (windows_core::Interface::vtable(this).EndpointDescriptor)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ClearStallAsync(&self) -> windows_core::Result { + pub fn ClearStallAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Devices/WiFi/mod.rs b/crates/libs/windows/src/Windows/Devices/WiFi/mod.rs index bc432dca7a..8169a508c9 100644 --- a/crates/libs/windows/src/Windows/Devices/WiFi/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/WiFi/mod.rs @@ -197,7 +197,7 @@ impl WiFiAdapter { (windows_core::Interface::vtable(this).NetworkAdapter)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ScanAsync(&self) -> windows_core::Result { + pub fn ScanAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -225,7 +225,7 @@ impl WiFiAdapter { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveAvailableNetworksChanged)(windows_core::Interface::as_raw(this), eventcookie).ok() } } - pub fn ConnectAsync(&self, availablenetwork: P0, reconnectionkind: WiFiReconnectionKind) -> windows_core::Result> + pub fn ConnectAsync(&self, availablenetwork: P0, reconnectionkind: WiFiReconnectionKind) -> windows_core::Result> where P0: windows_core::Param, { @@ -236,7 +236,7 @@ impl WiFiAdapter { } } #[cfg(feature = "Security_Credentials")] - pub fn ConnectWithPasswordCredentialAsync(&self, availablenetwork: P0, reconnectionkind: WiFiReconnectionKind, passwordcredential: P2) -> windows_core::Result> + pub fn ConnectWithPasswordCredentialAsync(&self, availablenetwork: P0, reconnectionkind: WiFiReconnectionKind, passwordcredential: P2) -> windows_core::Result> where P0: windows_core::Param, P2: windows_core::Param, @@ -248,7 +248,7 @@ impl WiFiAdapter { } } #[cfg(feature = "Security_Credentials")] - pub fn ConnectWithPasswordCredentialAndSsidAsync(&self, availablenetwork: P0, reconnectionkind: WiFiReconnectionKind, passwordcredential: P2, ssid: &windows_core::HSTRING) -> windows_core::Result> + pub fn ConnectWithPasswordCredentialAndSsidAsync(&self, availablenetwork: P0, reconnectionkind: WiFiReconnectionKind, passwordcredential: P2, ssid: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, P2: windows_core::Param, @@ -263,7 +263,7 @@ impl WiFiAdapter { let this = self; unsafe { (windows_core::Interface::vtable(this).Disconnect)(windows_core::Interface::as_raw(this)).ok() } } - pub fn GetWpsConfigurationAsync(&self, availablenetwork: P0) -> windows_core::Result> + pub fn GetWpsConfigurationAsync(&self, availablenetwork: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -274,7 +274,7 @@ impl WiFiAdapter { } } #[cfg(feature = "Security_Credentials")] - pub fn ConnectWithPasswordCredentialAndSsidAndConnectionMethodAsync(&self, availablenetwork: P0, reconnectionkind: WiFiReconnectionKind, passwordcredential: P2, ssid: &windows_core::HSTRING, connectionmethod: WiFiConnectionMethod) -> windows_core::Result> + pub fn ConnectWithPasswordCredentialAndSsidAndConnectionMethodAsync(&self, availablenetwork: P0, reconnectionkind: WiFiReconnectionKind, passwordcredential: P2, ssid: &windows_core::HSTRING, connectionmethod: WiFiConnectionMethod) -> windows_core::Result> where P0: windows_core::Param, P2: windows_core::Param, @@ -285,7 +285,7 @@ impl WiFiAdapter { (windows_core::Interface::vtable(this).ConnectWithPasswordCredentialAndSsidAndConnectionMethodAsync)(windows_core::Interface::as_raw(this), availablenetwork.param().abi(), reconnectionkind, passwordcredential.param().abi(), core::mem::transmute_copy(ssid), connectionmethod, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FindAllAdaptersAsync() -> windows_core::Result>> { + pub fn FindAllAdaptersAsync() -> windows_core::Result>> { Self::IWiFiAdapterStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAllAdaptersAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -297,13 +297,13 @@ impl WiFiAdapter { (windows_core::Interface::vtable(this).GetDeviceSelector)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IWiFiAdapterStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RequestAccessAsync() -> windows_core::Result> { + pub fn RequestAccessAsync() -> windows_core::Result> { Self::IWiFiAdapterStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestAccessAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -601,7 +601,7 @@ impl WiFiOnDemandHotspotConnectTriggerDetails { let this = self; unsafe { (windows_core::Interface::vtable(this).ReportError)(windows_core::Interface::as_raw(this), status).ok() } } - pub fn ConnectAsync(&self) -> windows_core::Result> { + pub fn ConnectAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Devices/WiFiDirect/Services/mod.rs b/crates/libs/windows/src/Windows/Devices/WiFiDirect/Services/mod.rs index a0a34b6a04..cb3cff8341 100644 --- a/crates/libs/windows/src/Windows/Devices/WiFiDirect/Services/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/WiFiDirect/Services/mod.rs @@ -276,21 +276,21 @@ impl WiFiDirectService { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveSessionDeferred)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn GetProvisioningInfoAsync(&self, selectedconfigurationmethod: WiFiDirectServiceConfigurationMethod) -> windows_core::Result> { + pub fn GetProvisioningInfoAsync(&self, selectedconfigurationmethod: WiFiDirectServiceConfigurationMethod) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetProvisioningInfoAsync)(windows_core::Interface::as_raw(this), selectedconfigurationmethod, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ConnectAsync(&self) -> windows_core::Result> { + pub fn ConnectAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ConnectAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ConnectAsyncWithPin(&self, pin: &windows_core::HSTRING) -> windows_core::Result> { + pub fn ConnectAsyncWithPin(&self, pin: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -313,7 +313,7 @@ impl WiFiDirectService { (windows_core::Interface::vtable(this).GetSelectorWithFilter)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(servicename), serviceinfofilter.param().abi(), &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IWiFiDirectServiceStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -510,7 +510,7 @@ impl WiFiDirectServiceAdvertiser { unsafe { (windows_core::Interface::vtable(this).RemoveAdvertisementStatusChanged)(windows_core::Interface::as_raw(this), token).ok() } } #[cfg(feature = "Devices_Enumeration")] - pub fn ConnectAsync(&self, deviceinfo: P0) -> windows_core::Result> + pub fn ConnectAsync(&self, deviceinfo: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -521,7 +521,7 @@ impl WiFiDirectServiceAdvertiser { } } #[cfg(feature = "Devices_Enumeration")] - pub fn ConnectAsyncWithPin(&self, deviceinfo: P0, pin: &windows_core::HSTRING) -> windows_core::Result> + pub fn ConnectAsyncWithPin(&self, deviceinfo: P0, pin: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -785,7 +785,7 @@ impl WiFiDirectServiceSession { unsafe { (windows_core::Interface::vtable(this).RemoveSessionStatusChanged)(windows_core::Interface::as_raw(this), token).ok() } } #[cfg(feature = "Networking_Sockets")] - pub fn AddStreamSocketListenerAsync(&self, value: P0) -> windows_core::Result + pub fn AddStreamSocketListenerAsync(&self, value: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -796,7 +796,7 @@ impl WiFiDirectServiceSession { } } #[cfg(feature = "Networking_Sockets")] - pub fn AddDatagramSocketAsync(&self, value: P0) -> windows_core::Result + pub fn AddDatagramSocketAsync(&self, value: P0) -> windows_core::Result where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Devices/WiFiDirect/mod.rs b/crates/libs/windows/src/Windows/Devices/WiFiDirect/mod.rs index feba066bde..5ff5cbf40b 100644 --- a/crates/libs/windows/src/Windows/Devices/WiFiDirect/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/WiFiDirect/mod.rs @@ -651,7 +651,7 @@ impl WiFiDirectDevice { (windows_core::Interface::vtable(this).GetDeviceSelector)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(deviceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IWiFiDirectDeviceStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(deviceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -664,7 +664,7 @@ impl WiFiDirectDevice { }) } #[cfg(feature = "Devices_Enumeration")] - pub fn FromIdAsync2(deviceid: &windows_core::HSTRING, connectionparameters: P1) -> windows_core::Result> + pub fn FromIdAsync2(deviceid: &windows_core::HSTRING, connectionparameters: P1) -> windows_core::Result> where P1: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Embedded/DeviceLockdown/mod.rs b/crates/libs/windows/src/Windows/Embedded/DeviceLockdown/mod.rs index e66898d1d8..35f528e725 100644 --- a/crates/libs/windows/src/Windows/Embedded/DeviceLockdown/mod.rs +++ b/crates/libs/windows/src/Windows/Embedded/DeviceLockdown/mod.rs @@ -12,7 +12,7 @@ impl DeviceLockdownProfile { (windows_core::Interface::vtable(this).GetCurrentLockdownProfile)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) }) } - pub fn ApplyLockdownProfileAsync(profileid: windows_core::GUID) -> windows_core::Result { + pub fn ApplyLockdownProfileAsync(profileid: windows_core::GUID) -> windows_core::Result { Self::IDeviceLockdownProfileStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ApplyLockdownProfileAsync)(windows_core::Interface::as_raw(this), profileid, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/Foundation/Diagnostics/mod.rs b/crates/libs/windows/src/Windows/Foundation/Diagnostics/mod.rs index 8ec7d6fb39..44df67e856 100644 --- a/crates/libs/windows/src/Windows/Foundation/Diagnostics/mod.rs +++ b/crates/libs/windows/src/Windows/Foundation/Diagnostics/mod.rs @@ -3,7 +3,7 @@ impl AsyncCausalityTracer { pub fn TraceOperationCreation(tracelevel: CausalityTraceLevel, source: CausalitySource, platformid: windows_core::GUID, operationid: u64, operationname: &windows_core::HSTRING, relatedcontext: u64) -> windows_core::Result<()> { Self::IAsyncCausalityTracerStatics(|this| unsafe { (windows_core::Interface::vtable(this).TraceOperationCreation)(windows_core::Interface::as_raw(this), tracelevel, source, platformid, operationid, core::mem::transmute_copy(operationname), relatedcontext).ok() }) } - pub fn TraceOperationCompletion(tracelevel: CausalityTraceLevel, source: CausalitySource, platformid: windows_core::GUID, operationid: u64, status: windows_async::AsyncStatus) -> windows_core::Result<()> { + pub fn TraceOperationCompletion(tracelevel: CausalityTraceLevel, source: CausalitySource, platformid: windows_core::GUID, operationid: u64, status: windows_future::AsyncStatus) -> windows_core::Result<()> { Self::IAsyncCausalityTracerStatics(|this| unsafe { (windows_core::Interface::vtable(this).TraceOperationCompletion)(windows_core::Interface::as_raw(this), tracelevel, source, platformid, operationid, status).ok() }) } pub fn TraceOperationRelation(tracelevel: CausalityTraceLevel, source: CausalitySource, platformid: windows_core::GUID, operationid: u64, relation: CausalityRelation) -> windows_core::Result<()> { @@ -119,7 +119,7 @@ impl ErrorDetails { (windows_core::Interface::vtable(this).HelpUri)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateFromHResultAsync(errorcode: i32) -> windows_core::Result> { + pub fn CreateFromHResultAsync(errorcode: i32) -> windows_core::Result> { Self::IErrorDetailsStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreateFromHResultAsync)(windows_core::Interface::as_raw(this), errorcode, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -230,7 +230,7 @@ impl FileLoggingSession { unsafe { (windows_core::Interface::vtable(this).RemoveLoggingChannel)(windows_core::Interface::as_raw(this), loggingchannel.param().abi()).ok() } } #[cfg(feature = "Storage_Streams")] - pub fn CloseAndSaveToFileAsync(&self) -> windows_core::Result> { + pub fn CloseAndSaveToFileAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -282,7 +282,7 @@ impl windows_core::RuntimeType for IAsyncCausalityTracerStatics { pub struct IAsyncCausalityTracerStatics_Vtbl { pub base__: windows_core::IInspectable_Vtbl, pub TraceOperationCreation: unsafe extern "system" fn(*mut core::ffi::c_void, CausalityTraceLevel, CausalitySource, windows_core::GUID, u64, *mut core::ffi::c_void, u64) -> windows_core::HRESULT, - pub TraceOperationCompletion: unsafe extern "system" fn(*mut core::ffi::c_void, CausalityTraceLevel, CausalitySource, windows_core::GUID, u64, windows_async::AsyncStatus) -> windows_core::HRESULT, + pub TraceOperationCompletion: unsafe extern "system" fn(*mut core::ffi::c_void, CausalityTraceLevel, CausalitySource, windows_core::GUID, u64, windows_future::AsyncStatus) -> windows_core::HRESULT, pub TraceOperationRelation: unsafe extern "system" fn(*mut core::ffi::c_void, CausalityTraceLevel, CausalitySource, windows_core::GUID, u64, CausalityRelation) -> windows_core::HRESULT, pub TraceSynchronousWorkStart: unsafe extern "system" fn(*mut core::ffi::c_void, CausalityTraceLevel, CausalitySource, windows_core::GUID, u64, CausalitySynchronousWork) -> windows_core::HRESULT, pub TraceSynchronousWorkCompletion: unsafe extern "system" fn(*mut core::ffi::c_void, CausalityTraceLevel, CausalitySource, CausalitySynchronousWork) -> windows_core::HRESULT, @@ -406,7 +406,7 @@ impl IFileLoggingSession { unsafe { (windows_core::Interface::vtable(this).RemoveLoggingChannel)(windows_core::Interface::as_raw(this), loggingchannel.param().abi()).ok() } } #[cfg(feature = "Storage_Streams")] - pub fn CloseAndSaveToFileAsync(&self) -> windows_core::Result> { + pub fn CloseAndSaveToFileAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -442,7 +442,7 @@ pub trait IFileLoggingSession_Impl: super::IClosable_Impl { fn AddLoggingChannel(&self, loggingChannel: windows_core::Ref<'_, ILoggingChannel>) -> windows_core::Result<()>; fn AddLoggingChannelWithLevel(&self, loggingChannel: windows_core::Ref<'_, ILoggingChannel>, maxLevel: LoggingLevel) -> windows_core::Result<()>; fn RemoveLoggingChannel(&self, loggingChannel: windows_core::Ref<'_, ILoggingChannel>) -> windows_core::Result<()>; - fn CloseAndSaveToFileAsync(&self) -> windows_core::Result>; + fn CloseAndSaveToFileAsync(&self) -> windows_core::Result>; fn LogFileGenerated(&self, handler: windows_core::Ref<'_, super::TypedEventHandler>) -> windows_core::Result; fn RemoveLogFileGenerated(&self, token: i64) -> windows_core::Result<()>; } @@ -998,7 +998,7 @@ impl ILoggingSession { } } #[cfg(feature = "Storage_Streams")] - pub fn SaveToFileAsync(&self, folder: P0, filename: &windows_core::HSTRING) -> windows_core::Result> + pub fn SaveToFileAsync(&self, folder: P0, filename: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -1041,7 +1041,7 @@ impl windows_core::RuntimeName for ILoggingSession { #[cfg(feature = "Storage_Streams")] pub trait ILoggingSession_Impl: super::IClosable_Impl { fn Name(&self) -> windows_core::Result; - fn SaveToFileAsync(&self, folder: windows_core::Ref<'_, super::super::Storage::IStorageFolder>, fileName: &windows_core::HSTRING) -> windows_core::Result>; + fn SaveToFileAsync(&self, folder: windows_core::Ref<'_, super::super::Storage::IStorageFolder>, fileName: &windows_core::HSTRING) -> windows_core::Result>; fn AddLoggingChannel(&self, loggingChannel: windows_core::Ref<'_, ILoggingChannel>) -> windows_core::Result<()>; fn AddLoggingChannelWithLevel(&self, loggingChannel: windows_core::Ref<'_, ILoggingChannel>, maxLevel: LoggingLevel) -> windows_core::Result<()>; fn RemoveLoggingChannel(&self, loggingChannel: windows_core::Ref<'_, ILoggingChannel>) -> windows_core::Result<()>; @@ -2502,7 +2502,7 @@ impl LoggingSession { } } #[cfg(feature = "Storage_Streams")] - pub fn SaveToFileAsync(&self, folder: P0, filename: &windows_core::HSTRING) -> windows_core::Result> + pub fn SaveToFileAsync(&self, folder: P0, filename: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Gaming/Input/Custom/mod.rs b/crates/libs/windows/src/Windows/Gaming/Input/Custom/mod.rs index 833964f701..36112a5f12 100644 --- a/crates/libs/windows/src/Windows/Gaming/Input/Custom/mod.rs +++ b/crates/libs/windows/src/Windows/Gaming/Input/Custom/mod.rs @@ -169,7 +169,7 @@ impl GipGameControllerProvider { unsafe { (windows_core::Interface::vtable(this).SendReceiveMessage)(windows_core::Interface::as_raw(this), messageclass, messageid, requestmessagebuffer.len().try_into().unwrap(), requestmessagebuffer.as_ptr(), responsemessagebuffer.len().try_into().unwrap(), responsemessagebuffer.as_mut_ptr()).ok() } } #[cfg(feature = "Storage_Streams")] - pub fn UpdateFirmwareAsync(&self, firmwareimage: P0) -> windows_core::Result> + pub fn UpdateFirmwareAsync(&self, firmwareimage: P0) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Gaming/Input/ForceFeedback/mod.rs b/crates/libs/windows/src/Windows/Gaming/Input/ForceFeedback/mod.rs index 5cbacb4ae8..6aeb30f47c 100644 --- a/crates/libs/windows/src/Windows/Gaming/Input/ForceFeedback/mod.rs +++ b/crates/libs/windows/src/Windows/Gaming/Input/ForceFeedback/mod.rs @@ -251,7 +251,7 @@ impl ForceFeedbackMotor { (windows_core::Interface::vtable(this).SupportedAxes)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn LoadEffectAsync(&self, effect: P0) -> windows_core::Result> + pub fn LoadEffectAsync(&self, effect: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -273,28 +273,28 @@ impl ForceFeedbackMotor { let this = self; unsafe { (windows_core::Interface::vtable(this).StopAllEffects)(windows_core::Interface::as_raw(this)).ok() } } - pub fn TryDisableAsync(&self) -> windows_core::Result> { + pub fn TryDisableAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryDisableAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryEnableAsync(&self) -> windows_core::Result> { + pub fn TryEnableAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryEnableAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryResetAsync(&self) -> windows_core::Result> { + pub fn TryResetAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryResetAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryUnloadEffectAsync(&self, effect: P0) -> windows_core::Result> + pub fn TryUnloadEffectAsync(&self, effect: P0) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Gaming/Preview/GamesEnumeration/mod.rs b/crates/libs/windows/src/Windows/Gaming/Preview/GamesEnumeration/mod.rs index 9cbe147b32..8017b02fc1 100644 --- a/crates/libs/windows/src/Windows/Gaming/Preview/GamesEnumeration/mod.rs +++ b/crates/libs/windows/src/Windows/Gaming/Preview/GamesEnumeration/mod.rs @@ -1,12 +1,12 @@ pub struct GameList; impl GameList { - pub fn FindAllAsync() -> windows_core::Result>> { + pub fn FindAllAsync() -> windows_core::Result>> { Self::IGameListStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAllAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn FindAllAsyncPackageFamilyName(packagefamilyname: &windows_core::HSTRING) -> windows_core::Result>> { + pub fn FindAllAsyncPackageFamilyName(packagefamilyname: &windows_core::HSTRING) -> windows_core::Result>> { Self::IGameListStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAllAsyncPackageFamilyName)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(packagefamilyname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -48,7 +48,7 @@ impl GameList { pub fn RemoveGameUpdated(token: i64) -> windows_core::Result<()> { Self::IGameListStatics(|this| unsafe { (windows_core::Interface::vtable(this).RemoveGameUpdated)(windows_core::Interface::as_raw(this), token).ok() }) } - pub fn MergeEntriesAsync(left: P0, right: P1) -> windows_core::Result> + pub fn MergeEntriesAsync(left: P0, right: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -58,7 +58,7 @@ impl GameList { (windows_core::Interface::vtable(this).MergeEntriesAsync)(windows_core::Interface::as_raw(this), left.param().abi(), right.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn UnmergeEntryAsync(mergedentry: P0) -> windows_core::Result>> + pub fn UnmergeEntryAsync(mergedentry: P0) -> windows_core::Result>> where P0: windows_core::Param, { @@ -174,7 +174,7 @@ impl GameListEntry { (windows_core::Interface::vtable(this).DisplayInfo)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn LaunchAsync(&self) -> windows_core::Result> { + pub fn LaunchAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -195,7 +195,7 @@ impl GameListEntry { (windows_core::Interface::vtable(this).Properties)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SetCategoryAsync(&self, value: GameListCategory) -> windows_core::Result { + pub fn SetCategoryAsync(&self, value: GameListCategory) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -225,7 +225,7 @@ impl GameListEntry { } } #[cfg(feature = "Storage_Streams")] - pub fn SetLauncherExecutableFileAsync(&self, executablefile: P0) -> windows_core::Result + pub fn SetLauncherExecutableFileAsync(&self, executablefile: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -236,7 +236,7 @@ impl GameListEntry { } } #[cfg(feature = "Storage_Streams")] - pub fn SetLauncherExecutableFileWithParamsAsync(&self, executablefile: P0, launchparams: &windows_core::HSTRING) -> windows_core::Result + pub fn SetLauncherExecutableFileWithParamsAsync(&self, executablefile: P0, launchparams: &windows_core::HSTRING) -> windows_core::Result where P0: windows_core::Param, { @@ -253,7 +253,7 @@ impl GameListEntry { (windows_core::Interface::vtable(this).TitleId)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn SetTitleIdAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result { + pub fn SetTitleIdAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -478,7 +478,7 @@ impl GameModeConfiguration { let this = self; unsafe { (windows_core::Interface::vtable(this).SetAffinitizeToExclusiveCpus)(windows_core::Interface::as_raw(this), value).ok() } } - pub fn SaveAsync(&self) -> windows_core::Result { + pub fn SaveAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -510,7 +510,7 @@ impl GameModeUserConfiguration { (windows_core::Interface::vtable(this).GamingRelatedProcessNames)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SaveAsync(&self) -> windows_core::Result { + pub fn SaveAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -554,7 +554,7 @@ impl IGameListEntry { (windows_core::Interface::vtable(this).DisplayInfo)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn LaunchAsync(&self) -> windows_core::Result> { + pub fn LaunchAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -575,7 +575,7 @@ impl IGameListEntry { (windows_core::Interface::vtable(this).Properties)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SetCategoryAsync(&self, value: GameListCategory) -> windows_core::Result { + pub fn SetCategoryAsync(&self, value: GameListCategory) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -590,10 +590,10 @@ impl windows_core::RuntimeName for IGameListEntry { #[cfg(feature = "ApplicationModel")] pub trait IGameListEntry_Impl: windows_core::IUnknownImpl { fn DisplayInfo(&self) -> windows_core::Result; - fn LaunchAsync(&self) -> windows_core::Result>; + fn LaunchAsync(&self) -> windows_core::Result>; fn Category(&self) -> windows_core::Result; fn Properties(&self) -> windows_core::Result>; - fn SetCategoryAsync(&self, value: GameListCategory) -> windows_core::Result; + fn SetCategoryAsync(&self, value: GameListCategory) -> windows_core::Result; } #[cfg(feature = "ApplicationModel")] impl IGameListEntry_Vtbl { diff --git a/crates/libs/windows/src/Windows/Gaming/XboxLive/Storage/mod.rs b/crates/libs/windows/src/Windows/Gaming/XboxLive/Storage/mod.rs index 3854f86508..8cd1b46c23 100644 --- a/crates/libs/windows/src/Windows/Gaming/XboxLive/Storage/mod.rs +++ b/crates/libs/windows/src/Windows/Gaming/XboxLive/Storage/mod.rs @@ -100,21 +100,21 @@ unsafe impl Sync for GameSaveBlobInfoGetResult {} pub struct GameSaveBlobInfoQuery(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(GameSaveBlobInfoQuery, windows_core::IUnknown, windows_core::IInspectable); impl GameSaveBlobInfoQuery { - pub fn GetBlobInfoAsync(&self) -> windows_core::Result> { + pub fn GetBlobInfoAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetBlobInfoAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetBlobInfoWithIndexAndMaxAsync(&self, startindex: u32, maxnumberofitems: u32) -> windows_core::Result> { + pub fn GetBlobInfoWithIndexAndMaxAsync(&self, startindex: u32, maxnumberofitems: u32) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetBlobInfoWithIndexAndMaxAsync)(windows_core::Interface::as_raw(this), startindex, maxnumberofitems, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetItemCountAsync(&self) -> windows_core::Result> { + pub fn GetItemCountAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -154,7 +154,7 @@ impl GameSaveContainer { } } #[cfg(feature = "Storage_Streams")] - pub fn SubmitUpdatesAsync(&self, blobstowrite: P0, blobstodelete: P1, displayname: &windows_core::HSTRING) -> windows_core::Result> + pub fn SubmitUpdatesAsync(&self, blobstowrite: P0, blobstodelete: P1, displayname: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param>, P1: windows_core::Param>, @@ -166,7 +166,7 @@ impl GameSaveContainer { } } #[cfg(feature = "Storage_Streams")] - pub fn ReadAsync(&self, blobstoread: P0) -> windows_core::Result> + pub fn ReadAsync(&self, blobstoread: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -176,7 +176,7 @@ impl GameSaveContainer { (windows_core::Interface::vtable(this).ReadAsync)(windows_core::Interface::as_raw(this), blobstoread.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAsync(&self, blobstoread: P0) -> windows_core::Result> + pub fn GetAsync(&self, blobstoread: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -187,7 +187,7 @@ impl GameSaveContainer { } } #[cfg(feature = "Foundation_Collections")] - pub fn SubmitPropertySetUpdatesAsync(&self, blobstowrite: P0, blobstodelete: P1, displayname: &windows_core::HSTRING) -> windows_core::Result> + pub fn SubmitPropertySetUpdatesAsync(&self, blobstowrite: P0, blobstodelete: P1, displayname: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param>, @@ -308,21 +308,21 @@ unsafe impl Sync for GameSaveContainerInfoGetResult {} pub struct GameSaveContainerInfoQuery(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(GameSaveContainerInfoQuery, windows_core::IUnknown, windows_core::IInspectable); impl GameSaveContainerInfoQuery { - pub fn GetContainerInfoAsync(&self) -> windows_core::Result> { + pub fn GetContainerInfoAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetContainerInfoAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetContainerInfoWithIndexAndMaxAsync(&self, startindex: u32, maxnumberofitems: u32) -> windows_core::Result> { + pub fn GetContainerInfoWithIndexAndMaxAsync(&self, startindex: u32, maxnumberofitems: u32) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetContainerInfoWithIndexAndMaxAsync)(windows_core::Interface::as_raw(this), startindex, maxnumberofitems, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetItemCountAsync(&self) -> windows_core::Result> { + pub fn GetItemCountAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -413,7 +413,7 @@ impl GameSaveProvider { (windows_core::Interface::vtable(this).CreateContainer)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(name), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteContainerAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { + pub fn DeleteContainerAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -434,7 +434,7 @@ impl GameSaveProvider { (windows_core::Interface::vtable(this).CreateContainerInfoQueryWithName)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(containernameprefix), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetRemainingBytesInQuotaAsync(&self) -> windows_core::Result> { + pub fn GetRemainingBytesInQuotaAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -449,7 +449,7 @@ impl GameSaveProvider { } } #[cfg(feature = "System")] - pub fn GetForUserAsync(user: P0, serviceconfigid: &windows_core::HSTRING) -> windows_core::Result> + pub fn GetForUserAsync(user: P0, serviceconfigid: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -459,7 +459,7 @@ impl GameSaveProvider { }) } #[cfg(feature = "System")] - pub fn GetSyncOnDemandForUserAsync(user: P0, serviceconfigid: &windows_core::HSTRING) -> windows_core::Result> + pub fn GetSyncOnDemandForUserAsync(user: P0, serviceconfigid: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Graphics/Capture/mod.rs b/crates/libs/windows/src/Windows/Graphics/Capture/mod.rs index 39358133b4..f896eacc1d 100644 --- a/crates/libs/windows/src/Windows/Graphics/Capture/mod.rs +++ b/crates/libs/windows/src/Windows/Graphics/Capture/mod.rs @@ -158,7 +158,7 @@ unsafe impl Sync for Direct3D11CaptureFramePool {} pub struct GraphicsCaptureAccess; impl GraphicsCaptureAccess { #[cfg(feature = "Security_Authorization_AppCapabilityAccess")] - pub fn RequestAccessAsync(request: GraphicsCaptureAccessKind) -> windows_core::Result> { + pub fn RequestAccessAsync(request: GraphicsCaptureAccessKind) -> windows_core::Result> { Self::IGraphicsCaptureAccessStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestAccessAsync)(windows_core::Interface::as_raw(this), request, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -287,7 +287,7 @@ impl GraphicsCapturePicker { static SHARED: windows_core::imp::FactoryCache = windows_core::imp::FactoryCache::new(); SHARED.call(callback) } - pub fn PickSingleItemAsync(&self) -> windows_core::Result> { + pub fn PickSingleItemAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Graphics/Display/Core/mod.rs b/crates/libs/windows/src/Windows/Graphics/Display/Core/mod.rs index 895e7f4254..08275c9a10 100644 --- a/crates/libs/windows/src/Windows/Graphics/Display/Core/mod.rs +++ b/crates/libs/windows/src/Windows/Graphics/Display/Core/mod.rs @@ -69,14 +69,14 @@ impl HdmiDisplayInformation { (windows_core::Interface::vtable(this).GetCurrentDisplayMode)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SetDefaultDisplayModeAsync(&self) -> windows_core::Result { + pub fn SetDefaultDisplayModeAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).SetDefaultDisplayModeAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestSetCurrentDisplayModeAsync(&self, mode: P0) -> windows_core::Result> + pub fn RequestSetCurrentDisplayModeAsync(&self, mode: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -86,7 +86,7 @@ impl HdmiDisplayInformation { (windows_core::Interface::vtable(this).RequestSetCurrentDisplayModeAsync)(windows_core::Interface::as_raw(this), mode.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestSetCurrentDisplayModeWithHdrAsync(&self, mode: P0, hdroption: HdmiDisplayHdrOption) -> windows_core::Result> + pub fn RequestSetCurrentDisplayModeWithHdrAsync(&self, mode: P0, hdroption: HdmiDisplayHdrOption) -> windows_core::Result> where P0: windows_core::Param, { @@ -96,7 +96,7 @@ impl HdmiDisplayInformation { (windows_core::Interface::vtable(this).RequestSetCurrentDisplayModeWithHdrAsync)(windows_core::Interface::as_raw(this), mode.param().abi(), hdroption, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestSetCurrentDisplayModeWithHdrAndMetadataAsync(&self, mode: P0, hdroption: HdmiDisplayHdrOption, hdrmetadata: HdmiDisplayHdr2086Metadata) -> windows_core::Result> + pub fn RequestSetCurrentDisplayModeWithHdrAndMetadataAsync(&self, mode: P0, hdroption: HdmiDisplayHdrOption, hdrmetadata: HdmiDisplayHdr2086Metadata) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Graphics/Display/mod.rs b/crates/libs/windows/src/Windows/Graphics/Display/mod.rs index 9d3d57d0ff..992e9f4a53 100644 --- a/crates/libs/windows/src/Windows/Graphics/Display/mod.rs +++ b/crates/libs/windows/src/Windows/Graphics/Display/mod.rs @@ -212,7 +212,7 @@ impl BrightnessOverride { (windows_core::Interface::vtable(this).GetForCurrentView)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn SaveForSystemAsync(value: P0) -> windows_core::Result> + pub fn SaveForSystemAsync(value: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -702,7 +702,7 @@ impl DisplayInformation { unsafe { (windows_core::Interface::vtable(this).RemoveStereoEnabledChanged)(windows_core::Interface::as_raw(this), token).ok() } } #[cfg(feature = "Storage_Streams")] - pub fn GetColorProfileAsync(&self) -> windows_core::Result> { + pub fn GetColorProfileAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -945,7 +945,7 @@ impl DisplayProperties { Self::IDisplayPropertiesStatics(|this| unsafe { (windows_core::Interface::vtable(this).RemoveStereoEnabledChanged)(windows_core::Interface::as_raw(this), token).ok() }) } #[cfg(feature = "Storage_Streams")] - pub fn GetColorProfileAsync() -> windows_core::Result> { + pub fn GetColorProfileAsync() -> windows_core::Result> { Self::IDisplayPropertiesStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetColorProfileAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/Graphics/Imaging/mod.rs b/crates/libs/windows/src/Windows/Graphics/Imaging/mod.rs index dda2091621..8c2171ac63 100644 --- a/crates/libs/windows/src/Windows/Graphics/Imaging/mod.rs +++ b/crates/libs/windows/src/Windows/Graphics/Imaging/mod.rs @@ -158,14 +158,14 @@ impl BitmapDecoder { } } #[cfg(feature = "Storage_Streams")] - pub fn GetPreviewAsync(&self) -> windows_core::Result> { + pub fn GetPreviewAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetPreviewAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetFrameAsync(&self, frameindex: u32) -> windows_core::Result> { + pub fn GetFrameAsync(&self, frameindex: u32) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -221,7 +221,7 @@ impl BitmapDecoder { }) } #[cfg(feature = "Storage_Streams")] - pub fn CreateAsync(stream: P0) -> windows_core::Result> + pub fn CreateAsync(stream: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -231,7 +231,7 @@ impl BitmapDecoder { }) } #[cfg(feature = "Storage_Streams")] - pub fn CreateWithIdAsync(decoderid: windows_core::GUID, stream: P1) -> windows_core::Result> + pub fn CreateWithIdAsync(decoderid: windows_core::GUID, stream: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -253,7 +253,7 @@ impl BitmapDecoder { }) } #[cfg(feature = "Storage_Streams")] - pub fn GetThumbnailAsync(&self) -> windows_core::Result> { + pub fn GetThumbnailAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -323,14 +323,14 @@ impl BitmapDecoder { (windows_core::Interface::vtable(this).OrientedPixelHeight)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn GetPixelDataAsync(&self) -> windows_core::Result> { + pub fn GetPixelDataAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetPixelDataAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetPixelDataTransformedAsync(&self, pixelformat: BitmapPixelFormat, alphamode: BitmapAlphaMode, transform: P2, exiforientationmode: ExifOrientationMode, colormanagementmode: ColorManagementMode) -> windows_core::Result> + pub fn GetPixelDataTransformedAsync(&self, pixelformat: BitmapPixelFormat, alphamode: BitmapAlphaMode, transform: P2, exiforientationmode: ExifOrientationMode, colormanagementmode: ColorManagementMode) -> windows_core::Result> where P2: windows_core::Param, { @@ -340,21 +340,21 @@ impl BitmapDecoder { (windows_core::Interface::vtable(this).GetPixelDataTransformedAsync)(windows_core::Interface::as_raw(this), pixelformat, alphamode, transform.param().abi(), exiforientationmode, colormanagementmode, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetSoftwareBitmapAsync(&self) -> windows_core::Result> { + pub fn GetSoftwareBitmapAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetSoftwareBitmapAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetSoftwareBitmapConvertedAsync(&self, pixelformat: BitmapPixelFormat, alphamode: BitmapAlphaMode) -> windows_core::Result> { + pub fn GetSoftwareBitmapConvertedAsync(&self, pixelformat: BitmapPixelFormat, alphamode: BitmapAlphaMode) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetSoftwareBitmapConvertedAsync)(windows_core::Interface::as_raw(this), pixelformat, alphamode, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetSoftwareBitmapTransformedAsync(&self, pixelformat: BitmapPixelFormat, alphamode: BitmapAlphaMode, transform: P2, exiforientationmode: ExifOrientationMode, colormanagementmode: ColorManagementMode) -> windows_core::Result> + pub fn GetSoftwareBitmapTransformedAsync(&self, pixelformat: BitmapPixelFormat, alphamode: BitmapAlphaMode, transform: P2, exiforientationmode: ExifOrientationMode, colormanagementmode: ColorManagementMode) -> windows_core::Result> where P2: windows_core::Param, { @@ -455,14 +455,14 @@ impl BitmapEncoder { let this = self; unsafe { (windows_core::Interface::vtable(this).SetPixelData)(windows_core::Interface::as_raw(this), pixelformat, alphamode, width, height, dpix, dpiy, pixels.len().try_into().unwrap(), pixels.as_ptr()).ok() } } - pub fn GoToNextFrameAsync(&self) -> windows_core::Result { + pub fn GoToNextFrameAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GoToNextFrameAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GoToNextFrameWithEncodingOptionsAsync(&self, encodingoptions: P0) -> windows_core::Result + pub fn GoToNextFrameWithEncodingOptionsAsync(&self, encodingoptions: P0) -> windows_core::Result where P0: windows_core::Param>>, { @@ -472,7 +472,7 @@ impl BitmapEncoder { (windows_core::Interface::vtable(this).GoToNextFrameWithEncodingOptionsAsync)(windows_core::Interface::as_raw(this), encodingoptions.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FlushAsync(&self) -> windows_core::Result { + pub fn FlushAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -522,7 +522,7 @@ impl BitmapEncoder { }) } #[cfg(feature = "Storage_Streams")] - pub fn CreateAsync(encoderid: windows_core::GUID, stream: P1) -> windows_core::Result> + pub fn CreateAsync(encoderid: windows_core::GUID, stream: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -532,7 +532,7 @@ impl BitmapEncoder { }) } #[cfg(feature = "Storage_Streams")] - pub fn CreateWithEncodingOptionsAsync(encoderid: windows_core::GUID, stream: P1, encodingoptions: P2) -> windows_core::Result> + pub fn CreateWithEncodingOptionsAsync(encoderid: windows_core::GUID, stream: P1, encodingoptions: P2) -> windows_core::Result> where P1: windows_core::Param, P2: windows_core::Param>>, @@ -543,7 +543,7 @@ impl BitmapEncoder { }) } #[cfg(feature = "Storage_Streams")] - pub fn CreateForTranscodingAsync(stream: P0, bitmapdecoder: P1) -> windows_core::Result> + pub fn CreateForTranscodingAsync(stream: P0, bitmapdecoder: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -553,7 +553,7 @@ impl BitmapEncoder { (windows_core::Interface::vtable(this).CreateForTranscodingAsync)(windows_core::Interface::as_raw(this), stream.param().abi(), bitmapdecoder.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn CreateForInPlacePropertyEncodingAsync(bitmapdecoder: P0) -> windows_core::Result> + pub fn CreateForInPlacePropertyEncodingAsync(bitmapdecoder: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -617,7 +617,7 @@ windows_core::imp::interface_hierarchy!(BitmapFrame, windows_core::IUnknown, win windows_core::imp::required_hierarchy!(BitmapFrame, IBitmapFrameWithSoftwareBitmap); impl BitmapFrame { #[cfg(feature = "Storage_Streams")] - pub fn GetThumbnailAsync(&self) -> windows_core::Result> { + pub fn GetThumbnailAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -687,14 +687,14 @@ impl BitmapFrame { (windows_core::Interface::vtable(this).OrientedPixelHeight)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn GetPixelDataAsync(&self) -> windows_core::Result> { + pub fn GetPixelDataAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetPixelDataAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetPixelDataTransformedAsync(&self, pixelformat: BitmapPixelFormat, alphamode: BitmapAlphaMode, transform: P2, exiforientationmode: ExifOrientationMode, colormanagementmode: ColorManagementMode) -> windows_core::Result> + pub fn GetPixelDataTransformedAsync(&self, pixelformat: BitmapPixelFormat, alphamode: BitmapAlphaMode, transform: P2, exiforientationmode: ExifOrientationMode, colormanagementmode: ColorManagementMode) -> windows_core::Result> where P2: windows_core::Param, { @@ -704,21 +704,21 @@ impl BitmapFrame { (windows_core::Interface::vtable(this).GetPixelDataTransformedAsync)(windows_core::Interface::as_raw(this), pixelformat, alphamode, transform.param().abi(), exiforientationmode, colormanagementmode, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetSoftwareBitmapAsync(&self) -> windows_core::Result> { + pub fn GetSoftwareBitmapAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetSoftwareBitmapAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetSoftwareBitmapConvertedAsync(&self, pixelformat: BitmapPixelFormat, alphamode: BitmapAlphaMode) -> windows_core::Result> { + pub fn GetSoftwareBitmapConvertedAsync(&self, pixelformat: BitmapPixelFormat, alphamode: BitmapAlphaMode) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetSoftwareBitmapConvertedAsync)(windows_core::Interface::as_raw(this), pixelformat, alphamode, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetSoftwareBitmapTransformedAsync(&self, pixelformat: BitmapPixelFormat, alphamode: BitmapAlphaMode, transform: P2, exiforientationmode: ExifOrientationMode, colormanagementmode: ColorManagementMode) -> windows_core::Result> + pub fn GetSoftwareBitmapTransformedAsync(&self, pixelformat: BitmapPixelFormat, alphamode: BitmapAlphaMode, transform: P2, exiforientationmode: ExifOrientationMode, colormanagementmode: ColorManagementMode) -> windows_core::Result> where P2: windows_core::Param, { @@ -796,7 +796,7 @@ pub struct BitmapProperties(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(BitmapProperties, windows_core::IUnknown, windows_core::IInspectable); windows_core::imp::required_hierarchy!(BitmapProperties, IBitmapPropertiesView); impl BitmapProperties { - pub fn SetPropertiesAsync(&self, propertiestoset: P0) -> windows_core::Result + pub fn SetPropertiesAsync(&self, propertiestoset: P0) -> windows_core::Result where P0: windows_core::Param>>, { @@ -806,7 +806,7 @@ impl BitmapProperties { (windows_core::Interface::vtable(this).SetPropertiesAsync)(windows_core::Interface::as_raw(this), propertiestoset.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetPropertiesAsync(&self, propertiestoretrieve: P0) -> windows_core::Result> + pub fn GetPropertiesAsync(&self, propertiestoretrieve: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -834,7 +834,7 @@ unsafe impl Sync for BitmapProperties {} pub struct BitmapPropertiesView(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(BitmapPropertiesView, windows_core::IUnknown, windows_core::IInspectable, IBitmapPropertiesView); impl BitmapPropertiesView { - pub fn GetPropertiesAsync(&self, propertiestoretrieve: P0) -> windows_core::Result> + pub fn GetPropertiesAsync(&self, propertiestoretrieve: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -1286,7 +1286,7 @@ impl windows_core::RuntimeType for IBitmapFrame { windows_core::imp::interface_hierarchy!(IBitmapFrame, windows_core::IUnknown, windows_core::IInspectable); impl IBitmapFrame { #[cfg(feature = "Storage_Streams")] - pub fn GetThumbnailAsync(&self) -> windows_core::Result> { + pub fn GetThumbnailAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1356,14 +1356,14 @@ impl IBitmapFrame { (windows_core::Interface::vtable(this).OrientedPixelHeight)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn GetPixelDataAsync(&self) -> windows_core::Result> { + pub fn GetPixelDataAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetPixelDataAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetPixelDataTransformedAsync(&self, pixelformat: BitmapPixelFormat, alphamode: BitmapAlphaMode, transform: P2, exiforientationmode: ExifOrientationMode, colormanagementmode: ColorManagementMode) -> windows_core::Result> + pub fn GetPixelDataTransformedAsync(&self, pixelformat: BitmapPixelFormat, alphamode: BitmapAlphaMode, transform: P2, exiforientationmode: ExifOrientationMode, colormanagementmode: ColorManagementMode) -> windows_core::Result> where P2: windows_core::Param, { @@ -1380,7 +1380,7 @@ impl windows_core::RuntimeName for IBitmapFrame { } #[cfg(feature = "Storage_Streams")] pub trait IBitmapFrame_Impl: windows_core::IUnknownImpl { - fn GetThumbnailAsync(&self) -> windows_core::Result>; + fn GetThumbnailAsync(&self) -> windows_core::Result>; fn BitmapProperties(&self) -> windows_core::Result; fn BitmapPixelFormat(&self) -> windows_core::Result; fn BitmapAlphaMode(&self) -> windows_core::Result; @@ -1390,8 +1390,8 @@ pub trait IBitmapFrame_Impl: windows_core::IUnknownImpl { fn PixelHeight(&self) -> windows_core::Result; fn OrientedPixelWidth(&self) -> windows_core::Result; fn OrientedPixelHeight(&self) -> windows_core::Result; - fn GetPixelDataAsync(&self) -> windows_core::Result>; - fn GetPixelDataTransformedAsync(&self, pixelFormat: BitmapPixelFormat, alphaMode: BitmapAlphaMode, transform: windows_core::Ref<'_, BitmapTransform>, exifOrientationMode: ExifOrientationMode, colorManagementMode: ColorManagementMode) -> windows_core::Result>; + fn GetPixelDataAsync(&self) -> windows_core::Result>; + fn GetPixelDataTransformedAsync(&self, pixelFormat: BitmapPixelFormat, alphaMode: BitmapAlphaMode, transform: windows_core::Ref<'_, BitmapTransform>, exifOrientationMode: ExifOrientationMode, colorManagementMode: ColorManagementMode) -> windows_core::Result>; } #[cfg(feature = "Storage_Streams")] impl IBitmapFrame_Vtbl { @@ -1590,21 +1590,21 @@ impl windows_core::RuntimeType for IBitmapFrameWithSoftwareBitmap { windows_core::imp::interface_hierarchy!(IBitmapFrameWithSoftwareBitmap, windows_core::IUnknown, windows_core::IInspectable); windows_core::imp::required_hierarchy!(IBitmapFrameWithSoftwareBitmap, IBitmapFrame); impl IBitmapFrameWithSoftwareBitmap { - pub fn GetSoftwareBitmapAsync(&self) -> windows_core::Result> { + pub fn GetSoftwareBitmapAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetSoftwareBitmapAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetSoftwareBitmapConvertedAsync(&self, pixelformat: BitmapPixelFormat, alphamode: BitmapAlphaMode) -> windows_core::Result> { + pub fn GetSoftwareBitmapConvertedAsync(&self, pixelformat: BitmapPixelFormat, alphamode: BitmapAlphaMode) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetSoftwareBitmapConvertedAsync)(windows_core::Interface::as_raw(this), pixelformat, alphamode, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetSoftwareBitmapTransformedAsync(&self, pixelformat: BitmapPixelFormat, alphamode: BitmapAlphaMode, transform: P2, exiforientationmode: ExifOrientationMode, colormanagementmode: ColorManagementMode) -> windows_core::Result> + pub fn GetSoftwareBitmapTransformedAsync(&self, pixelformat: BitmapPixelFormat, alphamode: BitmapAlphaMode, transform: P2, exiforientationmode: ExifOrientationMode, colormanagementmode: ColorManagementMode) -> windows_core::Result> where P2: windows_core::Param, { @@ -1615,7 +1615,7 @@ impl IBitmapFrameWithSoftwareBitmap { } } #[cfg(feature = "Storage_Streams")] - pub fn GetThumbnailAsync(&self) -> windows_core::Result> { + pub fn GetThumbnailAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1685,14 +1685,14 @@ impl IBitmapFrameWithSoftwareBitmap { (windows_core::Interface::vtable(this).OrientedPixelHeight)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn GetPixelDataAsync(&self) -> windows_core::Result> { + pub fn GetPixelDataAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetPixelDataAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetPixelDataTransformedAsync(&self, pixelformat: BitmapPixelFormat, alphamode: BitmapAlphaMode, transform: P2, exiforientationmode: ExifOrientationMode, colormanagementmode: ColorManagementMode) -> windows_core::Result> + pub fn GetPixelDataTransformedAsync(&self, pixelformat: BitmapPixelFormat, alphamode: BitmapAlphaMode, transform: P2, exiforientationmode: ExifOrientationMode, colormanagementmode: ColorManagementMode) -> windows_core::Result> where P2: windows_core::Param, { @@ -1709,9 +1709,9 @@ impl windows_core::RuntimeName for IBitmapFrameWithSoftwareBitmap { } #[cfg(feature = "Storage_Streams")] pub trait IBitmapFrameWithSoftwareBitmap_Impl: IBitmapFrame_Impl { - fn GetSoftwareBitmapAsync(&self) -> windows_core::Result>; - fn GetSoftwareBitmapConvertedAsync(&self, pixelFormat: BitmapPixelFormat, alphaMode: BitmapAlphaMode) -> windows_core::Result>; - fn GetSoftwareBitmapTransformedAsync(&self, pixelFormat: BitmapPixelFormat, alphaMode: BitmapAlphaMode, transform: windows_core::Ref<'_, BitmapTransform>, exifOrientationMode: ExifOrientationMode, colorManagementMode: ColorManagementMode) -> windows_core::Result>; + fn GetSoftwareBitmapAsync(&self) -> windows_core::Result>; + fn GetSoftwareBitmapConvertedAsync(&self, pixelFormat: BitmapPixelFormat, alphaMode: BitmapAlphaMode) -> windows_core::Result>; + fn GetSoftwareBitmapTransformedAsync(&self, pixelFormat: BitmapPixelFormat, alphaMode: BitmapAlphaMode, transform: windows_core::Ref<'_, BitmapTransform>, exifOrientationMode: ExifOrientationMode, colorManagementMode: ColorManagementMode) -> windows_core::Result>; } #[cfg(feature = "Storage_Streams")] impl IBitmapFrameWithSoftwareBitmap_Vtbl { @@ -1788,7 +1788,7 @@ impl windows_core::RuntimeType for IBitmapPropertiesView { } windows_core::imp::interface_hierarchy!(IBitmapPropertiesView, windows_core::IUnknown, windows_core::IInspectable); impl IBitmapPropertiesView { - pub fn GetPropertiesAsync(&self, propertiestoretrieve: P0) -> windows_core::Result> + pub fn GetPropertiesAsync(&self, propertiestoretrieve: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -1803,7 +1803,7 @@ impl windows_core::RuntimeName for IBitmapPropertiesView { const NAME: &'static str = "Windows.Graphics.Imaging.IBitmapPropertiesView"; } pub trait IBitmapPropertiesView_Impl: windows_core::IUnknownImpl { - fn GetPropertiesAsync(&self, propertiesToRetrieve: windows_core::Ref<'_, windows_collections::IIterable>) -> windows_core::Result>; + fn GetPropertiesAsync(&self, propertiesToRetrieve: windows_core::Ref<'_, windows_collections::IIterable>) -> windows_core::Result>; } impl IBitmapPropertiesView_Vtbl { pub const fn new() -> Self { @@ -1968,7 +1968,7 @@ impl ImageStream { (windows_core::Interface::vtable(this).ContentType)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn ReadAsync(&self, buffer: P0, count: u32, options: super::super::Storage::Streams::InputStreamOptions) -> windows_core::Result> + pub fn ReadAsync(&self, buffer: P0, count: u32, options: super::super::Storage::Streams::InputStreamOptions) -> windows_core::Result> where P0: windows_core::Param, { @@ -1978,7 +1978,7 @@ impl ImageStream { (windows_core::Interface::vtable(this).ReadAsync)(windows_core::Interface::as_raw(this), buffer.param().abi(), count, options, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn WriteAsync(&self, buffer: P0) -> windows_core::Result> + pub fn WriteAsync(&self, buffer: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1988,7 +1988,7 @@ impl ImageStream { (windows_core::Interface::vtable(this).WriteAsync)(windows_core::Interface::as_raw(this), buffer.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FlushAsync(&self) -> windows_core::Result> { + pub fn FlushAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -2292,7 +2292,7 @@ impl SoftwareBitmap { }) } #[cfg(feature = "Graphics_DirectX_Direct3D11")] - pub fn CreateCopyFromSurfaceAsync(surface: P0) -> windows_core::Result> + pub fn CreateCopyFromSurfaceAsync(surface: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2302,7 +2302,7 @@ impl SoftwareBitmap { }) } #[cfg(feature = "Graphics_DirectX_Direct3D11")] - pub fn CreateCopyWithAlphaFromSurfaceAsync(surface: P0, alpha: BitmapAlphaMode) -> windows_core::Result> + pub fn CreateCopyWithAlphaFromSurfaceAsync(surface: P0, alpha: BitmapAlphaMode) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Graphics/Printing/PrintTicket/mod.rs b/crates/libs/windows/src/Windows/Graphics/Printing/PrintTicket/mod.rs index 2369c1a23f..bbd16c65e7 100644 --- a/crates/libs/windows/src/Windows/Graphics/Printing/PrintTicket/mod.rs +++ b/crates/libs/windows/src/Windows/Graphics/Printing/PrintTicket/mod.rs @@ -832,14 +832,14 @@ impl WorkflowPrintTicket { (windows_core::Interface::vtable(this).GetFeature)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(name), core::mem::transmute_copy(xmlnamespace), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn NotifyXmlChangedAsync(&self) -> windows_core::Result { + pub fn NotifyXmlChangedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).NotifyXmlChangedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ValidateAsync(&self) -> windows_core::Result> { + pub fn ValidateAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Graphics/Printing/Workflow/mod.rs b/crates/libs/windows/src/Windows/Graphics/Printing/Workflow/mod.rs index 288030a936..282069bbce 100644 --- a/crates/libs/windows/src/Windows/Graphics/Printing/Workflow/mod.rs +++ b/crates/libs/windows/src/Windows/Graphics/Printing/Workflow/mod.rs @@ -680,7 +680,7 @@ pub struct PrintWorkflowBackgroundSetupRequestedEventArgs(windows_core::IUnknown windows_core::imp::interface_hierarchy!(PrintWorkflowBackgroundSetupRequestedEventArgs, windows_core::IUnknown, windows_core::IInspectable); impl PrintWorkflowBackgroundSetupRequestedEventArgs { #[cfg(feature = "Graphics_Printing_PrintTicket")] - pub fn GetUserPrintTicketAsync(&self) -> windows_core::Result> { + pub fn GetUserPrintTicketAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -824,7 +824,7 @@ pub struct PrintWorkflowForegroundSetupRequestedEventArgs(windows_core::IUnknown windows_core::imp::interface_hierarchy!(PrintWorkflowForegroundSetupRequestedEventArgs, windows_core::IUnknown, windows_core::IInspectable); impl PrintWorkflowForegroundSetupRequestedEventArgs { #[cfg(feature = "Graphics_Printing_PrintTicket")] - pub fn GetUserPrintTicketAsync(&self) -> windows_core::Result> { + pub fn GetUserPrintTicketAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1370,7 +1370,7 @@ pub struct PrintWorkflowPdlConverter(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(PrintWorkflowPdlConverter, windows_core::IUnknown, windows_core::IInspectable); impl PrintWorkflowPdlConverter { #[cfg(all(feature = "Graphics_Printing_PrintTicket", feature = "Storage_Streams"))] - pub fn ConvertPdlAsync(&self, printticket: P0, inputstream: P1, outputstream: P2) -> windows_core::Result + pub fn ConvertPdlAsync(&self, printticket: P0, inputstream: P1, outputstream: P2) -> windows_core::Result where P0: windows_core::Param, P1: windows_core::Param, @@ -1383,7 +1383,7 @@ impl PrintWorkflowPdlConverter { } } #[cfg(all(feature = "Graphics_Printing_PrintTicket", feature = "Storage_Streams"))] - pub fn ConvertPdlAsync2(&self, printticket: P0, inputstream: P1, outputstream: P2, hostbasedprocessingoperations: PdlConversionHostBasedProcessingOperations) -> windows_core::Result + pub fn ConvertPdlAsync2(&self, printticket: P0, inputstream: P1, outputstream: P2, hostbasedprocessingoperations: PdlConversionHostBasedProcessingOperations) -> windows_core::Result where P0: windows_core::Param, P1: windows_core::Param, @@ -1588,7 +1588,7 @@ impl PrintWorkflowPdlSourceContent { } } #[cfg(feature = "Storage_Streams")] - pub fn GetContentFileAsync(&self) -> windows_core::Result> { + pub fn GetContentFileAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1778,7 +1778,7 @@ pub struct PrintWorkflowSourceContent(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(PrintWorkflowSourceContent, windows_core::IUnknown, windows_core::IInspectable); impl PrintWorkflowSourceContent { #[cfg(feature = "Graphics_Printing_PrintTicket")] - pub fn GetJobPrintTicketAsync(&self) -> windows_core::Result> { + pub fn GetJobPrintTicketAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2105,7 +2105,7 @@ impl PrintWorkflowUILauncher { (windows_core::Interface::vtable(this).IsUILaunchEnabled)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn LaunchAndCompleteUIAsync(&self) -> windows_core::Result> { + pub fn LaunchAndCompleteUIAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2167,7 +2167,7 @@ impl PrintWorkflowVirtualPrinterDataAvailableEventArgs { } } #[cfg(feature = "Storage_Streams")] - pub fn GetTargetFileAsync(&self) -> windows_core::Result> { + pub fn GetTargetFileAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Graphics/Printing/mod.rs b/crates/libs/windows/src/Windows/Graphics/Printing/mod.rs index ad13589353..77300e1e71 100644 --- a/crates/libs/windows/src/Windows/Graphics/Printing/mod.rs +++ b/crates/libs/windows/src/Windows/Graphics/Printing/mod.rs @@ -973,7 +973,7 @@ impl PrintManager { (windows_core::Interface::vtable(this).GetForCurrentView)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn ShowPrintUIAsync() -> windows_core::Result> { + pub fn ShowPrintUIAsync() -> windows_core::Result> { Self::IPrintManagerStatic(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ShowPrintUIAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/Graphics/Printing3D/mod.rs b/crates/libs/windows/src/Windows/Graphics/Printing3D/mod.rs index 0f740b8a82..534617b0aa 100644 --- a/crates/libs/windows/src/Windows/Graphics/Printing3D/mod.rs +++ b/crates/libs/windows/src/Windows/Graphics/Printing3D/mod.rs @@ -546,7 +546,7 @@ impl Print3DManager { (windows_core::Interface::vtable(this).GetForCurrentView)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn ShowPrintUIAsync() -> windows_core::Result> { + pub fn ShowPrintUIAsync() -> windows_core::Result> { Self::IPrint3DManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ShowPrintUIAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -886,7 +886,7 @@ impl Printing3D3MFPackage { SHARED.call(callback) } #[cfg(feature = "Storage_Streams")] - pub fn SaveAsync(&self) -> windows_core::Result> { + pub fn SaveAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -947,7 +947,7 @@ impl Printing3D3MFPackage { } } #[cfg(feature = "Storage_Streams")] - pub fn LoadModelFromPackageAsync(&self, value: P0) -> windows_core::Result> + pub fn LoadModelFromPackageAsync(&self, value: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -957,7 +957,7 @@ impl Printing3D3MFPackage { (windows_core::Interface::vtable(this).LoadModelFromPackageAsync)(windows_core::Interface::as_raw(this), value.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SaveModelToPackageAsync(&self, value: P0) -> windows_core::Result + pub fn SaveModelToPackageAsync(&self, value: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -979,7 +979,7 @@ impl Printing3D3MFPackage { unsafe { (windows_core::Interface::vtable(this).SetCompression)(windows_core::Interface::as_raw(this), value).ok() } } #[cfg(feature = "Storage_Streams")] - pub fn LoadAsync(value: P0) -> windows_core::Result> + pub fn LoadAsync(value: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1732,7 +1732,7 @@ impl Printing3DMesh { (windows_core::Interface::vtable(this).BufferSet)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn VerifyAsync(&self, value: Printing3DMeshVerificationMode) -> windows_core::Result> { + pub fn VerifyAsync(&self, value: Printing3DMeshVerificationMode) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1901,7 +1901,7 @@ impl Printing3DModel { (windows_core::Interface::vtable(this).Metadata)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RepairAsync(&self) -> windows_core::Result { + pub fn RepairAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1915,28 +1915,28 @@ impl Printing3DModel { (windows_core::Interface::vtable(this).Clone)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryPartialRepairAsync(&self) -> windows_core::Result> { + pub fn TryPartialRepairAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryPartialRepairAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryPartialRepairWithTimeAsync(&self, maxwaittime: super::super::Foundation::TimeSpan) -> windows_core::Result> { + pub fn TryPartialRepairWithTimeAsync(&self, maxwaittime: super::super::Foundation::TimeSpan) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryPartialRepairWithTimeAsync)(windows_core::Interface::as_raw(this), maxwaittime, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryReduceFacesAsync(&self) -> windows_core::Result> { + pub fn TryReduceFacesAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryReduceFacesAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryReduceFacesWithOptionsAsync(&self, printing3dfacereductionoptions: P0) -> windows_core::Result> + pub fn TryReduceFacesWithOptionsAsync(&self, printing3dfacereductionoptions: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1946,7 +1946,7 @@ impl Printing3DModel { (windows_core::Interface::vtable(this).TryReduceFacesWithOptionsAsync)(windows_core::Interface::as_raw(this), printing3dfacereductionoptions.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryReduceFacesWithOptionsAndTimeAsync(&self, printing3dfacereductionoptions: P0, maxwait: super::super::Foundation::TimeSpan) -> windows_core::Result> + pub fn TryReduceFacesWithOptionsAndTimeAsync(&self, printing3dfacereductionoptions: P0, maxwait: super::super::Foundation::TimeSpan) -> windows_core::Result> where P0: windows_core::Param, { @@ -1956,7 +1956,7 @@ impl Printing3DModel { (windows_core::Interface::vtable(this).TryReduceFacesWithOptionsAndTimeAsync)(windows_core::Interface::as_raw(this), printing3dfacereductionoptions.param().abi(), maxwait, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RepairWithProgressAsync(&self) -> windows_core::Result> { + pub fn RepairWithProgressAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Management/Deployment/mod.rs b/crates/libs/windows/src/Windows/Management/Deployment/mod.rs index 1d35fff1f5..fdc95befb0 100644 --- a/crates/libs/windows/src/Windows/Management/Deployment/mod.rs +++ b/crates/libs/windows/src/Windows/Management/Deployment/mod.rs @@ -1619,7 +1619,7 @@ impl PackageManager { static SHARED: windows_core::imp::FactoryCache = windows_core::imp::FactoryCache::new(); SHARED.call(callback) } - pub fn AddPackageAsync(&self, packageuri: P0, dependencypackageuris: P1, deploymentoptions: DeploymentOptions) -> windows_core::Result> + pub fn AddPackageAsync(&self, packageuri: P0, dependencypackageuris: P1, deploymentoptions: DeploymentOptions) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param>, @@ -1630,7 +1630,7 @@ impl PackageManager { (windows_core::Interface::vtable(this).AddPackageAsync)(windows_core::Interface::as_raw(this), packageuri.param().abi(), dependencypackageuris.param().abi(), deploymentoptions, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn UpdatePackageAsync(&self, packageuri: P0, dependencypackageuris: P1, deploymentoptions: DeploymentOptions) -> windows_core::Result> + pub fn UpdatePackageAsync(&self, packageuri: P0, dependencypackageuris: P1, deploymentoptions: DeploymentOptions) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param>, @@ -1641,14 +1641,14 @@ impl PackageManager { (windows_core::Interface::vtable(this).UpdatePackageAsync)(windows_core::Interface::as_raw(this), packageuri.param().abi(), dependencypackageuris.param().abi(), deploymentoptions, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RemovePackageAsync(&self, packagefullname: &windows_core::HSTRING) -> windows_core::Result> { + pub fn RemovePackageAsync(&self, packagefullname: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RemovePackageAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(packagefullname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StagePackageAsync(&self, packageuri: P0, dependencypackageuris: P1) -> windows_core::Result> + pub fn StagePackageAsync(&self, packageuri: P0, dependencypackageuris: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param>, @@ -1659,7 +1659,7 @@ impl PackageManager { (windows_core::Interface::vtable(this).StagePackageAsync)(windows_core::Interface::as_raw(this), packageuri.param().abi(), dependencypackageuris.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RegisterPackageAsync(&self, manifesturi: P0, dependencypackageuris: P1, deploymentoptions: DeploymentOptions) -> windows_core::Result> + pub fn RegisterPackageAsync(&self, manifesturi: P0, dependencypackageuris: P1, deploymentoptions: DeploymentOptions) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param>, @@ -1721,7 +1721,7 @@ impl PackageManager { (windows_core::Interface::vtable(this).FindPackageByPackageFullName)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(packagefullname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CleanupPackageForUserAsync(&self, packagename: &windows_core::HSTRING, usersecurityid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CleanupPackageForUserAsync(&self, packagename: &windows_core::HSTRING, usersecurityid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1752,7 +1752,7 @@ impl PackageManager { (windows_core::Interface::vtable(this).FindPackageByUserSecurityIdPackageFullName)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(usersecurityid), core::mem::transmute_copy(packagefullname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ProvisionPackageForAllUsersWithOptionsAsync(&self, mainpackagefamilyname: &windows_core::HSTRING, options: P1) -> windows_core::Result> + pub fn ProvisionPackageForAllUsersWithOptionsAsync(&self, mainpackagefamilyname: &windows_core::HSTRING, options: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -1762,7 +1762,7 @@ impl PackageManager { (windows_core::Interface::vtable(this).ProvisionPackageForAllUsersWithOptionsAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(mainpackagefamilyname), options.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RemovePackageByUriAsync(&self, packageuri: P0, options: P1) -> windows_core::Result> + pub fn RemovePackageByUriAsync(&self, packageuri: P0, options: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -1807,14 +1807,14 @@ impl PackageManager { (windows_core::Interface::vtable(this).IsPackageRemovalPendingByUriForUser)(windows_core::Interface::as_raw(this), packageuri.param().abi(), core::mem::transmute_copy(usersecurityid), &mut result__).map(|| result__) } } - pub fn RemovePackageWithOptionsAsync(&self, packagefullname: &windows_core::HSTRING, removaloptions: RemovalOptions) -> windows_core::Result> { + pub fn RemovePackageWithOptionsAsync(&self, packagefullname: &windows_core::HSTRING, removaloptions: RemovalOptions) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RemovePackageWithOptionsAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(packagefullname), removaloptions, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StagePackageWithOptionsAsync(&self, packageuri: P0, dependencypackageuris: P1, deploymentoptions: DeploymentOptions) -> windows_core::Result> + pub fn StagePackageWithOptionsAsync(&self, packageuri: P0, dependencypackageuris: P1, deploymentoptions: DeploymentOptions) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param>, @@ -1825,7 +1825,7 @@ impl PackageManager { (windows_core::Interface::vtable(this).StagePackageWithOptionsAsync)(windows_core::Interface::as_raw(this), packageuri.param().abi(), dependencypackageuris.param().abi(), deploymentoptions, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RegisterPackageByFullNameAsync(&self, mainpackagefullname: &windows_core::HSTRING, dependencypackagefullnames: P1, deploymentoptions: DeploymentOptions) -> windows_core::Result> + pub fn RegisterPackageByFullNameAsync(&self, mainpackagefullname: &windows_core::HSTRING, dependencypackagefullnames: P1, deploymentoptions: DeploymentOptions) -> windows_core::Result> where P1: windows_core::Param>, { @@ -1883,21 +1883,21 @@ impl PackageManager { (windows_core::Interface::vtable(this).FindPackagesByUserSecurityIdPackageFamilyNameWithPackageTypes)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(usersecurityid), core::mem::transmute_copy(packagefamilyname), packagetypes, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StageUserDataAsync(&self, packagefullname: &windows_core::HSTRING) -> windows_core::Result> { + pub fn StageUserDataAsync(&self, packagefullname: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).StageUserDataAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(packagefullname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn AddPackageVolumeAsync(&self, packagestorepath: &windows_core::HSTRING) -> windows_core::Result> { + pub fn AddPackageVolumeAsync(&self, packagestorepath: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).AddPackageVolumeAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(packagestorepath), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn AddPackageToVolumeAsync(&self, packageuri: P0, dependencypackageuris: P1, deploymentoptions: DeploymentOptions, targetvolume: P3) -> windows_core::Result> + pub fn AddPackageToVolumeAsync(&self, packageuri: P0, dependencypackageuris: P1, deploymentoptions: DeploymentOptions, targetvolume: P3) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param>, @@ -1913,7 +1913,7 @@ impl PackageManager { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).ClearPackageStatus)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(packagefullname), status).ok() } } - pub fn RegisterPackageWithAppDataVolumeAsync(&self, manifesturi: P0, dependencypackageuris: P1, deploymentoptions: DeploymentOptions, appdatavolume: P3) -> windows_core::Result> + pub fn RegisterPackageWithAppDataVolumeAsync(&self, manifesturi: P0, dependencypackageuris: P1, deploymentoptions: DeploymentOptions, appdatavolume: P3) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param>, @@ -1946,7 +1946,7 @@ impl PackageManager { (windows_core::Interface::vtable(this).GetDefaultPackageVolume)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn MovePackageToVolumeAsync(&self, packagefullname: &windows_core::HSTRING, deploymentoptions: DeploymentOptions, targetvolume: P2) -> windows_core::Result> + pub fn MovePackageToVolumeAsync(&self, packagefullname: &windows_core::HSTRING, deploymentoptions: DeploymentOptions, targetvolume: P2) -> windows_core::Result> where P2: windows_core::Param, { @@ -1956,7 +1956,7 @@ impl PackageManager { (windows_core::Interface::vtable(this).MovePackageToVolumeAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(packagefullname), deploymentoptions, targetvolume.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RemovePackageVolumeAsync(&self, volume: P0) -> windows_core::Result> + pub fn RemovePackageVolumeAsync(&self, volume: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1977,7 +1977,7 @@ impl PackageManager { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).SetPackageStatus)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(packagefullname), status).ok() } } - pub fn SetPackageVolumeOfflineAsync(&self, packagevolume: P0) -> windows_core::Result> + pub fn SetPackageVolumeOfflineAsync(&self, packagevolume: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1987,7 +1987,7 @@ impl PackageManager { (windows_core::Interface::vtable(this).SetPackageVolumeOfflineAsync)(windows_core::Interface::as_raw(this), packagevolume.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SetPackageVolumeOnlineAsync(&self, packagevolume: P0) -> windows_core::Result> + pub fn SetPackageVolumeOnlineAsync(&self, packagevolume: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1997,7 +1997,7 @@ impl PackageManager { (windows_core::Interface::vtable(this).SetPackageVolumeOnlineAsync)(windows_core::Interface::as_raw(this), packagevolume.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StagePackageToVolumeAsync(&self, packageuri: P0, dependencypackageuris: P1, deploymentoptions: DeploymentOptions, targetvolume: P3) -> windows_core::Result> + pub fn StagePackageToVolumeAsync(&self, packageuri: P0, dependencypackageuris: P1, deploymentoptions: DeploymentOptions, targetvolume: P3) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param>, @@ -2009,21 +2009,21 @@ impl PackageManager { (windows_core::Interface::vtable(this).StagePackageToVolumeAsync)(windows_core::Interface::as_raw(this), packageuri.param().abi(), dependencypackageuris.param().abi(), deploymentoptions, targetvolume.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StageUserDataWithOptionsAsync(&self, packagefullname: &windows_core::HSTRING, deploymentoptions: DeploymentOptions) -> windows_core::Result> { + pub fn StageUserDataWithOptionsAsync(&self, packagefullname: &windows_core::HSTRING, deploymentoptions: DeploymentOptions) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).StageUserDataWithOptionsAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(packagefullname), deploymentoptions, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetPackageVolumesAsync(&self) -> windows_core::Result>> { + pub fn GetPackageVolumesAsync(&self) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetPackageVolumesAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn AddPackageToVolumeAndOptionalPackagesAsync(&self, packageuri: P0, dependencypackageuris: P1, deploymentoptions: DeploymentOptions, targetvolume: P3, optionalpackagefamilynames: P4, externalpackageuris: P5) -> windows_core::Result> + pub fn AddPackageToVolumeAndOptionalPackagesAsync(&self, packageuri: P0, dependencypackageuris: P1, deploymentoptions: DeploymentOptions, targetvolume: P3, optionalpackagefamilynames: P4, externalpackageuris: P5) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param>, @@ -2037,7 +2037,7 @@ impl PackageManager { (windows_core::Interface::vtable(this).AddPackageToVolumeAndOptionalPackagesAsync)(windows_core::Interface::as_raw(this), packageuri.param().abi(), dependencypackageuris.param().abi(), deploymentoptions, targetvolume.param().abi(), optionalpackagefamilynames.param().abi(), externalpackageuris.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StagePackageToVolumeAndOptionalPackagesAsync(&self, packageuri: P0, dependencypackageuris: P1, deploymentoptions: DeploymentOptions, targetvolume: P3, optionalpackagefamilynames: P4, externalpackageuris: P5) -> windows_core::Result> + pub fn StagePackageToVolumeAndOptionalPackagesAsync(&self, packageuri: P0, dependencypackageuris: P1, deploymentoptions: DeploymentOptions, targetvolume: P3, optionalpackagefamilynames: P4, externalpackageuris: P5) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param>, @@ -2051,7 +2051,7 @@ impl PackageManager { (windows_core::Interface::vtable(this).StagePackageToVolumeAndOptionalPackagesAsync)(windows_core::Interface::as_raw(this), packageuri.param().abi(), dependencypackageuris.param().abi(), deploymentoptions, targetvolume.param().abi(), optionalpackagefamilynames.param().abi(), externalpackageuris.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RegisterPackageByFamilyNameAndOptionalPackagesAsync(&self, mainpackagefamilyname: &windows_core::HSTRING, dependencypackagefamilynames: P1, deploymentoptions: DeploymentOptions, appdatavolume: P3, optionalpackagefamilynames: P4) -> windows_core::Result> + pub fn RegisterPackageByFamilyNameAndOptionalPackagesAsync(&self, mainpackagefamilyname: &windows_core::HSTRING, dependencypackagefamilynames: P1, deploymentoptions: DeploymentOptions, appdatavolume: P3, optionalpackagefamilynames: P4) -> windows_core::Result> where P1: windows_core::Param>, P3: windows_core::Param, @@ -2070,14 +2070,14 @@ impl PackageManager { (windows_core::Interface::vtable(this).DebugSettings)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ProvisionPackageForAllUsersAsync(&self, packagefamilyname: &windows_core::HSTRING) -> windows_core::Result> { + pub fn ProvisionPackageForAllUsersAsync(&self, packagefamilyname: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ProvisionPackageForAllUsersAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(packagefamilyname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn AddPackageByAppInstallerFileAsync(&self, appinstallerfileuri: P0, options: AddPackageByAppInstallerOptions, targetvolume: P2) -> windows_core::Result> + pub fn AddPackageByAppInstallerFileAsync(&self, appinstallerfileuri: P0, options: AddPackageByAppInstallerOptions, targetvolume: P2) -> windows_core::Result> where P0: windows_core::Param, P2: windows_core::Param, @@ -2088,7 +2088,7 @@ impl PackageManager { (windows_core::Interface::vtable(this).AddPackageByAppInstallerFileAsync)(windows_core::Interface::as_raw(this), appinstallerfileuri.param().abi(), options, targetvolume.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestAddPackageByAppInstallerFileAsync(&self, appinstallerfileuri: P0, options: AddPackageByAppInstallerOptions, targetvolume: P2) -> windows_core::Result> + pub fn RequestAddPackageByAppInstallerFileAsync(&self, appinstallerfileuri: P0, options: AddPackageByAppInstallerOptions, targetvolume: P2) -> windows_core::Result> where P0: windows_core::Param, P2: windows_core::Param, @@ -2099,7 +2099,7 @@ impl PackageManager { (windows_core::Interface::vtable(this).RequestAddPackageByAppInstallerFileAsync)(windows_core::Interface::as_raw(this), appinstallerfileuri.param().abi(), options, targetvolume.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn AddPackageToVolumeAndRelatedSetAsync(&self, packageuri: P0, dependencypackageuris: P1, options: DeploymentOptions, targetvolume: P3, optionalpackagefamilynames: P4, packageuristoinstall: P5, relatedpackageuris: P6) -> windows_core::Result> + pub fn AddPackageToVolumeAndRelatedSetAsync(&self, packageuri: P0, dependencypackageuris: P1, options: DeploymentOptions, targetvolume: P3, optionalpackagefamilynames: P4, packageuristoinstall: P5, relatedpackageuris: P6) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param>, @@ -2114,7 +2114,7 @@ impl PackageManager { (windows_core::Interface::vtable(this).AddPackageToVolumeAndRelatedSetAsync)(windows_core::Interface::as_raw(this), packageuri.param().abi(), dependencypackageuris.param().abi(), options, targetvolume.param().abi(), optionalpackagefamilynames.param().abi(), packageuristoinstall.param().abi(), relatedpackageuris.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StagePackageToVolumeAndRelatedSetAsync(&self, packageuri: P0, dependencypackageuris: P1, options: DeploymentOptions, targetvolume: P3, optionalpackagefamilynames: P4, packageuristoinstall: P5, relatedpackageuris: P6) -> windows_core::Result> + pub fn StagePackageToVolumeAndRelatedSetAsync(&self, packageuri: P0, dependencypackageuris: P1, options: DeploymentOptions, targetvolume: P3, optionalpackagefamilynames: P4, packageuristoinstall: P5, relatedpackageuris: P6) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param>, @@ -2129,7 +2129,7 @@ impl PackageManager { (windows_core::Interface::vtable(this).StagePackageToVolumeAndRelatedSetAsync)(windows_core::Interface::as_raw(this), packageuri.param().abi(), dependencypackageuris.param().abi(), options, targetvolume.param().abi(), optionalpackagefamilynames.param().abi(), packageuristoinstall.param().abi(), relatedpackageuris.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestAddPackageAsync(&self, packageuri: P0, dependencypackageuris: P1, deploymentoptions: DeploymentOptions, targetvolume: P3, optionalpackagefamilynames: P4, relatedpackageuris: P5) -> windows_core::Result> + pub fn RequestAddPackageAsync(&self, packageuri: P0, dependencypackageuris: P1, deploymentoptions: DeploymentOptions, targetvolume: P3, optionalpackagefamilynames: P4, relatedpackageuris: P5) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param>, @@ -2143,7 +2143,7 @@ impl PackageManager { (windows_core::Interface::vtable(this).RequestAddPackageAsync)(windows_core::Interface::as_raw(this), packageuri.param().abi(), dependencypackageuris.param().abi(), deploymentoptions, targetvolume.param().abi(), optionalpackagefamilynames.param().abi(), relatedpackageuris.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestAddPackageAndRelatedSetAsync(&self, packageuri: P0, dependencypackageuris: P1, deploymentoptions: DeploymentOptions, targetvolume: P3, optionalpackagefamilynames: P4, relatedpackageuris: P5, packageuristoinstall: P6) -> windows_core::Result> + pub fn RequestAddPackageAndRelatedSetAsync(&self, packageuri: P0, dependencypackageuris: P1, deploymentoptions: DeploymentOptions, targetvolume: P3, optionalpackagefamilynames: P4, relatedpackageuris: P5, packageuristoinstall: P6) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param>, @@ -2158,7 +2158,7 @@ impl PackageManager { (windows_core::Interface::vtable(this).RequestAddPackageAndRelatedSetAsync)(windows_core::Interface::as_raw(this), packageuri.param().abi(), dependencypackageuris.param().abi(), deploymentoptions, targetvolume.param().abi(), optionalpackagefamilynames.param().abi(), relatedpackageuris.param().abi(), packageuristoinstall.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeprovisionPackageForAllUsersAsync(&self, packagefamilyname: &windows_core::HSTRING) -> windows_core::Result> { + pub fn DeprovisionPackageForAllUsersAsync(&self, packagefamilyname: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -2173,7 +2173,7 @@ impl PackageManager { (windows_core::Interface::vtable(this).FindProvisionedPackages)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn AddPackageByUriAsync(&self, packageuri: P0, options: P1) -> windows_core::Result> + pub fn AddPackageByUriAsync(&self, packageuri: P0, options: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -2184,7 +2184,7 @@ impl PackageManager { (windows_core::Interface::vtable(this).AddPackageByUriAsync)(windows_core::Interface::as_raw(this), packageuri.param().abi(), options.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StagePackageByUriAsync(&self, packageuri: P0, options: P1) -> windows_core::Result> + pub fn StagePackageByUriAsync(&self, packageuri: P0, options: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -2195,7 +2195,7 @@ impl PackageManager { (windows_core::Interface::vtable(this).StagePackageByUriAsync)(windows_core::Interface::as_raw(this), packageuri.param().abi(), options.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RegisterPackageByUriAsync(&self, manifesturi: P0, options: P1) -> windows_core::Result> + pub fn RegisterPackageByUriAsync(&self, manifesturi: P0, options: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -2206,7 +2206,7 @@ impl PackageManager { (windows_core::Interface::vtable(this).RegisterPackageByUriAsync)(windows_core::Interface::as_raw(this), manifesturi.param().abi(), options.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RegisterPackagesByFullNameAsync(&self, packagefullnames: P0, options: P1) -> windows_core::Result> + pub fn RegisterPackagesByFullNameAsync(&self, packagefullnames: P0, options: P1) -> windows_core::Result> where P0: windows_core::Param>, P1: windows_core::Param, @@ -2247,7 +2247,7 @@ pub struct PackageManagerDebugSettings(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(PackageManagerDebugSettings, windows_core::IUnknown, windows_core::IInspectable); impl PackageManagerDebugSettings { #[cfg(feature = "ApplicationModel")] - pub fn SetContentGroupStateAsync(&self, package: P0, contentgroupname: &windows_core::HSTRING, state: super::super::ApplicationModel::PackageContentGroupState) -> windows_core::Result + pub fn SetContentGroupStateAsync(&self, package: P0, contentgroupname: &windows_core::HSTRING, state: super::super::ApplicationModel::PackageContentGroupState) -> windows_core::Result where P0: windows_core::Param, { @@ -2258,7 +2258,7 @@ impl PackageManagerDebugSettings { } } #[cfg(feature = "ApplicationModel")] - pub fn SetContentGroupStateWithPercentageAsync(&self, package: P0, contentgroupname: &windows_core::HSTRING, state: super::super::ApplicationModel::PackageContentGroupState, completionpercentage: f64) -> windows_core::Result + pub fn SetContentGroupStateWithPercentageAsync(&self, package: P0, contentgroupname: &windows_core::HSTRING, state: super::super::ApplicationModel::PackageContentGroupState, completionpercentage: f64) -> windows_core::Result where P0: windows_core::Param, { @@ -2615,7 +2615,7 @@ impl PackageVolume { (windows_core::Interface::vtable(this).IsAppxInstallSupported)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn GetAvailableSpaceAsync(&self) -> windows_core::Result> { + pub fn GetAvailableSpaceAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Management/Setup/mod.rs b/crates/libs/windows/src/Windows/Management/Setup/mod.rs index 2c57c1a254..5714ceb110 100644 --- a/crates/libs/windows/src/Windows/Management/Setup/mod.rs +++ b/crates/libs/windows/src/Windows/Management/Setup/mod.rs @@ -734,7 +734,7 @@ impl MachineProvisioningProgressReporter { let this = self; unsafe { (windows_core::Interface::vtable(this).ReportProgress)(windows_core::Interface::as_raw(this), updatereport.param().abi()).ok() } } - pub fn GetDevicePreparationExecutionContextAsync(&self) -> windows_core::Result> { + pub fn GetDevicePreparationExecutionContextAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Management/Update/mod.rs b/crates/libs/windows/src/Windows/Management/Update/mod.rs index ce1aaf0306..7af68fdaae 100644 --- a/crates/libs/windows/src/Windows/Management/Update/mod.rs +++ b/crates/libs/windows/src/Windows/Management/Update/mod.rs @@ -302,7 +302,7 @@ impl PreviewBuildsManager { (windows_core::Interface::vtable(this).GetCurrentState)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SyncAsync(&self) -> windows_core::Result> { + pub fn SyncAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1254,7 +1254,7 @@ impl WindowsUpdateManager { (windows_core::Interface::vtable(this).GetMostRecentCompletedUpdates)(windows_core::Interface::as_raw(this), count, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetMostRecentCompletedUpdatesAsync(&self, count: i32) -> windows_core::Result>> { + pub fn GetMostRecentCompletedUpdatesAsync(&self, count: i32) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Management/mod.rs b/crates/libs/windows/src/Windows/Management/mod.rs index 88fcc26a1a..d94e845135 100644 --- a/crates/libs/windows/src/Windows/Management/mod.rs +++ b/crates/libs/windows/src/Windows/Management/mod.rs @@ -219,7 +219,7 @@ impl MdmSession { (windows_core::Interface::vtable(this).State)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn AttachAsync(&self) -> windows_core::Result { + pub fn AttachAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -230,14 +230,14 @@ impl MdmSession { let this = self; unsafe { (windows_core::Interface::vtable(this).Delete)(windows_core::Interface::as_raw(this)).ok() } } - pub fn StartAsync(&self) -> windows_core::Result { + pub fn StartAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).StartAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StartWithAlertsAsync(&self, alerts: P0) -> windows_core::Result + pub fn StartWithAlertsAsync(&self, alerts: P0) -> windows_core::Result where P0: windows_core::Param>, { diff --git a/crates/libs/windows/src/Windows/Media/AppRecording/mod.rs b/crates/libs/windows/src/Windows/Media/AppRecording/mod.rs index a9fea381f5..fadeaaf501 100644 --- a/crates/libs/windows/src/Windows/Media/AppRecording/mod.rs +++ b/crates/libs/windows/src/Windows/Media/AppRecording/mod.rs @@ -11,7 +11,7 @@ impl AppRecordingManager { } } #[cfg(feature = "Storage_Streams")] - pub fn StartRecordingToFileAsync(&self, file: P0) -> windows_core::Result> + pub fn StartRecordingToFileAsync(&self, file: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -22,7 +22,7 @@ impl AppRecordingManager { } } #[cfg(feature = "Storage_Streams")] - pub fn RecordTimeSpanToFileAsync(&self, starttime: super::super::Foundation::DateTime, duration: super::super::Foundation::TimeSpan, file: P2) -> windows_core::Result> + pub fn RecordTimeSpanToFileAsync(&self, starttime: super::super::Foundation::DateTime, duration: super::super::Foundation::TimeSpan, file: P2) -> windows_core::Result> where P2: windows_core::Param, { @@ -40,7 +40,7 @@ impl AppRecordingManager { } } #[cfg(feature = "Storage_Search")] - pub fn SaveScreenshotToFilesAsync(&self, folder: P0, filenameprefix: &windows_core::HSTRING, option: AppRecordingSaveScreenshotOption, requestedformats: P3) -> windows_core::Result> + pub fn SaveScreenshotToFilesAsync(&self, folder: P0, filenameprefix: &windows_core::HSTRING, option: AppRecordingSaveScreenshotOption, requestedformats: P3) -> windows_core::Result> where P0: windows_core::Param, P3: windows_core::Param>, diff --git a/crates/libs/windows/src/Windows/Media/Audio/mod.rs b/crates/libs/windows/src/Windows/Media/Audio/mod.rs index 6316a4474c..9c444aa91c 100644 --- a/crates/libs/windows/src/Windows/Media/Audio/mod.rs +++ b/crates/libs/windows/src/Windows/Media/Audio/mod.rs @@ -596,7 +596,7 @@ impl AudioFileOutputNode { } } #[cfg(feature = "Media_Transcoding")] - pub fn FinalizeAsync(&self) -> windows_core::Result> { + pub fn FinalizeAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1013,7 +1013,7 @@ impl AudioGraph { } } #[cfg(feature = "Media_Capture")] - pub fn CreateDeviceInputNodeAsync(&self, category: super::Capture::MediaCategory) -> windows_core::Result> { + pub fn CreateDeviceInputNodeAsync(&self, category: super::Capture::MediaCategory) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1021,7 +1021,7 @@ impl AudioGraph { } } #[cfg(all(feature = "Media_Capture", feature = "Media_MediaProperties"))] - pub fn CreateDeviceInputNodeWithFormatAsync(&self, category: super::Capture::MediaCategory, encodingproperties: P1) -> windows_core::Result> + pub fn CreateDeviceInputNodeWithFormatAsync(&self, category: super::Capture::MediaCategory, encodingproperties: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -1032,7 +1032,7 @@ impl AudioGraph { } } #[cfg(all(feature = "Devices_Enumeration", feature = "Media_Capture", feature = "Media_MediaProperties"))] - pub fn CreateDeviceInputNodeWithFormatOnDeviceAsync(&self, category: super::Capture::MediaCategory, encodingproperties: P1, device: P2) -> windows_core::Result> + pub fn CreateDeviceInputNodeWithFormatOnDeviceAsync(&self, category: super::Capture::MediaCategory, encodingproperties: P1, device: P2) -> windows_core::Result> where P1: windows_core::Param, P2: windows_core::Param, @@ -1061,7 +1061,7 @@ impl AudioGraph { (windows_core::Interface::vtable(this).CreateFrameOutputNodeWithFormat)(windows_core::Interface::as_raw(this), encodingproperties.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateDeviceOutputNodeAsync(&self) -> windows_core::Result> { + pub fn CreateDeviceOutputNodeAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1069,7 +1069,7 @@ impl AudioGraph { } } #[cfg(feature = "Storage_Streams")] - pub fn CreateFileInputNodeAsync(&self, file: P0) -> windows_core::Result> + pub fn CreateFileInputNodeAsync(&self, file: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1080,7 +1080,7 @@ impl AudioGraph { } } #[cfg(feature = "Storage_Streams")] - pub fn CreateFileOutputNodeAsync(&self, file: P0) -> windows_core::Result> + pub fn CreateFileOutputNodeAsync(&self, file: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1091,7 +1091,7 @@ impl AudioGraph { } } #[cfg(all(feature = "Media_MediaProperties", feature = "Storage_Streams"))] - pub fn CreateFileOutputNodeWithFileProfileAsync(&self, file: P0, fileencodingprofile: P1) -> windows_core::Result> + pub fn CreateFileOutputNodeWithFileProfileAsync(&self, file: P0, fileencodingprofile: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -1231,7 +1231,7 @@ impl AudioGraph { } } #[cfg(all(feature = "Devices_Enumeration", feature = "Media_Capture", feature = "Media_MediaProperties"))] - pub fn CreateDeviceInputNodeWithFormatAndEmitterOnDeviceAsync(&self, category: super::Capture::MediaCategory, encodingproperties: P1, device: P2, emitter: P3) -> windows_core::Result> + pub fn CreateDeviceInputNodeWithFormatAndEmitterOnDeviceAsync(&self, category: super::Capture::MediaCategory, encodingproperties: P1, device: P2, emitter: P3) -> windows_core::Result> where P1: windows_core::Param, P2: windows_core::Param, @@ -1244,7 +1244,7 @@ impl AudioGraph { } } #[cfg(feature = "Storage_Streams")] - pub fn CreateFileInputNodeWithEmitterAsync(&self, file: P0, emitter: P1) -> windows_core::Result> + pub fn CreateFileInputNodeWithEmitterAsync(&self, file: P0, emitter: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -1275,7 +1275,7 @@ impl AudioGraph { } } #[cfg(all(feature = "Media_Core", feature = "Media_Playback"))] - pub fn CreateMediaSourceAudioInputNodeAsync(&self, mediasource: P0) -> windows_core::Result> + pub fn CreateMediaSourceAudioInputNodeAsync(&self, mediasource: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1286,7 +1286,7 @@ impl AudioGraph { } } #[cfg(all(feature = "Media_Core", feature = "Media_Playback"))] - pub fn CreateMediaSourceAudioInputNodeWithEmitterAsync(&self, mediasource: P0, emitter: P1) -> windows_core::Result> + pub fn CreateMediaSourceAudioInputNodeWithEmitterAsync(&self, mediasource: P0, emitter: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -1297,7 +1297,7 @@ impl AudioGraph { (windows_core::Interface::vtable(this).CreateMediaSourceAudioInputNodeWithEmitterAsync)(windows_core::Interface::as_raw(this), mediasource.param().abi(), emitter.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateAsync(settings: P0) -> windows_core::Result> + pub fn CreateAsync(settings: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2029,7 +2029,7 @@ impl AudioPlaybackConnection { let this = self; unsafe { (windows_core::Interface::vtable(this).Start)(windows_core::Interface::as_raw(this)).ok() } } - pub fn StartAsync(&self) -> windows_core::Result { + pub fn StartAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2057,7 +2057,7 @@ impl AudioPlaybackConnection { (windows_core::Interface::vtable(this).Open)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn OpenAsync(&self) -> windows_core::Result> { + pub fn OpenAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -5200,7 +5200,7 @@ impl SpatialAudioDeviceConfiguration { (windows_core::Interface::vtable(this).DefaultSpatialAudioFormat)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn SetDefaultSpatialAudioFormatAsync(&self, subtype: &windows_core::HSTRING) -> windows_core::Result> { + pub fn SetDefaultSpatialAudioFormatAsync(&self, subtype: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -5249,14 +5249,14 @@ unsafe impl Sync for SpatialAudioDeviceConfiguration {} pub struct SpatialAudioFormatConfiguration(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(SpatialAudioFormatConfiguration, windows_core::IUnknown, windows_core::IInspectable); impl SpatialAudioFormatConfiguration { - pub fn ReportLicenseChangedAsync(&self, subtype: &windows_core::HSTRING) -> windows_core::Result { + pub fn ReportLicenseChangedAsync(&self, subtype: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportLicenseChangedAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(subtype), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportConfigurationChangedAsync(&self, subtype: &windows_core::HSTRING) -> windows_core::Result { + pub fn ReportConfigurationChangedAsync(&self, subtype: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Media/Capture/Core/mod.rs b/crates/libs/windows/src/Windows/Media/Capture/Core/mod.rs index 104f737191..32251869ac 100644 --- a/crates/libs/windows/src/Windows/Media/Capture/Core/mod.rs +++ b/crates/libs/windows/src/Windows/Media/Capture/Core/mod.rs @@ -89,21 +89,21 @@ unsafe impl Sync for VariablePhotoCapturedEventArgs {} pub struct VariablePhotoSequenceCapture(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(VariablePhotoSequenceCapture, windows_core::IUnknown, windows_core::IInspectable); impl VariablePhotoSequenceCapture { - pub fn StartAsync(&self) -> windows_core::Result { + pub fn StartAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).StartAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StopAsync(&self) -> windows_core::Result { + pub fn StopAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).StopAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FinishAsync(&self) -> windows_core::Result { + pub fn FinishAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -138,7 +138,7 @@ impl VariablePhotoSequenceCapture { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveStopped)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn UpdateSettingsAsync(&self) -> windows_core::Result { + pub fn UpdateSettingsAsync(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Media/Capture/Frames/mod.rs b/crates/libs/windows/src/Windows/Media/Capture/Frames/mod.rs index 6a90f15656..9eec976a33 100644 --- a/crates/libs/windows/src/Windows/Media/Capture/Frames/mod.rs +++ b/crates/libs/windows/src/Windows/Media/Capture/Frames/mod.rs @@ -693,14 +693,14 @@ impl MediaFrameReader { (windows_core::Interface::vtable(this).TryAcquireLatestFrame)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StartAsync(&self) -> windows_core::Result> { + pub fn StartAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).StartAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StopAsync(&self) -> windows_core::Result { + pub fn StopAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -880,7 +880,7 @@ impl MediaFrameSource { (windows_core::Interface::vtable(this).CurrentFormat)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SetFormatAsync(&self, format: P0) -> windows_core::Result + pub fn SetFormatAsync(&self, format: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -933,14 +933,14 @@ unsafe impl Sync for MediaFrameSource {} pub struct MediaFrameSourceController(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(MediaFrameSourceController, windows_core::IUnknown, windows_core::IInspectable); impl MediaFrameSourceController { - pub fn GetPropertyAsync(&self, propertyid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetPropertyAsync(&self, propertyid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetPropertyAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(propertyid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SetPropertyAsync(&self, propertyid: &windows_core::HSTRING, propertyvalue: P1) -> windows_core::Result> + pub fn SetPropertyAsync(&self, propertyid: &windows_core::HSTRING, propertyvalue: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -958,7 +958,7 @@ impl MediaFrameSourceController { (windows_core::Interface::vtable(this).VideoDeviceController)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetPropertyByExtendedIdAsync(&self, extendedpropertyid: &[u8], maxpropertyvaluesize: P1) -> windows_core::Result> + pub fn GetPropertyByExtendedIdAsync(&self, extendedpropertyid: &[u8], maxpropertyvaluesize: P1) -> windows_core::Result> where P1: windows_core::Param>, { @@ -968,7 +968,7 @@ impl MediaFrameSourceController { (windows_core::Interface::vtable(this).GetPropertyByExtendedIdAsync)(windows_core::Interface::as_raw(this), extendedpropertyid.len().try_into().unwrap(), extendedpropertyid.as_ptr(), maxpropertyvaluesize.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SetPropertyByExtendedIdAsync(&self, extendedpropertyid: &[u8], propertyvalue: &[u8]) -> windows_core::Result> { + pub fn SetPropertyByExtendedIdAsync(&self, extendedpropertyid: &[u8], propertyvalue: &[u8]) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1071,13 +1071,13 @@ impl MediaFrameSourceGroup { (windows_core::Interface::vtable(this).SourceInfos)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FindAllAsync() -> windows_core::Result>> { + pub fn FindAllAsync() -> windows_core::Result>> { Self::IMediaFrameSourceGroupStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAllAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn FromIdAsync(id: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(id: &windows_core::HSTRING) -> windows_core::Result> { Self::IMediaFrameSourceGroupStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(id), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -1290,14 +1290,14 @@ impl MultiSourceMediaFrameReader { (windows_core::Interface::vtable(this).TryAcquireLatestFrame)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StartAsync(&self) -> windows_core::Result> { + pub fn StartAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).StartAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StopAsync(&self) -> windows_core::Result { + pub fn StopAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Media/Capture/mod.rs b/crates/libs/windows/src/Windows/Media/Capture/mod.rs index ed82f55778..8c4eef2303 100644 --- a/crates/libs/windows/src/Windows/Media/Capture/mod.rs +++ b/crates/libs/windows/src/Windows/Media/Capture/mod.rs @@ -55,14 +55,14 @@ unsafe impl Sync for AdvancedCapturedPhoto {} pub struct AdvancedPhotoCapture(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(AdvancedPhotoCapture, windows_core::IUnknown, windows_core::IInspectable); impl AdvancedPhotoCapture { - pub fn CaptureAsync(&self) -> windows_core::Result> { + pub fn CaptureAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CaptureAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CaptureWithContextAsync(&self, context: P0) -> windows_core::Result> + pub fn CaptureWithContextAsync(&self, context: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -100,7 +100,7 @@ impl AdvancedPhotoCapture { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveAllPhotosCaptured)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn FinishAsync(&self) -> windows_core::Result { + pub fn FinishAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1428,7 +1428,7 @@ impl AppBroadcastServices { (windows_core::Interface::vtable(this).CanCapture)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn EnterBroadcastModeAsync(&self, plugin: P0) -> windows_core::Result> + pub fn EnterBroadcastModeAsync(&self, plugin: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2245,7 +2245,7 @@ impl AppCapture { (windows_core::Interface::vtable(this).GetForCurrentView)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn SetAllowedAsync(allowed: bool) -> windows_core::Result { + pub fn SetAllowedAsync(allowed: bool) -> windows_core::Result { Self::IAppCaptureStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).SetAllowedAsync)(windows_core::Interface::as_raw(this), allowed, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -3392,7 +3392,7 @@ impl CameraCaptureUI { } } #[cfg(feature = "Storage_Streams")] - pub fn CaptureFileAsync(&self, mode: CameraCaptureUIMode) -> windows_core::Result> { + pub fn CaptureFileAsync(&self, mode: CameraCaptureUIMode) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -3692,7 +3692,7 @@ impl CapturedFrame { (windows_core::Interface::vtable(this).ContentType)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn ReadAsync(&self, buffer: P0, count: u32, options: super::super::Storage::Streams::InputStreamOptions) -> windows_core::Result> + pub fn ReadAsync(&self, buffer: P0, count: u32, options: super::super::Storage::Streams::InputStreamOptions) -> windows_core::Result> where P0: windows_core::Param, { @@ -3702,7 +3702,7 @@ impl CapturedFrame { (windows_core::Interface::vtable(this).ReadAsync)(windows_core::Interface::as_raw(this), buffer.param().abi(), count, options, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn WriteAsync(&self, buffer: P0) -> windows_core::Result> + pub fn WriteAsync(&self, buffer: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -3712,7 +3712,7 @@ impl CapturedFrame { (windows_core::Interface::vtable(this).WriteAsync)(windows_core::Interface::as_raw(this), buffer.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FlushAsync(&self) -> windows_core::Result> { + pub fn FlushAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -6122,21 +6122,21 @@ impl windows_core::RuntimeType for KnownVideoProfile { pub struct LowLagMediaRecording(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(LowLagMediaRecording, windows_core::IUnknown, windows_core::IInspectable); impl LowLagMediaRecording { - pub fn StartAsync(&self) -> windows_core::Result { + pub fn StartAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).StartAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StopAsync(&self) -> windows_core::Result { + pub fn StopAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).StopAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FinishAsync(&self) -> windows_core::Result { + pub fn FinishAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -6144,14 +6144,14 @@ impl LowLagMediaRecording { } } #[cfg(feature = "Media_Devices")] - pub fn PauseAsync(&self, behavior: super::Devices::MediaCapturePauseBehavior) -> windows_core::Result { + pub fn PauseAsync(&self, behavior: super::Devices::MediaCapturePauseBehavior) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).PauseAsync)(windows_core::Interface::as_raw(this), behavior, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ResumeAsync(&self) -> windows_core::Result { + pub fn ResumeAsync(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -6159,14 +6159,14 @@ impl LowLagMediaRecording { } } #[cfg(feature = "Media_Devices")] - pub fn PauseWithResultAsync(&self, behavior: super::Devices::MediaCapturePauseBehavior) -> windows_core::Result> { + pub fn PauseWithResultAsync(&self, behavior: super::Devices::MediaCapturePauseBehavior) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).PauseWithResultAsync)(windows_core::Interface::as_raw(this), behavior, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StopWithResultAsync(&self) -> windows_core::Result> { + pub fn StopWithResultAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -6189,14 +6189,14 @@ impl windows_core::RuntimeName for LowLagMediaRecording { pub struct LowLagPhotoCapture(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(LowLagPhotoCapture, windows_core::IUnknown, windows_core::IInspectable); impl LowLagPhotoCapture { - pub fn CaptureAsync(&self) -> windows_core::Result> { + pub fn CaptureAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CaptureAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FinishAsync(&self) -> windows_core::Result { + pub fn FinishAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -6219,21 +6219,21 @@ impl windows_core::RuntimeName for LowLagPhotoCapture { pub struct LowLagPhotoSequenceCapture(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(LowLagPhotoSequenceCapture, windows_core::IUnknown, windows_core::IInspectable); impl LowLagPhotoSequenceCapture { - pub fn StartAsync(&self) -> windows_core::Result { + pub fn StartAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).StartAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StopAsync(&self) -> windows_core::Result { + pub fn StopAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).StopAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FinishAsync(&self) -> windows_core::Result { + pub fn FinishAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -6282,14 +6282,14 @@ impl MediaCapture { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).Close)(windows_core::Interface::as_raw(this)).ok() } } - pub fn InitializeAsync(&self) -> windows_core::Result { + pub fn InitializeAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).InitializeAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn InitializeWithSettingsAsync(&self, mediacaptureinitializationsettings: P0) -> windows_core::Result + pub fn InitializeWithSettingsAsync(&self, mediacaptureinitializationsettings: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -6300,7 +6300,7 @@ impl MediaCapture { } } #[cfg(all(feature = "Media_MediaProperties", feature = "Storage_Streams"))] - pub fn StartRecordToStorageFileAsync(&self, encodingprofile: P0, file: P1) -> windows_core::Result + pub fn StartRecordToStorageFileAsync(&self, encodingprofile: P0, file: P1) -> windows_core::Result where P0: windows_core::Param, P1: windows_core::Param, @@ -6312,7 +6312,7 @@ impl MediaCapture { } } #[cfg(all(feature = "Media_MediaProperties", feature = "Storage_Streams"))] - pub fn StartRecordToStreamAsync(&self, encodingprofile: P0, stream: P1) -> windows_core::Result + pub fn StartRecordToStreamAsync(&self, encodingprofile: P0, stream: P1) -> windows_core::Result where P0: windows_core::Param, P1: windows_core::Param, @@ -6324,7 +6324,7 @@ impl MediaCapture { } } #[cfg(feature = "Media_MediaProperties")] - pub fn StartRecordToCustomSinkAsync(&self, encodingprofile: P0, custommediasink: P1) -> windows_core::Result + pub fn StartRecordToCustomSinkAsync(&self, encodingprofile: P0, custommediasink: P1) -> windows_core::Result where P0: windows_core::Param, P1: windows_core::Param, @@ -6336,7 +6336,7 @@ impl MediaCapture { } } #[cfg(all(feature = "Foundation_Collections", feature = "Media_MediaProperties"))] - pub fn StartRecordToCustomSinkIdAsync(&self, encodingprofile: P0, customsinkactivationid: &windows_core::HSTRING, customsinksettings: P2) -> windows_core::Result + pub fn StartRecordToCustomSinkIdAsync(&self, encodingprofile: P0, customsinkactivationid: &windows_core::HSTRING, customsinksettings: P2) -> windows_core::Result where P0: windows_core::Param, P2: windows_core::Param, @@ -6347,7 +6347,7 @@ impl MediaCapture { (windows_core::Interface::vtable(this).StartRecordToCustomSinkIdAsync)(windows_core::Interface::as_raw(this), encodingprofile.param().abi(), core::mem::transmute_copy(customsinkactivationid), customsinksettings.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StopRecordAsync(&self) -> windows_core::Result { + pub fn StopRecordAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -6355,7 +6355,7 @@ impl MediaCapture { } } #[cfg(all(feature = "Media_MediaProperties", feature = "Storage_Streams"))] - pub fn CapturePhotoToStorageFileAsync(&self, r#type: P0, file: P1) -> windows_core::Result + pub fn CapturePhotoToStorageFileAsync(&self, r#type: P0, file: P1) -> windows_core::Result where P0: windows_core::Param, P1: windows_core::Param, @@ -6367,7 +6367,7 @@ impl MediaCapture { } } #[cfg(all(feature = "Media_MediaProperties", feature = "Storage_Streams"))] - pub fn CapturePhotoToStreamAsync(&self, r#type: P0, stream: P1) -> windows_core::Result + pub fn CapturePhotoToStreamAsync(&self, r#type: P0, stream: P1) -> windows_core::Result where P0: windows_core::Param, P1: windows_core::Param, @@ -6379,7 +6379,7 @@ impl MediaCapture { } } #[cfg(all(feature = "Foundation_Collections", feature = "deprecated"))] - pub fn AddEffectAsync(&self, mediastreamtype: MediaStreamType, effectactivationid: &windows_core::HSTRING, effectsettings: P2) -> windows_core::Result + pub fn AddEffectAsync(&self, mediastreamtype: MediaStreamType, effectactivationid: &windows_core::HSTRING, effectsettings: P2) -> windows_core::Result where P2: windows_core::Param, { @@ -6389,7 +6389,7 @@ impl MediaCapture { (windows_core::Interface::vtable(this).AddEffectAsync)(windows_core::Interface::as_raw(this), mediastreamtype, core::mem::transmute_copy(effectactivationid), effectsettings.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ClearEffectsAsync(&self, mediastreamtype: MediaStreamType) -> windows_core::Result { + pub fn ClearEffectsAsync(&self, mediastreamtype: MediaStreamType) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -6495,7 +6495,7 @@ impl MediaCapture { } } #[cfg(all(feature = "Media_MediaProperties", feature = "Storage_Streams"))] - pub fn PrepareLowLagRecordToStorageFileAsync(&self, encodingprofile: P0, file: P1) -> windows_core::Result> + pub fn PrepareLowLagRecordToStorageFileAsync(&self, encodingprofile: P0, file: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -6507,7 +6507,7 @@ impl MediaCapture { } } #[cfg(all(feature = "Media_MediaProperties", feature = "Storage_Streams"))] - pub fn PrepareLowLagRecordToStreamAsync(&self, encodingprofile: P0, stream: P1) -> windows_core::Result> + pub fn PrepareLowLagRecordToStreamAsync(&self, encodingprofile: P0, stream: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -6519,7 +6519,7 @@ impl MediaCapture { } } #[cfg(feature = "Media_MediaProperties")] - pub fn PrepareLowLagRecordToCustomSinkAsync(&self, encodingprofile: P0, custommediasink: P1) -> windows_core::Result> + pub fn PrepareLowLagRecordToCustomSinkAsync(&self, encodingprofile: P0, custommediasink: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -6531,7 +6531,7 @@ impl MediaCapture { } } #[cfg(all(feature = "Foundation_Collections", feature = "Media_MediaProperties"))] - pub fn PrepareLowLagRecordToCustomSinkIdAsync(&self, encodingprofile: P0, customsinkactivationid: &windows_core::HSTRING, customsinksettings: P2) -> windows_core::Result> + pub fn PrepareLowLagRecordToCustomSinkIdAsync(&self, encodingprofile: P0, customsinkactivationid: &windows_core::HSTRING, customsinksettings: P2) -> windows_core::Result> where P0: windows_core::Param, P2: windows_core::Param, @@ -6543,7 +6543,7 @@ impl MediaCapture { } } #[cfg(feature = "Media_MediaProperties")] - pub fn PrepareLowLagPhotoCaptureAsync(&self, r#type: P0) -> windows_core::Result> + pub fn PrepareLowLagPhotoCaptureAsync(&self, r#type: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -6554,7 +6554,7 @@ impl MediaCapture { } } #[cfg(feature = "Media_MediaProperties")] - pub fn PrepareLowLagPhotoSequenceCaptureAsync(&self, r#type: P0) -> windows_core::Result> + pub fn PrepareLowLagPhotoSequenceCaptureAsync(&self, r#type: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -6565,7 +6565,7 @@ impl MediaCapture { } } #[cfg(feature = "Media_MediaProperties")] - pub fn SetEncodingPropertiesAsync(&self, mediastreamtype: MediaStreamType, mediaencodingproperties: P1, encoderproperties: P2) -> windows_core::Result + pub fn SetEncodingPropertiesAsync(&self, mediastreamtype: MediaStreamType, mediaencodingproperties: P1, encoderproperties: P2) -> windows_core::Result where P1: windows_core::Param, P2: windows_core::Param, @@ -6577,7 +6577,7 @@ impl MediaCapture { } } #[cfg(all(feature = "Media_Capture_Core", feature = "Media_MediaProperties"))] - pub fn PrepareVariablePhotoSequenceCaptureAsync(&self, r#type: P0) -> windows_core::Result> + pub fn PrepareVariablePhotoSequenceCaptureAsync(&self, r#type: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -6616,7 +6616,7 @@ impl MediaCapture { unsafe { (windows_core::Interface::vtable(this).RemovePhotoConfirmationCaptured)(windows_core::Interface::as_raw(this), token).ok() } } #[cfg(feature = "Media_Effects")] - pub fn AddAudioEffectAsync(&self, definition: P0) -> windows_core::Result> + pub fn AddAudioEffectAsync(&self, definition: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -6627,7 +6627,7 @@ impl MediaCapture { } } #[cfg(feature = "Media_Effects")] - pub fn AddVideoEffectAsync(&self, definition: P0, mediastreamtype: MediaStreamType) -> windows_core::Result> + pub fn AddVideoEffectAsync(&self, definition: P0, mediastreamtype: MediaStreamType) -> windows_core::Result> where P0: windows_core::Param, { @@ -6638,14 +6638,14 @@ impl MediaCapture { } } #[cfg(feature = "Media_Devices")] - pub fn PauseRecordAsync(&self, behavior: super::Devices::MediaCapturePauseBehavior) -> windows_core::Result { + pub fn PauseRecordAsync(&self, behavior: super::Devices::MediaCapturePauseBehavior) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).PauseRecordAsync)(windows_core::Interface::as_raw(this), behavior, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ResumeRecordAsync(&self) -> windows_core::Result { + pub fn ResumeRecordAsync(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -6674,14 +6674,14 @@ impl MediaCapture { (windows_core::Interface::vtable(this).CameraStreamState)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn GetPreviewFrameAsync(&self) -> windows_core::Result> { + pub fn GetPreviewFrameAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetPreviewFrameAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetPreviewFrameCopyAsync(&self, destination: P0) -> windows_core::Result> + pub fn GetPreviewFrameCopyAsync(&self, destination: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -6713,7 +6713,7 @@ impl MediaCapture { } } #[cfg(feature = "Media_MediaProperties")] - pub fn PrepareAdvancedPhotoCaptureAsync(&self, encodingproperties: P0) -> windows_core::Result> + pub fn PrepareAdvancedPhotoCaptureAsync(&self, encodingproperties: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -6723,7 +6723,7 @@ impl MediaCapture { (windows_core::Interface::vtable(this).PrepareAdvancedPhotoCaptureAsync)(windows_core::Interface::as_raw(this), encodingproperties.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RemoveEffectAsync(&self, effect: P0) -> windows_core::Result + pub fn RemoveEffectAsync(&self, effect: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -6734,14 +6734,14 @@ impl MediaCapture { } } #[cfg(feature = "Media_Devices")] - pub fn PauseRecordWithResultAsync(&self, behavior: super::Devices::MediaCapturePauseBehavior) -> windows_core::Result> { + pub fn PauseRecordWithResultAsync(&self, behavior: super::Devices::MediaCapturePauseBehavior) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).PauseRecordWithResultAsync)(windows_core::Interface::as_raw(this), behavior, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StopRecordWithResultAsync(&self) -> windows_core::Result> { + pub fn StopRecordWithResultAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -6757,7 +6757,7 @@ impl MediaCapture { } } #[cfg(feature = "Media_Capture_Frames")] - pub fn CreateFrameReaderAsync(&self, inputsource: P0) -> windows_core::Result> + pub fn CreateFrameReaderAsync(&self, inputsource: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -6768,7 +6768,7 @@ impl MediaCapture { } } #[cfg(feature = "Media_Capture_Frames")] - pub fn CreateFrameReaderWithSubtypeAsync(&self, inputsource: P0, outputsubtype: &windows_core::HSTRING) -> windows_core::Result> + pub fn CreateFrameReaderWithSubtypeAsync(&self, inputsource: P0, outputsubtype: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -6779,7 +6779,7 @@ impl MediaCapture { } } #[cfg(all(feature = "Graphics_Imaging", feature = "Media_Capture_Frames"))] - pub fn CreateFrameReaderWithSubtypeAndSizeAsync(&self, inputsource: P0, outputsubtype: &windows_core::HSTRING, outputsize: super::super::Graphics::Imaging::BitmapSize) -> windows_core::Result> + pub fn CreateFrameReaderWithSubtypeAndSizeAsync(&self, inputsource: P0, outputsubtype: &windows_core::HSTRING, outputsize: super::super::Graphics::Imaging::BitmapSize) -> windows_core::Result> where P0: windows_core::Param, { @@ -6804,7 +6804,7 @@ impl MediaCapture { unsafe { (windows_core::Interface::vtable(this).RemoveCaptureDeviceExclusiveControlStatusChanged)(windows_core::Interface::as_raw(this), token).ok() } } #[cfg(feature = "Media_Capture_Frames")] - pub fn CreateMultiSourceFrameReaderAsync(&self, inputsources: P0) -> windows_core::Result> + pub fn CreateMultiSourceFrameReaderAsync(&self, inputsources: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -6849,7 +6849,7 @@ impl MediaCapture { (windows_core::Interface::vtable(this).FindKnownVideoProfiles)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(videodeviceid), name, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn StartPreviewAsync(&self) -> windows_core::Result { + pub fn StartPreviewAsync(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -6857,7 +6857,7 @@ impl MediaCapture { } } #[cfg(feature = "Media_MediaProperties")] - pub fn StartPreviewToCustomSinkAsync(&self, encodingprofile: P0, custommediasink: P1) -> windows_core::Result + pub fn StartPreviewToCustomSinkAsync(&self, encodingprofile: P0, custommediasink: P1) -> windows_core::Result where P0: windows_core::Param, P1: windows_core::Param, @@ -6869,7 +6869,7 @@ impl MediaCapture { } } #[cfg(all(feature = "Foundation_Collections", feature = "Media_MediaProperties"))] - pub fn StartPreviewToCustomSinkIdAsync(&self, encodingprofile: P0, customsinkactivationid: &windows_core::HSTRING, customsinksettings: P2) -> windows_core::Result + pub fn StartPreviewToCustomSinkIdAsync(&self, encodingprofile: P0, customsinkactivationid: &windows_core::HSTRING, customsinksettings: P2) -> windows_core::Result where P0: windows_core::Param, P2: windows_core::Param, @@ -6880,7 +6880,7 @@ impl MediaCapture { (windows_core::Interface::vtable(this).StartPreviewToCustomSinkIdAsync)(windows_core::Interface::as_raw(this), encodingprofile.param().abi(), core::mem::transmute_copy(customsinkactivationid), customsinksettings.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StopPreviewAsync(&self) -> windows_core::Result { + pub fn StopPreviewAsync(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Media/Casting/mod.rs b/crates/libs/windows/src/Windows/Media/Casting/mod.rs index 62060ea1f4..2f846088b9 100644 --- a/crates/libs/windows/src/Windows/Media/Casting/mod.rs +++ b/crates/libs/windows/src/Windows/Media/Casting/mod.rs @@ -60,7 +60,7 @@ impl CastingConnection { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveErrorOccurred)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn RequestStartCastingAsync(&self, value: P0) -> windows_core::Result> + pub fn RequestStartCastingAsync(&self, value: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -70,7 +70,7 @@ impl CastingConnection { (windows_core::Interface::vtable(this).RequestStartCastingAsync)(windows_core::Interface::as_raw(this), value.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DisconnectAsync(&self) -> windows_core::Result> { + pub fn DisconnectAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -187,7 +187,7 @@ impl CastingDevice { (windows_core::Interface::vtable(this).Icon)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetSupportedCastingPlaybackTypesAsync(&self) -> windows_core::Result> { + pub fn GetSupportedCastingPlaybackTypesAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -207,7 +207,7 @@ impl CastingDevice { (windows_core::Interface::vtable(this).GetDeviceSelector)(windows_core::Interface::as_raw(this), r#type, &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn GetDeviceSelectorFromCastingSourceAsync(castingsource: P0) -> windows_core::Result> + pub fn GetDeviceSelectorFromCastingSourceAsync(castingsource: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -216,14 +216,14 @@ impl CastingDevice { (windows_core::Interface::vtable(this).GetDeviceSelectorFromCastingSourceAsync)(windows_core::Interface::as_raw(this), castingsource.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn FromIdAsync(value: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(value: &windows_core::HSTRING) -> windows_core::Result> { Self::ICastingDeviceStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(value), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "Devices_Enumeration")] - pub fn DeviceInfoSupportsCastingAsync(device: P0) -> windows_core::Result> + pub fn DeviceInfoSupportsCastingAsync(device: P0) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Media/ContentRestrictions/mod.rs b/crates/libs/windows/src/Windows/Media/ContentRestrictions/mod.rs index 0007f3f60b..7f6cedac66 100644 --- a/crates/libs/windows/src/Windows/Media/ContentRestrictions/mod.rs +++ b/crates/libs/windows/src/Windows/Media/ContentRestrictions/mod.rs @@ -238,14 +238,14 @@ impl RatedContentRestrictions { static SHARED: windows_core::imp::FactoryCache = windows_core::imp::FactoryCache::new(); SHARED.call(callback) } - pub fn GetBrowsePolicyAsync(&self) -> windows_core::Result> { + pub fn GetBrowsePolicyAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetBrowsePolicyAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetRestrictionLevelAsync(&self, ratedcontentdescription: P0) -> windows_core::Result> + pub fn GetRestrictionLevelAsync(&self, ratedcontentdescription: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -255,7 +255,7 @@ impl RatedContentRestrictions { (windows_core::Interface::vtable(this).GetRestrictionLevelAsync)(windows_core::Interface::as_raw(this), ratedcontentdescription.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestContentAccessAsync(&self, ratedcontentdescription: P0) -> windows_core::Result> + pub fn RequestContentAccessAsync(&self, ratedcontentdescription: P0) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Media/Control/mod.rs b/crates/libs/windows/src/Windows/Media/Control/mod.rs index 70d77ecca0..c58fcebf1c 100644 --- a/crates/libs/windows/src/Windows/Media/Control/mod.rs +++ b/crates/libs/windows/src/Windows/Media/Control/mod.rs @@ -27,7 +27,7 @@ impl GlobalSystemMediaTransportControlsSession { (windows_core::Interface::vtable(this).SourceAppUserModelId)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn TryGetMediaPropertiesAsync(&self) -> windows_core::Result> { + pub fn TryGetMediaPropertiesAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -48,105 +48,105 @@ impl GlobalSystemMediaTransportControlsSession { (windows_core::Interface::vtable(this).GetPlaybackInfo)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryPlayAsync(&self) -> windows_core::Result> { + pub fn TryPlayAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryPlayAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryPauseAsync(&self) -> windows_core::Result> { + pub fn TryPauseAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryPauseAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryStopAsync(&self) -> windows_core::Result> { + pub fn TryStopAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryStopAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryRecordAsync(&self) -> windows_core::Result> { + pub fn TryRecordAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryRecordAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryFastForwardAsync(&self) -> windows_core::Result> { + pub fn TryFastForwardAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryFastForwardAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryRewindAsync(&self) -> windows_core::Result> { + pub fn TryRewindAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryRewindAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TrySkipNextAsync(&self) -> windows_core::Result> { + pub fn TrySkipNextAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TrySkipNextAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TrySkipPreviousAsync(&self) -> windows_core::Result> { + pub fn TrySkipPreviousAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TrySkipPreviousAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryChangeChannelUpAsync(&self) -> windows_core::Result> { + pub fn TryChangeChannelUpAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryChangeChannelUpAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryChangeChannelDownAsync(&self) -> windows_core::Result> { + pub fn TryChangeChannelDownAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryChangeChannelDownAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryTogglePlayPauseAsync(&self) -> windows_core::Result> { + pub fn TryTogglePlayPauseAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryTogglePlayPauseAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryChangeAutoRepeatModeAsync(&self, requestedautorepeatmode: super::MediaPlaybackAutoRepeatMode) -> windows_core::Result> { + pub fn TryChangeAutoRepeatModeAsync(&self, requestedautorepeatmode: super::MediaPlaybackAutoRepeatMode) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryChangeAutoRepeatModeAsync)(windows_core::Interface::as_raw(this), requestedautorepeatmode, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryChangePlaybackRateAsync(&self, requestedplaybackrate: f64) -> windows_core::Result> { + pub fn TryChangePlaybackRateAsync(&self, requestedplaybackrate: f64) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryChangePlaybackRateAsync)(windows_core::Interface::as_raw(this), requestedplaybackrate, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryChangeShuffleActiveAsync(&self, requestedshufflestate: bool) -> windows_core::Result> { + pub fn TryChangeShuffleActiveAsync(&self, requestedshufflestate: bool) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryChangeShuffleActiveAsync)(windows_core::Interface::as_raw(this), requestedshufflestate, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryChangePlaybackPositionAsync(&self, requestedplaybackposition: i64) -> windows_core::Result> { + pub fn TryChangePlaybackPositionAsync(&self, requestedplaybackposition: i64) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -255,7 +255,7 @@ impl GlobalSystemMediaTransportControlsSessionManager { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveSessionsChanged)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn RequestAsync() -> windows_core::Result> { + pub fn RequestAsync() -> windows_core::Result> { Self::IGlobalSystemMediaTransportControlsSessionManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/Media/Core/mod.rs b/crates/libs/windows/src/Windows/Media/Core/mod.rs index d1a567437e..2c6d1c0b16 100644 --- a/crates/libs/windows/src/Windows/Media/Core/mod.rs +++ b/crates/libs/windows/src/Windows/Media/Core/mod.rs @@ -471,7 +471,7 @@ impl CodecQuery { static SHARED: windows_core::imp::FactoryCache = windows_core::imp::FactoryCache::new(); SHARED.call(callback) } - pub fn FindAllAsync(&self, kind: CodecKind, category: CodecCategory, subtype: &windows_core::HSTRING) -> windows_core::Result>> { + pub fn FindAllAsync(&self, kind: CodecKind, category: CodecCategory, subtype: &windows_core::HSTRING) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -3513,7 +3513,7 @@ impl LowLightFusion { }) } #[cfg(feature = "Graphics_Imaging")] - pub fn FuseAsync(frameset: P0) -> windows_core::Result> + pub fn FuseAsync(frameset: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -3872,7 +3872,7 @@ impl MediaSource { (windows_core::Interface::vtable(this).Uri)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn OpenAsync(&self) -> windows_core::Result { + pub fn OpenAsync(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -4296,7 +4296,7 @@ impl MediaStreamSample { }) } #[cfg(feature = "Storage_Streams")] - pub fn CreateFromStreamAsync(stream: P0, count: u32, timestamp: super::super::Foundation::TimeSpan) -> windows_core::Result> + pub fn CreateFromStreamAsync(stream: P0, count: u32, timestamp: super::super::Foundation::TimeSpan) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Media/Devices/mod.rs b/crates/libs/windows/src/Windows/Media/Devices/mod.rs index f2b257155c..81a90a7809 100644 --- a/crates/libs/windows/src/Windows/Media/Devices/mod.rs +++ b/crates/libs/windows/src/Windows/Media/Devices/mod.rs @@ -150,7 +150,7 @@ impl AudioDeviceController { } } #[cfg(all(feature = "Media_Capture", feature = "Media_MediaProperties"))] - pub fn SetMediaStreamPropertiesAsync(&self, mediastreamtype: super::Capture::MediaStreamType, mediaencodingproperties: P1) -> windows_core::Result + pub fn SetMediaStreamPropertiesAsync(&self, mediastreamtype: super::Capture::MediaStreamType, mediaencodingproperties: P1) -> windows_core::Result where P1: windows_core::Param, { @@ -212,7 +212,7 @@ impl AudioDeviceModule { } } #[cfg(feature = "Storage_Streams")] - pub fn SendCommandAsync(&self, command: P0) -> windows_core::Result> + pub fn SendCommandAsync(&self, command: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1157,7 +1157,7 @@ impl ExposureCompensationControl { (windows_core::Interface::vtable(this).Value)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn SetValueAsync(&self, value: f32) -> windows_core::Result { + pub fn SetValueAsync(&self, value: f32) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1194,7 +1194,7 @@ impl ExposureControl { (windows_core::Interface::vtable(this).Auto)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn SetAutoAsync(&self, value: bool) -> windows_core::Result { + pub fn SetAutoAsync(&self, value: bool) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1229,7 +1229,7 @@ impl ExposureControl { (windows_core::Interface::vtable(this).Value)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn SetValueAsync(&self, shutterduration: super::super::Foundation::TimeSpan) -> windows_core::Result { + pub fn SetValueAsync(&self, shutterduration: super::super::Foundation::TimeSpan) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1408,14 +1408,14 @@ impl FocusControl { (windows_core::Interface::vtable(this).Preset)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn SetPresetAsync(&self, preset: FocusPreset) -> windows_core::Result { + pub fn SetPresetAsync(&self, preset: FocusPreset) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).SetPresetAsync)(windows_core::Interface::as_raw(this), preset, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SetPresetWithCompletionOptionAsync(&self, preset: FocusPreset, completebeforefocus: bool) -> windows_core::Result { + pub fn SetPresetWithCompletionOptionAsync(&self, preset: FocusPreset, completebeforefocus: bool) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1450,14 +1450,14 @@ impl FocusControl { (windows_core::Interface::vtable(this).Value)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn SetValueAsync(&self, focus: u32) -> windows_core::Result { + pub fn SetValueAsync(&self, focus: u32) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).SetValueAsync)(windows_core::Interface::as_raw(this), focus, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FocusAsync(&self) -> windows_core::Result { + pub fn FocusAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1513,14 +1513,14 @@ impl FocusControl { (windows_core::Interface::vtable(this).FocusState)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn UnlockAsync(&self) -> windows_core::Result { + pub fn UnlockAsync(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).UnlockAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn LockAsync(&self) -> windows_core::Result { + pub fn LockAsync(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -2465,7 +2465,7 @@ impl IMediaDeviceController { } } #[cfg(all(feature = "Media_Capture", feature = "Media_MediaProperties"))] - pub fn SetMediaStreamPropertiesAsync(&self, mediastreamtype: super::Capture::MediaStreamType, mediaencodingproperties: P1) -> windows_core::Result + pub fn SetMediaStreamPropertiesAsync(&self, mediastreamtype: super::Capture::MediaStreamType, mediaencodingproperties: P1) -> windows_core::Result where P1: windows_core::Param, { @@ -2484,7 +2484,7 @@ impl windows_core::RuntimeName for IMediaDeviceController { pub trait IMediaDeviceController_Impl: windows_core::IUnknownImpl { fn GetAvailableMediaStreamProperties(&self, mediaStreamType: super::Capture::MediaStreamType) -> windows_core::Result>; fn GetMediaStreamProperties(&self, mediaStreamType: super::Capture::MediaStreamType) -> windows_core::Result; - fn SetMediaStreamPropertiesAsync(&self, mediaStreamType: super::Capture::MediaStreamType, mediaEncodingProperties: windows_core::Ref<'_, super::MediaProperties::IMediaEncodingProperties>) -> windows_core::Result; + fn SetMediaStreamPropertiesAsync(&self, mediaStreamType: super::Capture::MediaStreamType, mediaEncodingProperties: windows_core::Ref<'_, super::MediaProperties::IMediaEncodingProperties>) -> windows_core::Result; } #[cfg(all(feature = "Media_Capture", feature = "Media_MediaProperties"))] impl IMediaDeviceController_Vtbl { @@ -2932,7 +2932,7 @@ impl IsoSpeedControl { } } #[cfg(feature = "deprecated")] - pub fn SetPresetAsync(&self, preset: IsoSpeedPreset) -> windows_core::Result { + pub fn SetPresetAsync(&self, preset: IsoSpeedPreset) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2967,7 +2967,7 @@ impl IsoSpeedControl { (windows_core::Interface::vtable(this).Value)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn SetValueAsync(&self, isospeed: u32) -> windows_core::Result { + pub fn SetValueAsync(&self, isospeed: u32) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -2981,7 +2981,7 @@ impl IsoSpeedControl { (windows_core::Interface::vtable(this).Auto)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn SetAutoAsync(&self) -> windows_core::Result { + pub fn SetAutoAsync(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -3938,7 +3938,7 @@ impl RegionsOfInterestControl { (windows_core::Interface::vtable(this).MaxRegions)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn SetRegionsAsync(&self, regions: P0) -> windows_core::Result + pub fn SetRegionsAsync(&self, regions: P0) -> windows_core::Result where P0: windows_core::Param>, { @@ -3948,7 +3948,7 @@ impl RegionsOfInterestControl { (windows_core::Interface::vtable(this).SetRegionsAsync)(windows_core::Interface::as_raw(this), regions.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SetRegionsWithLockAsync(&self, regions: P0, lockvalues: bool) -> windows_core::Result + pub fn SetRegionsWithLockAsync(&self, regions: P0, lockvalues: bool) -> windows_core::Result where P0: windows_core::Param>, { @@ -3958,7 +3958,7 @@ impl RegionsOfInterestControl { (windows_core::Interface::vtable(this).SetRegionsWithLockAsync)(windows_core::Interface::as_raw(this), regions.param().abi(), lockvalues, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ClearRegionsAsync(&self) -> windows_core::Result { + pub fn ClearRegionsAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -4016,7 +4016,7 @@ impl SceneModeControl { (windows_core::Interface::vtable(this).Value)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn SetValueAsync(&self, scenemode: CaptureSceneMode) -> windows_core::Result { + pub fn SetValueAsync(&self, scenemode: CaptureSceneMode) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -4399,7 +4399,7 @@ impl VideoDeviceController { } } #[cfg(all(feature = "Media_Capture", feature = "Media_MediaProperties"))] - pub fn SetMediaStreamPropertiesAsync(&self, mediastreamtype: super::Capture::MediaStreamType, mediaencodingproperties: P1) -> windows_core::Result + pub fn SetMediaStreamPropertiesAsync(&self, mediastreamtype: super::Capture::MediaStreamType, mediaencodingproperties: P1) -> windows_core::Result where P1: windows_core::Param, { @@ -4656,7 +4656,7 @@ impl WhiteBalanceControl { (windows_core::Interface::vtable(this).Preset)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn SetPresetAsync(&self, preset: ColorTemperaturePreset) -> windows_core::Result { + pub fn SetPresetAsync(&self, preset: ColorTemperaturePreset) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -4691,7 +4691,7 @@ impl WhiteBalanceControl { (windows_core::Interface::vtable(this).Value)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn SetValueAsync(&self, temperature: u32) -> windows_core::Result { + pub fn SetValueAsync(&self, temperature: u32) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Media/DialProtocol/mod.rs b/crates/libs/windows/src/Windows/Media/DialProtocol/mod.rs index e87828b680..51d39c39f8 100644 --- a/crates/libs/windows/src/Windows/Media/DialProtocol/mod.rs +++ b/crates/libs/windows/src/Windows/Media/DialProtocol/mod.rs @@ -10,21 +10,21 @@ impl DialApp { (windows_core::Interface::vtable(this).AppName)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn RequestLaunchAsync(&self, appargument: &windows_core::HSTRING) -> windows_core::Result> { + pub fn RequestLaunchAsync(&self, appargument: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestLaunchAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(appargument), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StopAsync(&self) -> windows_core::Result> { + pub fn StopAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).StopAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAppStateAsync(&self) -> windows_core::Result> { + pub fn GetAppStateAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -161,14 +161,14 @@ impl DialDevice { (windows_core::Interface::vtable(this).GetDeviceSelector)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(appname), &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn FromIdAsync(value: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(value: &windows_core::HSTRING) -> windows_core::Result> { Self::IDialDeviceStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(value), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "Devices_Enumeration")] - pub fn DeviceInfoSupportsDialAsync(device: P0) -> windows_core::Result> + pub fn DeviceInfoSupportsDialAsync(device: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -289,7 +289,7 @@ impl DialDevicePicker { let this = self; unsafe { (windows_core::Interface::vtable(this).ShowWithPlacement)(windows_core::Interface::as_raw(this), selection, preferredplacement).ok() } } - pub fn PickSingleDialDeviceAsync(&self, selection: super::super::Foundation::Rect) -> windows_core::Result> { + pub fn PickSingleDialDeviceAsync(&self, selection: super::super::Foundation::Rect) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -297,7 +297,7 @@ impl DialDevicePicker { } } #[cfg(feature = "UI_Popups")] - pub fn PickSingleDialDeviceAsyncWithPlacement(&self, selection: super::super::Foundation::Rect, preferredplacement: super::super::UI::Popups::Placement) -> windows_core::Result> { + pub fn PickSingleDialDeviceAsyncWithPlacement(&self, selection: super::super::Foundation::Rect, preferredplacement: super::super::UI::Popups::Placement) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -408,14 +408,14 @@ unsafe impl Sync for DialDisconnectButtonClickedEventArgs {} pub struct DialReceiverApp(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(DialReceiverApp, windows_core::IUnknown, windows_core::IInspectable); impl DialReceiverApp { - pub fn GetAdditionalDataAsync(&self) -> windows_core::Result>> { + pub fn GetAdditionalDataAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetAdditionalDataAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SetAdditionalDataAsync(&self, additionaldata: P0) -> windows_core::Result + pub fn SetAdditionalDataAsync(&self, additionaldata: P0) -> windows_core::Result where P0: windows_core::Param>>, { @@ -425,7 +425,7 @@ impl DialReceiverApp { (windows_core::Interface::vtable(this).SetAdditionalDataAsync)(windows_core::Interface::as_raw(this), additionaldata.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetUniqueDeviceNameAsync(&self) -> windows_core::Result> { + pub fn GetUniqueDeviceNameAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Media/Editing/mod.rs b/crates/libs/windows/src/Windows/Media/Editing/mod.rs index fd54d74466..a04c126b1d 100644 --- a/crates/libs/windows/src/Windows/Media/Editing/mod.rs +++ b/crates/libs/windows/src/Windows/Media/Editing/mod.rs @@ -101,7 +101,7 @@ impl BackgroundAudioTrack { }) } #[cfg(feature = "Storage_Streams")] - pub fn CreateFromFileAsync(file: P0) -> windows_core::Result> + pub fn CreateFromFileAsync(file: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -531,7 +531,7 @@ impl MediaClip { }) } #[cfg(feature = "Storage_Streams")] - pub fn CreateFromFileAsync(file: P0) -> windows_core::Result> + pub fn CreateFromFileAsync(file: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -541,7 +541,7 @@ impl MediaClip { }) } #[cfg(feature = "Storage_Streams")] - pub fn CreateFromImageFileAsync(file: P0, originalduration: super::super::Foundation::TimeSpan) -> windows_core::Result> + pub fn CreateFromImageFileAsync(file: P0, originalduration: super::super::Foundation::TimeSpan) -> windows_core::Result> where P0: windows_core::Param, { @@ -629,7 +629,7 @@ impl MediaComposition { } } #[cfg(feature = "Storage_Streams")] - pub fn SaveAsync(&self, file: P0) -> windows_core::Result + pub fn SaveAsync(&self, file: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -640,7 +640,7 @@ impl MediaComposition { } } #[cfg(all(feature = "Graphics_Imaging", feature = "Storage_Streams"))] - pub fn GetThumbnailAsync(&self, timefromstart: super::super::Foundation::TimeSpan, scaledwidth: i32, scaledheight: i32, frameprecision: VideoFramePrecision) -> windows_core::Result> { + pub fn GetThumbnailAsync(&self, timefromstart: super::super::Foundation::TimeSpan, scaledwidth: i32, scaledheight: i32, frameprecision: VideoFramePrecision) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -648,7 +648,7 @@ impl MediaComposition { } } #[cfg(all(feature = "Graphics_Imaging", feature = "Storage_Streams"))] - pub fn GetThumbnailsAsync(&self, timesfromstart: P0, scaledwidth: i32, scaledheight: i32, frameprecision: VideoFramePrecision) -> windows_core::Result>> + pub fn GetThumbnailsAsync(&self, timesfromstart: P0, scaledwidth: i32, scaledheight: i32, frameprecision: VideoFramePrecision) -> windows_core::Result>> where P0: windows_core::Param>, { @@ -659,7 +659,7 @@ impl MediaComposition { } } #[cfg(all(feature = "Media_Transcoding", feature = "Storage_Streams"))] - pub fn RenderToFileAsync(&self, destination: P0) -> windows_core::Result> + pub fn RenderToFileAsync(&self, destination: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -670,7 +670,7 @@ impl MediaComposition { } } #[cfg(all(feature = "Media_Transcoding", feature = "Storage_Streams"))] - pub fn RenderToFileWithTrimmingPreferenceAsync(&self, destination: P0, trimmingpreference: MediaTrimmingPreference) -> windows_core::Result> + pub fn RenderToFileWithTrimmingPreferenceAsync(&self, destination: P0, trimmingpreference: MediaTrimmingPreference) -> windows_core::Result> where P0: windows_core::Param, { @@ -681,7 +681,7 @@ impl MediaComposition { } } #[cfg(all(feature = "Media_MediaProperties", feature = "Media_Transcoding", feature = "Storage_Streams"))] - pub fn RenderToFileWithProfileAsync(&self, destination: P0, trimmingpreference: MediaTrimmingPreference, encodingprofile: P2) -> windows_core::Result> + pub fn RenderToFileWithProfileAsync(&self, destination: P0, trimmingpreference: MediaTrimmingPreference, encodingprofile: P2) -> windows_core::Result> where P0: windows_core::Param, P2: windows_core::Param, @@ -735,7 +735,7 @@ impl MediaComposition { } } #[cfg(feature = "Storage_Streams")] - pub fn LoadAsync(file: P0) -> windows_core::Result> + pub fn LoadAsync(file: P0) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Media/FaceAnalysis/mod.rs b/crates/libs/windows/src/Windows/Media/FaceAnalysis/mod.rs index f159cdc01b..51006e4670 100644 --- a/crates/libs/windows/src/Windows/Media/FaceAnalysis/mod.rs +++ b/crates/libs/windows/src/Windows/Media/FaceAnalysis/mod.rs @@ -30,7 +30,7 @@ pub struct FaceDetector(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(FaceDetector, windows_core::IUnknown, windows_core::IInspectable); impl FaceDetector { #[cfg(feature = "Graphics_Imaging")] - pub fn DetectFacesAsync(&self, image: P0) -> windows_core::Result>> + pub fn DetectFacesAsync(&self, image: P0) -> windows_core::Result>> where P0: windows_core::Param, { @@ -41,7 +41,7 @@ impl FaceDetector { } } #[cfg(feature = "Graphics_Imaging")] - pub fn DetectFacesWithSearchAreaAsync(&self, image: P0, searcharea: super::super::Graphics::Imaging::BitmapBounds) -> windows_core::Result>> + pub fn DetectFacesWithSearchAreaAsync(&self, image: P0, searcharea: super::super::Graphics::Imaging::BitmapBounds) -> windows_core::Result>> where P0: windows_core::Param, { @@ -77,7 +77,7 @@ impl FaceDetector { let this = self; unsafe { (windows_core::Interface::vtable(this).SetMaxDetectableFaceSize)(windows_core::Interface::as_raw(this), value).ok() } } - pub fn CreateAsync() -> windows_core::Result> { + pub fn CreateAsync() -> windows_core::Result> { Self::IFaceDetectorStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreateAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -125,7 +125,7 @@ unsafe impl Sync for FaceDetector {} pub struct FaceTracker(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(FaceTracker, windows_core::IUnknown, windows_core::IInspectable); impl FaceTracker { - pub fn ProcessNextFrameAsync(&self, videoframe: P0) -> windows_core::Result>> + pub fn ProcessNextFrameAsync(&self, videoframe: P0) -> windows_core::Result>> where P0: windows_core::Param, { @@ -161,7 +161,7 @@ impl FaceTracker { let this = self; unsafe { (windows_core::Interface::vtable(this).SetMaxDetectableFaceSize)(windows_core::Interface::as_raw(this), value).ok() } } - pub fn CreateAsync() -> windows_core::Result> { + pub fn CreateAsync() -> windows_core::Result> { Self::IFaceTrackerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreateAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/Media/Import/mod.rs b/crates/libs/windows/src/Windows/Media/Import/mod.rs index d37adcd9a5..634254d543 100644 --- a/crates/libs/windows/src/Windows/Media/Import/mod.rs +++ b/crates/libs/windows/src/Windows/Media/Import/mod.rs @@ -555,7 +555,7 @@ impl PhotoImportFindItemsResult { let this = self; unsafe { (windows_core::Interface::vtable(this).SelectNone)(windows_core::Interface::as_raw(this)).ok() } } - pub fn SelectNewAsync(&self) -> windows_core::Result { + pub fn SelectNewAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -657,7 +657,7 @@ impl PhotoImportFindItemsResult { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveSelectionChanged)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn ImportItemsAsync(&self) -> windows_core::Result> { + pub fn ImportItemsAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -791,7 +791,7 @@ impl PhotoImportImportItemsResult { (windows_core::Interface::vtable(this).TotalSizeInBytes)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn DeleteImportedItemsFromSourceAsync(&self) -> windows_core::Result> { + pub fn DeleteImportedItemsFromSourceAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -981,13 +981,13 @@ impl windows_core::RuntimeType for PhotoImportItemSelectionMode { } pub struct PhotoImportManager; impl PhotoImportManager { - pub fn IsSupportedAsync() -> windows_core::Result> { + pub fn IsSupportedAsync() -> windows_core::Result> { Self::IPhotoImportManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).IsSupportedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn FindAllSourcesAsync() -> windows_core::Result>> { + pub fn FindAllSourcesAsync() -> windows_core::Result>> { Self::IPhotoImportManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAllSourcesAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -1026,21 +1026,21 @@ impl PhotoImportOperation { (windows_core::Interface::vtable(this).Session)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ContinueFindingItemsAsync(&self) -> windows_core::Result> { + pub fn ContinueFindingItemsAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ContinueFindingItemsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ContinueImportingItemsAsync(&self) -> windows_core::Result> { + pub fn ContinueImportingItemsAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ContinueImportingItemsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ContinueDeletingImportedItemsFromSourceAsync(&self) -> windows_core::Result> { + pub fn ContinueDeletingImportedItemsFromSourceAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1187,7 +1187,7 @@ impl PhotoImportSession { (windows_core::Interface::vtable(this).DestinationFileNamePrefix)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn FindItemsAsync(&self, contenttypefilter: PhotoImportContentTypeFilter, itemselectionmode: PhotoImportItemSelectionMode) -> windows_core::Result> { + pub fn FindItemsAsync(&self, contenttypefilter: PhotoImportContentTypeFilter, itemselectionmode: PhotoImportItemSelectionMode) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1393,14 +1393,14 @@ impl PhotoImportSource { (windows_core::Interface::vtable(this).CreateImportSession)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FromIdAsync(sourceid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FromIdAsync(sourceid: &windows_core::HSTRING) -> windows_core::Result> { Self::IPhotoImportSourceStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FromIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(sourceid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "Storage")] - pub fn FromFolderAsync(sourcerootfolder: P0) -> windows_core::Result> + pub fn FromFolderAsync(sourcerootfolder: P0) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Media/MediaProperties/mod.rs b/crates/libs/windows/src/Windows/Media/MediaProperties/mod.rs index d7a408ebba..d0a80e6d6a 100644 --- a/crates/libs/windows/src/Windows/Media/MediaProperties/mod.rs +++ b/crates/libs/windows/src/Windows/Media/MediaProperties/mod.rs @@ -1463,7 +1463,7 @@ impl MediaEncodingProfile { }) } #[cfg(feature = "Storage_Streams")] - pub fn CreateFromFileAsync(file: P0) -> windows_core::Result> + pub fn CreateFromFileAsync(file: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1473,7 +1473,7 @@ impl MediaEncodingProfile { }) } #[cfg(feature = "Storage_Streams")] - pub fn CreateFromStreamAsync(stream: P0) -> windows_core::Result> + pub fn CreateFromStreamAsync(stream: P0) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Media/Miracast/mod.rs b/crates/libs/windows/src/Windows/Media/Miracast/mod.rs index 5c395d4c73..aaff85781d 100644 --- a/crates/libs/windows/src/Windows/Media/Miracast/mod.rs +++ b/crates/libs/windows/src/Windows/Media/Miracast/mod.rs @@ -305,7 +305,7 @@ impl MiracastReceiver { (windows_core::Interface::vtable(this).GetCurrentSettings)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetCurrentSettingsAsync(&self) -> windows_core::Result> { + pub fn GetCurrentSettingsAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -322,7 +322,7 @@ impl MiracastReceiver { (windows_core::Interface::vtable(this).DisconnectAllAndApplySettings)(windows_core::Interface::as_raw(this), settings.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DisconnectAllAndApplySettingsAsync(&self, settings: P0) -> windows_core::Result> + pub fn DisconnectAllAndApplySettingsAsync(&self, settings: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -339,7 +339,7 @@ impl MiracastReceiver { (windows_core::Interface::vtable(this).GetStatus)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetStatusAsync(&self) -> windows_core::Result> { + pub fn GetStatusAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -372,7 +372,7 @@ impl MiracastReceiver { } } #[cfg(feature = "ApplicationModel_Core")] - pub fn CreateSessionAsync(&self, view: P0) -> windows_core::Result> + pub fn CreateSessionAsync(&self, view: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -494,7 +494,7 @@ impl MiracastReceiverConnection { let this = self; unsafe { (windows_core::Interface::vtable(this).Pause)(windows_core::Interface::as_raw(this)).ok() } } - pub fn PauseAsync(&self) -> windows_core::Result { + pub fn PauseAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -505,7 +505,7 @@ impl MiracastReceiverConnection { let this = self; unsafe { (windows_core::Interface::vtable(this).Resume)(windows_core::Interface::as_raw(this)).ok() } } - pub fn ResumeAsync(&self) -> windows_core::Result { + pub fn ResumeAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1070,7 +1070,7 @@ impl MiracastReceiverSession { (windows_core::Interface::vtable(this).Start)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StartAsync(&self) -> windows_core::Result> { + pub fn StartAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1275,7 +1275,7 @@ impl MiracastReceiverStreamControl { (windows_core::Interface::vtable(this).GetVideoStreamSettings)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetVideoStreamSettingsAsync(&self) -> windows_core::Result> { + pub fn GetVideoStreamSettingsAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1289,7 +1289,7 @@ impl MiracastReceiverStreamControl { let this = self; unsafe { (windows_core::Interface::vtable(this).SuggestVideoStreamSettings)(windows_core::Interface::as_raw(this), settings.param().abi()).ok() } } - pub fn SuggestVideoStreamSettingsAsync(&self, settings: P0) -> windows_core::Result + pub fn SuggestVideoStreamSettingsAsync(&self, settings: P0) -> windows_core::Result where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Media/Ocr/mod.rs b/crates/libs/windows/src/Windows/Media/Ocr/mod.rs index 9ed71f8128..246bbdcb86 100644 --- a/crates/libs/windows/src/Windows/Media/Ocr/mod.rs +++ b/crates/libs/windows/src/Windows/Media/Ocr/mod.rs @@ -73,7 +73,7 @@ pub struct OcrEngine(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(OcrEngine, windows_core::IUnknown, windows_core::IInspectable); impl OcrEngine { #[cfg(feature = "Graphics_Imaging")] - pub fn RecognizeAsync(&self, bitmap: P0) -> windows_core::Result> + pub fn RecognizeAsync(&self, bitmap: P0) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Media/PlayTo/mod.rs b/crates/libs/windows/src/Windows/Media/PlayTo/mod.rs index 36689e794c..fbebe227d1 100644 --- a/crates/libs/windows/src/Windows/Media/PlayTo/mod.rs +++ b/crates/libs/windows/src/Windows/Media/PlayTo/mod.rs @@ -870,14 +870,14 @@ impl PlayToReceiver { (windows_core::Interface::vtable(this).Properties)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StartAsync(&self) -> windows_core::Result { + pub fn StartAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).StartAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StopAsync(&self) -> windows_core::Result { + pub fn StopAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Media/Playlists/mod.rs b/crates/libs/windows/src/Windows/Media/Playlists/mod.rs index 2857ce2be2..006096af5d 100644 --- a/crates/libs/windows/src/Windows/Media/Playlists/mod.rs +++ b/crates/libs/windows/src/Windows/Media/Playlists/mod.rs @@ -51,7 +51,7 @@ impl Playlist { (windows_core::Interface::vtable(this).Files)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SaveAsync(&self) -> windows_core::Result { + pub fn SaveAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -59,7 +59,7 @@ impl Playlist { } } #[cfg(feature = "Storage_Streams")] - pub fn SaveAsAsync(&self, savelocation: P0, desiredname: &windows_core::HSTRING, option: super::super::Storage::NameCollisionOption) -> windows_core::Result> + pub fn SaveAsAsync(&self, savelocation: P0, desiredname: &windows_core::HSTRING, option: super::super::Storage::NameCollisionOption) -> windows_core::Result> where P0: windows_core::Param, { @@ -70,7 +70,7 @@ impl Playlist { } } #[cfg(feature = "Storage_Streams")] - pub fn SaveAsWithFormatAsync(&self, savelocation: P0, desiredname: &windows_core::HSTRING, option: super::super::Storage::NameCollisionOption, playlistformat: PlaylistFormat) -> windows_core::Result> + pub fn SaveAsWithFormatAsync(&self, savelocation: P0, desiredname: &windows_core::HSTRING, option: super::super::Storage::NameCollisionOption, playlistformat: PlaylistFormat) -> windows_core::Result> where P0: windows_core::Param, { @@ -81,7 +81,7 @@ impl Playlist { } } #[cfg(feature = "Storage_Streams")] - pub fn LoadAsync(file: P0) -> windows_core::Result> + pub fn LoadAsync(file: P0) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Media/Protection/PlayReady/mod.rs b/crates/libs/windows/src/Windows/Media/Protection/PlayReady/mod.rs index 4d179c86b0..23cddfe366 100644 --- a/crates/libs/windows/src/Windows/Media/Protection/PlayReady/mod.rs +++ b/crates/libs/windows/src/Windows/Media/Protection/PlayReady/mod.rs @@ -792,28 +792,28 @@ impl windows_core::RuntimeType for INDMessenger { windows_core::imp::interface_hierarchy!(INDMessenger, windows_core::IUnknown, windows_core::IInspectable); #[cfg(feature = "deprecated")] impl INDMessenger { - pub fn SendRegistrationRequestAsync(&self, sessionidbytes: &[u8], challengedatabytes: &[u8]) -> windows_core::Result> { + pub fn SendRegistrationRequestAsync(&self, sessionidbytes: &[u8], challengedatabytes: &[u8]) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).SendRegistrationRequestAsync)(windows_core::Interface::as_raw(this), sessionidbytes.len().try_into().unwrap(), sessionidbytes.as_ptr(), challengedatabytes.len().try_into().unwrap(), challengedatabytes.as_ptr(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SendProximityDetectionStartAsync(&self, pdtype: NDProximityDetectionType, transmitterchannelbytes: &[u8], sessionidbytes: &[u8], challengedatabytes: &[u8]) -> windows_core::Result> { + pub fn SendProximityDetectionStartAsync(&self, pdtype: NDProximityDetectionType, transmitterchannelbytes: &[u8], sessionidbytes: &[u8], challengedatabytes: &[u8]) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).SendProximityDetectionStartAsync)(windows_core::Interface::as_raw(this), pdtype, transmitterchannelbytes.len().try_into().unwrap(), transmitterchannelbytes.as_ptr(), sessionidbytes.len().try_into().unwrap(), sessionidbytes.as_ptr(), challengedatabytes.len().try_into().unwrap(), challengedatabytes.as_ptr(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SendProximityDetectionResponseAsync(&self, pdtype: NDProximityDetectionType, transmitterchannelbytes: &[u8], sessionidbytes: &[u8], responsedatabytes: &[u8]) -> windows_core::Result> { + pub fn SendProximityDetectionResponseAsync(&self, pdtype: NDProximityDetectionType, transmitterchannelbytes: &[u8], sessionidbytes: &[u8], responsedatabytes: &[u8]) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).SendProximityDetectionResponseAsync)(windows_core::Interface::as_raw(this), pdtype, transmitterchannelbytes.len().try_into().unwrap(), transmitterchannelbytes.as_ptr(), sessionidbytes.len().try_into().unwrap(), sessionidbytes.as_ptr(), responsedatabytes.len().try_into().unwrap(), responsedatabytes.as_ptr(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SendLicenseFetchRequestAsync(&self, sessionidbytes: &[u8], challengedatabytes: &[u8]) -> windows_core::Result> { + pub fn SendLicenseFetchRequestAsync(&self, sessionidbytes: &[u8], challengedatabytes: &[u8]) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -827,10 +827,10 @@ impl windows_core::RuntimeName for INDMessenger { } #[cfg(feature = "deprecated")] pub trait INDMessenger_Impl: windows_core::IUnknownImpl { - fn SendRegistrationRequestAsync(&self, sessionIDBytes: &[u8], challengeDataBytes: &[u8]) -> windows_core::Result>; - fn SendProximityDetectionStartAsync(&self, pdType: NDProximityDetectionType, transmitterChannelBytes: &[u8], sessionIDBytes: &[u8], challengeDataBytes: &[u8]) -> windows_core::Result>; - fn SendProximityDetectionResponseAsync(&self, pdType: NDProximityDetectionType, transmitterChannelBytes: &[u8], sessionIDBytes: &[u8], responseDataBytes: &[u8]) -> windows_core::Result>; - fn SendLicenseFetchRequestAsync(&self, sessionIDBytes: &[u8], challengeDataBytes: &[u8]) -> windows_core::Result>; + fn SendRegistrationRequestAsync(&self, sessionIDBytes: &[u8], challengeDataBytes: &[u8]) -> windows_core::Result>; + fn SendProximityDetectionStartAsync(&self, pdType: NDProximityDetectionType, transmitterChannelBytes: &[u8], sessionIDBytes: &[u8], challengeDataBytes: &[u8]) -> windows_core::Result>; + fn SendProximityDetectionResponseAsync(&self, pdType: NDProximityDetectionType, transmitterChannelBytes: &[u8], sessionIDBytes: &[u8], responseDataBytes: &[u8]) -> windows_core::Result>; + fn SendLicenseFetchRequestAsync(&self, sessionIDBytes: &[u8], challengeDataBytes: &[u8]) -> windows_core::Result>; } #[cfg(feature = "deprecated")] impl INDMessenger_Vtbl { @@ -2307,7 +2307,7 @@ impl IPlayReadyLicenseAcquisitionServiceRequest { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).SetChallengeCustomData)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(value)).ok() } } - pub fn BeginServiceRequest(&self) -> windows_core::Result { + pub fn BeginServiceRequest(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -2699,7 +2699,7 @@ impl IPlayReadySecureStopServiceRequest { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).SetChallengeCustomData)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(value)).ok() } } - pub fn BeginServiceRequest(&self) -> windows_core::Result { + pub fn BeginServiceRequest(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -2873,7 +2873,7 @@ impl IPlayReadyServiceRequest { let this = self; unsafe { (windows_core::Interface::vtable(this).SetChallengeCustomData)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(value)).ok() } } - pub fn BeginServiceRequest(&self) -> windows_core::Result { + pub fn BeginServiceRequest(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2925,7 +2925,7 @@ pub trait IPlayReadyServiceRequest_Impl: super::IMediaProtectionServiceRequest_I fn ResponseCustomData(&self) -> windows_core::Result; fn ChallengeCustomData(&self) -> windows_core::Result; fn SetChallengeCustomData(&self, value: &windows_core::HSTRING) -> windows_core::Result<()>; - fn BeginServiceRequest(&self) -> windows_core::Result; + fn BeginServiceRequest(&self) -> windows_core::Result; fn NextServiceRequest(&self) -> windows_core::Result; fn GenerateManualEnablingChallenge(&self) -> windows_core::Result; fn ProcessManualEnablingResponse(&self, responseBytes: &[u8]) -> windows_core::Result; @@ -3277,7 +3277,7 @@ impl NDClient { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveClosedCaptionDataReceived)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn StartAsync(&self, contenturl: P0, startasyncoptions: u32, registrationcustomdata: P2, licensefetchdescriptor: P3) -> windows_core::Result> + pub fn StartAsync(&self, contenturl: P0, startasyncoptions: u32, registrationcustomdata: P2, licensefetchdescriptor: P3) -> windows_core::Result> where P0: windows_core::Param, P2: windows_core::Param, @@ -3289,7 +3289,7 @@ impl NDClient { (windows_core::Interface::vtable(this).StartAsync)(windows_core::Interface::as_raw(this), contenturl.param().abi(), startasyncoptions, registrationcustomdata.param().abi(), licensefetchdescriptor.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn LicenseFetchAsync(&self, licensefetchdescriptor: P0) -> windows_core::Result> + pub fn LicenseFetchAsync(&self, licensefetchdescriptor: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -3299,7 +3299,7 @@ impl NDClient { (windows_core::Interface::vtable(this).LicenseFetchAsync)(windows_core::Interface::as_raw(this), licensefetchdescriptor.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReRegistrationAsync(&self, registrationcustomdata: P0) -> windows_core::Result + pub fn ReRegistrationAsync(&self, registrationcustomdata: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -3684,28 +3684,28 @@ pub struct NDTCPMessenger(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(NDTCPMessenger, windows_core::IUnknown, windows_core::IInspectable, INDMessenger); #[cfg(feature = "deprecated")] impl NDTCPMessenger { - pub fn SendRegistrationRequestAsync(&self, sessionidbytes: &[u8], challengedatabytes: &[u8]) -> windows_core::Result> { + pub fn SendRegistrationRequestAsync(&self, sessionidbytes: &[u8], challengedatabytes: &[u8]) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).SendRegistrationRequestAsync)(windows_core::Interface::as_raw(this), sessionidbytes.len().try_into().unwrap(), sessionidbytes.as_ptr(), challengedatabytes.len().try_into().unwrap(), challengedatabytes.as_ptr(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SendProximityDetectionStartAsync(&self, pdtype: NDProximityDetectionType, transmitterchannelbytes: &[u8], sessionidbytes: &[u8], challengedatabytes: &[u8]) -> windows_core::Result> { + pub fn SendProximityDetectionStartAsync(&self, pdtype: NDProximityDetectionType, transmitterchannelbytes: &[u8], sessionidbytes: &[u8], challengedatabytes: &[u8]) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).SendProximityDetectionStartAsync)(windows_core::Interface::as_raw(this), pdtype, transmitterchannelbytes.len().try_into().unwrap(), transmitterchannelbytes.as_ptr(), sessionidbytes.len().try_into().unwrap(), sessionidbytes.as_ptr(), challengedatabytes.len().try_into().unwrap(), challengedatabytes.as_ptr(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SendProximityDetectionResponseAsync(&self, pdtype: NDProximityDetectionType, transmitterchannelbytes: &[u8], sessionidbytes: &[u8], responsedatabytes: &[u8]) -> windows_core::Result> { + pub fn SendProximityDetectionResponseAsync(&self, pdtype: NDProximityDetectionType, transmitterchannelbytes: &[u8], sessionidbytes: &[u8], responsedatabytes: &[u8]) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).SendProximityDetectionResponseAsync)(windows_core::Interface::as_raw(this), pdtype, transmitterchannelbytes.len().try_into().unwrap(), transmitterchannelbytes.as_ptr(), sessionidbytes.len().try_into().unwrap(), sessionidbytes.as_ptr(), responsedatabytes.len().try_into().unwrap(), responsedatabytes.as_ptr(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SendLicenseFetchRequestAsync(&self, sessionidbytes: &[u8], challengedatabytes: &[u8]) -> windows_core::Result> { + pub fn SendLicenseFetchRequestAsync(&self, sessionidbytes: &[u8], challengedatabytes: &[u8]) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -4146,7 +4146,7 @@ impl PlayReadyDomainJoinServiceRequest { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).SetChallengeCustomData)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(value)).ok() } } - pub fn BeginServiceRequest(&self) -> windows_core::Result { + pub fn BeginServiceRequest(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -4266,7 +4266,7 @@ impl PlayReadyDomainLeaveServiceRequest { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).SetChallengeCustomData)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(value)).ok() } } - pub fn BeginServiceRequest(&self) -> windows_core::Result { + pub fn BeginServiceRequest(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -4442,7 +4442,7 @@ impl PlayReadyIndividualizationServiceRequest { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).SetChallengeCustomData)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(value)).ok() } } - pub fn BeginServiceRequest(&self) -> windows_core::Result { + pub fn BeginServiceRequest(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -4675,7 +4675,7 @@ impl PlayReadyLicenseAcquisitionServiceRequest { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).SetChallengeCustomData)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(value)).ok() } } - pub fn BeginServiceRequest(&self) -> windows_core::Result { + pub fn BeginServiceRequest(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -4817,7 +4817,7 @@ impl windows_core::RuntimeName for PlayReadyLicenseIterator { } pub struct PlayReadyLicenseManagement; impl PlayReadyLicenseManagement { - pub fn DeleteLicenses(contentheader: P0) -> windows_core::Result + pub fn DeleteLicenses(contentheader: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -4959,7 +4959,7 @@ impl PlayReadyMeteringReportServiceRequest { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).SetChallengeCustomData)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(value)).ok() } } - pub fn BeginServiceRequest(&self) -> windows_core::Result { + pub fn BeginServiceRequest(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -5057,7 +5057,7 @@ impl PlayReadyRevocationServiceRequest { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).SetChallengeCustomData)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(value)).ok() } } - pub fn BeginServiceRequest(&self) -> windows_core::Result { + pub fn BeginServiceRequest(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -5286,7 +5286,7 @@ impl PlayReadySecureStopServiceRequest { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).SetChallengeCustomData)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(value)).ok() } } - pub fn BeginServiceRequest(&self) -> windows_core::Result { + pub fn BeginServiceRequest(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Media/Protection/mod.rs b/crates/libs/windows/src/Windows/Media/Protection/mod.rs index e896b3b0f5..755326211d 100644 --- a/crates/libs/windows/src/Windows/Media/Protection/mod.rs +++ b/crates/libs/windows/src/Windows/Media/Protection/mod.rs @@ -103,7 +103,7 @@ impl, windows_core::Ref<' } pub struct ComponentRenewal; impl ComponentRenewal { - pub fn RenewSystemComponentsAsync(information: P0) -> windows_core::Result> + pub fn RenewSystemComponentsAsync(information: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -182,7 +182,7 @@ impl HdcpSession { (windows_core::Interface::vtable(this).GetEffectiveProtection)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SetDesiredMinProtectionAsync(&self, protection: HdcpProtection) -> windows_core::Result> { + pub fn SetDesiredMinProtectionAsync(&self, protection: HdcpProtection) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Media/SpeechRecognition/mod.rs b/crates/libs/windows/src/Windows/Media/SpeechRecognition/mod.rs index 9440646076..fe2845a929 100644 --- a/crates/libs/windows/src/Windows/Media/SpeechRecognition/mod.rs +++ b/crates/libs/windows/src/Windows/Media/SpeechRecognition/mod.rs @@ -557,35 +557,35 @@ impl SpeechContinuousRecognitionSession { let this = self; unsafe { (windows_core::Interface::vtable(this).SetAutoStopSilenceTimeout)(windows_core::Interface::as_raw(this), value).ok() } } - pub fn StartAsync(&self) -> windows_core::Result { + pub fn StartAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).StartAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StartWithModeAsync(&self, mode: SpeechContinuousRecognitionMode) -> windows_core::Result { + pub fn StartWithModeAsync(&self, mode: SpeechContinuousRecognitionMode) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).StartWithModeAsync)(windows_core::Interface::as_raw(this), mode, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StopAsync(&self) -> windows_core::Result { + pub fn StopAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).StopAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CancelAsync(&self) -> windows_core::Result { + pub fn CancelAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CancelAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn PauseAsync(&self) -> windows_core::Result { + pub fn PauseAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1321,21 +1321,21 @@ impl SpeechRecognizer { (windows_core::Interface::vtable(this).UIOptions)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CompileConstraintsAsync(&self) -> windows_core::Result> { + pub fn CompileConstraintsAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CompileConstraintsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RecognizeAsync(&self) -> windows_core::Result> { + pub fn RecognizeAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RecognizeAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RecognizeWithUIAsync(&self) -> windows_core::Result> { + pub fn RecognizeWithUIAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1384,7 +1384,7 @@ impl SpeechRecognizer { (windows_core::Interface::vtable(this).State)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn StopRecognitionAsync(&self) -> windows_core::Result { + pub fn StopRecognitionAsync(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1437,7 +1437,7 @@ impl SpeechRecognizer { }) } #[cfg(feature = "Globalization")] - pub fn TrySetSystemSpeechLanguageAsync(speechlanguage: P0) -> windows_core::Result> + pub fn TrySetSystemSpeechLanguageAsync(speechlanguage: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1630,7 +1630,7 @@ unsafe impl Sync for SpeechRecognizerUIOptions {} pub struct VoiceCommandManager; impl VoiceCommandManager { #[cfg(feature = "Storage_Streams")] - pub fn InstallCommandSetsFromStorageFileAsync(file: P0) -> windows_core::Result + pub fn InstallCommandSetsFromStorageFileAsync(file: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -1672,7 +1672,7 @@ impl VoiceCommandSet { (windows_core::Interface::vtable(this).Name)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn SetPhraseListAsync(&self, phraselistname: &windows_core::HSTRING, phraselist: P1) -> windows_core::Result + pub fn SetPhraseListAsync(&self, phraselistname: &windows_core::HSTRING, phraselist: P1) -> windows_core::Result where P1: windows_core::Param>, { diff --git a/crates/libs/windows/src/Windows/Media/SpeechSynthesis/mod.rs b/crates/libs/windows/src/Windows/Media/SpeechSynthesis/mod.rs index aa0a269540..2c6195a8a3 100644 --- a/crates/libs/windows/src/Windows/Media/SpeechSynthesis/mod.rs +++ b/crates/libs/windows/src/Windows/Media/SpeechSynthesis/mod.rs @@ -154,7 +154,7 @@ impl SpeechSynthesisStream { (windows_core::Interface::vtable(this).ContentType)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn ReadAsync(&self, buffer: P0, count: u32, options: super::super::Storage::Streams::InputStreamOptions) -> windows_core::Result> + pub fn ReadAsync(&self, buffer: P0, count: u32, options: super::super::Storage::Streams::InputStreamOptions) -> windows_core::Result> where P0: windows_core::Param, { @@ -164,7 +164,7 @@ impl SpeechSynthesisStream { (windows_core::Interface::vtable(this).ReadAsync)(windows_core::Interface::as_raw(this), buffer.param().abi(), count, options, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn WriteAsync(&self, buffer: P0) -> windows_core::Result> + pub fn WriteAsync(&self, buffer: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -174,7 +174,7 @@ impl SpeechSynthesisStream { (windows_core::Interface::vtable(this).WriteAsync)(windows_core::Interface::as_raw(this), buffer.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FlushAsync(&self) -> windows_core::Result> { + pub fn FlushAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -299,7 +299,7 @@ impl SpeechSynthesizer { (windows_core::Interface::vtable(this).DefaultVoice)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn TrySetDefaultVoiceAsync(voice: P0) -> windows_core::Result> + pub fn TrySetDefaultVoiceAsync(voice: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -309,7 +309,7 @@ impl SpeechSynthesizer { }) } #[cfg(all(feature = "Media_Core", feature = "Storage_Streams"))] - pub fn SynthesizeTextToStreamAsync(&self, text: &windows_core::HSTRING) -> windows_core::Result> { + pub fn SynthesizeTextToStreamAsync(&self, text: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -317,7 +317,7 @@ impl SpeechSynthesizer { } } #[cfg(all(feature = "Media_Core", feature = "Storage_Streams"))] - pub fn SynthesizeSsmlToStreamAsync(&self, ssml: &windows_core::HSTRING) -> windows_core::Result> { + pub fn SynthesizeSsmlToStreamAsync(&self, ssml: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Media/Streaming/Adaptive/mod.rs b/crates/libs/windows/src/Windows/Media/Streaming/Adaptive/mod.rs index 399f5286a8..f4dd1bc5a5 100644 --- a/crates/libs/windows/src/Windows/Media/Streaming/Adaptive/mod.rs +++ b/crates/libs/windows/src/Windows/Media/Streaming/Adaptive/mod.rs @@ -236,7 +236,7 @@ impl AdaptiveMediaSource { (windows_core::Interface::vtable(this).IsContentTypeSupported)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(contenttype), &mut result__).map(|| result__) }) } - pub fn CreateFromUriAsync(uri: P0) -> windows_core::Result> + pub fn CreateFromUriAsync(uri: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -246,7 +246,7 @@ impl AdaptiveMediaSource { }) } #[cfg(feature = "Web_Http")] - pub fn CreateFromUriWithDownloaderAsync(uri: P0, httpclient: P1) -> windows_core::Result> + pub fn CreateFromUriWithDownloaderAsync(uri: P0, httpclient: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -257,7 +257,7 @@ impl AdaptiveMediaSource { }) } #[cfg(feature = "Storage_Streams")] - pub fn CreateFromStreamAsync(stream: P0, uri: P1, contenttype: &windows_core::HSTRING) -> windows_core::Result> + pub fn CreateFromStreamAsync(stream: P0, uri: P1, contenttype: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -268,7 +268,7 @@ impl AdaptiveMediaSource { }) } #[cfg(all(feature = "Storage_Streams", feature = "Web_Http"))] - pub fn CreateFromStreamWithDownloaderAsync(stream: P0, uri: P1, contenttype: &windows_core::HSTRING, httpclient: P3) -> windows_core::Result> + pub fn CreateFromStreamWithDownloaderAsync(stream: P0, uri: P1, contenttype: &windows_core::HSTRING, httpclient: P3) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, diff --git a/crates/libs/windows/src/Windows/Media/Transcoding/mod.rs b/crates/libs/windows/src/Windows/Media/Transcoding/mod.rs index 103fc2260e..9de09f4593 100644 --- a/crates/libs/windows/src/Windows/Media/Transcoding/mod.rs +++ b/crates/libs/windows/src/Windows/Media/Transcoding/mod.rs @@ -143,7 +143,7 @@ impl MediaTranscoder { unsafe { (windows_core::Interface::vtable(this).ClearEffects)(windows_core::Interface::as_raw(this)).ok() } } #[cfg(all(feature = "Media_MediaProperties", feature = "Storage_Streams"))] - pub fn PrepareFileTranscodeAsync(&self, source: P0, destination: P1, profile: P2) -> windows_core::Result> + pub fn PrepareFileTranscodeAsync(&self, source: P0, destination: P1, profile: P2) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -156,7 +156,7 @@ impl MediaTranscoder { } } #[cfg(all(feature = "Media_MediaProperties", feature = "Storage_Streams"))] - pub fn PrepareStreamTranscodeAsync(&self, source: P0, destination: P1, profile: P2) -> windows_core::Result> + pub fn PrepareStreamTranscodeAsync(&self, source: P0, destination: P1, profile: P2) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -169,7 +169,7 @@ impl MediaTranscoder { } } #[cfg(all(feature = "Media_Core", feature = "Media_MediaProperties", feature = "Storage_Streams"))] - pub fn PrepareMediaStreamSourceTranscodeAsync(&self, source: P0, destination: P1, profile: P2) -> windows_core::Result> + pub fn PrepareMediaStreamSourceTranscodeAsync(&self, source: P0, destination: P1, profile: P2) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -237,7 +237,7 @@ impl PrepareTranscodeResult { (windows_core::Interface::vtable(this).FailureReason)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn TranscodeAsync(&self) -> windows_core::Result> { + pub fn TranscodeAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Media/mod.rs b/crates/libs/windows/src/Windows/Media/mod.rs index 9ad990cc4e..78eb64cafa 100644 --- a/crates/libs/windows/src/Windows/Media/mod.rs +++ b/crates/libs/windows/src/Windows/Media/mod.rs @@ -2442,7 +2442,7 @@ impl SystemMediaTransportControlsDisplayUpdater { } } #[cfg(feature = "Storage_Streams")] - pub fn CopyFromFileAsync(&self, r#type: MediaPlaybackType, source: P1) -> windows_core::Result> + pub fn CopyFromFileAsync(&self, r#type: MediaPlaybackType, source: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -2746,7 +2746,7 @@ impl VideoFrame { (windows_core::Interface::vtable(this).SoftwareBitmap)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CopyToAsync(&self, frame: P0) -> windows_core::Result + pub fn CopyToAsync(&self, frame: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -2765,7 +2765,7 @@ impl VideoFrame { } } #[cfg(feature = "Graphics_Imaging")] - pub fn CopyToWithBoundsAsync(&self, frame: P0, sourcebounds: P1, destinationbounds: P2) -> windows_core::Result + pub fn CopyToWithBoundsAsync(&self, frame: P0, sourcebounds: P1, destinationbounds: P2) -> windows_core::Result where P0: windows_core::Param, P1: windows_core::Param>, diff --git a/crates/libs/windows/src/Windows/Networking/BackgroundTransfer/mod.rs b/crates/libs/windows/src/Windows/Networking/BackgroundTransfer/mod.rs index 51e5021d70..98bcc0ab47 100644 --- a/crates/libs/windows/src/Windows/Networking/BackgroundTransfer/mod.rs +++ b/crates/libs/windows/src/Windows/Networking/BackgroundTransfer/mod.rs @@ -52,7 +52,7 @@ impl BackgroundDownloader { } } #[cfg(feature = "Storage_Streams")] - pub fn CreateDownloadAsync(&self, uri: P0, resultfile: P1, requestbodystream: P2) -> windows_core::Result> + pub fn CreateDownloadAsync(&self, uri: P0, resultfile: P1, requestbodystream: P2) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -158,20 +158,20 @@ impl BackgroundDownloader { (windows_core::Interface::vtable(this).CreateWithCompletionGroup)(windows_core::Interface::as_raw(this), completiongroup.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetCurrentDownloadsAsync() -> windows_core::Result>> { + pub fn GetCurrentDownloadsAsync() -> windows_core::Result>> { Self::IBackgroundDownloaderStaticMethods(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetCurrentDownloadsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "deprecated")] - pub fn GetCurrentDownloadsForGroupAsync(group: &windows_core::HSTRING) -> windows_core::Result>> { + pub fn GetCurrentDownloadsForGroupAsync(group: &windows_core::HSTRING) -> windows_core::Result>> { Self::IBackgroundDownloaderStaticMethods(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetCurrentDownloadsForGroupAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(group), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetCurrentDownloadsForTransferGroupAsync(group: P0) -> windows_core::Result>> + pub fn GetCurrentDownloadsForTransferGroupAsync(group: P0) -> windows_core::Result>> where P0: windows_core::Param, { @@ -181,7 +181,7 @@ impl BackgroundDownloader { }) } #[cfg(feature = "deprecated")] - pub fn RequestUnconstrainedDownloadsAsync(operations: P0) -> windows_core::Result> + pub fn RequestUnconstrainedDownloadsAsync(operations: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -715,7 +715,7 @@ impl BackgroundUploader { } } #[cfg(feature = "Storage_Streams")] - pub fn CreateUploadFromStreamAsync(&self, uri: P0, sourcestream: P1) -> windows_core::Result> + pub fn CreateUploadFromStreamAsync(&self, uri: P0, sourcestream: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -726,7 +726,7 @@ impl BackgroundUploader { (windows_core::Interface::vtable(this).CreateUploadFromStreamAsync)(windows_core::Interface::as_raw(this), uri.param().abi(), sourcestream.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateUploadWithFormDataAndAutoBoundaryAsync(&self, uri: P0, parts: P1) -> windows_core::Result> + pub fn CreateUploadWithFormDataAndAutoBoundaryAsync(&self, uri: P0, parts: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param>, @@ -737,7 +737,7 @@ impl BackgroundUploader { (windows_core::Interface::vtable(this).CreateUploadWithFormDataAndAutoBoundaryAsync)(windows_core::Interface::as_raw(this), uri.param().abi(), parts.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateUploadWithSubTypeAsync(&self, uri: P0, parts: P1, subtype: &windows_core::HSTRING) -> windows_core::Result> + pub fn CreateUploadWithSubTypeAsync(&self, uri: P0, parts: P1, subtype: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param>, @@ -748,7 +748,7 @@ impl BackgroundUploader { (windows_core::Interface::vtable(this).CreateUploadWithSubTypeAsync)(windows_core::Interface::as_raw(this), uri.param().abi(), parts.param().abi(), core::mem::transmute_copy(subtype), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateUploadWithSubTypeAndBoundaryAsync(&self, uri: P0, parts: P1, subtype: &windows_core::HSTRING, boundary: &windows_core::HSTRING) -> windows_core::Result> + pub fn CreateUploadWithSubTypeAndBoundaryAsync(&self, uri: P0, parts: P1, subtype: &windows_core::HSTRING, boundary: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param>, @@ -853,20 +853,20 @@ impl BackgroundUploader { (windows_core::Interface::vtable(this).CreateWithCompletionGroup)(windows_core::Interface::as_raw(this), completiongroup.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetCurrentUploadsAsync() -> windows_core::Result>> { + pub fn GetCurrentUploadsAsync() -> windows_core::Result>> { Self::IBackgroundUploaderStaticMethods(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetCurrentUploadsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "deprecated")] - pub fn GetCurrentUploadsForGroupAsync(group: &windows_core::HSTRING) -> windows_core::Result>> { + pub fn GetCurrentUploadsForGroupAsync(group: &windows_core::HSTRING) -> windows_core::Result>> { Self::IBackgroundUploaderStaticMethods(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetCurrentUploadsForGroupAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(group), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetCurrentUploadsForTransferGroupAsync(group: P0) -> windows_core::Result>> + pub fn GetCurrentUploadsForTransferGroupAsync(group: P0) -> windows_core::Result>> where P0: windows_core::Param, { @@ -876,7 +876,7 @@ impl BackgroundUploader { }) } #[cfg(feature = "deprecated")] - pub fn RequestUnconstrainedUploadsAsync(operations: P0) -> windows_core::Result> + pub fn RequestUnconstrainedUploadsAsync(operations: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -1040,14 +1040,14 @@ impl DownloadOperation { (windows_core::Interface::vtable(this).Progress)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn StartAsync(&self) -> windows_core::Result> { + pub fn StartAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).StartAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn AttachAsync(&self) -> windows_core::Result> { + pub fn AttachAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2382,14 +2382,14 @@ impl UploadOperation { (windows_core::Interface::vtable(this).Progress)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn StartAsync(&self) -> windows_core::Result> { + pub fn StartAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).StartAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn AttachAsync(&self) -> windows_core::Result> { + pub fn AttachAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Networking/Connectivity/mod.rs b/crates/libs/windows/src/Windows/Networking/Connectivity/mod.rs index 53c91786e7..ab9a6368eb 100644 --- a/crates/libs/windows/src/Windows/Networking/Connectivity/mod.rs +++ b/crates/libs/windows/src/Windows/Networking/Connectivity/mod.rs @@ -341,28 +341,28 @@ impl ConnectionProfile { (windows_core::Interface::vtable(this).GetDomainConnectivityLevel)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn GetNetworkUsageAsync(&self, starttime: super::super::Foundation::DateTime, endtime: super::super::Foundation::DateTime, granularity: DataUsageGranularity, states: NetworkUsageStates) -> windows_core::Result>> { + pub fn GetNetworkUsageAsync(&self, starttime: super::super::Foundation::DateTime, endtime: super::super::Foundation::DateTime, granularity: DataUsageGranularity, states: NetworkUsageStates) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetNetworkUsageAsync)(windows_core::Interface::as_raw(this), starttime, endtime, granularity, states, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetConnectivityIntervalsAsync(&self, starttime: super::super::Foundation::DateTime, endtime: super::super::Foundation::DateTime, states: NetworkUsageStates) -> windows_core::Result>> { + pub fn GetConnectivityIntervalsAsync(&self, starttime: super::super::Foundation::DateTime, endtime: super::super::Foundation::DateTime, states: NetworkUsageStates) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetConnectivityIntervalsAsync)(windows_core::Interface::as_raw(this), starttime, endtime, states, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAttributedNetworkUsageAsync(&self, starttime: super::super::Foundation::DateTime, endtime: super::super::Foundation::DateTime, states: NetworkUsageStates) -> windows_core::Result>> { + pub fn GetAttributedNetworkUsageAsync(&self, starttime: super::super::Foundation::DateTime, endtime: super::super::Foundation::DateTime, states: NetworkUsageStates) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetAttributedNetworkUsageAsync)(windows_core::Interface::as_raw(this), starttime, endtime, states, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetProviderNetworkUsageAsync(&self, starttime: super::super::Foundation::DateTime, endtime: super::super::Foundation::DateTime, states: NetworkUsageStates) -> windows_core::Result>> { + pub fn GetProviderNetworkUsageAsync(&self, starttime: super::super::Foundation::DateTime, endtime: super::super::Foundation::DateTime, states: NetworkUsageStates) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -376,7 +376,7 @@ impl ConnectionProfile { (windows_core::Interface::vtable(this).CanDelete)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn TryDeleteAsync(&self) -> windows_core::Result> { + pub fn TryDeleteAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -629,7 +629,7 @@ unsafe impl Send for ConnectivityInterval {} unsafe impl Sync for ConnectivityInterval {} pub struct ConnectivityManager; impl ConnectivityManager { - pub fn AcquireConnectionAsync(cellularapncontext: P0) -> windows_core::Result> + pub fn AcquireConnectionAsync(cellularapncontext: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1430,7 +1430,7 @@ impl NetworkAdapter { (windows_core::Interface::vtable(this).NetworkAdapterId)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn GetConnectedProfileAsync(&self) -> windows_core::Result> { + pub fn GetConnectedProfileAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1555,7 +1555,7 @@ impl NetworkInformation { (windows_core::Interface::vtable(this).GetHostNames)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetProxyConfigurationAsync(uri: P0) -> windows_core::Result> + pub fn GetProxyConfigurationAsync(uri: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1585,7 +1585,7 @@ impl NetworkInformation { pub fn RemoveNetworkStatusChanged(eventcookie: i64) -> windows_core::Result<()> { Self::INetworkInformationStatics(|this| unsafe { (windows_core::Interface::vtable(this).RemoveNetworkStatusChanged)(windows_core::Interface::as_raw(this), eventcookie).ok() }) } - pub fn FindConnectionProfilesAsync(pprofilefilter: P0) -> windows_core::Result>> + pub fn FindConnectionProfilesAsync(pprofilefilter: P0) -> windows_core::Result>> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Networking/NetworkOperators/mod.rs b/crates/libs/windows/src/Windows/Networking/NetworkOperators/mod.rs index 553130be89..d1920f08c8 100644 --- a/crates/libs/windows/src/Windows/Networking/NetworkOperators/mod.rs +++ b/crates/libs/windows/src/Windows/Networking/NetworkOperators/mod.rs @@ -113,21 +113,21 @@ impl ESim { (windows_core::Interface::vtable(this).GetProfiles)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteProfileAsync(&self, profileid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn DeleteProfileAsync(&self, profileid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeleteProfileAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(profileid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DownloadProfileMetadataAsync(&self, activationcode: &windows_core::HSTRING) -> windows_core::Result> { + pub fn DownloadProfileMetadataAsync(&self, activationcode: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DownloadProfileMetadataAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(activationcode), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ResetAsync(&self) -> windows_core::Result> { + pub fn ResetAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -162,14 +162,14 @@ impl ESim { (windows_core::Interface::vtable(this).DiscoverWithServerAddressAndMatchingId)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(serveraddress), core::mem::transmute_copy(matchingid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DiscoverAsync(&self) -> windows_core::Result> { + pub fn DiscoverAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DiscoverAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DiscoverWithServerAddressAndMatchingIdAsync(&self, serveraddress: &windows_core::HSTRING, matchingid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn DiscoverWithServerAddressAndMatchingIdAsync(&self, serveraddress: &windows_core::HSTRING, matchingid: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -545,21 +545,21 @@ impl ESimProfile { (windows_core::Interface::vtable(this).State)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn DisableAsync(&self) -> windows_core::Result> { + pub fn DisableAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DisableAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn EnableAsync(&self) -> windows_core::Result> { + pub fn EnableAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).EnableAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SetNicknameAsync(&self, newnickname: &windows_core::HSTRING) -> windows_core::Result> { + pub fn SetNicknameAsync(&self, newnickname: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -660,28 +660,28 @@ impl ESimProfileMetadata { (windows_core::Interface::vtable(this).State)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn DenyInstallAsync(&self) -> windows_core::Result> { + pub fn DenyInstallAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DenyInstallAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ConfirmInstallAsync(&self) -> windows_core::Result> { + pub fn ConfirmInstallAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ConfirmInstallAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ConfirmInstallWithConfirmationCodeAsync(&self, confirmationcode: &windows_core::HSTRING) -> windows_core::Result> { + pub fn ConfirmInstallWithConfirmationCodeAsync(&self, confirmationcode: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ConfirmInstallWithConfirmationCodeAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(confirmationcode), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn PostponeInstallAsync(&self) -> windows_core::Result> { + pub fn PostponeInstallAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1006,7 +1006,7 @@ impl windows_core::RuntimeType for ESimWatcherStatus { } pub struct FdnAccessManager; impl FdnAccessManager { - pub fn RequestUnlockAsync(contactlistid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn RequestUnlockAsync(contactlistid: &windows_core::HSTRING) -> windows_core::Result> { Self::IFdnAccessManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestUnlockAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(contactlistid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -1078,7 +1078,7 @@ impl HotspotAuthenticationContext { let this = self; unsafe { (windows_core::Interface::vtable(this).TriggerAttentionRequired)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(packagerelativeapplicationid), core::mem::transmute_copy(applicationparameters)).ok() } } - pub fn IssueCredentialsAsync(&self, username: &windows_core::HSTRING, password: &windows_core::HSTRING, extraparameters: &windows_core::HSTRING, markasmanualconnectonfailure: bool) -> windows_core::Result> { + pub fn IssueCredentialsAsync(&self, username: &windows_core::HSTRING, password: &windows_core::HSTRING, extraparameters: &windows_core::HSTRING, markasmanualconnectonfailure: bool) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -3963,7 +3963,7 @@ pub struct MobileBroadbandDeviceServiceCommandSession(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(MobileBroadbandDeviceServiceCommandSession, windows_core::IUnknown, windows_core::IInspectable); impl MobileBroadbandDeviceServiceCommandSession { #[cfg(feature = "Storage_Streams")] - pub fn SendQueryCommandAsync(&self, commandid: u32, data: P1) -> windows_core::Result> + pub fn SendQueryCommandAsync(&self, commandid: u32, data: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -3974,7 +3974,7 @@ impl MobileBroadbandDeviceServiceCommandSession { } } #[cfg(feature = "Storage_Streams")] - pub fn SendSetCommandAsync(&self, commandid: u32, data: P1) -> windows_core::Result> + pub fn SendSetCommandAsync(&self, commandid: u32, data: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -4047,7 +4047,7 @@ pub struct MobileBroadbandDeviceServiceDataSession(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(MobileBroadbandDeviceServiceDataSession, windows_core::IUnknown, windows_core::IInspectable); impl MobileBroadbandDeviceServiceDataSession { #[cfg(feature = "Storage_Streams")] - pub fn WriteDataAsync(&self, value: P0) -> windows_core::Result + pub fn WriteDataAsync(&self, value: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -4243,14 +4243,14 @@ impl MobileBroadbandModem { (windows_core::Interface::vtable(this).IsResetSupported)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn ResetAsync(&self) -> windows_core::Result { + pub fn ResetAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ResetAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetCurrentConfigurationAsync(&self) -> windows_core::Result> { + pub fn GetCurrentConfigurationAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -4264,21 +4264,21 @@ impl MobileBroadbandModem { (windows_core::Interface::vtable(this).CurrentNetwork)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetIsPassthroughEnabledAsync(&self) -> windows_core::Result> { + pub fn GetIsPassthroughEnabledAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetIsPassthroughEnabledAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SetIsPassthroughEnabledAsync(&self, value: bool) -> windows_core::Result> { + pub fn SetIsPassthroughEnabledAsync(&self, value: bool) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).SetIsPassthroughEnabledAsync)(windows_core::Interface::as_raw(this), value, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryGetPcoAsync(&self) -> windows_core::Result> { + pub fn TryGetPcoAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -4306,14 +4306,14 @@ impl MobileBroadbandModem { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).RemoveIsInEmergencyCallModeChanged)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn SetIsPassthroughEnabledWithSlotIndexAsync(&self, value: bool, slotindex: i32) -> windows_core::Result> { + pub fn SetIsPassthroughEnabledWithSlotIndexAsync(&self, value: bool, slotindex: i32) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).SetIsPassthroughEnabledWithSlotIndexAsync)(windows_core::Interface::as_raw(this), value, slotindex, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetIsPassthroughEnabledWithSlotIndexAsync(&self, slotindex: i32) -> windows_core::Result> { + pub fn GetIsPassthroughEnabledWithSlotIndexAsync(&self, slotindex: i32) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -4433,14 +4433,14 @@ impl MobileBroadbandModemIsolation { let this = self; unsafe { (windows_core::Interface::vtable(this).AddAllowedHostRange)(windows_core::Interface::as_raw(this), first.param().abi(), last.param().abi()).ok() } } - pub fn ApplyConfigurationAsync(&self) -> windows_core::Result { + pub fn ApplyConfigurationAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ApplyConfigurationAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ClearConfigurationAsync(&self) -> windows_core::Result { + pub fn ClearConfigurationAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -4558,7 +4558,7 @@ impl MobileBroadbandNetwork { let this = self; unsafe { (windows_core::Interface::vtable(this).ShowConnectionUI)(windows_core::Interface::as_raw(this)).ok() } } - pub fn GetVoiceCallSupportAsync(&self) -> windows_core::Result> { + pub fn GetVoiceCallSupportAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -4572,7 +4572,7 @@ impl MobileBroadbandNetwork { (windows_core::Interface::vtable(this).RegistrationUiccApps)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetCellsInfoAsync(&self) -> windows_core::Result> { + pub fn GetCellsInfoAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -4766,35 +4766,35 @@ impl MobileBroadbandPin { (windows_core::Interface::vtable(this).AttemptsRemaining)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn EnableAsync(&self, currentpin: &windows_core::HSTRING) -> windows_core::Result> { + pub fn EnableAsync(&self, currentpin: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).EnableAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(currentpin), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DisableAsync(&self, currentpin: &windows_core::HSTRING) -> windows_core::Result> { + pub fn DisableAsync(&self, currentpin: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DisableAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(currentpin), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn EnterAsync(&self, currentpin: &windows_core::HSTRING) -> windows_core::Result> { + pub fn EnterAsync(&self, currentpin: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).EnterAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(currentpin), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ChangeAsync(&self, currentpin: &windows_core::HSTRING, newpin: &windows_core::HSTRING) -> windows_core::Result> { + pub fn ChangeAsync(&self, currentpin: &windows_core::HSTRING, newpin: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ChangeAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(currentpin), core::mem::transmute_copy(newpin), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn UnblockAsync(&self, pinunblockkey: &windows_core::HSTRING, newpin: &windows_core::HSTRING) -> windows_core::Result> { + pub fn UnblockAsync(&self, pinunblockkey: &windows_core::HSTRING, newpin: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -5117,21 +5117,21 @@ impl MobileBroadbandSarManager { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveTransmissionStateChanged)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn EnableBackoffAsync(&self) -> windows_core::Result { + pub fn EnableBackoffAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).EnableBackoffAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DisableBackoffAsync(&self) -> windows_core::Result { + pub fn DisableBackoffAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DisableBackoffAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SetConfigurationAsync(&self, antennas: P0) -> windows_core::Result + pub fn SetConfigurationAsync(&self, antennas: P0) -> windows_core::Result where P0: windows_core::Param>, { @@ -5141,21 +5141,21 @@ impl MobileBroadbandSarManager { (windows_core::Interface::vtable(this).SetConfigurationAsync)(windows_core::Interface::as_raw(this), antennas.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RevertSarToHardwareControlAsync(&self) -> windows_core::Result { + pub fn RevertSarToHardwareControlAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RevertSarToHardwareControlAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SetTransmissionStateChangedHysteresisAsync(&self, timerperiod: super::super::Foundation::TimeSpan) -> windows_core::Result { + pub fn SetTransmissionStateChangedHysteresisAsync(&self, timerperiod: super::super::Foundation::TimeSpan) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).SetTransmissionStateChangedHysteresisAsync)(windows_core::Interface::as_raw(this), timerperiod, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetIsTransmittingAsync(&self) -> windows_core::Result> { + pub fn GetIsTransmittingAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -5273,7 +5273,7 @@ impl MobileBroadbandSlotManager { (windows_core::Interface::vtable(this).SetCurrentSlot)(windows_core::Interface::as_raw(this), slotindex, &mut result__).map(|| result__) } } - pub fn SetCurrentSlotAsync(&self, slotindex: i32) -> windows_core::Result> { + pub fn SetCurrentSlotAsync(&self, slotindex: i32) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -5379,7 +5379,7 @@ impl MobileBroadbandUicc { (windows_core::Interface::vtable(this).SimIccId)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn GetUiccAppsAsync(&self) -> windows_core::Result> { + pub fn GetUiccAppsAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -5419,7 +5419,7 @@ impl MobileBroadbandUiccApp { (windows_core::Interface::vtable(this).Kind)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn GetRecordDetailsAsync(&self, uiccfilepath: P0) -> windows_core::Result> + pub fn GetRecordDetailsAsync(&self, uiccfilepath: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -5429,7 +5429,7 @@ impl MobileBroadbandUiccApp { (windows_core::Interface::vtable(this).GetRecordDetailsAsync)(windows_core::Interface::as_raw(this), uiccfilepath.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReadRecordAsync(&self, uiccfilepath: P0, recordindex: i32) -> windows_core::Result> + pub fn ReadRecordAsync(&self, uiccfilepath: P0, recordindex: i32) -> windows_core::Result> where P0: windows_core::Param>, { @@ -5778,7 +5778,7 @@ impl NetworkOperatorTetheringAccessPointConfiguration { (windows_core::Interface::vtable(this).IsBandSupported)(windows_core::Interface::as_raw(this), band, &mut result__).map(|| result__) } } - pub fn IsBandSupportedAsync(&self, band: TetheringWiFiBand) -> windows_core::Result> { + pub fn IsBandSupportedAsync(&self, band: TetheringWiFiBand) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -5803,7 +5803,7 @@ impl NetworkOperatorTetheringAccessPointConfiguration { (windows_core::Interface::vtable(this).IsAuthenticationKindSupported)(windows_core::Interface::as_raw(this), authenticationkind, &mut result__).map(|| result__) } } - pub fn IsAuthenticationKindSupportedAsync(&self, authenticationkind: TetheringWiFiAuthenticationKind) -> windows_core::Result> { + pub fn IsAuthenticationKindSupportedAsync(&self, authenticationkind: TetheringWiFiAuthenticationKind) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -5906,7 +5906,7 @@ impl NetworkOperatorTetheringManager { (windows_core::Interface::vtable(this).GetCurrentAccessPointConfiguration)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ConfigureAccessPointAsync(&self, configuration: P0) -> windows_core::Result + pub fn ConfigureAccessPointAsync(&self, configuration: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -5916,21 +5916,21 @@ impl NetworkOperatorTetheringManager { (windows_core::Interface::vtable(this).ConfigureAccessPointAsync)(windows_core::Interface::as_raw(this), configuration.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StartTetheringAsync(&self) -> windows_core::Result> { + pub fn StartTetheringAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).StartTetheringAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StopTetheringAsync(&self) -> windows_core::Result> { + pub fn StopTetheringAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).StopTetheringAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StartTetheringAsync2(&self, configuration: P0) -> windows_core::Result> + pub fn StartTetheringAsync2(&self, configuration: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -5992,7 +5992,7 @@ impl NetworkOperatorTetheringManager { pub fn EnableNoConnectionsTimeout() -> windows_core::Result<()> { Self::INetworkOperatorTetheringManagerStatics4(|this| unsafe { (windows_core::Interface::vtable(this).EnableNoConnectionsTimeout)(windows_core::Interface::as_raw(this)).ok() }) } - pub fn EnableNoConnectionsTimeoutAsync() -> windows_core::Result { + pub fn EnableNoConnectionsTimeoutAsync() -> windows_core::Result { Self::INetworkOperatorTetheringManagerStatics4(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).EnableNoConnectionsTimeoutAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -6001,7 +6001,7 @@ impl NetworkOperatorTetheringManager { pub fn DisableNoConnectionsTimeout() -> windows_core::Result<()> { Self::INetworkOperatorTetheringManagerStatics4(|this| unsafe { (windows_core::Interface::vtable(this).DisableNoConnectionsTimeout)(windows_core::Interface::as_raw(this)).ok() }) } - pub fn DisableNoConnectionsTimeoutAsync() -> windows_core::Result { + pub fn DisableNoConnectionsTimeoutAsync() -> windows_core::Result { Self::INetworkOperatorTetheringManagerStatics4(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DisableNoConnectionsTimeoutAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -6105,7 +6105,7 @@ impl NetworkOperatorTetheringSessionAccessPointConfiguration { (windows_core::Interface::vtable(this).IsBandSupported)(windows_core::Interface::as_raw(this), band, &mut result__).map(|| result__) } } - pub fn IsBandSupportedAsync(&self, band: TetheringWiFiBand) -> windows_core::Result> { + pub fn IsBandSupportedAsync(&self, band: TetheringWiFiBand) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -6130,7 +6130,7 @@ impl NetworkOperatorTetheringSessionAccessPointConfiguration { (windows_core::Interface::vtable(this).IsAuthenticationKindSupported)(windows_core::Interface::as_raw(this), authenticationkind, &mut result__).map(|| result__) } } - pub fn IsAuthenticationKindSupportedAsync(&self, authenticationkind: TetheringWiFiAuthenticationKind) -> windows_core::Result> { + pub fn IsAuthenticationKindSupportedAsync(&self, authenticationkind: TetheringWiFiAuthenticationKind) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -6282,7 +6282,7 @@ impl ProvisioningAgent { static SHARED: windows_core::imp::FactoryCache = windows_core::imp::FactoryCache::new(); SHARED.call(callback) } - pub fn ProvisionFromXmlDocumentAsync(&self, provisioningxmldocument: &windows_core::HSTRING) -> windows_core::Result> { + pub fn ProvisionFromXmlDocumentAsync(&self, provisioningxmldocument: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -6613,7 +6613,7 @@ impl windows_core::RuntimeType for UssdResultCode { pub struct UssdSession(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(UssdSession, windows_core::IUnknown, windows_core::IInspectable); impl UssdSession { - pub fn SendMessageAndGetReplyAsync(&self, message: P0) -> windows_core::Result> + pub fn SendMessageAndGetReplyAsync(&self, message: P0) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Networking/Proximity/mod.rs b/crates/libs/windows/src/Windows/Networking/Proximity/mod.rs index ff2f9882ae..d5c12815e2 100644 --- a/crates/libs/windows/src/Windows/Networking/Proximity/mod.rs +++ b/crates/libs/windows/src/Windows/Networking/Proximity/mod.rs @@ -607,14 +607,14 @@ impl PeerFinder { pub fn RemoveConnectionRequested(cookie: i64) -> windows_core::Result<()> { Self::IPeerFinderStatics(|this| unsafe { (windows_core::Interface::vtable(this).RemoveConnectionRequested)(windows_core::Interface::as_raw(this), cookie).ok() }) } - pub fn FindAllPeersAsync() -> windows_core::Result>> { + pub fn FindAllPeersAsync() -> windows_core::Result>> { Self::IPeerFinderStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAllPeersAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "Networking_Sockets")] - pub fn ConnectAsync(peerinformation: P0) -> windows_core::Result> + pub fn ConnectAsync(peerinformation: P0) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Networking/PushNotifications/mod.rs b/crates/libs/windows/src/Windows/Networking/PushNotifications/mod.rs index e25a74a10d..f9d93bdf64 100644 --- a/crates/libs/windows/src/Windows/Networking/PushNotifications/mod.rs +++ b/crates/libs/windows/src/Windows/Networking/PushNotifications/mod.rs @@ -199,19 +199,19 @@ unsafe impl Send for PushNotificationChannel {} unsafe impl Sync for PushNotificationChannel {} pub struct PushNotificationChannelManager; impl PushNotificationChannelManager { - pub fn CreatePushNotificationChannelForApplicationAsync() -> windows_core::Result> { + pub fn CreatePushNotificationChannelForApplicationAsync() -> windows_core::Result> { Self::IPushNotificationChannelManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreatePushNotificationChannelForApplicationAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn CreatePushNotificationChannelForApplicationAsyncWithId(applicationid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CreatePushNotificationChannelForApplicationAsyncWithId(applicationid: &windows_core::HSTRING) -> windows_core::Result> { Self::IPushNotificationChannelManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreatePushNotificationChannelForApplicationAsyncWithId)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(applicationid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn CreatePushNotificationChannelForSecondaryTileAsync(tileid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CreatePushNotificationChannelForSecondaryTileAsync(tileid: &windows_core::HSTRING) -> windows_core::Result> { Self::IPushNotificationChannelManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreatePushNotificationChannelForSecondaryTileAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(tileid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -270,21 +270,21 @@ impl windows_core::RuntimeName for PushNotificationChannelManager { pub struct PushNotificationChannelManagerForUser(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(PushNotificationChannelManagerForUser, windows_core::IUnknown, windows_core::IInspectable); impl PushNotificationChannelManagerForUser { - pub fn CreatePushNotificationChannelForApplicationAsync(&self) -> windows_core::Result> { + pub fn CreatePushNotificationChannelForApplicationAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreatePushNotificationChannelForApplicationAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreatePushNotificationChannelForApplicationAsyncWithId(&self, applicationid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CreatePushNotificationChannelForApplicationAsyncWithId(&self, applicationid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreatePushNotificationChannelForApplicationAsyncWithId)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(applicationid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreatePushNotificationChannelForSecondaryTileAsync(&self, tileid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CreatePushNotificationChannelForSecondaryTileAsync(&self, tileid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -300,7 +300,7 @@ impl PushNotificationChannelManagerForUser { } } #[cfg(feature = "Storage_Streams")] - pub fn CreateRawPushNotificationChannelWithAlternateKeyForApplicationAsync(&self, appserverkey: P0, channelid: &windows_core::HSTRING) -> windows_core::Result> + pub fn CreateRawPushNotificationChannelWithAlternateKeyForApplicationAsync(&self, appserverkey: P0, channelid: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -311,7 +311,7 @@ impl PushNotificationChannelManagerForUser { } } #[cfg(feature = "Storage_Streams")] - pub fn CreateRawPushNotificationChannelWithAlternateKeyForApplicationAsyncWithId(&self, appserverkey: P0, channelid: &windows_core::HSTRING, appid: &windows_core::HSTRING) -> windows_core::Result> + pub fn CreateRawPushNotificationChannelWithAlternateKeyForApplicationAsyncWithId(&self, appserverkey: P0, channelid: &windows_core::HSTRING, appid: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Networking/ServiceDiscovery/Dnssd/mod.rs b/crates/libs/windows/src/Windows/Networking/ServiceDiscovery/Dnssd/mod.rs index d2520a28b7..634385d3ae 100644 --- a/crates/libs/windows/src/Windows/Networking/ServiceDiscovery/Dnssd/mod.rs +++ b/crates/libs/windows/src/Windows/Networking/ServiceDiscovery/Dnssd/mod.rs @@ -139,7 +139,7 @@ impl DnssdServiceInstance { } } #[cfg(feature = "Networking_Sockets")] - pub fn RegisterStreamSocketListenerAsync(&self, socket: P0) -> windows_core::Result> + pub fn RegisterStreamSocketListenerAsync(&self, socket: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -150,7 +150,7 @@ impl DnssdServiceInstance { } } #[cfg(all(feature = "Networking_Connectivity", feature = "Networking_Sockets"))] - pub fn RegisterStreamSocketListenerAsync2(&self, socket: P0, adapter: P1) -> windows_core::Result> + pub fn RegisterStreamSocketListenerAsync2(&self, socket: P0, adapter: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -162,7 +162,7 @@ impl DnssdServiceInstance { } } #[cfg(feature = "Networking_Sockets")] - pub fn RegisterDatagramSocketAsync(&self, socket: P0) -> windows_core::Result> + pub fn RegisterDatagramSocketAsync(&self, socket: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -173,7 +173,7 @@ impl DnssdServiceInstance { } } #[cfg(all(feature = "Networking_Connectivity", feature = "Networking_Sockets"))] - pub fn RegisterDatagramSocketAsync2(&self, socket: P0, adapter: P1) -> windows_core::Result> + pub fn RegisterDatagramSocketAsync2(&self, socket: P0, adapter: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, diff --git a/crates/libs/windows/src/Windows/Networking/Sockets/mod.rs b/crates/libs/windows/src/Windows/Networking/Sockets/mod.rs index 75e39176b4..e8df1f8625 100644 --- a/crates/libs/windows/src/Windows/Networking/Sockets/mod.rs +++ b/crates/libs/windows/src/Windows/Networking/Sockets/mod.rs @@ -215,7 +215,7 @@ impl DatagramSocket { (windows_core::Interface::vtable(this).OutputStream)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ConnectAsync(&self, remotehostname: P0, remoteservicename: &windows_core::HSTRING) -> windows_core::Result + pub fn ConnectAsync(&self, remotehostname: P0, remoteservicename: &windows_core::HSTRING) -> windows_core::Result where P0: windows_core::Param, { @@ -225,7 +225,7 @@ impl DatagramSocket { (windows_core::Interface::vtable(this).ConnectAsync)(windows_core::Interface::as_raw(this), remotehostname.param().abi(), core::mem::transmute_copy(remoteservicename), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ConnectWithEndpointPairAsync(&self, endpointpair: P0) -> windows_core::Result + pub fn ConnectWithEndpointPairAsync(&self, endpointpair: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -235,14 +235,14 @@ impl DatagramSocket { (windows_core::Interface::vtable(this).ConnectWithEndpointPairAsync)(windows_core::Interface::as_raw(this), endpointpair.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn BindServiceNameAsync(&self, localservicename: &windows_core::HSTRING) -> windows_core::Result { + pub fn BindServiceNameAsync(&self, localservicename: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).BindServiceNameAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(localservicename), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn BindEndpointAsync(&self, localhostname: P0, localservicename: &windows_core::HSTRING) -> windows_core::Result + pub fn BindEndpointAsync(&self, localhostname: P0, localservicename: &windows_core::HSTRING) -> windows_core::Result where P0: windows_core::Param, { @@ -260,7 +260,7 @@ impl DatagramSocket { unsafe { (windows_core::Interface::vtable(this).JoinMulticastGroup)(windows_core::Interface::as_raw(this), host.param().abi()).ok() } } #[cfg(feature = "Storage_Streams")] - pub fn GetOutputStreamAsync(&self, remotehostname: P0, remoteservicename: &windows_core::HSTRING) -> windows_core::Result> + pub fn GetOutputStreamAsync(&self, remotehostname: P0, remoteservicename: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -271,7 +271,7 @@ impl DatagramSocket { } } #[cfg(feature = "Storage_Streams")] - pub fn GetOutputStreamWithEndpointPairAsync(&self, endpointpair: P0) -> windows_core::Result> + pub fn GetOutputStreamWithEndpointPairAsync(&self, endpointpair: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -296,7 +296,7 @@ impl DatagramSocket { unsafe { (windows_core::Interface::vtable(this).RemoveMessageReceived)(windows_core::Interface::as_raw(this), eventcookie).ok() } } #[cfg(feature = "Networking_Connectivity")] - pub fn BindServiceNameAndAdapterAsync(&self, localservicename: &windows_core::HSTRING, adapter: P1) -> windows_core::Result + pub fn BindServiceNameAndAdapterAsync(&self, localservicename: &windows_core::HSTRING, adapter: P1) -> windows_core::Result where P1: windows_core::Param, { @@ -306,7 +306,7 @@ impl DatagramSocket { (windows_core::Interface::vtable(this).BindServiceNameAndAdapterAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(localservicename), adapter.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CancelIOAsync(&self) -> windows_core::Result { + pub fn CancelIOAsync(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -339,7 +339,7 @@ impl DatagramSocket { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).TransferOwnershipWithContextAndKeepAliveTime)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(socketid), data.param().abi(), keepalivetime).ok() } } - pub fn GetEndpointPairsAsync(remotehostname: P0, remoteservicename: &windows_core::HSTRING) -> windows_core::Result>> + pub fn GetEndpointPairsAsync(remotehostname: P0, remoteservicename: &windows_core::HSTRING) -> windows_core::Result>> where P0: windows_core::Param, { @@ -348,7 +348,7 @@ impl DatagramSocket { (windows_core::Interface::vtable(this).GetEndpointPairsAsync)(windows_core::Interface::as_raw(this), remotehostname.param().abi(), core::mem::transmute_copy(remoteservicename), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetEndpointPairsWithSortOptionsAsync(remotehostname: P0, remoteservicename: &windows_core::HSTRING, sortoptions: super::HostNameSortOptions) -> windows_core::Result>> + pub fn GetEndpointPairsWithSortOptionsAsync(remotehostname: P0, remoteservicename: &windows_core::HSTRING, sortoptions: super::HostNameSortOptions) -> windows_core::Result>> where P0: windows_core::Param, { @@ -1409,7 +1409,7 @@ impl IWebSocket { (windows_core::Interface::vtable(this).OutputStream)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ConnectAsync(&self, uri: P0) -> windows_core::Result + pub fn ConnectAsync(&self, uri: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -1453,7 +1453,7 @@ impl windows_core::RuntimeName for IWebSocket { #[cfg(feature = "Storage_Streams")] pub trait IWebSocket_Impl: super::super::Foundation::IClosable_Impl { fn OutputStream(&self) -> windows_core::Result; - fn ConnectAsync(&self, uri: windows_core::Ref<'_, super::super::Foundation::Uri>) -> windows_core::Result; + fn ConnectAsync(&self, uri: windows_core::Ref<'_, super::super::Foundation::Uri>) -> windows_core::Result; fn SetRequestHeader(&self, headerName: &windows_core::HSTRING, headerValue: &windows_core::HSTRING) -> windows_core::Result<()>; fn Closed(&self, eventHandler: windows_core::Ref<'_, super::super::Foundation::TypedEventHandler>) -> windows_core::Result; fn RemoveClosed(&self, eventCookie: i64) -> windows_core::Result<()>; @@ -2186,7 +2186,7 @@ impl MessageWebSocket { unsafe { (windows_core::Interface::vtable(this).RemoveServerCustomValidationRequested)(windows_core::Interface::as_raw(this), eventcookie).ok() } } #[cfg(feature = "Storage_Streams")] - pub fn SendNonfinalFrameAsync(&self, data: P0) -> windows_core::Result> + pub fn SendNonfinalFrameAsync(&self, data: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2197,7 +2197,7 @@ impl MessageWebSocket { } } #[cfg(feature = "Storage_Streams")] - pub fn SendFinalFrameAsync(&self, data: P0) -> windows_core::Result> + pub fn SendFinalFrameAsync(&self, data: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2215,7 +2215,7 @@ impl MessageWebSocket { (windows_core::Interface::vtable(this).OutputStream)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ConnectAsync(&self, uri: P0) -> windows_core::Result + pub fn ConnectAsync(&self, uri: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -3158,7 +3158,7 @@ impl StreamSocket { (windows_core::Interface::vtable(this).OutputStream)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ConnectWithEndpointPairAsync(&self, endpointpair: P0) -> windows_core::Result + pub fn ConnectWithEndpointPairAsync(&self, endpointpair: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -3168,7 +3168,7 @@ impl StreamSocket { (windows_core::Interface::vtable(this).ConnectWithEndpointPairAsync)(windows_core::Interface::as_raw(this), endpointpair.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ConnectAsync(&self, remotehostname: P0, remoteservicename: &windows_core::HSTRING) -> windows_core::Result + pub fn ConnectAsync(&self, remotehostname: P0, remoteservicename: &windows_core::HSTRING) -> windows_core::Result where P0: windows_core::Param, { @@ -3178,7 +3178,7 @@ impl StreamSocket { (windows_core::Interface::vtable(this).ConnectAsync)(windows_core::Interface::as_raw(this), remotehostname.param().abi(), core::mem::transmute_copy(remoteservicename), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ConnectWithEndpointPairAndProtectionLevelAsync(&self, endpointpair: P0, protectionlevel: SocketProtectionLevel) -> windows_core::Result + pub fn ConnectWithEndpointPairAndProtectionLevelAsync(&self, endpointpair: P0, protectionlevel: SocketProtectionLevel) -> windows_core::Result where P0: windows_core::Param, { @@ -3188,7 +3188,7 @@ impl StreamSocket { (windows_core::Interface::vtable(this).ConnectWithEndpointPairAndProtectionLevelAsync)(windows_core::Interface::as_raw(this), endpointpair.param().abi(), protectionlevel, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ConnectWithProtectionLevelAsync(&self, remotehostname: P0, remoteservicename: &windows_core::HSTRING, protectionlevel: SocketProtectionLevel) -> windows_core::Result + pub fn ConnectWithProtectionLevelAsync(&self, remotehostname: P0, remoteservicename: &windows_core::HSTRING, protectionlevel: SocketProtectionLevel) -> windows_core::Result where P0: windows_core::Param, { @@ -3198,7 +3198,7 @@ impl StreamSocket { (windows_core::Interface::vtable(this).ConnectWithProtectionLevelAsync)(windows_core::Interface::as_raw(this), remotehostname.param().abi(), core::mem::transmute_copy(remoteservicename), protectionlevel, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn UpgradeToSslAsync(&self, protectionlevel: SocketProtectionLevel, validationhostname: P1) -> windows_core::Result + pub fn UpgradeToSslAsync(&self, protectionlevel: SocketProtectionLevel, validationhostname: P1) -> windows_core::Result where P1: windows_core::Param, { @@ -3209,7 +3209,7 @@ impl StreamSocket { } } #[cfg(feature = "Networking_Connectivity")] - pub fn ConnectWithProtectionLevelAndAdapterAsync(&self, remotehostname: P0, remoteservicename: &windows_core::HSTRING, protectionlevel: SocketProtectionLevel, adapter: P3) -> windows_core::Result + pub fn ConnectWithProtectionLevelAndAdapterAsync(&self, remotehostname: P0, remoteservicename: &windows_core::HSTRING, protectionlevel: SocketProtectionLevel, adapter: P3) -> windows_core::Result where P0: windows_core::Param, P3: windows_core::Param, @@ -3220,7 +3220,7 @@ impl StreamSocket { (windows_core::Interface::vtable(this).ConnectWithProtectionLevelAndAdapterAsync)(windows_core::Interface::as_raw(this), remotehostname.param().abi(), core::mem::transmute_copy(remoteservicename), protectionlevel, adapter.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CancelIOAsync(&self) -> windows_core::Result { + pub fn CancelIOAsync(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -3253,7 +3253,7 @@ impl StreamSocket { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).TransferOwnershipWithContextAndKeepAliveTime)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(socketid), data.param().abi(), keepalivetime).ok() } } - pub fn GetEndpointPairsAsync(remotehostname: P0, remoteservicename: &windows_core::HSTRING) -> windows_core::Result>> + pub fn GetEndpointPairsAsync(remotehostname: P0, remoteservicename: &windows_core::HSTRING) -> windows_core::Result>> where P0: windows_core::Param, { @@ -3262,7 +3262,7 @@ impl StreamSocket { (windows_core::Interface::vtable(this).GetEndpointPairsAsync)(windows_core::Interface::as_raw(this), remotehostname.param().abi(), core::mem::transmute_copy(remoteservicename), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetEndpointPairsWithSortOptionsAsync(remotehostname: P0, remoteservicename: &windows_core::HSTRING, sortoptions: super::HostNameSortOptions) -> windows_core::Result>> + pub fn GetEndpointPairsWithSortOptionsAsync(remotehostname: P0, remoteservicename: &windows_core::HSTRING, sortoptions: super::HostNameSortOptions) -> windows_core::Result>> where P0: windows_core::Param, { @@ -3558,14 +3558,14 @@ impl StreamSocketListener { (windows_core::Interface::vtable(this).Information)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn BindServiceNameAsync(&self, localservicename: &windows_core::HSTRING) -> windows_core::Result { + pub fn BindServiceNameAsync(&self, localservicename: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).BindServiceNameAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(localservicename), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn BindEndpointAsync(&self, localhostname: P0, localservicename: &windows_core::HSTRING) -> windows_core::Result + pub fn BindEndpointAsync(&self, localhostname: P0, localservicename: &windows_core::HSTRING) -> windows_core::Result where P0: windows_core::Param, { @@ -3589,7 +3589,7 @@ impl StreamSocketListener { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveConnectionReceived)(windows_core::Interface::as_raw(this), eventcookie).ok() } } - pub fn BindServiceNameWithProtectionLevelAsync(&self, localservicename: &windows_core::HSTRING, protectionlevel: SocketProtectionLevel) -> windows_core::Result { + pub fn BindServiceNameWithProtectionLevelAsync(&self, localservicename: &windows_core::HSTRING, protectionlevel: SocketProtectionLevel) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -3597,7 +3597,7 @@ impl StreamSocketListener { } } #[cfg(feature = "Networking_Connectivity")] - pub fn BindServiceNameWithProtectionLevelAndAdapterAsync(&self, localservicename: &windows_core::HSTRING, protectionlevel: SocketProtectionLevel, adapter: P2) -> windows_core::Result + pub fn BindServiceNameWithProtectionLevelAndAdapterAsync(&self, localservicename: &windows_core::HSTRING, protectionlevel: SocketProtectionLevel, adapter: P2) -> windows_core::Result where P2: windows_core::Param, { @@ -3607,7 +3607,7 @@ impl StreamSocketListener { (windows_core::Interface::vtable(this).BindServiceNameWithProtectionLevelAndAdapterAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(localservicename), protectionlevel, adapter.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CancelIOAsync(&self) -> windows_core::Result { + pub fn CancelIOAsync(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -3830,7 +3830,7 @@ impl StreamWebSocket { (windows_core::Interface::vtable(this).OutputStream)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ConnectAsync(&self, uri: P0) -> windows_core::Result + pub fn ConnectAsync(&self, uri: P0) -> windows_core::Result where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Networking/Vpn/mod.rs b/crates/libs/windows/src/Windows/Networking/Vpn/mod.rs index 0283f27d52..2417e53f8c 100644 --- a/crates/libs/windows/src/Windows/Networking/Vpn/mod.rs +++ b/crates/libs/windows/src/Windows/Networking/Vpn/mod.rs @@ -1895,7 +1895,7 @@ impl VpnChannel { (windows_core::Interface::vtable(this).GetVpnReceivePacketBuffer)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestCustomPromptAsync(&self, custompromptelement: P0) -> windows_core::Result + pub fn RequestCustomPromptAsync(&self, custompromptelement: P0) -> windows_core::Result where P0: windows_core::Param>, { @@ -1906,7 +1906,7 @@ impl VpnChannel { } } #[cfg(feature = "Security_Cryptography_Certificates")] - pub fn RequestCredentialsWithCertificateAsync(&self, credtype: VpnCredentialType, credoptions: u32, certificate: P2) -> windows_core::Result> + pub fn RequestCredentialsWithCertificateAsync(&self, credtype: VpnCredentialType, credoptions: u32, certificate: P2) -> windows_core::Result> where P2: windows_core::Param, { @@ -1916,14 +1916,14 @@ impl VpnChannel { (windows_core::Interface::vtable(this).RequestCredentialsWithCertificateAsync)(windows_core::Interface::as_raw(this), credtype, credoptions, certificate.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestCredentialsWithOptionsAsync(&self, credtype: VpnCredentialType, credoptions: u32) -> windows_core::Result> { + pub fn RequestCredentialsWithOptionsAsync(&self, credtype: VpnCredentialType, credoptions: u32) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestCredentialsWithOptionsAsync)(windows_core::Interface::as_raw(this), credtype, credoptions, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestCredentialsSimpleAsync(&self, credtype: VpnCredentialType) -> windows_core::Result> { + pub fn RequestCredentialsSimpleAsync(&self, credtype: VpnCredentialType) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -3285,14 +3285,14 @@ impl VpnManagementAgent { static SHARED: windows_core::imp::FactoryCache = windows_core::imp::FactoryCache::new(); SHARED.call(callback) } - pub fn AddProfileFromXmlAsync(&self, xml: &windows_core::HSTRING) -> windows_core::Result> { + pub fn AddProfileFromXmlAsync(&self, xml: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).AddProfileFromXmlAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(xml), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn AddProfileFromObjectAsync(&self, profile: P0) -> windows_core::Result> + pub fn AddProfileFromObjectAsync(&self, profile: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -3302,14 +3302,14 @@ impl VpnManagementAgent { (windows_core::Interface::vtable(this).AddProfileFromObjectAsync)(windows_core::Interface::as_raw(this), profile.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn UpdateProfileFromXmlAsync(&self, xml: &windows_core::HSTRING) -> windows_core::Result> { + pub fn UpdateProfileFromXmlAsync(&self, xml: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).UpdateProfileFromXmlAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(xml), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn UpdateProfileFromObjectAsync(&self, profile: P0) -> windows_core::Result> + pub fn UpdateProfileFromObjectAsync(&self, profile: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -3319,14 +3319,14 @@ impl VpnManagementAgent { (windows_core::Interface::vtable(this).UpdateProfileFromObjectAsync)(windows_core::Interface::as_raw(this), profile.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetProfilesAsync(&self) -> windows_core::Result>> { + pub fn GetProfilesAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetProfilesAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteProfileAsync(&self, profile: P0) -> windows_core::Result> + pub fn DeleteProfileAsync(&self, profile: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -3336,7 +3336,7 @@ impl VpnManagementAgent { (windows_core::Interface::vtable(this).DeleteProfileAsync)(windows_core::Interface::as_raw(this), profile.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ConnectProfileAsync(&self, profile: P0) -> windows_core::Result> + pub fn ConnectProfileAsync(&self, profile: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -3347,7 +3347,7 @@ impl VpnManagementAgent { } } #[cfg(feature = "Security_Credentials")] - pub fn ConnectProfileWithPasswordCredentialAsync(&self, profile: P0, passwordcredential: P1) -> windows_core::Result> + pub fn ConnectProfileWithPasswordCredentialAsync(&self, profile: P0, passwordcredential: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -3358,7 +3358,7 @@ impl VpnManagementAgent { (windows_core::Interface::vtable(this).ConnectProfileWithPasswordCredentialAsync)(windows_core::Interface::as_raw(this), profile.param().abi(), passwordcredential.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DisconnectProfileAsync(&self, profile: P0) -> windows_core::Result> + pub fn DisconnectProfileAsync(&self, profile: P0) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Networking/XboxLive/mod.rs b/crates/libs/windows/src/Windows/Networking/XboxLive/mod.rs index 4a833e1969..7f471ab33b 100644 --- a/crates/libs/windows/src/Windows/Networking/XboxLive/mod.rs +++ b/crates/libs/windows/src/Windows/Networking/XboxLive/mod.rs @@ -340,7 +340,7 @@ impl XboxLiveEndpointPair { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveStateChanged)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn DeleteAsync(&self) -> windows_core::Result { + pub fn DeleteAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -618,7 +618,7 @@ impl XboxLiveEndpointPairTemplate { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveInboundEndpointPairCreated)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn CreateEndpointPairDefaultAsync(&self, deviceaddress: P0) -> windows_core::Result> + pub fn CreateEndpointPairDefaultAsync(&self, deviceaddress: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -628,7 +628,7 @@ impl XboxLiveEndpointPairTemplate { (windows_core::Interface::vtable(this).CreateEndpointPairDefaultAsync)(windows_core::Interface::as_raw(this), deviceaddress.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateEndpointPairWithBehaviorsAsync(&self, deviceaddress: P0, behaviors: XboxLiveEndpointPairCreationBehaviors) -> windows_core::Result> + pub fn CreateEndpointPairWithBehaviorsAsync(&self, deviceaddress: P0, behaviors: XboxLiveEndpointPairCreationBehaviors) -> windows_core::Result> where P0: windows_core::Param, { @@ -638,7 +638,7 @@ impl XboxLiveEndpointPairTemplate { (windows_core::Interface::vtable(this).CreateEndpointPairWithBehaviorsAsync)(windows_core::Interface::as_raw(this), deviceaddress.param().abi(), behaviors, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateEndpointPairForPortsDefaultAsync(&self, deviceaddress: P0, initiatorport: &windows_core::HSTRING, acceptorport: &windows_core::HSTRING) -> windows_core::Result> + pub fn CreateEndpointPairForPortsDefaultAsync(&self, deviceaddress: P0, initiatorport: &windows_core::HSTRING, acceptorport: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -648,7 +648,7 @@ impl XboxLiveEndpointPairTemplate { (windows_core::Interface::vtable(this).CreateEndpointPairForPortsDefaultAsync)(windows_core::Interface::as_raw(this), deviceaddress.param().abi(), core::mem::transmute_copy(initiatorport), core::mem::transmute_copy(acceptorport), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateEndpointPairForPortsWithBehaviorsAsync(&self, deviceaddress: P0, initiatorport: &windows_core::HSTRING, acceptorport: &windows_core::HSTRING, behaviors: XboxLiveEndpointPairCreationBehaviors) -> windows_core::Result> + pub fn CreateEndpointPairForPortsWithBehaviorsAsync(&self, deviceaddress: P0, initiatorport: &windows_core::HSTRING, acceptorport: &windows_core::HSTRING, behaviors: XboxLiveEndpointPairCreationBehaviors) -> windows_core::Result> where P0: windows_core::Param, { @@ -787,7 +787,7 @@ impl XboxLiveQualityOfServiceMeasurement { static SHARED: windows_core::imp::FactoryCache = windows_core::imp::FactoryCache::new(); SHARED.call(callback) } - pub fn MeasureAsync(&self) -> windows_core::Result { + pub fn MeasureAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Perception/People/mod.rs b/crates/libs/windows/src/Windows/Perception/People/mod.rs index a70c1754d1..693bba451e 100644 --- a/crates/libs/windows/src/Windows/Perception/People/mod.rs +++ b/crates/libs/windows/src/Windows/Perception/People/mod.rs @@ -32,7 +32,7 @@ impl EyesPose { }) } #[cfg(feature = "UI_Input")] - pub fn RequestAccessAsync() -> windows_core::Result> { + pub fn RequestAccessAsync() -> windows_core::Result> { Self::IEyesPoseStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestAccessAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/Perception/Spatial/Surfaces/mod.rs b/crates/libs/windows/src/Windows/Perception/Spatial/Surfaces/mod.rs index c4037e53cb..fbd3f8565b 100644 --- a/crates/libs/windows/src/Windows/Perception/Spatial/Surfaces/mod.rs +++ b/crates/libs/windows/src/Windows/Perception/Spatial/Surfaces/mod.rs @@ -161,14 +161,14 @@ impl SpatialSurfaceInfo { (windows_core::Interface::vtable(this).TryGetBounds)(windows_core::Interface::as_raw(this), coordinatesystem.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryComputeLatestMeshAsync(&self, maxtrianglespercubicmeter: f64) -> windows_core::Result> { + pub fn TryComputeLatestMeshAsync(&self, maxtrianglespercubicmeter: f64) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryComputeLatestMeshAsync)(windows_core::Interface::as_raw(this), maxtrianglespercubicmeter, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryComputeLatestMeshWithOptionsAsync(&self, maxtrianglespercubicmeter: f64, options: P1) -> windows_core::Result> + pub fn TryComputeLatestMeshWithOptionsAsync(&self, maxtrianglespercubicmeter: f64, options: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -446,7 +446,7 @@ impl SpatialSurfaceObserver { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveObservedSurfacesChanged)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn RequestAccessAsync() -> windows_core::Result> { + pub fn RequestAccessAsync() -> windows_core::Result> { Self::ISpatialSurfaceObserverStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestAccessAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/Perception/Spatial/mod.rs b/crates/libs/windows/src/Windows/Perception/Spatial/mod.rs index a20c620902..68b14c9682 100644 --- a/crates/libs/windows/src/Windows/Perception/Spatial/mod.rs +++ b/crates/libs/windows/src/Windows/Perception/Spatial/mod.rs @@ -536,7 +536,7 @@ unsafe impl Sync for SpatialAnchorExportSufficiency {} pub struct SpatialAnchorExporter(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(SpatialAnchorExporter, windows_core::IUnknown, windows_core::IInspectable); impl SpatialAnchorExporter { - pub fn GetAnchorExportSufficiencyAsync(&self, anchor: P0, purpose: SpatialAnchorExportPurpose) -> windows_core::Result> + pub fn GetAnchorExportSufficiencyAsync(&self, anchor: P0, purpose: SpatialAnchorExportPurpose) -> windows_core::Result> where P0: windows_core::Param, { @@ -547,7 +547,7 @@ impl SpatialAnchorExporter { } } #[cfg(feature = "Storage_Streams")] - pub fn TryExportAnchorAsync(&self, anchor: P0, purpose: SpatialAnchorExportPurpose, stream: P2) -> windows_core::Result> + pub fn TryExportAnchorAsync(&self, anchor: P0, purpose: SpatialAnchorExportPurpose, stream: P2) -> windows_core::Result> where P0: windows_core::Param, P2: windows_core::Param, @@ -564,7 +564,7 @@ impl SpatialAnchorExporter { (windows_core::Interface::vtable(this).GetDefault)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RequestAccessAsync() -> windows_core::Result> { + pub fn RequestAccessAsync() -> windows_core::Result> { Self::ISpatialAnchorExporterStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestAccessAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -589,7 +589,7 @@ unsafe impl Send for SpatialAnchorExporter {} unsafe impl Sync for SpatialAnchorExporter {} pub struct SpatialAnchorManager; impl SpatialAnchorManager { - pub fn RequestStoreAsync() -> windows_core::Result> { + pub fn RequestStoreAsync() -> windows_core::Result> { Self::ISpatialAnchorManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestStoreAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -676,7 +676,7 @@ pub struct SpatialAnchorTransferManager; #[cfg(feature = "deprecated")] impl SpatialAnchorTransferManager { #[cfg(feature = "Storage_Streams")] - pub fn TryImportAnchorsAsync(stream: P0) -> windows_core::Result>> + pub fn TryImportAnchorsAsync(stream: P0) -> windows_core::Result>> where P0: windows_core::Param, { @@ -686,7 +686,7 @@ impl SpatialAnchorTransferManager { }) } #[cfg(feature = "Storage_Streams")] - pub fn TryExportAnchorsAsync(anchors: P0, stream: P1) -> windows_core::Result> + pub fn TryExportAnchorsAsync(anchors: P0, stream: P1) -> windows_core::Result> where P0: windows_core::Param>>, P1: windows_core::Param, @@ -696,7 +696,7 @@ impl SpatialAnchorTransferManager { (windows_core::Interface::vtable(this).TryExportAnchorsAsync)(windows_core::Interface::as_raw(this), anchors.param().abi(), stream.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RequestAccessAsync() -> windows_core::Result> { + pub fn RequestAccessAsync() -> windows_core::Result> { Self::ISpatialAnchorTransferManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestAccessAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -971,7 +971,7 @@ unsafe impl Sync for SpatialEntityRemovedEventArgs {} pub struct SpatialEntityStore(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(SpatialEntityStore, windows_core::IUnknown, windows_core::IInspectable); impl SpatialEntityStore { - pub fn SaveAsync(&self, entity: P0) -> windows_core::Result + pub fn SaveAsync(&self, entity: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -981,7 +981,7 @@ impl SpatialEntityStore { (windows_core::Interface::vtable(this).SaveAsync)(windows_core::Interface::as_raw(this), entity.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RemoveAsync(&self, entity: P0) -> windows_core::Result + pub fn RemoveAsync(&self, entity: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -1601,7 +1601,7 @@ impl SpatialStageFrameOfReference { pub fn RemoveCurrentChanged(cookie: i64) -> windows_core::Result<()> { Self::ISpatialStageFrameOfReferenceStatics(|this| unsafe { (windows_core::Interface::vtable(this).RemoveCurrentChanged)(windows_core::Interface::as_raw(this), cookie).ok() }) } - pub fn RequestNewStageAsync() -> windows_core::Result> { + pub fn RequestNewStageAsync() -> windows_core::Result> { Self::ISpatialStageFrameOfReferenceStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestNewStageAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/Phone/Management/Deployment/mod.rs b/crates/libs/windows/src/Windows/Phone/Management/Deployment/mod.rs index 479c705371..d299be3f63 100644 --- a/crates/libs/windows/src/Windows/Phone/Management/Deployment/mod.rs +++ b/crates/libs/windows/src/Windows/Phone/Management/Deployment/mod.rs @@ -72,19 +72,19 @@ impl EnterpriseEnrollmentManager { (windows_core::Interface::vtable(this).CurrentEnterprise)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn ValidateEnterprisesAsync() -> windows_core::Result { + pub fn ValidateEnterprisesAsync() -> windows_core::Result { Self::IEnterpriseEnrollmentManager(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ValidateEnterprisesAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RequestEnrollmentAsync(enrollmenttoken: &windows_core::HSTRING) -> windows_core::Result> { + pub fn RequestEnrollmentAsync(enrollmenttoken: &windows_core::HSTRING) -> windows_core::Result> { Self::IEnterpriseEnrollmentManager(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestEnrollmentAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(enrollmenttoken), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RequestUnenrollmentAsync(enterprise: P0) -> windows_core::Result> + pub fn RequestUnenrollmentAsync(enterprise: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -260,7 +260,7 @@ pub struct IPackageInstallResult2_Vtbl { } pub struct InstallationManager; impl InstallationManager { - pub fn AddPackageAsync(title: &windows_core::HSTRING, sourcelocation: P1) -> windows_core::Result> + pub fn AddPackageAsync(title: &windows_core::HSTRING, sourcelocation: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -269,7 +269,7 @@ impl InstallationManager { (windows_core::Interface::vtable(this).AddPackageAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(title), sourcelocation.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn AddPackagePreloadedAsync(title: &windows_core::HSTRING, sourcelocation: P1, instanceid: &windows_core::HSTRING, offerid: &windows_core::HSTRING, license: P4) -> windows_core::Result> + pub fn AddPackagePreloadedAsync(title: &windows_core::HSTRING, sourcelocation: P1, instanceid: &windows_core::HSTRING, offerid: &windows_core::HSTRING, license: P4) -> windows_core::Result> where P1: windows_core::Param, P4: windows_core::Param, @@ -279,7 +279,7 @@ impl InstallationManager { (windows_core::Interface::vtable(this).AddPackagePreloadedAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(title), sourcelocation.param().abi(), core::mem::transmute_copy(instanceid), core::mem::transmute_copy(offerid), license.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetPendingPackageInstalls() -> windows_core::Result>> { + pub fn GetPendingPackageInstalls() -> windows_core::Result>> { Self::IInstallationManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetPendingPackageInstalls)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -300,14 +300,14 @@ impl InstallationManager { }) } #[cfg(feature = "Management_Deployment")] - pub fn RemovePackageAsync(packagefullname: &windows_core::HSTRING, removaloptions: super::super::super::Management::Deployment::RemovalOptions) -> windows_core::Result> { + pub fn RemovePackageAsync(packagefullname: &windows_core::HSTRING, removaloptions: super::super::super::Management::Deployment::RemovalOptions) -> windows_core::Result> { Self::IInstallationManagerStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RemovePackageAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(packagefullname), removaloptions, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "Management_Deployment")] - pub fn RegisterPackageAsync(manifesturi: P0, dependencypackageuris: P1, deploymentoptions: super::super::super::Management::Deployment::DeploymentOptions) -> windows_core::Result> + pub fn RegisterPackageAsync(manifesturi: P0, dependencypackageuris: P1, deploymentoptions: super::super::super::Management::Deployment::DeploymentOptions) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param>, diff --git a/crates/libs/windows/src/Windows/Phone/PersonalInformation/Provisioning/mod.rs b/crates/libs/windows/src/Windows/Phone/PersonalInformation/Provisioning/mod.rs index 26fab355f9..64eeec9907 100644 --- a/crates/libs/windows/src/Windows/Phone/PersonalInformation/Provisioning/mod.rs +++ b/crates/libs/windows/src/Windows/Phone/PersonalInformation/Provisioning/mod.rs @@ -1,6 +1,6 @@ pub struct ContactPartnerProvisioningManager; impl ContactPartnerProvisioningManager { - pub fn AssociateNetworkAccountAsync(store: P0, networkname: &windows_core::HSTRING, networkaccountid: &windows_core::HSTRING) -> windows_core::Result + pub fn AssociateNetworkAccountAsync(store: P0, networkname: &windows_core::HSTRING, networkaccountid: &windows_core::HSTRING) -> windows_core::Result where P0: windows_core::Param, { @@ -10,7 +10,7 @@ impl ContactPartnerProvisioningManager { }) } #[cfg(feature = "Storage_Streams")] - pub fn ImportVcardToSystemAsync(stream: P0) -> windows_core::Result + pub fn ImportVcardToSystemAsync(stream: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -19,7 +19,7 @@ impl ContactPartnerProvisioningManager { (windows_core::Interface::vtable(this).ImportVcardToSystemAsync)(windows_core::Interface::as_raw(this), stream.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn AssociateSocialNetworkAccountAsync(store: P0, networkname: &windows_core::HSTRING, networkaccountid: &windows_core::HSTRING) -> windows_core::Result + pub fn AssociateSocialNetworkAccountAsync(store: P0, networkname: &windows_core::HSTRING, networkaccountid: &windows_core::HSTRING) -> windows_core::Result where P0: windows_core::Param, { @@ -74,7 +74,7 @@ pub struct IMessagePartnerProvisioningManagerStatics_Vtbl { } pub struct MessagePartnerProvisioningManager; impl MessagePartnerProvisioningManager { - pub fn ImportSmsToSystemAsync(incoming: bool, read: bool, body: &windows_core::HSTRING, sender: &windows_core::HSTRING, recipients: P4, deliverytime: super::super::super::Foundation::DateTime) -> windows_core::Result + pub fn ImportSmsToSystemAsync(incoming: bool, read: bool, body: &windows_core::HSTRING, sender: &windows_core::HSTRING, recipients: P4, deliverytime: super::super::super::Foundation::DateTime) -> windows_core::Result where P4: windows_core::Param>, { @@ -83,7 +83,7 @@ impl MessagePartnerProvisioningManager { (windows_core::Interface::vtable(this).ImportSmsToSystemAsync)(windows_core::Interface::as_raw(this), incoming, read, core::mem::transmute_copy(body), core::mem::transmute_copy(sender), recipients.param().abi(), deliverytime, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn ImportMmsToSystemAsync(incoming: bool, read: bool, subject: &windows_core::HSTRING, sender: &windows_core::HSTRING, recipients: P4, deliverytime: super::super::super::Foundation::DateTime, attachments: P6) -> windows_core::Result + pub fn ImportMmsToSystemAsync(incoming: bool, read: bool, subject: &windows_core::HSTRING, sender: &windows_core::HSTRING, recipients: P4, deliverytime: super::super::super::Foundation::DateTime, attachments: P6) -> windows_core::Result where P4: windows_core::Param>, P6: windows_core::Param>>, diff --git a/crates/libs/windows/src/Windows/Phone/PersonalInformation/mod.rs b/crates/libs/windows/src/Windows/Phone/PersonalInformation/mod.rs index 4aa7104dff..78c72a77d3 100644 --- a/crates/libs/windows/src/Windows/Phone/PersonalInformation/mod.rs +++ b/crates/libs/windows/src/Windows/Phone/PersonalInformation/mod.rs @@ -208,7 +208,7 @@ impl ContactInformation { unsafe { (windows_core::Interface::vtable(this).SetHonorificSuffix)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(value)).ok() } } #[cfg(feature = "Storage_Streams")] - pub fn GetDisplayPictureAsync(&self) -> windows_core::Result> { + pub fn GetDisplayPictureAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -216,7 +216,7 @@ impl ContactInformation { } } #[cfg(feature = "Storage_Streams")] - pub fn SetDisplayPictureAsync(&self, stream: P0) -> windows_core::Result + pub fn SetDisplayPictureAsync(&self, stream: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -234,7 +234,7 @@ impl ContactInformation { (windows_core::Interface::vtable(this).DisplayPicture)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetPropertiesAsync(&self) -> windows_core::Result>> { + pub fn GetPropertiesAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -242,7 +242,7 @@ impl ContactInformation { } } #[cfg(feature = "Storage_Streams")] - pub fn ToVcardAsync(&self) -> windows_core::Result> { + pub fn ToVcardAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -250,7 +250,7 @@ impl ContactInformation { } } #[cfg(feature = "Storage_Streams")] - pub fn ToVcardWithOptionsAsync(&self, format: VCardFormat) -> windows_core::Result> { + pub fn ToVcardWithOptionsAsync(&self, format: VCardFormat) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -258,7 +258,7 @@ impl ContactInformation { } } #[cfg(feature = "Storage_Streams")] - pub fn ParseVcardAsync(vcard: P0) -> windows_core::Result> + pub fn ParseVcardAsync(vcard: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -332,21 +332,21 @@ unsafe impl Sync for ContactQueryOptions {} pub struct ContactQueryResult(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(ContactQueryResult, windows_core::IUnknown, windows_core::IInspectable); impl ContactQueryResult { - pub fn GetContactCountAsync(&self) -> windows_core::Result> { + pub fn GetContactCountAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetContactCountAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetContactsAsync(&self) -> windows_core::Result>> { + pub fn GetContactsAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetContactsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetContactsAsyncInRange(&self, startindex: u32, maxnumberofitems: u32) -> windows_core::Result>> { + pub fn GetContactsAsyncInRange(&self, startindex: u32, maxnumberofitems: u32) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -392,21 +392,21 @@ impl windows_core::RuntimeType for ContactQueryResultOrdering { pub struct ContactStore(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(ContactStore, windows_core::IUnknown, windows_core::IInspectable); impl ContactStore { - pub fn FindContactByRemoteIdAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FindContactByRemoteIdAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindContactByRemoteIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(id), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FindContactByIdAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FindContactByIdAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindContactByIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(id), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteContactAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result { + pub fn DeleteContactAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -430,7 +430,7 @@ impl ContactStore { (windows_core::Interface::vtable(this).CreateContactQueryWithOptions)(windows_core::Interface::as_raw(this), options.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAsync(&self) -> windows_core::Result { + pub fn DeleteAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -444,21 +444,21 @@ impl ContactStore { (windows_core::Interface::vtable(this).RevisionNumber)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn GetChangesAsync(&self, baserevisionnumber: u64) -> windows_core::Result>> { + pub fn GetChangesAsync(&self, baserevisionnumber: u64) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetChangesAsync)(windows_core::Interface::as_raw(this), baserevisionnumber, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn LoadExtendedPropertiesAsync(&self) -> windows_core::Result>> { + pub fn LoadExtendedPropertiesAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).LoadExtendedPropertiesAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SaveExtendedPropertiesAsync(&self, data: P0) -> windows_core::Result + pub fn SaveExtendedPropertiesAsync(&self, data: P0) -> windows_core::Result where P0: windows_core::Param>, { @@ -468,20 +468,20 @@ impl ContactStore { (windows_core::Interface::vtable(this).SaveExtendedPropertiesAsync)(windows_core::Interface::as_raw(this), data.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateMeContactAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CreateMeContactAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreateMeContactAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(id), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateOrOpenAsync() -> windows_core::Result> { + pub fn CreateOrOpenAsync() -> windows_core::Result> { Self::IContactStoreStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreateOrOpenAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn CreateOrOpenWithOptionsAsync(access: ContactStoreSystemAccessMode, sharing: ContactStoreApplicationAccessMode) -> windows_core::Result> { + pub fn CreateOrOpenWithOptionsAsync(access: ContactStoreSystemAccessMode, sharing: ContactStoreApplicationAccessMode) -> windows_core::Result> { Self::IContactStoreStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreateOrOpenWithOptionsAsync)(windows_core::Interface::as_raw(this), access, sharing, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -622,7 +622,7 @@ impl IContactInformation { unsafe { (windows_core::Interface::vtable(this).SetHonorificSuffix)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(value)).ok() } } #[cfg(feature = "Storage_Streams")] - pub fn GetDisplayPictureAsync(&self) -> windows_core::Result> { + pub fn GetDisplayPictureAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -630,7 +630,7 @@ impl IContactInformation { } } #[cfg(feature = "Storage_Streams")] - pub fn SetDisplayPictureAsync(&self, stream: P0) -> windows_core::Result + pub fn SetDisplayPictureAsync(&self, stream: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -648,7 +648,7 @@ impl IContactInformation { (windows_core::Interface::vtable(this).DisplayPicture)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetPropertiesAsync(&self) -> windows_core::Result>> { + pub fn GetPropertiesAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -656,7 +656,7 @@ impl IContactInformation { } } #[cfg(feature = "Storage_Streams")] - pub fn ToVcardAsync(&self) -> windows_core::Result> { + pub fn ToVcardAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -664,7 +664,7 @@ impl IContactInformation { } } #[cfg(feature = "Storage_Streams")] - pub fn ToVcardWithOptionsAsync(&self, format: VCardFormat) -> windows_core::Result> { + pub fn ToVcardWithOptionsAsync(&self, format: VCardFormat) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -688,12 +688,12 @@ pub trait IContactInformation_Impl: windows_core::IUnknownImpl { fn SetHonorificPrefix(&self, value: &windows_core::HSTRING) -> windows_core::Result<()>; fn HonorificSuffix(&self) -> windows_core::Result; fn SetHonorificSuffix(&self, value: &windows_core::HSTRING) -> windows_core::Result<()>; - fn GetDisplayPictureAsync(&self) -> windows_core::Result>; - fn SetDisplayPictureAsync(&self, stream: windows_core::Ref<'_, super::super::Storage::Streams::IInputStream>) -> windows_core::Result; + fn GetDisplayPictureAsync(&self) -> windows_core::Result>; + fn SetDisplayPictureAsync(&self, stream: windows_core::Ref<'_, super::super::Storage::Streams::IInputStream>) -> windows_core::Result; fn DisplayPicture(&self) -> windows_core::Result; - fn GetPropertiesAsync(&self) -> windows_core::Result>>; - fn ToVcardAsync(&self) -> windows_core::Result>; - fn ToVcardWithOptionsAsync(&self, format: VCardFormat) -> windows_core::Result>; + fn GetPropertiesAsync(&self) -> windows_core::Result>>; + fn ToVcardAsync(&self) -> windows_core::Result>; + fn ToVcardWithOptionsAsync(&self, format: VCardFormat) -> windows_core::Result>; } #[cfg(feature = "Storage_Streams")] impl IContactInformation_Vtbl { @@ -1413,7 +1413,7 @@ impl StoredContact { unsafe { (windows_core::Interface::vtable(this).SetHonorificSuffix)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(value)).ok() } } #[cfg(feature = "Storage_Streams")] - pub fn GetDisplayPictureAsync(&self) -> windows_core::Result> { + pub fn GetDisplayPictureAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1421,7 +1421,7 @@ impl StoredContact { } } #[cfg(feature = "Storage_Streams")] - pub fn SetDisplayPictureAsync(&self, stream: P0) -> windows_core::Result + pub fn SetDisplayPictureAsync(&self, stream: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -1439,7 +1439,7 @@ impl StoredContact { (windows_core::Interface::vtable(this).DisplayPicture)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetPropertiesAsync(&self) -> windows_core::Result>> { + pub fn GetPropertiesAsync(&self) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1447,7 +1447,7 @@ impl StoredContact { } } #[cfg(feature = "Storage_Streams")] - pub fn ToVcardAsync(&self) -> windows_core::Result> { + pub fn ToVcardAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1455,7 +1455,7 @@ impl StoredContact { } } #[cfg(feature = "Storage_Streams")] - pub fn ToVcardWithOptionsAsync(&self, format: VCardFormat) -> windows_core::Result> { + pub fn ToVcardWithOptionsAsync(&self, format: VCardFormat) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1498,21 +1498,21 @@ impl StoredContact { let this = self; unsafe { (windows_core::Interface::vtable(this).SetRemoteId)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(value)).ok() } } - pub fn GetExtendedPropertiesAsync(&self) -> windows_core::Result>> { + pub fn GetExtendedPropertiesAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetExtendedPropertiesAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SaveAsync(&self) -> windows_core::Result { + pub fn SaveAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).SaveAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReplaceExistingContactAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result { + pub fn ReplaceExistingContactAsync(&self, id: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Phone/StartScreen/mod.rs b/crates/libs/windows/src/Windows/Phone/StartScreen/mod.rs index ea997b4aa7..0f2e8b1871 100644 --- a/crates/libs/windows/src/Windows/Phone/StartScreen/mod.rs +++ b/crates/libs/windows/src/Windows/Phone/StartScreen/mod.rs @@ -28,21 +28,21 @@ impl DualSimTile { (windows_core::Interface::vtable(this).IsPinnedToStart)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn CreateAsync(&self) -> windows_core::Result> { + pub fn CreateAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreateAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn UpdateAsync(&self) -> windows_core::Result> { + pub fn UpdateAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).UpdateAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAsync(&self) -> windows_core::Result> { + pub fn DeleteAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -55,7 +55,7 @@ impl DualSimTile { (windows_core::Interface::vtable(this).GetTileForSim2)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn UpdateDisplayNameForSim1Async(name: &windows_core::HSTRING) -> windows_core::Result> { + pub fn UpdateDisplayNameForSim1Async(name: &windows_core::HSTRING) -> windows_core::Result> { Self::IDualSimTileStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).UpdateDisplayNameForSim1Async)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(name), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/Phone/System/UserProfile/GameServices/Core/mod.rs b/crates/libs/windows/src/Windows/Phone/System/UserProfile/GameServices/Core/mod.rs index 73034d5510..9829bfd331 100644 --- a/crates/libs/windows/src/Windows/Phone/System/UserProfile/GameServices/Core/mod.rs +++ b/crates/libs/windows/src/Windows/Phone/System/UserProfile/GameServices/Core/mod.rs @@ -6,19 +6,19 @@ impl GameService { (windows_core::Interface::vtable(this).ServiceUri)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetGamerProfileAsync() -> windows_core::Result> { + pub fn GetGamerProfileAsync() -> windows_core::Result> { Self::IGameService(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetGamerProfileAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetInstalledGameItemsAsync() -> windows_core::Result> { + pub fn GetInstalledGameItemsAsync() -> windows_core::Result> { Self::IGameService(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetInstalledGameItemsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetPartnerTokenAsync(audienceuri: P0) -> windows_core::Result> + pub fn GetPartnerTokenAsync(audienceuri: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -27,7 +27,7 @@ impl GameService { (windows_core::Interface::vtable(this).GetPartnerTokenAsync)(windows_core::Interface::as_raw(this), audienceuri.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetPrivilegesAsync() -> windows_core::Result> { + pub fn GetPrivilegesAsync() -> windows_core::Result> { Self::IGameService(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetPrivilegesAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -90,7 +90,7 @@ impl windows_core::RuntimeType for GameServiceGameOutcome { pub struct GameServicePropertyCollection(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(GameServicePropertyCollection, windows_core::IUnknown, windows_core::IInspectable); impl GameServicePropertyCollection { - pub fn GetPropertyAsync(&self, propertyname: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetPropertyAsync(&self, propertyname: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Security/Authentication/Identity/Core/mod.rs b/crates/libs/windows/src/Windows/Security/Authentication/Identity/Core/mod.rs index 8a575adf2c..5582e61798 100644 --- a/crates/libs/windows/src/Windows/Security/Authentication/Identity/Core/mod.rs +++ b/crates/libs/windows/src/Windows/Security/Authentication/Identity/Core/mod.rs @@ -78,35 +78,35 @@ pub struct IMicrosoftAccountMultiFactorUnregisteredAccountsAndSessionInfo_Vtbl { pub struct MicrosoftAccountMultiFactorAuthenticationManager(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(MicrosoftAccountMultiFactorAuthenticationManager, windows_core::IUnknown, windows_core::IInspectable); impl MicrosoftAccountMultiFactorAuthenticationManager { - pub fn GetOneTimePassCodeAsync(&self, useraccountid: &windows_core::HSTRING, codelength: u32) -> windows_core::Result> { + pub fn GetOneTimePassCodeAsync(&self, useraccountid: &windows_core::HSTRING, codelength: u32) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetOneTimePassCodeAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(useraccountid), codelength, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn AddDeviceAsync(&self, useraccountid: &windows_core::HSTRING, authenticationtoken: &windows_core::HSTRING, wnschannelid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn AddDeviceAsync(&self, useraccountid: &windows_core::HSTRING, authenticationtoken: &windows_core::HSTRING, wnschannelid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).AddDeviceAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(useraccountid), core::mem::transmute_copy(authenticationtoken), core::mem::transmute_copy(wnschannelid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RemoveDeviceAsync(&self, useraccountid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn RemoveDeviceAsync(&self, useraccountid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RemoveDeviceAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(useraccountid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn UpdateWnsChannelAsync(&self, useraccountid: &windows_core::HSTRING, channeluri: &windows_core::HSTRING) -> windows_core::Result> { + pub fn UpdateWnsChannelAsync(&self, useraccountid: &windows_core::HSTRING, channeluri: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).UpdateWnsChannelAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(useraccountid), core::mem::transmute_copy(channeluri), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetSessionsAsync(&self, useraccountidlist: P0) -> windows_core::Result> + pub fn GetSessionsAsync(&self, useraccountidlist: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -116,7 +116,7 @@ impl MicrosoftAccountMultiFactorAuthenticationManager { (windows_core::Interface::vtable(this).GetSessionsAsync)(windows_core::Interface::as_raw(this), useraccountidlist.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetSessionsAndUnregisteredAccountsAsync(&self, useraccountidlist: P0) -> windows_core::Result> + pub fn GetSessionsAndUnregisteredAccountsAsync(&self, useraccountidlist: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -126,7 +126,7 @@ impl MicrosoftAccountMultiFactorAuthenticationManager { (windows_core::Interface::vtable(this).GetSessionsAndUnregisteredAccountsAsync)(windows_core::Interface::as_raw(this), useraccountidlist.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ApproveSessionUsingAuthSessionInfoAsync(&self, sessionauthentictionstatus: MicrosoftAccountMultiFactorSessionAuthenticationStatus, authenticationsessioninfo: P1) -> windows_core::Result> + pub fn ApproveSessionUsingAuthSessionInfoAsync(&self, sessionauthentictionstatus: MicrosoftAccountMultiFactorSessionAuthenticationStatus, authenticationsessioninfo: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -136,14 +136,14 @@ impl MicrosoftAccountMultiFactorAuthenticationManager { (windows_core::Interface::vtable(this).ApproveSessionUsingAuthSessionInfoAsync)(windows_core::Interface::as_raw(this), sessionauthentictionstatus, authenticationsessioninfo.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ApproveSessionAsync(&self, sessionauthentictionstatus: MicrosoftAccountMultiFactorSessionAuthenticationStatus, useraccountid: &windows_core::HSTRING, sessionid: &windows_core::HSTRING, sessionauthenticationtype: MicrosoftAccountMultiFactorAuthenticationType) -> windows_core::Result> { + pub fn ApproveSessionAsync(&self, sessionauthentictionstatus: MicrosoftAccountMultiFactorSessionAuthenticationStatus, useraccountid: &windows_core::HSTRING, sessionid: &windows_core::HSTRING, sessionauthenticationtype: MicrosoftAccountMultiFactorAuthenticationType) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ApproveSessionAsync)(windows_core::Interface::as_raw(this), sessionauthentictionstatus, core::mem::transmute_copy(useraccountid), core::mem::transmute_copy(sessionid), sessionauthenticationtype, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DenySessionUsingAuthSessionInfoAsync(&self, authenticationsessioninfo: P0) -> windows_core::Result> + pub fn DenySessionUsingAuthSessionInfoAsync(&self, authenticationsessioninfo: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -153,7 +153,7 @@ impl MicrosoftAccountMultiFactorAuthenticationManager { (windows_core::Interface::vtable(this).DenySessionUsingAuthSessionInfoAsync)(windows_core::Interface::as_raw(this), authenticationsessioninfo.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DenySessionAsync(&self, useraccountid: &windows_core::HSTRING, sessionid: &windows_core::HSTRING, sessionauthenticationtype: MicrosoftAccountMultiFactorAuthenticationType) -> windows_core::Result> { + pub fn DenySessionAsync(&self, useraccountid: &windows_core::HSTRING, sessionid: &windows_core::HSTRING, sessionauthenticationtype: MicrosoftAccountMultiFactorAuthenticationType) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Security/Authentication/Identity/mod.rs b/crates/libs/windows/src/Windows/Security/Authentication/Identity/mod.rs index df28dffad7..3072d8b232 100644 --- a/crates/libs/windows/src/Windows/Security/Authentication/Identity/mod.rs +++ b/crates/libs/windows/src/Windows/Security/Authentication/Identity/mod.rs @@ -58,7 +58,7 @@ unsafe impl Sync for EnterpriseKeyCredentialRegistrationInfo {} pub struct EnterpriseKeyCredentialRegistrationManager(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(EnterpriseKeyCredentialRegistrationManager, windows_core::IUnknown, windows_core::IInspectable); impl EnterpriseKeyCredentialRegistrationManager { - pub fn GetRegistrationsAsync(&self) -> windows_core::Result>> { + pub fn GetRegistrationsAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Security/Authentication/OnlineId/mod.rs b/crates/libs/windows/src/Windows/Security/Authentication/OnlineId/mod.rs index 7cf68082ec..7c97200d29 100644 --- a/crates/libs/windows/src/Windows/Security/Authentication/OnlineId/mod.rs +++ b/crates/libs/windows/src/Windows/Security/Authentication/OnlineId/mod.rs @@ -318,7 +318,7 @@ impl windows_core::RuntimeName for OnlineIdSystemAuthenticator { pub struct OnlineIdSystemAuthenticatorForUser(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(OnlineIdSystemAuthenticatorForUser, windows_core::IUnknown, windows_core::IInspectable); impl OnlineIdSystemAuthenticatorForUser { - pub fn GetTicketAsync(&self, request: P0) -> windows_core::Result> + pub fn GetTicketAsync(&self, request: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -445,8 +445,8 @@ impl windows_core::TypeKind for OnlineIdSystemTicketStatus { impl windows_core::RuntimeType for OnlineIdSystemTicketStatus { const SIGNATURE: windows_core::imp::ConstBuffer = windows_core::imp::ConstBuffer::from_slice(b"enum(Windows.Security.Authentication.OnlineId.OnlineIdSystemTicketStatus;i4)"); } -pub type SignOutUserOperation = windows_async::IAsyncAction; -pub type UserAuthenticationOperation = windows_async::IAsyncOperation; +pub type SignOutUserOperation = windows_future::IAsyncAction; +pub type UserAuthenticationOperation = windows_future::IAsyncOperation; #[repr(transparent)] #[derive(Clone, Debug, Eq, PartialEq)] pub struct UserIdentity(windows_core::IUnknown); diff --git a/crates/libs/windows/src/Windows/Security/Authentication/Web/Core/mod.rs b/crates/libs/windows/src/Windows/Security/Authentication/Web/Core/mod.rs index 683a06ea55..8582866153 100644 --- a/crates/libs/windows/src/Windows/Security/Authentication/Web/Core/mod.rs +++ b/crates/libs/windows/src/Windows/Security/Authentication/Web/Core/mod.rs @@ -590,7 +590,7 @@ impl windows_core::RuntimeType for WebAuthenticationAddAccountStatus { } pub struct WebAuthenticationCoreManager; impl WebAuthenticationCoreManager { - pub fn GetTokenSilentlyAsync(request: P0) -> windows_core::Result> + pub fn GetTokenSilentlyAsync(request: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -600,7 +600,7 @@ impl WebAuthenticationCoreManager { }) } #[cfg(feature = "Security_Credentials")] - pub fn GetTokenSilentlyWithWebAccountAsync(request: P0, webaccount: P1) -> windows_core::Result> + pub fn GetTokenSilentlyWithWebAccountAsync(request: P0, webaccount: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -610,7 +610,7 @@ impl WebAuthenticationCoreManager { (windows_core::Interface::vtable(this).GetTokenSilentlyWithWebAccountAsync)(windows_core::Interface::as_raw(this), request.param().abi(), webaccount.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RequestTokenAsync(request: P0) -> windows_core::Result> + pub fn RequestTokenAsync(request: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -620,7 +620,7 @@ impl WebAuthenticationCoreManager { }) } #[cfg(feature = "Security_Credentials")] - pub fn RequestTokenWithWebAccountAsync(request: P0, webaccount: P1) -> windows_core::Result> + pub fn RequestTokenWithWebAccountAsync(request: P0, webaccount: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -631,7 +631,7 @@ impl WebAuthenticationCoreManager { }) } #[cfg(feature = "Security_Credentials")] - pub fn FindAccountAsync(provider: P0, webaccountid: &windows_core::HSTRING) -> windows_core::Result> + pub fn FindAccountAsync(provider: P0, webaccountid: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -641,21 +641,21 @@ impl WebAuthenticationCoreManager { }) } #[cfg(feature = "Security_Credentials")] - pub fn FindAccountProviderAsync(webaccountproviderid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FindAccountProviderAsync(webaccountproviderid: &windows_core::HSTRING) -> windows_core::Result> { Self::IWebAuthenticationCoreManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAccountProviderAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(webaccountproviderid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "Security_Credentials")] - pub fn FindAccountProviderWithAuthorityAsync(webaccountproviderid: &windows_core::HSTRING, authority: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FindAccountProviderWithAuthorityAsync(webaccountproviderid: &windows_core::HSTRING, authority: &windows_core::HSTRING) -> windows_core::Result> { Self::IWebAuthenticationCoreManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAccountProviderWithAuthorityAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(webaccountproviderid), core::mem::transmute_copy(authority), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(all(feature = "Security_Credentials", feature = "System"))] - pub fn FindAccountProviderWithAuthorityForUserAsync(webaccountproviderid: &windows_core::HSTRING, authority: &windows_core::HSTRING, user: P2) -> windows_core::Result> + pub fn FindAccountProviderWithAuthorityForUserAsync(webaccountproviderid: &windows_core::HSTRING, authority: &windows_core::HSTRING, user: P2) -> windows_core::Result> where P2: windows_core::Param, { @@ -675,7 +675,7 @@ impl WebAuthenticationCoreManager { }) } #[cfg(feature = "Security_Credentials")] - pub fn FindAllAccountsAsync(provider: P0) -> windows_core::Result> + pub fn FindAllAccountsAsync(provider: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -685,7 +685,7 @@ impl WebAuthenticationCoreManager { }) } #[cfg(feature = "Security_Credentials")] - pub fn FindAllAccountsWithClientIdAsync(provider: P0, clientid: &windows_core::HSTRING) -> windows_core::Result> + pub fn FindAllAccountsWithClientIdAsync(provider: P0, clientid: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -695,21 +695,21 @@ impl WebAuthenticationCoreManager { }) } #[cfg(feature = "Security_Credentials")] - pub fn FindSystemAccountProviderAsync(webaccountproviderid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FindSystemAccountProviderAsync(webaccountproviderid: &windows_core::HSTRING) -> windows_core::Result> { Self::IWebAuthenticationCoreManagerStatics4(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindSystemAccountProviderAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(webaccountproviderid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "Security_Credentials")] - pub fn FindSystemAccountProviderWithAuthorityAsync(webaccountproviderid: &windows_core::HSTRING, authority: &windows_core::HSTRING) -> windows_core::Result> { + pub fn FindSystemAccountProviderWithAuthorityAsync(webaccountproviderid: &windows_core::HSTRING, authority: &windows_core::HSTRING) -> windows_core::Result> { Self::IWebAuthenticationCoreManagerStatics4(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindSystemAccountProviderWithAuthorityAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(webaccountproviderid), core::mem::transmute_copy(authority), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(all(feature = "Security_Credentials", feature = "System"))] - pub fn FindSystemAccountProviderWithAuthorityForUserAsync(webaccountproviderid: &windows_core::HSTRING, authority: &windows_core::HSTRING, user: P2) -> windows_core::Result> + pub fn FindSystemAccountProviderWithAuthorityForUserAsync(webaccountproviderid: &windows_core::HSTRING, authority: &windows_core::HSTRING, user: P2) -> windows_core::Result> where P2: windows_core::Param, { @@ -718,7 +718,7 @@ impl WebAuthenticationCoreManager { (windows_core::Interface::vtable(this).FindSystemAccountProviderWithAuthorityForUserAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(webaccountproviderid), core::mem::transmute_copy(authority), user.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn AddAccountWithTransferTokenAsync(request: P0) -> windows_core::Result> + pub fn AddAccountWithTransferTokenAsync(request: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1034,7 +1034,7 @@ impl WebTokenRequestResult { (windows_core::Interface::vtable(this).ResponseError)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn InvalidateCacheAsync(&self) -> windows_core::Result { + pub fn InvalidateCacheAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Security/Authentication/Web/Provider/mod.rs b/crates/libs/windows/src/Windows/Security/Authentication/Web/Provider/mod.rs index c88a42d135..18b7f08f9b 100644 --- a/crates/libs/windows/src/Windows/Security/Authentication/Web/Provider/mod.rs +++ b/crates/libs/windows/src/Windows/Security/Authentication/Web/Provider/mod.rs @@ -826,7 +826,7 @@ impl windows_core::RuntimeType for WebAccountClientViewType { pub struct WebAccountManager; impl WebAccountManager { #[cfg(feature = "Security_Credentials")] - pub fn UpdateWebAccountPropertiesAsync(webaccount: P0, webaccountusername: &windows_core::HSTRING, additionalproperties: P2) -> windows_core::Result + pub fn UpdateWebAccountPropertiesAsync(webaccount: P0, webaccountusername: &windows_core::HSTRING, additionalproperties: P2) -> windows_core::Result where P0: windows_core::Param, P2: windows_core::Param>, @@ -837,7 +837,7 @@ impl WebAccountManager { }) } #[cfg(feature = "Security_Credentials")] - pub fn AddWebAccountAsync(webaccountid: &windows_core::HSTRING, webaccountusername: &windows_core::HSTRING, props: P2) -> windows_core::Result> + pub fn AddWebAccountAsync(webaccountid: &windows_core::HSTRING, webaccountusername: &windows_core::HSTRING, props: P2) -> windows_core::Result> where P2: windows_core::Param>, { @@ -847,7 +847,7 @@ impl WebAccountManager { }) } #[cfg(feature = "Security_Credentials")] - pub fn DeleteWebAccountAsync(webaccount: P0) -> windows_core::Result + pub fn DeleteWebAccountAsync(webaccount: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -857,14 +857,14 @@ impl WebAccountManager { }) } #[cfg(feature = "Security_Credentials")] - pub fn FindAllProviderWebAccountsAsync() -> windows_core::Result>> { + pub fn FindAllProviderWebAccountsAsync() -> windows_core::Result>> { Self::IWebAccountManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAllProviderWebAccountsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "Web_Http")] - pub fn PushCookiesAsync(uri: P0, cookies: P1) -> windows_core::Result + pub fn PushCookiesAsync(uri: P0, cookies: P1) -> windows_core::Result where P0: windows_core::Param, P1: windows_core::Param>, @@ -875,7 +875,7 @@ impl WebAccountManager { }) } #[cfg(feature = "Security_Credentials")] - pub fn SetViewAsync(webaccount: P0, view: P1) -> windows_core::Result + pub fn SetViewAsync(webaccount: P0, view: P1) -> windows_core::Result where P0: windows_core::Param, P1: windows_core::Param, @@ -886,7 +886,7 @@ impl WebAccountManager { }) } #[cfg(feature = "Security_Credentials")] - pub fn ClearViewAsync(webaccount: P0, applicationcallbackuri: P1) -> windows_core::Result + pub fn ClearViewAsync(webaccount: P0, applicationcallbackuri: P1) -> windows_core::Result where P0: windows_core::Param, P1: windows_core::Param, @@ -897,7 +897,7 @@ impl WebAccountManager { }) } #[cfg(feature = "Security_Credentials")] - pub fn GetViewsAsync(webaccount: P0) -> windows_core::Result>> + pub fn GetViewsAsync(webaccount: P0) -> windows_core::Result>> where P0: windows_core::Param, { @@ -907,7 +907,7 @@ impl WebAccountManager { }) } #[cfg(all(feature = "Security_Credentials", feature = "Storage_Streams"))] - pub fn SetWebAccountPictureAsync(webaccount: P0, webaccountpicture: P1) -> windows_core::Result + pub fn SetWebAccountPictureAsync(webaccount: P0, webaccountpicture: P1) -> windows_core::Result where P0: windows_core::Param, P1: windows_core::Param, @@ -918,7 +918,7 @@ impl WebAccountManager { }) } #[cfg(feature = "Security_Credentials")] - pub fn ClearWebAccountPictureAsync(webaccount: P0) -> windows_core::Result + pub fn ClearWebAccountPictureAsync(webaccount: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -927,14 +927,14 @@ impl WebAccountManager { (windows_core::Interface::vtable(this).ClearWebAccountPictureAsync)(windows_core::Interface::as_raw(this), webaccount.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn PullCookiesAsync(uristring: &windows_core::HSTRING, callerpfn: &windows_core::HSTRING) -> windows_core::Result { + pub fn PullCookiesAsync(uristring: &windows_core::HSTRING, callerpfn: &windows_core::HSTRING) -> windows_core::Result { Self::IWebAccountManagerStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).PullCookiesAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(uristring), core::mem::transmute_copy(callerpfn), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(all(feature = "Security_Credentials", feature = "System"))] - pub fn FindAllProviderWebAccountsForUserAsync(user: P0) -> windows_core::Result>> + pub fn FindAllProviderWebAccountsForUserAsync(user: P0) -> windows_core::Result>> where P0: windows_core::Param, { @@ -944,7 +944,7 @@ impl WebAccountManager { }) } #[cfg(all(feature = "Security_Credentials", feature = "System"))] - pub fn AddWebAccountForUserAsync(user: P0, webaccountid: &windows_core::HSTRING, webaccountusername: &windows_core::HSTRING, props: P3) -> windows_core::Result> + pub fn AddWebAccountForUserAsync(user: P0, webaccountid: &windows_core::HSTRING, webaccountusername: &windows_core::HSTRING, props: P3) -> windows_core::Result> where P0: windows_core::Param, P3: windows_core::Param>, @@ -955,7 +955,7 @@ impl WebAccountManager { }) } #[cfg(all(feature = "Security_Credentials", feature = "System"))] - pub fn AddWebAccountWithScopeForUserAsync(user: P0, webaccountid: &windows_core::HSTRING, webaccountusername: &windows_core::HSTRING, props: P3, scope: WebAccountScope) -> windows_core::Result> + pub fn AddWebAccountWithScopeForUserAsync(user: P0, webaccountid: &windows_core::HSTRING, webaccountusername: &windows_core::HSTRING, props: P3, scope: WebAccountScope) -> windows_core::Result> where P0: windows_core::Param, P3: windows_core::Param>, @@ -966,7 +966,7 @@ impl WebAccountManager { }) } #[cfg(all(feature = "Security_Credentials", feature = "System"))] - pub fn AddWebAccountWithScopeAndMapForUserAsync(user: P0, webaccountid: &windows_core::HSTRING, webaccountusername: &windows_core::HSTRING, props: P3, scope: WebAccountScope, peruserwebaccountid: &windows_core::HSTRING) -> windows_core::Result> + pub fn AddWebAccountWithScopeAndMapForUserAsync(user: P0, webaccountid: &windows_core::HSTRING, webaccountusername: &windows_core::HSTRING, props: P3, scope: WebAccountScope, peruserwebaccountid: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, P3: windows_core::Param>, @@ -976,14 +976,14 @@ impl WebAccountManager { (windows_core::Interface::vtable(this).AddWebAccountWithScopeAndMapForUserAsync)(windows_core::Interface::as_raw(this), user.param().abi(), core::mem::transmute_copy(webaccountid), core::mem::transmute_copy(webaccountusername), props.param().abi(), scope, core::mem::transmute_copy(peruserwebaccountid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn InvalidateAppCacheForAllAccountsAsync() -> windows_core::Result { + pub fn InvalidateAppCacheForAllAccountsAsync() -> windows_core::Result { Self::IWebAccountManagerStatics4(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).InvalidateAppCacheForAllAccountsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "Security_Credentials")] - pub fn InvalidateAppCacheForAccountAsync(webaccount: P0) -> windows_core::Result + pub fn InvalidateAppCacheForAccountAsync(webaccount: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -993,7 +993,7 @@ impl WebAccountManager { }) } #[cfg(feature = "Security_Credentials")] - pub fn AddWebAccountWithScopeAndMapAsync(webaccountid: &windows_core::HSTRING, webaccountusername: &windows_core::HSTRING, props: P2, scope: WebAccountScope, peruserwebaccountid: &windows_core::HSTRING) -> windows_core::Result> + pub fn AddWebAccountWithScopeAndMapAsync(webaccountid: &windows_core::HSTRING, webaccountusername: &windows_core::HSTRING, props: P2, scope: WebAccountScope, peruserwebaccountid: &windows_core::HSTRING) -> windows_core::Result> where P2: windows_core::Param>, { @@ -1003,7 +1003,7 @@ impl WebAccountManager { }) } #[cfg(feature = "Security_Credentials")] - pub fn SetPerAppToPerUserAccountAsync(perappaccount: P0, peruserwebaccountid: &windows_core::HSTRING) -> windows_core::Result + pub fn SetPerAppToPerUserAccountAsync(perappaccount: P0, peruserwebaccountid: &windows_core::HSTRING) -> windows_core::Result where P0: windows_core::Param, { @@ -1013,7 +1013,7 @@ impl WebAccountManager { }) } #[cfg(feature = "Security_Credentials")] - pub fn GetPerUserFromPerAppAccountAsync(perappaccount: P0) -> windows_core::Result> + pub fn GetPerUserFromPerAppAccountAsync(perappaccount: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1023,7 +1023,7 @@ impl WebAccountManager { }) } #[cfg(feature = "Security_Credentials")] - pub fn ClearPerUserFromPerAppAccountAsync(perappaccount: P0) -> windows_core::Result + pub fn ClearPerUserFromPerAppAccountAsync(perappaccount: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -1033,7 +1033,7 @@ impl WebAccountManager { }) } #[cfg(feature = "Security_Credentials")] - pub fn AddWebAccountWithScopeAsync(webaccountid: &windows_core::HSTRING, webaccountusername: &windows_core::HSTRING, props: P2, scope: WebAccountScope) -> windows_core::Result> + pub fn AddWebAccountWithScopeAsync(webaccountid: &windows_core::HSTRING, webaccountusername: &windows_core::HSTRING, props: P2, scope: WebAccountScope) -> windows_core::Result> where P2: windows_core::Param>, { @@ -1043,7 +1043,7 @@ impl WebAccountManager { }) } #[cfg(feature = "Security_Credentials")] - pub fn SetScopeAsync(webaccount: P0, scope: WebAccountScope) -> windows_core::Result + pub fn SetScopeAsync(webaccount: P0, scope: WebAccountScope) -> windows_core::Result where P0: windows_core::Param, { @@ -1627,7 +1627,7 @@ impl WebProviderTokenRequest { } } #[cfg(feature = "Security_Cryptography_Core")] - pub fn GetApplicationTokenBindingKeyAsync(&self, keytype: super::TokenBindingKeyType, target: P1) -> windows_core::Result> + pub fn GetApplicationTokenBindingKeyAsync(&self, keytype: super::TokenBindingKeyType, target: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -1638,7 +1638,7 @@ impl WebProviderTokenRequest { } } #[cfg(feature = "Storage_Streams")] - pub fn GetApplicationTokenBindingKeyIdAsync(&self, keytype: super::TokenBindingKeyType, target: P1) -> windows_core::Result> + pub fn GetApplicationTokenBindingKeyIdAsync(&self, keytype: super::TokenBindingKeyType, target: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -1662,7 +1662,7 @@ impl WebProviderTokenRequest { (windows_core::Interface::vtable(this).ApplicationProcessName)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn CheckApplicationForCapabilityAsync(&self, capabilityname: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CheckApplicationForCapabilityAsync(&self, capabilityname: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Security/Authentication/Web/mod.rs b/crates/libs/windows/src/Windows/Security/Authentication/Web/mod.rs index 22e4e671c2..76e644aa00 100644 --- a/crates/libs/windows/src/Windows/Security/Authentication/Web/mod.rs +++ b/crates/libs/windows/src/Windows/Security/Authentication/Web/mod.rs @@ -56,7 +56,7 @@ impl windows_core::RuntimeType for TokenBindingKeyType { } pub struct WebAuthenticationBroker; impl WebAuthenticationBroker { - pub fn AuthenticateWithCallbackUriAsync(options: WebAuthenticationOptions, requesturi: P1, callbackuri: P2) -> windows_core::Result> + pub fn AuthenticateWithCallbackUriAsync(options: WebAuthenticationOptions, requesturi: P1, callbackuri: P2) -> windows_core::Result> where P1: windows_core::Param, P2: windows_core::Param, @@ -66,7 +66,7 @@ impl WebAuthenticationBroker { (windows_core::Interface::vtable(this).AuthenticateWithCallbackUriAsync)(windows_core::Interface::as_raw(this), options, requesturi.param().abi(), callbackuri.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn AuthenticateWithoutCallbackUriAsync(options: WebAuthenticationOptions, requesturi: P1) -> windows_core::Result> + pub fn AuthenticateWithoutCallbackUriAsync(options: WebAuthenticationOptions, requesturi: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -103,7 +103,7 @@ impl WebAuthenticationBroker { { Self::IWebAuthenticationBrokerStatics2(|this| unsafe { (windows_core::Interface::vtable(this).AuthenticateWithCallbackUriContinuationDataAndOptionsAndContinue)(windows_core::Interface::as_raw(this), requesturi.param().abi(), callbackuri.param().abi(), continuationdata.param().abi(), options).ok() }) } - pub fn AuthenticateSilentlyAsync(requesturi: P0) -> windows_core::Result> + pub fn AuthenticateSilentlyAsync(requesturi: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -112,7 +112,7 @@ impl WebAuthenticationBroker { (windows_core::Interface::vtable(this).AuthenticateSilentlyAsync)(windows_core::Interface::as_raw(this), requesturi.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn AuthenticateSilentlyWithOptionsAsync(requesturi: P0, options: WebAuthenticationOptions) -> windows_core::Result> + pub fn AuthenticateSilentlyWithOptionsAsync(requesturi: P0, options: WebAuthenticationOptions) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Security/Authorization/AppCapabilityAccess/mod.rs b/crates/libs/windows/src/Windows/Security/Authorization/AppCapabilityAccess/mod.rs index 53509fb9ed..8020ddd425 100644 --- a/crates/libs/windows/src/Windows/Security/Authorization/AppCapabilityAccess/mod.rs +++ b/crates/libs/windows/src/Windows/Security/Authorization/AppCapabilityAccess/mod.rs @@ -18,7 +18,7 @@ impl AppCapability { (windows_core::Interface::vtable(this).User)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestAccessAsync(&self) -> windows_core::Result> { + pub fn RequestAccessAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -57,7 +57,7 @@ impl AppCapability { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).SetDisplayMessage)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(value)).ok() } } - pub fn RequestAccessForCapabilitiesAsync(capabilitynames: P0) -> windows_core::Result>> + pub fn RequestAccessForCapabilitiesAsync(capabilitynames: P0) -> windows_core::Result>> where P0: windows_core::Param>, { @@ -67,7 +67,7 @@ impl AppCapability { }) } #[cfg(feature = "System")] - pub fn RequestAccessForCapabilitiesForUserAsync(user: P0, capabilitynames: P1) -> windows_core::Result>> + pub fn RequestAccessForCapabilitiesForUserAsync(user: P0, capabilitynames: P1) -> windows_core::Result>> where P0: windows_core::Param, P1: windows_core::Param>, diff --git a/crates/libs/windows/src/Windows/Security/Credentials/UI/mod.rs b/crates/libs/windows/src/Windows/Security/Credentials/UI/mod.rs index 4dbf54dcbe..90618d384a 100644 --- a/crates/libs/windows/src/Windows/Security/Credentials/UI/mod.rs +++ b/crates/libs/windows/src/Windows/Security/Credentials/UI/mod.rs @@ -18,7 +18,7 @@ impl windows_core::RuntimeType for AuthenticationProtocol { } pub struct CredentialPicker; impl CredentialPicker { - pub fn PickWithOptionsAsync(options: P0) -> windows_core::Result> + pub fn PickWithOptionsAsync(options: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -27,13 +27,13 @@ impl CredentialPicker { (windows_core::Interface::vtable(this).PickWithOptionsAsync)(windows_core::Interface::as_raw(this), options.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn PickWithMessageAsync(targetname: &windows_core::HSTRING, message: &windows_core::HSTRING) -> windows_core::Result> { + pub fn PickWithMessageAsync(targetname: &windows_core::HSTRING, message: &windows_core::HSTRING) -> windows_core::Result> { Self::ICredentialPickerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).PickWithMessageAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(targetname), core::mem::transmute_copy(message), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn PickWithCaptionAsync(targetname: &windows_core::HSTRING, message: &windows_core::HSTRING, caption: &windows_core::HSTRING) -> windows_core::Result> { + pub fn PickWithCaptionAsync(targetname: &windows_core::HSTRING, message: &windows_core::HSTRING, caption: &windows_core::HSTRING) -> windows_core::Result> { Self::ICredentialPickerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).PickWithCaptionAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(targetname), core::mem::transmute_copy(message), core::mem::transmute_copy(caption), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -358,13 +358,13 @@ impl windows_core::RuntimeType for UserConsentVerificationResult { } pub struct UserConsentVerifier; impl UserConsentVerifier { - pub fn CheckAvailabilityAsync() -> windows_core::Result> { + pub fn CheckAvailabilityAsync() -> windows_core::Result> { Self::IUserConsentVerifierStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CheckAvailabilityAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RequestVerificationAsync(message: &windows_core::HSTRING) -> windows_core::Result> { + pub fn RequestVerificationAsync(message: &windows_core::HSTRING) -> windows_core::Result> { Self::IUserConsentVerifierStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestVerificationAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(message), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/Security/Credentials/mod.rs b/crates/libs/windows/src/Windows/Security/Credentials/mod.rs index 6d0f69fe4c..eb2c68e35b 100644 --- a/crates/libs/windows/src/Windows/Security/Credentials/mod.rs +++ b/crates/libs/windows/src/Windows/Security/Credentials/mod.rs @@ -319,7 +319,7 @@ impl KeyCredential { } } #[cfg(feature = "Storage_Streams")] - pub fn RequestSignAsync(&self, data: P0) -> windows_core::Result> + pub fn RequestSignAsync(&self, data: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -329,7 +329,7 @@ impl KeyCredential { (windows_core::Interface::vtable(this).RequestSignAsync)(windows_core::Interface::as_raw(this), data.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAttestationAsync(&self) -> windows_core::Result> { + pub fn GetAttestationAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -420,31 +420,31 @@ impl windows_core::RuntimeType for KeyCredentialCreationOption { } pub struct KeyCredentialManager; impl KeyCredentialManager { - pub fn IsSupportedAsync() -> windows_core::Result> { + pub fn IsSupportedAsync() -> windows_core::Result> { Self::IKeyCredentialManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).IsSupportedAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RenewAttestationAsync() -> windows_core::Result { + pub fn RenewAttestationAsync() -> windows_core::Result { Self::IKeyCredentialManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RenewAttestationAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RequestCreateAsync(name: &windows_core::HSTRING, option: KeyCredentialCreationOption) -> windows_core::Result> { + pub fn RequestCreateAsync(name: &windows_core::HSTRING, option: KeyCredentialCreationOption) -> windows_core::Result> { Self::IKeyCredentialManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestCreateAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(name), option, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn OpenAsync(name: &windows_core::HSTRING) -> windows_core::Result> { + pub fn OpenAsync(name: &windows_core::HSTRING) -> windows_core::Result> { Self::IKeyCredentialManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).OpenAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(name), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn DeleteAsync(name: &windows_core::HSTRING) -> windows_core::Result { + pub fn DeleteAsync(name: &windows_core::HSTRING) -> windows_core::Result { Self::IKeyCredentialManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeleteAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(name), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -847,21 +847,21 @@ impl WebAccount { } } #[cfg(feature = "Storage_Streams")] - pub fn GetPictureAsync(&self, desizedsize: WebAccountPictureSize) -> windows_core::Result> { + pub fn GetPictureAsync(&self, desizedsize: WebAccountPictureSize) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetPictureAsync)(windows_core::Interface::as_raw(this), desizedsize, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SignOutAsync(&self) -> windows_core::Result { + pub fn SignOutAsync(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).SignOutAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SignOutWithClientIdAsync(&self, clientid: &windows_core::HSTRING) -> windows_core::Result { + pub fn SignOutWithClientIdAsync(&self, clientid: &windows_core::HSTRING) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Security/Cryptography/Certificates/mod.rs b/crates/libs/windows/src/Windows/Security/Cryptography/Certificates/mod.rs index 318453cd2f..407f056337 100644 --- a/crates/libs/windows/src/Windows/Security/Cryptography/Certificates/mod.rs +++ b/crates/libs/windows/src/Windows/Security/Cryptography/Certificates/mod.rs @@ -3,7 +3,7 @@ pub struct Certificate(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(Certificate, windows_core::IUnknown, windows_core::IInspectable); impl Certificate { - pub fn BuildChainAsync(&self, certificates: P0) -> windows_core::Result> + pub fn BuildChainAsync(&self, certificates: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -13,7 +13,7 @@ impl Certificate { (windows_core::Interface::vtable(this).BuildChainAsync)(windows_core::Interface::as_raw(this), certificates.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn BuildChainWithParametersAsync(&self, certificates: P0, parameters: P1) -> windows_core::Result> + pub fn BuildChainWithParametersAsync(&self, certificates: P0, parameters: P1) -> windows_core::Result> where P0: windows_core::Param>, P1: windows_core::Param, @@ -262,7 +262,7 @@ impl windows_core::RuntimeType for CertificateChainPolicy { } pub struct CertificateEnrollmentManager; impl CertificateEnrollmentManager { - pub fn CreateRequestAsync(request: P0) -> windows_core::Result> + pub fn CreateRequestAsync(request: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -271,13 +271,13 @@ impl CertificateEnrollmentManager { (windows_core::Interface::vtable(this).CreateRequestAsync)(windows_core::Interface::as_raw(this), request.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn InstallCertificateAsync(certificate: &windows_core::HSTRING, installoption: InstallOptions) -> windows_core::Result { + pub fn InstallCertificateAsync(certificate: &windows_core::HSTRING, installoption: InstallOptions) -> windows_core::Result { Self::ICertificateEnrollmentManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).InstallCertificateAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(certificate), installoption, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn ImportPfxDataAsync(pfxdata: &windows_core::HSTRING, password: &windows_core::HSTRING, exportable: ExportOption, keyprotectionlevel: KeyProtectionLevel, installoption: InstallOptions, friendlyname: &windows_core::HSTRING) -> windows_core::Result { + pub fn ImportPfxDataAsync(pfxdata: &windows_core::HSTRING, password: &windows_core::HSTRING, exportable: ExportOption, keyprotectionlevel: KeyProtectionLevel, installoption: InstallOptions, friendlyname: &windows_core::HSTRING) -> windows_core::Result { Self::ICertificateEnrollmentManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ImportPfxDataAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(pfxdata), core::mem::transmute_copy(password), exportable, keyprotectionlevel, installoption, core::mem::transmute_copy(friendlyname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -289,13 +289,13 @@ impl CertificateEnrollmentManager { (windows_core::Interface::vtable(this).UserCertificateEnrollmentManager)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn ImportPfxDataToKspAsync(pfxdata: &windows_core::HSTRING, password: &windows_core::HSTRING, exportable: ExportOption, keyprotectionlevel: KeyProtectionLevel, installoption: InstallOptions, friendlyname: &windows_core::HSTRING, keystorageprovider: &windows_core::HSTRING) -> windows_core::Result { + pub fn ImportPfxDataToKspAsync(pfxdata: &windows_core::HSTRING, password: &windows_core::HSTRING, exportable: ExportOption, keyprotectionlevel: KeyProtectionLevel, installoption: InstallOptions, friendlyname: &windows_core::HSTRING, keystorageprovider: &windows_core::HSTRING) -> windows_core::Result { Self::ICertificateEnrollmentManagerStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ImportPfxDataToKspAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(pfxdata), core::mem::transmute_copy(password), exportable, keyprotectionlevel, installoption, core::mem::transmute_copy(friendlyname), core::mem::transmute_copy(keystorageprovider), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn ImportPfxDataToKspWithParametersAsync(pfxdata: &windows_core::HSTRING, password: &windows_core::HSTRING, pfximportparameters: P2) -> windows_core::Result + pub fn ImportPfxDataToKspWithParametersAsync(pfxdata: &windows_core::HSTRING, password: &windows_core::HSTRING, pfximportparameters: P2) -> windows_core::Result where P2: windows_core::Param, { @@ -884,13 +884,13 @@ unsafe impl Send for CertificateStore {} unsafe impl Sync for CertificateStore {} pub struct CertificateStores; impl CertificateStores { - pub fn FindAllAsync() -> windows_core::Result>> { + pub fn FindAllAsync() -> windows_core::Result>> { Self::ICertificateStoresStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAllAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn FindAllWithQueryAsync(query: P0) -> windows_core::Result>> + pub fn FindAllWithQueryAsync(query: P0) -> windows_core::Result>> where P0: windows_core::Param, { @@ -1150,7 +1150,7 @@ impl CmsAttachedSignature { }) } #[cfg(feature = "Storage_Streams")] - pub fn GenerateSignatureAsync(data: P0, signers: P1, certificates: P2) -> windows_core::Result> + pub fn GenerateSignatureAsync(data: P0, signers: P1, certificates: P2) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param>, @@ -1202,7 +1202,7 @@ impl CmsDetachedSignature { } } #[cfg(feature = "Storage_Streams")] - pub fn VerifySignatureAsync(&self, data: P0) -> windows_core::Result> + pub fn VerifySignatureAsync(&self, data: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1223,7 +1223,7 @@ impl CmsDetachedSignature { }) } #[cfg(feature = "Storage_Streams")] - pub fn GenerateSignatureAsync(data: P0, signers: P1, certificates: P2) -> windows_core::Result> + pub fn GenerateSignatureAsync(data: P0, signers: P1, certificates: P2) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param>, @@ -2114,7 +2114,7 @@ impl windows_core::RuntimeName for KeyAlgorithmNames { } pub struct KeyAttestationHelper; impl KeyAttestationHelper { - pub fn DecryptTpmAttestationCredentialAsync(credential: &windows_core::HSTRING) -> windows_core::Result> { + pub fn DecryptTpmAttestationCredentialAsync(credential: &windows_core::HSTRING) -> windows_core::Result> { Self::IKeyAttestationHelperStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DecryptTpmAttestationCredentialAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(credential), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -2126,7 +2126,7 @@ impl KeyAttestationHelper { (windows_core::Interface::vtable(this).GetTpmAttestationCredentialId)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(credential), &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn DecryptTpmAttestationCredentialWithContainerNameAsync(credential: &windows_core::HSTRING, containername: &windows_core::HSTRING) -> windows_core::Result> { + pub fn DecryptTpmAttestationCredentialWithContainerNameAsync(credential: &windows_core::HSTRING, containername: &windows_core::HSTRING) -> windows_core::Result> { Self::IKeyAttestationHelperStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DecryptTpmAttestationCredentialWithContainerNameAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(credential), core::mem::transmute_copy(containername), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -2478,7 +2478,7 @@ unsafe impl Sync for SubjectAlternativeNameInfo {} pub struct UserCertificateEnrollmentManager(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(UserCertificateEnrollmentManager, windows_core::IUnknown, windows_core::IInspectable); impl UserCertificateEnrollmentManager { - pub fn CreateRequestAsync(&self, request: P0) -> windows_core::Result> + pub fn CreateRequestAsync(&self, request: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2488,28 +2488,28 @@ impl UserCertificateEnrollmentManager { (windows_core::Interface::vtable(this).CreateRequestAsync)(windows_core::Interface::as_raw(this), request.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn InstallCertificateAsync(&self, certificate: &windows_core::HSTRING, installoption: InstallOptions) -> windows_core::Result { + pub fn InstallCertificateAsync(&self, certificate: &windows_core::HSTRING, installoption: InstallOptions) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).InstallCertificateAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(certificate), installoption, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ImportPfxDataAsync(&self, pfxdata: &windows_core::HSTRING, password: &windows_core::HSTRING, exportable: ExportOption, keyprotectionlevel: KeyProtectionLevel, installoption: InstallOptions, friendlyname: &windows_core::HSTRING) -> windows_core::Result { + pub fn ImportPfxDataAsync(&self, pfxdata: &windows_core::HSTRING, password: &windows_core::HSTRING, exportable: ExportOption, keyprotectionlevel: KeyProtectionLevel, installoption: InstallOptions, friendlyname: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ImportPfxDataAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(pfxdata), core::mem::transmute_copy(password), exportable, keyprotectionlevel, installoption, core::mem::transmute_copy(friendlyname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ImportPfxDataToKspAsync(&self, pfxdata: &windows_core::HSTRING, password: &windows_core::HSTRING, exportable: ExportOption, keyprotectionlevel: KeyProtectionLevel, installoption: InstallOptions, friendlyname: &windows_core::HSTRING, keystorageprovider: &windows_core::HSTRING) -> windows_core::Result { + pub fn ImportPfxDataToKspAsync(&self, pfxdata: &windows_core::HSTRING, password: &windows_core::HSTRING, exportable: ExportOption, keyprotectionlevel: KeyProtectionLevel, installoption: InstallOptions, friendlyname: &windows_core::HSTRING, keystorageprovider: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ImportPfxDataToKspAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(pfxdata), core::mem::transmute_copy(password), exportable, keyprotectionlevel, installoption, core::mem::transmute_copy(friendlyname), core::mem::transmute_copy(keystorageprovider), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ImportPfxDataToKspWithParametersAsync(&self, pfxdata: &windows_core::HSTRING, password: &windows_core::HSTRING, pfximportparameters: P2) -> windows_core::Result + pub fn ImportPfxDataToKspWithParametersAsync(&self, pfxdata: &windows_core::HSTRING, password: &windows_core::HSTRING, pfximportparameters: P2) -> windows_core::Result where P2: windows_core::Param, { @@ -2537,7 +2537,7 @@ unsafe impl Sync for UserCertificateEnrollmentManager {} pub struct UserCertificateStore(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(UserCertificateStore, windows_core::IUnknown, windows_core::IInspectable); impl UserCertificateStore { - pub fn RequestAddAsync(&self, certificate: P0) -> windows_core::Result> + pub fn RequestAddAsync(&self, certificate: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2547,7 +2547,7 @@ impl UserCertificateStore { (windows_core::Interface::vtable(this).RequestAddAsync)(windows_core::Interface::as_raw(this), certificate.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestDeleteAsync(&self, certificate: P0) -> windows_core::Result> + pub fn RequestDeleteAsync(&self, certificate: P0) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Security/Cryptography/Core/mod.rs b/crates/libs/windows/src/Windows/Security/Cryptography/Core/mod.rs index 57e3c6d942..16682e4c85 100644 --- a/crates/libs/windows/src/Windows/Security/Cryptography/Core/mod.rs +++ b/crates/libs/windows/src/Windows/Security/Cryptography/Core/mod.rs @@ -362,7 +362,7 @@ impl CryptographicEngine { }) } #[cfg(feature = "Storage_Streams")] - pub fn DecryptAsync(key: P0, data: P1, iv: P2) -> windows_core::Result> + pub fn DecryptAsync(key: P0, data: P1, iv: P2) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -374,7 +374,7 @@ impl CryptographicEngine { }) } #[cfg(feature = "Storage_Streams")] - pub fn SignAsync(key: P0, data: P1) -> windows_core::Result> + pub fn SignAsync(key: P0, data: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -385,7 +385,7 @@ impl CryptographicEngine { }) } #[cfg(feature = "Storage_Streams")] - pub fn SignHashedDataAsync(key: P0, data: P1) -> windows_core::Result> + pub fn SignHashedDataAsync(key: P0, data: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -1882,7 +1882,7 @@ unsafe impl Sync for MacAlgorithmProvider {} pub struct PersistedKeyProvider; impl PersistedKeyProvider { #[cfg(feature = "Security_Cryptography_Certificates")] - pub fn OpenKeyPairFromCertificateAsync(certificate: P0, hashalgorithmname: &windows_core::HSTRING, padding: CryptographicPadding) -> windows_core::Result> + pub fn OpenKeyPairFromCertificateAsync(certificate: P0, hashalgorithmname: &windows_core::HSTRING, padding: CryptographicPadding) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Security/Cryptography/DataProtection/mod.rs b/crates/libs/windows/src/Windows/Security/Cryptography/DataProtection/mod.rs index 0e61157bc5..e886b8df3e 100644 --- a/crates/libs/windows/src/Windows/Security/Cryptography/DataProtection/mod.rs +++ b/crates/libs/windows/src/Windows/Security/Cryptography/DataProtection/mod.rs @@ -11,7 +11,7 @@ impl DataProtectionProvider { SHARED.call(callback) } #[cfg(feature = "Storage_Streams")] - pub fn ProtectAsync(&self, data: P0) -> windows_core::Result> + pub fn ProtectAsync(&self, data: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -22,7 +22,7 @@ impl DataProtectionProvider { } } #[cfg(feature = "Storage_Streams")] - pub fn UnprotectAsync(&self, data: P0) -> windows_core::Result> + pub fn UnprotectAsync(&self, data: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -33,7 +33,7 @@ impl DataProtectionProvider { } } #[cfg(feature = "Storage_Streams")] - pub fn ProtectStreamAsync(&self, src: P0, dest: P1) -> windows_core::Result + pub fn ProtectStreamAsync(&self, src: P0, dest: P1) -> windows_core::Result where P0: windows_core::Param, P1: windows_core::Param, @@ -45,7 +45,7 @@ impl DataProtectionProvider { } } #[cfg(feature = "Storage_Streams")] - pub fn UnprotectStreamAsync(&self, src: P0, dest: P1) -> windows_core::Result + pub fn UnprotectStreamAsync(&self, src: P0, dest: P1) -> windows_core::Result where P0: windows_core::Param, P1: windows_core::Param, diff --git a/crates/libs/windows/src/Windows/Security/DataProtection/mod.rs b/crates/libs/windows/src/Windows/Security/DataProtection/mod.rs index 539a049ec0..007e95e99c 100644 --- a/crates/libs/windows/src/Windows/Security/DataProtection/mod.rs +++ b/crates/libs/windows/src/Windows/Security/DataProtection/mod.rs @@ -160,7 +160,7 @@ pub struct UserDataProtectionManager(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(UserDataProtectionManager, windows_core::IUnknown, windows_core::IInspectable); impl UserDataProtectionManager { #[cfg(feature = "Storage")] - pub fn ProtectStorageItemAsync(&self, storageitem: P0, availability: UserDataAvailability) -> windows_core::Result> + pub fn ProtectStorageItemAsync(&self, storageitem: P0, availability: UserDataAvailability) -> windows_core::Result> where P0: windows_core::Param, { @@ -171,7 +171,7 @@ impl UserDataProtectionManager { } } #[cfg(feature = "Storage")] - pub fn GetStorageItemProtectionInfoAsync(&self, storageitem: P0) -> windows_core::Result> + pub fn GetStorageItemProtectionInfoAsync(&self, storageitem: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -182,7 +182,7 @@ impl UserDataProtectionManager { } } #[cfg(feature = "Storage_Streams")] - pub fn ProtectBufferAsync(&self, unprotectedbuffer: P0, availability: UserDataAvailability) -> windows_core::Result> + pub fn ProtectBufferAsync(&self, unprotectedbuffer: P0, availability: UserDataAvailability) -> windows_core::Result> where P0: windows_core::Param, { @@ -193,7 +193,7 @@ impl UserDataProtectionManager { } } #[cfg(feature = "Storage_Streams")] - pub fn UnprotectBufferAsync(&self, protectedbuffer: P0) -> windows_core::Result> + pub fn UnprotectBufferAsync(&self, protectedbuffer: P0) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Security/EnterpriseData/mod.rs b/crates/libs/windows/src/Windows/Security/EnterpriseData/mod.rs index 7a0e5cf4ae..52d497348e 100644 --- a/crates/libs/windows/src/Windows/Security/EnterpriseData/mod.rs +++ b/crates/libs/windows/src/Windows/Security/EnterpriseData/mod.rs @@ -66,7 +66,7 @@ unsafe impl Sync for DataProtectionInfo {} pub struct DataProtectionManager; impl DataProtectionManager { #[cfg(feature = "Storage_Streams")] - pub fn ProtectAsync(data: P0, identity: &windows_core::HSTRING) -> windows_core::Result> + pub fn ProtectAsync(data: P0, identity: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -76,7 +76,7 @@ impl DataProtectionManager { }) } #[cfg(feature = "Storage_Streams")] - pub fn UnprotectAsync(data: P0) -> windows_core::Result> + pub fn UnprotectAsync(data: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -86,7 +86,7 @@ impl DataProtectionManager { }) } #[cfg(feature = "Storage_Streams")] - pub fn ProtectStreamAsync(unprotectedstream: P0, identity: &windows_core::HSTRING, protectedstream: P2) -> windows_core::Result> + pub fn ProtectStreamAsync(unprotectedstream: P0, identity: &windows_core::HSTRING, protectedstream: P2) -> windows_core::Result> where P0: windows_core::Param, P2: windows_core::Param, @@ -97,7 +97,7 @@ impl DataProtectionManager { }) } #[cfg(feature = "Storage_Streams")] - pub fn UnprotectStreamAsync(protectedstream: P0, unprotectedstream: P1) -> windows_core::Result> + pub fn UnprotectStreamAsync(protectedstream: P0, unprotectedstream: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -108,7 +108,7 @@ impl DataProtectionManager { }) } #[cfg(feature = "Storage_Streams")] - pub fn GetProtectionInfoAsync(protecteddata: P0) -> windows_core::Result> + pub fn GetProtectionInfoAsync(protecteddata: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -118,7 +118,7 @@ impl DataProtectionManager { }) } #[cfg(feature = "Storage_Streams")] - pub fn GetStreamProtectionInfoAsync(protectedstream: P0) -> windows_core::Result> + pub fn GetStreamProtectionInfoAsync(protectedstream: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -216,7 +216,7 @@ unsafe impl Sync for FileProtectionInfo {} pub struct FileProtectionManager; impl FileProtectionManager { #[cfg(feature = "Storage")] - pub fn ProtectAsync(target: P0, identity: &windows_core::HSTRING) -> windows_core::Result> + pub fn ProtectAsync(target: P0, identity: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -226,7 +226,7 @@ impl FileProtectionManager { }) } #[cfg(feature = "Storage")] - pub fn CopyProtectionAsync(source: P0, target: P1) -> windows_core::Result> + pub fn CopyProtectionAsync(source: P0, target: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -237,7 +237,7 @@ impl FileProtectionManager { }) } #[cfg(feature = "Storage")] - pub fn GetProtectionInfoAsync(source: P0) -> windows_core::Result> + pub fn GetProtectionInfoAsync(source: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -247,7 +247,7 @@ impl FileProtectionManager { }) } #[cfg(feature = "Storage_Streams")] - pub fn SaveFileAsContainerAsync(protectedfile: P0) -> windows_core::Result> + pub fn SaveFileAsContainerAsync(protectedfile: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -257,7 +257,7 @@ impl FileProtectionManager { }) } #[cfg(feature = "Storage_Streams")] - pub fn LoadFileFromContainerAsync(containerfile: P0) -> windows_core::Result> + pub fn LoadFileFromContainerAsync(containerfile: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -267,7 +267,7 @@ impl FileProtectionManager { }) } #[cfg(feature = "Storage_Streams")] - pub fn LoadFileFromContainerWithTargetAsync(containerfile: P0, target: P1) -> windows_core::Result> + pub fn LoadFileFromContainerWithTargetAsync(containerfile: P0, target: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -278,7 +278,7 @@ impl FileProtectionManager { }) } #[cfg(feature = "Storage")] - pub fn CreateProtectedAndOpenAsync(parentfolder: P0, desiredname: &windows_core::HSTRING, identity: &windows_core::HSTRING, collisionoption: super::super::Storage::CreationCollisionOption) -> windows_core::Result> + pub fn CreateProtectedAndOpenAsync(parentfolder: P0, desiredname: &windows_core::HSTRING, identity: &windows_core::HSTRING, collisionoption: super::super::Storage::CreationCollisionOption) -> windows_core::Result> where P0: windows_core::Param, { @@ -288,7 +288,7 @@ impl FileProtectionManager { }) } #[cfg(feature = "Storage_Streams")] - pub fn IsContainerAsync(file: P0) -> windows_core::Result> + pub fn IsContainerAsync(file: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -298,7 +298,7 @@ impl FileProtectionManager { }) } #[cfg(feature = "Storage_Streams")] - pub fn LoadFileFromContainerWithTargetAndNameCollisionOptionAsync(containerfile: P0, target: P1, collisionoption: super::super::Storage::NameCollisionOption) -> windows_core::Result> + pub fn LoadFileFromContainerWithTargetAndNameCollisionOptionAsync(containerfile: P0, target: P1, collisionoption: super::super::Storage::NameCollisionOption) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -309,7 +309,7 @@ impl FileProtectionManager { }) } #[cfg(feature = "Storage_Streams")] - pub fn SaveFileAsContainerWithSharingAsync(protectedfile: P0, sharedwithidentities: P1) -> windows_core::Result> + pub fn SaveFileAsContainerWithSharingAsync(protectedfile: P0, sharedwithidentities: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param>, @@ -320,7 +320,7 @@ impl FileProtectionManager { }) } #[cfg(feature = "Storage")] - pub fn UnprotectAsync(target: P0) -> windows_core::Result> + pub fn UnprotectAsync(target: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -330,7 +330,7 @@ impl FileProtectionManager { }) } #[cfg(feature = "Storage")] - pub fn UnprotectWithOptionsAsync(target: P0, options: P1) -> windows_core::Result> + pub fn UnprotectWithOptionsAsync(target: P0, options: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -384,7 +384,7 @@ pub struct FileRevocationManager; #[cfg(feature = "deprecated")] impl FileRevocationManager { #[cfg(feature = "Storage")] - pub fn ProtectAsync(storageitem: P0, enterpriseidentity: &windows_core::HSTRING) -> windows_core::Result> + pub fn ProtectAsync(storageitem: P0, enterpriseidentity: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -394,7 +394,7 @@ impl FileRevocationManager { }) } #[cfg(feature = "Storage")] - pub fn CopyProtectionAsync(sourcestorageitem: P0, targetstorageitem: P1) -> windows_core::Result> + pub fn CopyProtectionAsync(sourcestorageitem: P0, targetstorageitem: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -408,7 +408,7 @@ impl FileRevocationManager { Self::IFileRevocationManagerStatics(|this| unsafe { (windows_core::Interface::vtable(this).Revoke)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(enterpriseidentity)).ok() }) } #[cfg(feature = "Storage")] - pub fn GetStatusAsync(storageitem: P0) -> windows_core::Result> + pub fn GetStatusAsync(storageitem: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1245,7 +1245,7 @@ impl ProtectionPolicyManager { }) } #[cfg(feature = "Networking")] - pub fn GetPrimaryManagedIdentityForNetworkEndpointAsync(endpointhost: P0) -> windows_core::Result> + pub fn GetPrimaryManagedIdentityForNetworkEndpointAsync(endpointhost: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1305,7 +1305,7 @@ impl ProtectionPolicyManager { (windows_core::Interface::vtable(this).CheckAccess)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(sourceidentity), core::mem::transmute_copy(targetidentity), &mut result__).map(|| result__) }) } - pub fn RequestAccessAsync(sourceidentity: &windows_core::HSTRING, targetidentity: &windows_core::HSTRING) -> windows_core::Result> { + pub fn RequestAccessAsync(sourceidentity: &windows_core::HSTRING, targetidentity: &windows_core::HSTRING) -> windows_core::Result> { Self::IProtectionPolicyManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestAccessAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(sourceidentity), core::mem::transmute_copy(targetidentity), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -1323,7 +1323,7 @@ impl ProtectionPolicyManager { (windows_core::Interface::vtable(this).CheckAccessForApp)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(sourceidentity), core::mem::transmute_copy(apppackagefamilyname), &mut result__).map(|| result__) }) } - pub fn RequestAccessForAppAsync(sourceidentity: &windows_core::HSTRING, apppackagefamilyname: &windows_core::HSTRING) -> windows_core::Result> { + pub fn RequestAccessForAppAsync(sourceidentity: &windows_core::HSTRING, apppackagefamilyname: &windows_core::HSTRING) -> windows_core::Result> { Self::IProtectionPolicyManagerStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestAccessForAppAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(sourceidentity), core::mem::transmute_copy(apppackagefamilyname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -1365,7 +1365,7 @@ impl ProtectionPolicyManager { (windows_core::Interface::vtable(this).IsProtectionEnabled)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) }) } - pub fn RequestAccessWithAuditingInfoAsync(sourceidentity: &windows_core::HSTRING, targetidentity: &windows_core::HSTRING, auditinfo: P2) -> windows_core::Result> + pub fn RequestAccessWithAuditingInfoAsync(sourceidentity: &windows_core::HSTRING, targetidentity: &windows_core::HSTRING, auditinfo: P2) -> windows_core::Result> where P2: windows_core::Param, { @@ -1374,7 +1374,7 @@ impl ProtectionPolicyManager { (windows_core::Interface::vtable(this).RequestAccessWithAuditingInfoAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(sourceidentity), core::mem::transmute_copy(targetidentity), auditinfo.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RequestAccessWithMessageAsync(sourceidentity: &windows_core::HSTRING, targetidentity: &windows_core::HSTRING, auditinfo: P2, messagefromapp: &windows_core::HSTRING) -> windows_core::Result> + pub fn RequestAccessWithMessageAsync(sourceidentity: &windows_core::HSTRING, targetidentity: &windows_core::HSTRING, auditinfo: P2, messagefromapp: &windows_core::HSTRING) -> windows_core::Result> where P2: windows_core::Param, { @@ -1383,7 +1383,7 @@ impl ProtectionPolicyManager { (windows_core::Interface::vtable(this).RequestAccessWithMessageAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(sourceidentity), core::mem::transmute_copy(targetidentity), auditinfo.param().abi(), core::mem::transmute_copy(messagefromapp), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RequestAccessForAppWithAuditingInfoAsync(sourceidentity: &windows_core::HSTRING, apppackagefamilyname: &windows_core::HSTRING, auditinfo: P2) -> windows_core::Result> + pub fn RequestAccessForAppWithAuditingInfoAsync(sourceidentity: &windows_core::HSTRING, apppackagefamilyname: &windows_core::HSTRING, auditinfo: P2) -> windows_core::Result> where P2: windows_core::Param, { @@ -1392,7 +1392,7 @@ impl ProtectionPolicyManager { (windows_core::Interface::vtable(this).RequestAccessForAppWithAuditingInfoAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(sourceidentity), core::mem::transmute_copy(apppackagefamilyname), auditinfo.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RequestAccessForAppWithMessageAsync(sourceidentity: &windows_core::HSTRING, apppackagefamilyname: &windows_core::HSTRING, auditinfo: P2, messagefromapp: &windows_core::HSTRING) -> windows_core::Result> + pub fn RequestAccessForAppWithMessageAsync(sourceidentity: &windows_core::HSTRING, apppackagefamilyname: &windows_core::HSTRING, auditinfo: P2, messagefromapp: &windows_core::HSTRING) -> windows_core::Result> where P2: windows_core::Param, { @@ -1413,7 +1413,7 @@ impl ProtectionPolicyManager { (windows_core::Interface::vtable(this).IsRoamableProtectionEnabled)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(identity), &mut result__).map(|| result__) }) } - pub fn RequestAccessWithBehaviorAsync(sourceidentity: &windows_core::HSTRING, targetidentity: &windows_core::HSTRING, auditinfo: P2, messagefromapp: &windows_core::HSTRING, behavior: ProtectionPolicyRequestAccessBehavior) -> windows_core::Result> + pub fn RequestAccessWithBehaviorAsync(sourceidentity: &windows_core::HSTRING, targetidentity: &windows_core::HSTRING, auditinfo: P2, messagefromapp: &windows_core::HSTRING, behavior: ProtectionPolicyRequestAccessBehavior) -> windows_core::Result> where P2: windows_core::Param, { @@ -1422,7 +1422,7 @@ impl ProtectionPolicyManager { (windows_core::Interface::vtable(this).RequestAccessWithBehaviorAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(sourceidentity), core::mem::transmute_copy(targetidentity), auditinfo.param().abi(), core::mem::transmute_copy(messagefromapp), behavior, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RequestAccessForAppWithBehaviorAsync(sourceidentity: &windows_core::HSTRING, apppackagefamilyname: &windows_core::HSTRING, auditinfo: P2, messagefromapp: &windows_core::HSTRING, behavior: ProtectionPolicyRequestAccessBehavior) -> windows_core::Result> + pub fn RequestAccessForAppWithBehaviorAsync(sourceidentity: &windows_core::HSTRING, apppackagefamilyname: &windows_core::HSTRING, auditinfo: P2, messagefromapp: &windows_core::HSTRING, behavior: ProtectionPolicyRequestAccessBehavior) -> windows_core::Result> where P2: windows_core::Param, { @@ -1432,7 +1432,7 @@ impl ProtectionPolicyManager { }) } #[cfg(feature = "Storage")] - pub fn RequestAccessToFilesForAppAsync(sourceitemlist: P0, apppackagefamilyname: &windows_core::HSTRING, auditinfo: P2) -> windows_core::Result> + pub fn RequestAccessToFilesForAppAsync(sourceitemlist: P0, apppackagefamilyname: &windows_core::HSTRING, auditinfo: P2) -> windows_core::Result> where P0: windows_core::Param>, P2: windows_core::Param, @@ -1443,7 +1443,7 @@ impl ProtectionPolicyManager { }) } #[cfg(feature = "Storage")] - pub fn RequestAccessToFilesForAppWithMessageAndBehaviorAsync(sourceitemlist: P0, apppackagefamilyname: &windows_core::HSTRING, auditinfo: P2, messagefromapp: &windows_core::HSTRING, behavior: ProtectionPolicyRequestAccessBehavior) -> windows_core::Result> + pub fn RequestAccessToFilesForAppWithMessageAndBehaviorAsync(sourceitemlist: P0, apppackagefamilyname: &windows_core::HSTRING, auditinfo: P2, messagefromapp: &windows_core::HSTRING, behavior: ProtectionPolicyRequestAccessBehavior) -> windows_core::Result> where P0: windows_core::Param>, P2: windows_core::Param, @@ -1454,7 +1454,7 @@ impl ProtectionPolicyManager { }) } #[cfg(feature = "Storage")] - pub fn RequestAccessToFilesForProcessAsync(sourceitemlist: P0, processid: u32, auditinfo: P2) -> windows_core::Result> + pub fn RequestAccessToFilesForProcessAsync(sourceitemlist: P0, processid: u32, auditinfo: P2) -> windows_core::Result> where P0: windows_core::Param>, P2: windows_core::Param, @@ -1465,7 +1465,7 @@ impl ProtectionPolicyManager { }) } #[cfg(feature = "Storage")] - pub fn RequestAccessToFilesForProcessWithMessageAndBehaviorAsync(sourceitemlist: P0, processid: u32, auditinfo: P2, messagefromapp: &windows_core::HSTRING, behavior: ProtectionPolicyRequestAccessBehavior) -> windows_core::Result> + pub fn RequestAccessToFilesForProcessWithMessageAndBehaviorAsync(sourceitemlist: P0, processid: u32, auditinfo: P2, messagefromapp: &windows_core::HSTRING, behavior: ProtectionPolicyRequestAccessBehavior) -> windows_core::Result> where P0: windows_core::Param>, P2: windows_core::Param, @@ -1476,7 +1476,7 @@ impl ProtectionPolicyManager { }) } #[cfg(feature = "Storage")] - pub fn IsFileProtectionRequiredAsync(target: P0, identity: &windows_core::HSTRING) -> windows_core::Result> + pub fn IsFileProtectionRequiredAsync(target: P0, identity: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -1486,7 +1486,7 @@ impl ProtectionPolicyManager { }) } #[cfg(feature = "Storage")] - pub fn IsFileProtectionRequiredForNewFileAsync(parentfolder: P0, identity: &windows_core::HSTRING, desiredname: &windows_core::HSTRING) -> windows_core::Result> + pub fn IsFileProtectionRequiredForNewFileAsync(parentfolder: P0, identity: &windows_core::HSTRING, desiredname: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Security/ExchangeActiveSyncProvisioning/mod.rs b/crates/libs/windows/src/Windows/Security/ExchangeActiveSyncProvisioning/mod.rs index 06dce5c3d4..f2bfd1c9b5 100644 --- a/crates/libs/windows/src/Windows/Security/ExchangeActiveSyncProvisioning/mod.rs +++ b/crates/libs/windows/src/Windows/Security/ExchangeActiveSyncProvisioning/mod.rs @@ -184,7 +184,7 @@ impl EasClientSecurityPolicy { (windows_core::Interface::vtable(this).CheckCompliance)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ApplyAsync(&self) -> windows_core::Result> { + pub fn ApplyAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Security/Isolation/mod.rs b/crates/libs/windows/src/Windows/Security/Isolation/mod.rs index d8318eb807..05646a68b3 100644 --- a/crates/libs/windows/src/Windows/Security/Isolation/mod.rs +++ b/crates/libs/windows/src/Windows/Security/Isolation/mod.rs @@ -503,14 +503,14 @@ impl IsolatedWindowsEnvironment { (windows_core::Interface::vtable(this).Id)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn StartProcessSilentlyAsync(&self, hostexepath: &windows_core::HSTRING, arguments: &windows_core::HSTRING, activator: IsolatedWindowsEnvironmentActivator) -> windows_core::Result> { + pub fn StartProcessSilentlyAsync(&self, hostexepath: &windows_core::HSTRING, arguments: &windows_core::HSTRING, activator: IsolatedWindowsEnvironmentActivator) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).StartProcessSilentlyAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(hostexepath), core::mem::transmute_copy(arguments), activator, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StartProcessSilentlyWithTelemetryAsync(&self, hostexepath: &windows_core::HSTRING, arguments: &windows_core::HSTRING, activator: IsolatedWindowsEnvironmentActivator, telemetryparameters: P3) -> windows_core::Result> + pub fn StartProcessSilentlyWithTelemetryAsync(&self, hostexepath: &windows_core::HSTRING, arguments: &windows_core::HSTRING, activator: IsolatedWindowsEnvironmentActivator, telemetryparameters: P3) -> windows_core::Result> where P3: windows_core::Param, { @@ -520,7 +520,7 @@ impl IsolatedWindowsEnvironment { (windows_core::Interface::vtable(this).StartProcessSilentlyWithTelemetryAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(hostexepath), core::mem::transmute_copy(arguments), activator, telemetryparameters.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ShareFolderAsync(&self, hostfolder: &windows_core::HSTRING, requestoptions: P1) -> windows_core::Result> + pub fn ShareFolderAsync(&self, hostfolder: &windows_core::HSTRING, requestoptions: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -530,7 +530,7 @@ impl IsolatedWindowsEnvironment { (windows_core::Interface::vtable(this).ShareFolderAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(hostfolder), requestoptions.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ShareFolderWithTelemetryAsync(&self, hostfolder: &windows_core::HSTRING, requestoptions: P1, telemetryparameters: P2) -> windows_core::Result> + pub fn ShareFolderWithTelemetryAsync(&self, hostfolder: &windows_core::HSTRING, requestoptions: P1, telemetryparameters: P2) -> windows_core::Result> where P1: windows_core::Param, P2: windows_core::Param, @@ -541,14 +541,14 @@ impl IsolatedWindowsEnvironment { (windows_core::Interface::vtable(this).ShareFolderWithTelemetryAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(hostfolder), requestoptions.param().abi(), telemetryparameters.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn LaunchFileWithUIAsync(&self, appexepath: &windows_core::HSTRING, argumentstemplate: &windows_core::HSTRING, filepath: &windows_core::HSTRING) -> windows_core::Result> { + pub fn LaunchFileWithUIAsync(&self, appexepath: &windows_core::HSTRING, argumentstemplate: &windows_core::HSTRING, filepath: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).LaunchFileWithUIAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(appexepath), core::mem::transmute_copy(argumentstemplate), core::mem::transmute_copy(filepath), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn LaunchFileWithUIAndTelemetryAsync(&self, appexepath: &windows_core::HSTRING, argumentstemplate: &windows_core::HSTRING, filepath: &windows_core::HSTRING, telemetryparameters: P3) -> windows_core::Result> + pub fn LaunchFileWithUIAndTelemetryAsync(&self, appexepath: &windows_core::HSTRING, argumentstemplate: &windows_core::HSTRING, filepath: &windows_core::HSTRING, telemetryparameters: P3) -> windows_core::Result> where P3: windows_core::Param, { @@ -558,14 +558,14 @@ impl IsolatedWindowsEnvironment { (windows_core::Interface::vtable(this).LaunchFileWithUIAndTelemetryAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(appexepath), core::mem::transmute_copy(argumentstemplate), core::mem::transmute_copy(filepath), telemetryparameters.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TerminateAsync(&self) -> windows_core::Result { + pub fn TerminateAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TerminateAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TerminateWithTelemetryAsync(&self, telemetryparameters: P0) -> windows_core::Result + pub fn TerminateWithTelemetryAsync(&self, telemetryparameters: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -586,7 +586,7 @@ impl IsolatedWindowsEnvironment { let this = self; unsafe { (windows_core::Interface::vtable(this).UnregisterMessageReceiver)(windows_core::Interface::as_raw(this), receiverid).ok() } } - pub fn PostMessageToReceiverAsync(&self, receiverid: windows_core::GUID, message: P1) -> windows_core::Result> + pub fn PostMessageToReceiverAsync(&self, receiverid: windows_core::GUID, message: P1) -> windows_core::Result> where P1: windows_core::Param>, { @@ -596,7 +596,7 @@ impl IsolatedWindowsEnvironment { (windows_core::Interface::vtable(this).PostMessageToReceiverAsync)(windows_core::Interface::as_raw(this), receiverid, message.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn PostMessageToReceiverWithTelemetryAsync(&self, receiverid: windows_core::GUID, message: P1, telemetryparameters: P2) -> windows_core::Result> + pub fn PostMessageToReceiverWithTelemetryAsync(&self, receiverid: windows_core::GUID, message: P1, telemetryparameters: P2) -> windows_core::Result> where P1: windows_core::Param>, P2: windows_core::Param, @@ -614,7 +614,7 @@ impl IsolatedWindowsEnvironment { (windows_core::Interface::vtable(this).GetUserInfo)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ShareFileAsync(&self, filepath: &windows_core::HSTRING, options: P1) -> windows_core::Result> + pub fn ShareFileAsync(&self, filepath: &windows_core::HSTRING, options: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -624,7 +624,7 @@ impl IsolatedWindowsEnvironment { (windows_core::Interface::vtable(this).ShareFileAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(filepath), options.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ShareFileWithTelemetryAsync(&self, filepath: &windows_core::HSTRING, options: P1, telemetryparameters: P2) -> windows_core::Result> + pub fn ShareFileWithTelemetryAsync(&self, filepath: &windows_core::HSTRING, options: P1, telemetryparameters: P2) -> windows_core::Result> where P1: windows_core::Param, P2: windows_core::Param, @@ -639,7 +639,7 @@ impl IsolatedWindowsEnvironment { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).ChangePriority)(windows_core::Interface::as_raw(this), priority).ok() } } - pub fn CreateAsync(options: P0) -> windows_core::Result> + pub fn CreateAsync(options: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -648,7 +648,7 @@ impl IsolatedWindowsEnvironment { (windows_core::Interface::vtable(this).CreateAsync)(windows_core::Interface::as_raw(this), options.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn CreateWithTelemetryAsync(options: P0, telemetryparameters: P1) -> windows_core::Result> + pub fn CreateWithTelemetryAsync(options: P0, telemetryparameters: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -1500,7 +1500,7 @@ impl IsolatedWindowsEnvironmentProcess { let this = self; unsafe { (windows_core::Interface::vtable(this).WaitForExitWithTimeout)(windows_core::Interface::as_raw(this), timeoutmilliseconds).ok() } } - pub fn WaitForExitAsync(&self) -> windows_core::Result { + pub fn WaitForExitAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1911,14 +1911,14 @@ impl IsolatedWindowsEnvironmentUserInfo { (windows_core::Interface::vtable(this).EnvironmentUserName)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn TryWaitForSignInAsync(&self) -> windows_core::Result> { + pub fn TryWaitForSignInAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryWaitForSignInAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryWaitForSignInWithProgressAsync(&self) -> windows_core::Result> { + pub fn TryWaitForSignInWithProgressAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Services/Maps/LocalSearch/mod.rs b/crates/libs/windows/src/Windows/Services/Maps/LocalSearch/mod.rs index c2d70a8402..a7d3004017 100644 --- a/crates/libs/windows/src/Windows/Services/Maps/LocalSearch/mod.rs +++ b/crates/libs/windows/src/Windows/Services/Maps/LocalSearch/mod.rs @@ -249,7 +249,7 @@ unsafe impl Sync for LocalLocation {} pub struct LocalLocationFinder; impl LocalLocationFinder { #[cfg(feature = "Devices_Geolocation")] - pub fn FindLocalLocationsAsync(searchterm: &windows_core::HSTRING, searcharea: P1, localcategory: &windows_core::HSTRING, maxresults: u32) -> windows_core::Result> + pub fn FindLocalLocationsAsync(searchterm: &windows_core::HSTRING, searcharea: P1, localcategory: &windows_core::HSTRING, maxresults: u32) -> windows_core::Result> where P1: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Services/Maps/OfflineMaps/mod.rs b/crates/libs/windows/src/Windows/Services/Maps/OfflineMaps/mod.rs index 6416b5d826..1519d5199f 100644 --- a/crates/libs/windows/src/Windows/Services/Maps/OfflineMaps/mod.rs +++ b/crates/libs/windows/src/Windows/Services/Maps/OfflineMaps/mod.rs @@ -99,7 +99,7 @@ impl OfflineMapPackage { (windows_core::Interface::vtable(this).StatusChanged)(windows_core::Interface::as_raw(this), value.param().abi(), &mut result__).map(|| result__) } } - pub fn RequestStartDownloadAsync(&self) -> windows_core::Result> { + pub fn RequestStartDownloadAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -107,7 +107,7 @@ impl OfflineMapPackage { } } #[cfg(feature = "Devices_Geolocation")] - pub fn FindPackagesAsync(querypoint: P0) -> windows_core::Result> + pub fn FindPackagesAsync(querypoint: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -117,7 +117,7 @@ impl OfflineMapPackage { }) } #[cfg(feature = "Devices_Geolocation")] - pub fn FindPackagesInBoundingBoxAsync(queryboundingbox: P0) -> windows_core::Result> + pub fn FindPackagesInBoundingBoxAsync(queryboundingbox: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -127,7 +127,7 @@ impl OfflineMapPackage { }) } #[cfg(feature = "Devices_Geolocation")] - pub fn FindPackagesInGeocircleAsync(querycircle: P0) -> windows_core::Result> + pub fn FindPackagesInGeocircleAsync(querycircle: P0) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Services/Maps/mod.rs b/crates/libs/windows/src/Windows/Services/Maps/mod.rs index 161aac5012..368491e140 100644 --- a/crates/libs/windows/src/Windows/Services/Maps/mod.rs +++ b/crates/libs/windows/src/Windows/Services/Maps/mod.rs @@ -806,7 +806,7 @@ impl windows_core::RuntimeType for MapLocationDesiredAccuracy { pub struct MapLocationFinder; impl MapLocationFinder { #[cfg(feature = "Devices_Geolocation")] - pub fn FindLocationsAtAsync(querypoint: P0) -> windows_core::Result> + pub fn FindLocationsAtAsync(querypoint: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -816,7 +816,7 @@ impl MapLocationFinder { }) } #[cfg(feature = "Devices_Geolocation")] - pub fn FindLocationsAsync(searchtext: &windows_core::HSTRING, referencepoint: P1) -> windows_core::Result> + pub fn FindLocationsAsync(searchtext: &windows_core::HSTRING, referencepoint: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -826,7 +826,7 @@ impl MapLocationFinder { }) } #[cfg(feature = "Devices_Geolocation")] - pub fn FindLocationsWithMaxCountAsync(searchtext: &windows_core::HSTRING, referencepoint: P1, maxcount: u32) -> windows_core::Result> + pub fn FindLocationsWithMaxCountAsync(searchtext: &windows_core::HSTRING, referencepoint: P1, maxcount: u32) -> windows_core::Result> where P1: windows_core::Param, { @@ -836,7 +836,7 @@ impl MapLocationFinder { }) } #[cfg(feature = "Devices_Geolocation")] - pub fn FindLocationsAtWithAccuracyAsync(querypoint: P0, accuracy: MapLocationDesiredAccuracy) -> windows_core::Result> + pub fn FindLocationsAtWithAccuracyAsync(querypoint: P0, accuracy: MapLocationDesiredAccuracy) -> windows_core::Result> where P0: windows_core::Param, { @@ -1156,7 +1156,7 @@ unsafe impl Sync for MapRouteDrivingOptions {} pub struct MapRouteFinder; impl MapRouteFinder { #[cfg(feature = "Devices_Geolocation")] - pub fn GetDrivingRouteAsync(startpoint: P0, endpoint: P1) -> windows_core::Result> + pub fn GetDrivingRouteAsync(startpoint: P0, endpoint: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -1167,7 +1167,7 @@ impl MapRouteFinder { }) } #[cfg(feature = "Devices_Geolocation")] - pub fn GetDrivingRouteWithOptimizationAsync(startpoint: P0, endpoint: P1, optimization: MapRouteOptimization) -> windows_core::Result> + pub fn GetDrivingRouteWithOptimizationAsync(startpoint: P0, endpoint: P1, optimization: MapRouteOptimization) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -1178,7 +1178,7 @@ impl MapRouteFinder { }) } #[cfg(feature = "Devices_Geolocation")] - pub fn GetDrivingRouteWithOptimizationAndRestrictionsAsync(startpoint: P0, endpoint: P1, optimization: MapRouteOptimization, restrictions: MapRouteRestrictions) -> windows_core::Result> + pub fn GetDrivingRouteWithOptimizationAndRestrictionsAsync(startpoint: P0, endpoint: P1, optimization: MapRouteOptimization, restrictions: MapRouteRestrictions) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -1189,7 +1189,7 @@ impl MapRouteFinder { }) } #[cfg(feature = "Devices_Geolocation")] - pub fn GetDrivingRouteWithOptimizationRestrictionsAndHeadingAsync(startpoint: P0, endpoint: P1, optimization: MapRouteOptimization, restrictions: MapRouteRestrictions, headingindegrees: f64) -> windows_core::Result> + pub fn GetDrivingRouteWithOptimizationRestrictionsAndHeadingAsync(startpoint: P0, endpoint: P1, optimization: MapRouteOptimization, restrictions: MapRouteRestrictions, headingindegrees: f64) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -1200,7 +1200,7 @@ impl MapRouteFinder { }) } #[cfg(feature = "Devices_Geolocation")] - pub fn GetDrivingRouteFromWaypointsAsync(waypoints: P0) -> windows_core::Result> + pub fn GetDrivingRouteFromWaypointsAsync(waypoints: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -1210,7 +1210,7 @@ impl MapRouteFinder { }) } #[cfg(feature = "Devices_Geolocation")] - pub fn GetDrivingRouteFromWaypointsAndOptimizationAsync(waypoints: P0, optimization: MapRouteOptimization) -> windows_core::Result> + pub fn GetDrivingRouteFromWaypointsAndOptimizationAsync(waypoints: P0, optimization: MapRouteOptimization) -> windows_core::Result> where P0: windows_core::Param>, { @@ -1220,7 +1220,7 @@ impl MapRouteFinder { }) } #[cfg(feature = "Devices_Geolocation")] - pub fn GetDrivingRouteFromWaypointsOptimizationAndRestrictionsAsync(waypoints: P0, optimization: MapRouteOptimization, restrictions: MapRouteRestrictions) -> windows_core::Result> + pub fn GetDrivingRouteFromWaypointsOptimizationAndRestrictionsAsync(waypoints: P0, optimization: MapRouteOptimization, restrictions: MapRouteRestrictions) -> windows_core::Result> where P0: windows_core::Param>, { @@ -1230,7 +1230,7 @@ impl MapRouteFinder { }) } #[cfg(feature = "Devices_Geolocation")] - pub fn GetDrivingRouteFromWaypointsOptimizationRestrictionsAndHeadingAsync(waypoints: P0, optimization: MapRouteOptimization, restrictions: MapRouteRestrictions, headingindegrees: f64) -> windows_core::Result> + pub fn GetDrivingRouteFromWaypointsOptimizationRestrictionsAndHeadingAsync(waypoints: P0, optimization: MapRouteOptimization, restrictions: MapRouteRestrictions, headingindegrees: f64) -> windows_core::Result> where P0: windows_core::Param>, { @@ -1240,7 +1240,7 @@ impl MapRouteFinder { }) } #[cfg(feature = "Devices_Geolocation")] - pub fn GetWalkingRouteAsync(startpoint: P0, endpoint: P1) -> windows_core::Result> + pub fn GetWalkingRouteAsync(startpoint: P0, endpoint: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -1251,7 +1251,7 @@ impl MapRouteFinder { }) } #[cfg(feature = "Devices_Geolocation")] - pub fn GetWalkingRouteFromWaypointsAsync(waypoints: P0) -> windows_core::Result> + pub fn GetWalkingRouteFromWaypointsAsync(waypoints: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -1261,7 +1261,7 @@ impl MapRouteFinder { }) } #[cfg(feature = "Devices_Geolocation")] - pub fn GetDrivingRouteWithOptionsAsync(startpoint: P0, endpoint: P1, options: P2) -> windows_core::Result> + pub fn GetDrivingRouteWithOptionsAsync(startpoint: P0, endpoint: P1, options: P2) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -1272,7 +1272,7 @@ impl MapRouteFinder { (windows_core::Interface::vtable(this).GetDrivingRouteWithOptionsAsync)(windows_core::Interface::as_raw(this), startpoint.param().abi(), endpoint.param().abi(), options.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetDrivingRouteFromEnhancedWaypointsAsync(waypoints: P0) -> windows_core::Result> + pub fn GetDrivingRouteFromEnhancedWaypointsAsync(waypoints: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -1281,7 +1281,7 @@ impl MapRouteFinder { (windows_core::Interface::vtable(this).GetDrivingRouteFromEnhancedWaypointsAsync)(windows_core::Interface::as_raw(this), waypoints.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetDrivingRouteFromEnhancedWaypointsWithOptionsAsync(waypoints: P0, options: P1) -> windows_core::Result> + pub fn GetDrivingRouteFromEnhancedWaypointsWithOptionsAsync(waypoints: P0, options: P1) -> windows_core::Result> where P0: windows_core::Param>, P1: windows_core::Param, diff --git a/crates/libs/windows/src/Windows/Services/Store/mod.rs b/crates/libs/windows/src/Windows/Services/Store/mod.rs index dcc6eecbbd..2af00741ab 100644 --- a/crates/libs/windows/src/Windows/Services/Store/mod.rs +++ b/crates/libs/windows/src/Windows/Services/Store/mod.rs @@ -714,14 +714,14 @@ impl StoreAvailability { (windows_core::Interface::vtable(this).ExtendedJsonData)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn RequestPurchaseAsync(&self) -> windows_core::Result> { + pub fn RequestPurchaseAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestPurchaseAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestPurchaseWithPurchasePropertiesAsync(&self, storepurchaseproperties: P0) -> windows_core::Result> + pub fn RequestPurchaseWithPurchasePropertiesAsync(&self, storepurchaseproperties: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -961,35 +961,35 @@ impl StoreContext { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveOfflineLicensesChanged)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn GetCustomerPurchaseIdAsync(&self, serviceticket: &windows_core::HSTRING, publisheruserid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetCustomerPurchaseIdAsync(&self, serviceticket: &windows_core::HSTRING, publisheruserid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetCustomerPurchaseIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(serviceticket), core::mem::transmute_copy(publisheruserid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetCustomerCollectionsIdAsync(&self, serviceticket: &windows_core::HSTRING, publisheruserid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetCustomerCollectionsIdAsync(&self, serviceticket: &windows_core::HSTRING, publisheruserid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetCustomerCollectionsIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(serviceticket), core::mem::transmute_copy(publisheruserid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAppLicenseAsync(&self) -> windows_core::Result> { + pub fn GetAppLicenseAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetAppLicenseAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetStoreProductForCurrentAppAsync(&self) -> windows_core::Result> { + pub fn GetStoreProductForCurrentAppAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetStoreProductForCurrentAppAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetStoreProductsAsync(&self, productkinds: P0, storeids: P1) -> windows_core::Result> + pub fn GetStoreProductsAsync(&self, productkinds: P0, storeids: P1) -> windows_core::Result> where P0: windows_core::Param>, P1: windows_core::Param>, @@ -1000,7 +1000,7 @@ impl StoreContext { (windows_core::Interface::vtable(this).GetStoreProductsAsync)(windows_core::Interface::as_raw(this), productkinds.param().abi(), storeids.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAssociatedStoreProductsAsync(&self, productkinds: P0) -> windows_core::Result> + pub fn GetAssociatedStoreProductsAsync(&self, productkinds: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -1010,7 +1010,7 @@ impl StoreContext { (windows_core::Interface::vtable(this).GetAssociatedStoreProductsAsync)(windows_core::Interface::as_raw(this), productkinds.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAssociatedStoreProductsWithPagingAsync(&self, productkinds: P0, maxitemstoretrieveperpage: u32) -> windows_core::Result> + pub fn GetAssociatedStoreProductsWithPagingAsync(&self, productkinds: P0, maxitemstoretrieveperpage: u32) -> windows_core::Result> where P0: windows_core::Param>, { @@ -1020,7 +1020,7 @@ impl StoreContext { (windows_core::Interface::vtable(this).GetAssociatedStoreProductsWithPagingAsync)(windows_core::Interface::as_raw(this), productkinds.param().abi(), maxitemstoretrieveperpage, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetUserCollectionAsync(&self, productkinds: P0) -> windows_core::Result> + pub fn GetUserCollectionAsync(&self, productkinds: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -1030,7 +1030,7 @@ impl StoreContext { (windows_core::Interface::vtable(this).GetUserCollectionAsync)(windows_core::Interface::as_raw(this), productkinds.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetUserCollectionWithPagingAsync(&self, productkinds: P0, maxitemstoretrieveperpage: u32) -> windows_core::Result> + pub fn GetUserCollectionWithPagingAsync(&self, productkinds: P0, maxitemstoretrieveperpage: u32) -> windows_core::Result> where P0: windows_core::Param>, { @@ -1040,14 +1040,14 @@ impl StoreContext { (windows_core::Interface::vtable(this).GetUserCollectionWithPagingAsync)(windows_core::Interface::as_raw(this), productkinds.param().abi(), maxitemstoretrieveperpage, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReportConsumableFulfillmentAsync(&self, productstoreid: &windows_core::HSTRING, quantity: u32, trackingid: windows_core::GUID) -> windows_core::Result> { + pub fn ReportConsumableFulfillmentAsync(&self, productstoreid: &windows_core::HSTRING, quantity: u32, trackingid: windows_core::GUID) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReportConsumableFulfillmentAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(productstoreid), quantity, trackingid, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetConsumableBalanceRemainingAsync(&self, productstoreid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetConsumableBalanceRemainingAsync(&self, productstoreid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1055,7 +1055,7 @@ impl StoreContext { } } #[cfg(feature = "ApplicationModel")] - pub fn AcquireStoreLicenseForOptionalPackageAsync(&self, optionalpackage: P0) -> windows_core::Result> + pub fn AcquireStoreLicenseForOptionalPackageAsync(&self, optionalpackage: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1065,14 +1065,14 @@ impl StoreContext { (windows_core::Interface::vtable(this).AcquireStoreLicenseForOptionalPackageAsync)(windows_core::Interface::as_raw(this), optionalpackage.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestPurchaseAsync(&self, storeid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn RequestPurchaseAsync(&self, storeid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestPurchaseAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(storeid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestPurchaseWithPurchasePropertiesAsync(&self, storeid: &windows_core::HSTRING, storepurchaseproperties: P1) -> windows_core::Result> + pub fn RequestPurchaseWithPurchasePropertiesAsync(&self, storeid: &windows_core::HSTRING, storepurchaseproperties: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -1082,14 +1082,14 @@ impl StoreContext { (windows_core::Interface::vtable(this).RequestPurchaseWithPurchasePropertiesAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(storeid), storepurchaseproperties.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAppAndOptionalStorePackageUpdatesAsync(&self) -> windows_core::Result>> { + pub fn GetAppAndOptionalStorePackageUpdatesAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetAppAndOptionalStorePackageUpdatesAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestDownloadStorePackageUpdatesAsync(&self, storepackageupdates: P0) -> windows_core::Result> + pub fn RequestDownloadStorePackageUpdatesAsync(&self, storepackageupdates: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -1099,7 +1099,7 @@ impl StoreContext { (windows_core::Interface::vtable(this).RequestDownloadStorePackageUpdatesAsync)(windows_core::Interface::as_raw(this), storepackageupdates.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestDownloadAndInstallStorePackageUpdatesAsync(&self, storepackageupdates: P0) -> windows_core::Result> + pub fn RequestDownloadAndInstallStorePackageUpdatesAsync(&self, storepackageupdates: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -1109,7 +1109,7 @@ impl StoreContext { (windows_core::Interface::vtable(this).RequestDownloadAndInstallStorePackageUpdatesAsync)(windows_core::Interface::as_raw(this), storepackageupdates.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestDownloadAndInstallStorePackagesAsync(&self, storeids: P0) -> windows_core::Result> + pub fn RequestDownloadAndInstallStorePackagesAsync(&self, storeids: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -1120,7 +1120,7 @@ impl StoreContext { } } #[cfg(feature = "ApplicationModel")] - pub fn FindStoreProductForPackageAsync(&self, productkinds: P0, package: P1) -> windows_core::Result> + pub fn FindStoreProductForPackageAsync(&self, productkinds: P0, package: P1) -> windows_core::Result> where P0: windows_core::Param>, P1: windows_core::Param, @@ -1138,7 +1138,7 @@ impl StoreContext { (windows_core::Interface::vtable(this).CanSilentlyDownloadStorePackageUpdates)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn TrySilentDownloadStorePackageUpdatesAsync(&self, storepackageupdates: P0) -> windows_core::Result> + pub fn TrySilentDownloadStorePackageUpdatesAsync(&self, storepackageupdates: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -1148,7 +1148,7 @@ impl StoreContext { (windows_core::Interface::vtable(this).TrySilentDownloadStorePackageUpdatesAsync)(windows_core::Interface::as_raw(this), storepackageupdates.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TrySilentDownloadAndInstallStorePackageUpdatesAsync(&self, storepackageupdates: P0) -> windows_core::Result> + pub fn TrySilentDownloadAndInstallStorePackageUpdatesAsync(&self, storepackageupdates: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -1159,7 +1159,7 @@ impl StoreContext { } } #[cfg(feature = "ApplicationModel")] - pub fn CanAcquireStoreLicenseForOptionalPackageAsync(&self, optionalpackage: P0) -> windows_core::Result> + pub fn CanAcquireStoreLicenseForOptionalPackageAsync(&self, optionalpackage: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1169,14 +1169,14 @@ impl StoreContext { (windows_core::Interface::vtable(this).CanAcquireStoreLicenseForOptionalPackageAsync)(windows_core::Interface::as_raw(this), optionalpackage.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CanAcquireStoreLicenseAsync(&self, productstoreid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CanAcquireStoreLicenseAsync(&self, productstoreid: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CanAcquireStoreLicenseAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(productstoreid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetStoreProductsWithOptionsAsync(&self, productkinds: P0, storeids: P1, storeproductoptions: P2) -> windows_core::Result> + pub fn GetStoreProductsWithOptionsAsync(&self, productkinds: P0, storeids: P1, storeproductoptions: P2) -> windows_core::Result> where P0: windows_core::Param>, P1: windows_core::Param>, @@ -1188,14 +1188,14 @@ impl StoreContext { (windows_core::Interface::vtable(this).GetStoreProductsWithOptionsAsync)(windows_core::Interface::as_raw(this), productkinds.param().abi(), storeids.param().abi(), storeproductoptions.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAssociatedStoreQueueItemsAsync(&self) -> windows_core::Result>> { + pub fn GetAssociatedStoreQueueItemsAsync(&self) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetAssociatedStoreQueueItemsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetStoreQueueItemsAsync(&self, storeids: P0) -> windows_core::Result>> + pub fn GetStoreQueueItemsAsync(&self, storeids: P0) -> windows_core::Result>> where P0: windows_core::Param>, { @@ -1205,7 +1205,7 @@ impl StoreContext { (windows_core::Interface::vtable(this).GetStoreQueueItemsAsync)(windows_core::Interface::as_raw(this), storeids.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestDownloadAndInstallStorePackagesWithInstallOptionsAsync(&self, storeids: P0, storepackageinstalloptions: P1) -> windows_core::Result> + pub fn RequestDownloadAndInstallStorePackagesWithInstallOptionsAsync(&self, storeids: P0, storepackageinstalloptions: P1) -> windows_core::Result> where P0: windows_core::Param>, P1: windows_core::Param, @@ -1216,7 +1216,7 @@ impl StoreContext { (windows_core::Interface::vtable(this).RequestDownloadAndInstallStorePackagesWithInstallOptionsAsync)(windows_core::Interface::as_raw(this), storeids.param().abi(), storepackageinstalloptions.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DownloadAndInstallStorePackagesAsync(&self, storeids: P0) -> windows_core::Result> + pub fn DownloadAndInstallStorePackagesAsync(&self, storeids: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -1227,7 +1227,7 @@ impl StoreContext { } } #[cfg(feature = "ApplicationModel")] - pub fn RequestUninstallStorePackageAsync(&self, package: P0) -> windows_core::Result> + pub fn RequestUninstallStorePackageAsync(&self, package: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1237,7 +1237,7 @@ impl StoreContext { (windows_core::Interface::vtable(this).RequestUninstallStorePackageAsync)(windows_core::Interface::as_raw(this), package.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestUninstallStorePackageByStoreIdAsync(&self, storeid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn RequestUninstallStorePackageByStoreIdAsync(&self, storeid: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1245,7 +1245,7 @@ impl StoreContext { } } #[cfg(feature = "ApplicationModel")] - pub fn UninstallStorePackageAsync(&self, package: P0) -> windows_core::Result> + pub fn UninstallStorePackageAsync(&self, package: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1255,21 +1255,21 @@ impl StoreContext { (windows_core::Interface::vtable(this).UninstallStorePackageAsync)(windows_core::Interface::as_raw(this), package.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn UninstallStorePackageByStoreIdAsync(&self, storeid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn UninstallStorePackageByStoreIdAsync(&self, storeid: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).UninstallStorePackageByStoreIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(storeid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestRateAndReviewAppAsync(&self) -> windows_core::Result> { + pub fn RequestRateAndReviewAppAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestRateAndReviewAppAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SetInstallOrderForAssociatedStoreQueueItemsAsync(&self, items: P0) -> windows_core::Result>> + pub fn SetInstallOrderForAssociatedStoreQueueItemsAsync(&self, items: P0) -> windows_core::Result>> where P0: windows_core::Param>, { @@ -1279,7 +1279,7 @@ impl StoreContext { (windows_core::Interface::vtable(this).SetInstallOrderForAssociatedStoreQueueItemsAsync)(windows_core::Interface::as_raw(this), items.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetUserPurchaseHistoryAsync(&self, productkinds: P0) -> windows_core::Result> + pub fn GetUserPurchaseHistoryAsync(&self, productkinds: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -1289,7 +1289,7 @@ impl StoreContext { (windows_core::Interface::vtable(this).GetUserPurchaseHistoryAsync)(windows_core::Interface::as_raw(this), productkinds.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAssociatedStoreProductsByInAppOfferTokenAsync(&self, inappoffertokens: P0) -> windows_core::Result> + pub fn GetAssociatedStoreProductsByInAppOfferTokenAsync(&self, inappoffertokens: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -1299,7 +1299,7 @@ impl StoreContext { (windows_core::Interface::vtable(this).GetAssociatedStoreProductsByInAppOfferTokenAsync)(windows_core::Interface::as_raw(this), inappoffertokens.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestPurchaseByInAppOfferTokenAsync(&self, inappoffertoken: &windows_core::HSTRING) -> windows_core::Result> { + pub fn RequestPurchaseByInAppOfferTokenAsync(&self, inappoffertoken: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1846,21 +1846,21 @@ impl StoreProduct { (windows_core::Interface::vtable(this).LinkUri)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetIsAnySkuInstalledAsync(&self) -> windows_core::Result> { + pub fn GetIsAnySkuInstalledAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetIsAnySkuInstalledAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestPurchaseAsync(&self) -> windows_core::Result> { + pub fn RequestPurchaseAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestPurchaseAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestPurchaseWithPurchasePropertiesAsync(&self, storepurchaseproperties: P0) -> windows_core::Result> + pub fn RequestPurchaseWithPurchasePropertiesAsync(&self, storepurchaseproperties: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1948,7 +1948,7 @@ impl StoreProductPagedQueryResult { (windows_core::Interface::vtable(this).ExtendedError)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn GetNextAsync(&self) -> windows_core::Result> { + pub fn GetNextAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2198,21 +2198,21 @@ impl StoreQueueItem { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveStatusChanged)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn CancelInstallAsync(&self) -> windows_core::Result { + pub fn CancelInstallAsync(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CancelInstallAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn PauseInstallAsync(&self) -> windows_core::Result { + pub fn PauseInstallAsync(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).PauseInstallAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ResumeInstallAsync(&self) -> windows_core::Result { + pub fn ResumeInstallAsync(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -2422,7 +2422,7 @@ impl windows_core::RuntimeType for StoreRateAndReviewStatus { } pub struct StoreRequestHelper; impl StoreRequestHelper { - pub fn SendRequestAsync(context: P0, requestkind: u32, parametersasjson: &windows_core::HSTRING) -> windows_core::Result> + pub fn SendRequestAsync(context: P0, requestkind: u32, parametersasjson: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -2582,21 +2582,21 @@ impl StoreSku { (windows_core::Interface::vtable(this).CollectionData)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetIsInstalledAsync(&self) -> windows_core::Result> { + pub fn GetIsInstalledAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetIsInstalledAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestPurchaseAsync(&self) -> windows_core::Result> { + pub fn RequestPurchaseAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestPurchaseAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestPurchaseWithPurchasePropertiesAsync(&self, storepurchaseproperties: P0) -> windows_core::Result> + pub fn RequestPurchaseWithPurchasePropertiesAsync(&self, storepurchaseproperties: P0) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Services/TargetedContent/mod.rs b/crates/libs/windows/src/Windows/Services/TargetedContent/mod.rs index 5a4ed77d62..18ce825373 100644 --- a/crates/libs/windows/src/Windows/Services/TargetedContent/mod.rs +++ b/crates/libs/windows/src/Windows/Services/TargetedContent/mod.rs @@ -202,7 +202,7 @@ pub struct ITargetedContentValue_Vtbl { pub struct TargetedContentAction(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(TargetedContentAction, windows_core::IUnknown, windows_core::IInspectable); impl TargetedContentAction { - pub fn InvokeAsync(&self) -> windows_core::Result { + pub fn InvokeAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -408,7 +408,7 @@ impl TargetedContentContainer { (windows_core::Interface::vtable(this).SelectSingleObject)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(path), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAsync(contentid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetAsync(contentid: &windows_core::HSTRING) -> windows_core::Result> { Self::ITargetedContentContainerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(contentid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -439,7 +439,7 @@ pub struct TargetedContentFile(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(TargetedContentFile, windows_core::IUnknown, windows_core::IInspectable, super::super::Storage::Streams::IRandomAccessStreamReference); #[cfg(feature = "Storage_Streams")] impl TargetedContentFile { - pub fn OpenReadAsync(&self) -> windows_core::Result> { + pub fn OpenReadAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -474,7 +474,7 @@ windows_core::imp::interface_hierarchy!(TargetedContentImage, windows_core::IUnk windows_core::imp::required_hierarchy!(TargetedContentImage, super::super::Storage::Streams::IRandomAccessStreamReference); #[cfg(feature = "Storage_Streams")] impl TargetedContentImage { - pub fn OpenReadAsync(&self) -> windows_core::Result> { + pub fn OpenReadAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -720,7 +720,7 @@ impl TargetedContentSubscription { (windows_core::Interface::vtable(this).Id)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn GetContentContainerAsync(&self) -> windows_core::Result> { + pub fn GetContentContainerAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -769,7 +769,7 @@ impl TargetedContentSubscription { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveStateChanged)(windows_core::Interface::as_raw(this), cookie).ok() } } - pub fn GetAsync(subscriptionid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetAsync(subscriptionid: &windows_core::HSTRING) -> windows_core::Result> { Self::ITargetedContentSubscriptionStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(subscriptionid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/Storage/AccessCache/mod.rs b/crates/libs/windows/src/Windows/Storage/AccessCache/mod.rs index 0beab565dd..45b6ec2828 100644 --- a/crates/libs/windows/src/Windows/Storage/AccessCache/mod.rs +++ b/crates/libs/windows/src/Windows/Storage/AccessCache/mod.rs @@ -200,7 +200,7 @@ impl IStorageItemAccessList { let this = self; unsafe { (windows_core::Interface::vtable(this).AddOrReplace)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(token), file.param().abi(), core::mem::transmute_copy(metadata)).ok() } } - pub fn GetItemAsync(&self, token: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetItemAsync(&self, token: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -208,7 +208,7 @@ impl IStorageItemAccessList { } } #[cfg(feature = "Storage_Streams")] - pub fn GetFileAsync(&self, token: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetFileAsync(&self, token: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -216,14 +216,14 @@ impl IStorageItemAccessList { } } #[cfg(feature = "Storage_Search")] - pub fn GetFolderAsync(&self, token: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetFolderAsync(&self, token: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFolderAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(token), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetItemWithOptionsAsync(&self, token: &windows_core::HSTRING, options: AccessCacheOptions) -> windows_core::Result> { + pub fn GetItemWithOptionsAsync(&self, token: &windows_core::HSTRING, options: AccessCacheOptions) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -231,7 +231,7 @@ impl IStorageItemAccessList { } } #[cfg(feature = "Storage_Streams")] - pub fn GetFileWithOptionsAsync(&self, token: &windows_core::HSTRING, options: AccessCacheOptions) -> windows_core::Result> { + pub fn GetFileWithOptionsAsync(&self, token: &windows_core::HSTRING, options: AccessCacheOptions) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -239,7 +239,7 @@ impl IStorageItemAccessList { } } #[cfg(feature = "Storage_Search")] - pub fn GetFolderWithOptionsAsync(&self, token: &windows_core::HSTRING, options: AccessCacheOptions) -> windows_core::Result> { + pub fn GetFolderWithOptionsAsync(&self, token: &windows_core::HSTRING, options: AccessCacheOptions) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -296,12 +296,12 @@ pub trait IStorageItemAccessList_Impl: windows_core::IUnknownImpl { fn Add(&self, file: windows_core::Ref<'_, super::IStorageItem>, metadata: &windows_core::HSTRING) -> windows_core::Result; fn AddOrReplaceOverloadDefaultMetadata(&self, token: &windows_core::HSTRING, file: windows_core::Ref<'_, super::IStorageItem>) -> windows_core::Result<()>; fn AddOrReplace(&self, token: &windows_core::HSTRING, file: windows_core::Ref<'_, super::IStorageItem>, metadata: &windows_core::HSTRING) -> windows_core::Result<()>; - fn GetItemAsync(&self, token: &windows_core::HSTRING) -> windows_core::Result>; - fn GetFileAsync(&self, token: &windows_core::HSTRING) -> windows_core::Result>; - fn GetFolderAsync(&self, token: &windows_core::HSTRING) -> windows_core::Result>; - fn GetItemWithOptionsAsync(&self, token: &windows_core::HSTRING, options: AccessCacheOptions) -> windows_core::Result>; - fn GetFileWithOptionsAsync(&self, token: &windows_core::HSTRING, options: AccessCacheOptions) -> windows_core::Result>; - fn GetFolderWithOptionsAsync(&self, token: &windows_core::HSTRING, options: AccessCacheOptions) -> windows_core::Result>; + fn GetItemAsync(&self, token: &windows_core::HSTRING) -> windows_core::Result>; + fn GetFileAsync(&self, token: &windows_core::HSTRING) -> windows_core::Result>; + fn GetFolderAsync(&self, token: &windows_core::HSTRING) -> windows_core::Result>; + fn GetItemWithOptionsAsync(&self, token: &windows_core::HSTRING, options: AccessCacheOptions) -> windows_core::Result>; + fn GetFileWithOptionsAsync(&self, token: &windows_core::HSTRING, options: AccessCacheOptions) -> windows_core::Result>; + fn GetFolderWithOptionsAsync(&self, token: &windows_core::HSTRING, options: AccessCacheOptions) -> windows_core::Result>; fn Remove(&self, token: &windows_core::HSTRING) -> windows_core::Result<()>; fn ContainsItem(&self, token: &windows_core::HSTRING) -> windows_core::Result; fn Clear(&self) -> windows_core::Result<()>; @@ -686,7 +686,7 @@ impl StorageItemAccessList { let this = self; unsafe { (windows_core::Interface::vtable(this).AddOrReplace)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(token), file.param().abi(), core::mem::transmute_copy(metadata)).ok() } } - pub fn GetItemAsync(&self, token: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetItemAsync(&self, token: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -694,7 +694,7 @@ impl StorageItemAccessList { } } #[cfg(feature = "Storage_Streams")] - pub fn GetFileAsync(&self, token: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetFileAsync(&self, token: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -702,14 +702,14 @@ impl StorageItemAccessList { } } #[cfg(feature = "Storage_Search")] - pub fn GetFolderAsync(&self, token: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetFolderAsync(&self, token: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFolderAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(token), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetItemWithOptionsAsync(&self, token: &windows_core::HSTRING, options: AccessCacheOptions) -> windows_core::Result> { + pub fn GetItemWithOptionsAsync(&self, token: &windows_core::HSTRING, options: AccessCacheOptions) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -717,7 +717,7 @@ impl StorageItemAccessList { } } #[cfg(feature = "Storage_Streams")] - pub fn GetFileWithOptionsAsync(&self, token: &windows_core::HSTRING, options: AccessCacheOptions) -> windows_core::Result> { + pub fn GetFileWithOptionsAsync(&self, token: &windows_core::HSTRING, options: AccessCacheOptions) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -725,7 +725,7 @@ impl StorageItemAccessList { } } #[cfg(feature = "Storage_Search")] - pub fn GetFolderWithOptionsAsync(&self, token: &windows_core::HSTRING, options: AccessCacheOptions) -> windows_core::Result> { + pub fn GetFolderWithOptionsAsync(&self, token: &windows_core::HSTRING, options: AccessCacheOptions) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -822,7 +822,7 @@ impl StorageItemMostRecentlyUsedList { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).AddOrReplace)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(token), file.param().abi(), core::mem::transmute_copy(metadata)).ok() } } - pub fn GetItemAsync(&self, token: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetItemAsync(&self, token: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -830,7 +830,7 @@ impl StorageItemMostRecentlyUsedList { } } #[cfg(feature = "Storage_Streams")] - pub fn GetFileAsync(&self, token: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetFileAsync(&self, token: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -838,14 +838,14 @@ impl StorageItemMostRecentlyUsedList { } } #[cfg(feature = "Storage_Search")] - pub fn GetFolderAsync(&self, token: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetFolderAsync(&self, token: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFolderAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(token), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetItemWithOptionsAsync(&self, token: &windows_core::HSTRING, options: AccessCacheOptions) -> windows_core::Result> { + pub fn GetItemWithOptionsAsync(&self, token: &windows_core::HSTRING, options: AccessCacheOptions) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -853,7 +853,7 @@ impl StorageItemMostRecentlyUsedList { } } #[cfg(feature = "Storage_Streams")] - pub fn GetFileWithOptionsAsync(&self, token: &windows_core::HSTRING, options: AccessCacheOptions) -> windows_core::Result> { + pub fn GetFileWithOptionsAsync(&self, token: &windows_core::HSTRING, options: AccessCacheOptions) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -861,7 +861,7 @@ impl StorageItemMostRecentlyUsedList { } } #[cfg(feature = "Storage_Search")] - pub fn GetFolderWithOptionsAsync(&self, token: &windows_core::HSTRING, options: AccessCacheOptions) -> windows_core::Result> { + pub fn GetFolderWithOptionsAsync(&self, token: &windows_core::HSTRING, options: AccessCacheOptions) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Storage/BulkAccess/mod.rs b/crates/libs/windows/src/Windows/Storage/BulkAccess/mod.rs index ca4a8689a0..1542b4d4ce 100644 --- a/crates/libs/windows/src/Windows/Storage/BulkAccess/mod.rs +++ b/crates/libs/windows/src/Windows/Storage/BulkAccess/mod.rs @@ -8,14 +8,14 @@ windows_core::imp::interface_hierarchy!(FileInformation, windows_core::IUnknown, windows_core::imp::required_hierarchy!(FileInformation, super::Streams::IInputStreamReference, super::Streams::IRandomAccessStreamReference, super::IStorageFile, super::IStorageFile2, super::IStorageFilePropertiesWithAvailability, super::IStorageItem, super::IStorageItem2, super::IStorageItemProperties, super::IStorageItemPropertiesWithProvider); #[cfg(feature = "Storage_Streams")] impl FileInformation { - pub fn OpenSequentialReadAsync(&self) -> windows_core::Result> { + pub fn OpenSequentialReadAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).OpenSequentialReadAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn OpenReadAsync(&self) -> windows_core::Result> { + pub fn OpenReadAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -36,21 +36,21 @@ impl FileInformation { (windows_core::Interface::vtable(this).ContentType)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn OpenAsync(&self, accessmode: super::FileAccessMode) -> windows_core::Result> { + pub fn OpenAsync(&self, accessmode: super::FileAccessMode) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).OpenAsync)(windows_core::Interface::as_raw(this), accessmode, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn OpenTransactedWriteAsync(&self) -> windows_core::Result> { + pub fn OpenTransactedWriteAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).OpenTransactedWriteAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CopyOverloadDefaultNameAndOptions(&self, destinationfolder: P0) -> windows_core::Result> + pub fn CopyOverloadDefaultNameAndOptions(&self, destinationfolder: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -60,7 +60,7 @@ impl FileInformation { (windows_core::Interface::vtable(this).CopyOverloadDefaultNameAndOptions)(windows_core::Interface::as_raw(this), destinationfolder.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CopyOverloadDefaultOptions(&self, destinationfolder: P0, desirednewname: &windows_core::HSTRING) -> windows_core::Result> + pub fn CopyOverloadDefaultOptions(&self, destinationfolder: P0, desirednewname: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -70,7 +70,7 @@ impl FileInformation { (windows_core::Interface::vtable(this).CopyOverloadDefaultOptions)(windows_core::Interface::as_raw(this), destinationfolder.param().abi(), core::mem::transmute_copy(desirednewname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CopyOverload(&self, destinationfolder: P0, desirednewname: &windows_core::HSTRING, option: super::NameCollisionOption) -> windows_core::Result> + pub fn CopyOverload(&self, destinationfolder: P0, desirednewname: &windows_core::HSTRING, option: super::NameCollisionOption) -> windows_core::Result> where P0: windows_core::Param, { @@ -80,7 +80,7 @@ impl FileInformation { (windows_core::Interface::vtable(this).CopyOverload)(windows_core::Interface::as_raw(this), destinationfolder.param().abi(), core::mem::transmute_copy(desirednewname), option, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CopyAndReplaceAsync(&self, filetoreplace: P0) -> windows_core::Result + pub fn CopyAndReplaceAsync(&self, filetoreplace: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -90,7 +90,7 @@ impl FileInformation { (windows_core::Interface::vtable(this).CopyAndReplaceAsync)(windows_core::Interface::as_raw(this), filetoreplace.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn MoveOverloadDefaultNameAndOptions(&self, destinationfolder: P0) -> windows_core::Result + pub fn MoveOverloadDefaultNameAndOptions(&self, destinationfolder: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -100,7 +100,7 @@ impl FileInformation { (windows_core::Interface::vtable(this).MoveOverloadDefaultNameAndOptions)(windows_core::Interface::as_raw(this), destinationfolder.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn MoveOverloadDefaultOptions(&self, destinationfolder: P0, desirednewname: &windows_core::HSTRING) -> windows_core::Result + pub fn MoveOverloadDefaultOptions(&self, destinationfolder: P0, desirednewname: &windows_core::HSTRING) -> windows_core::Result where P0: windows_core::Param, { @@ -110,7 +110,7 @@ impl FileInformation { (windows_core::Interface::vtable(this).MoveOverloadDefaultOptions)(windows_core::Interface::as_raw(this), destinationfolder.param().abi(), core::mem::transmute_copy(desirednewname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn MoveOverload(&self, destinationfolder: P0, desirednewname: &windows_core::HSTRING, option: super::NameCollisionOption) -> windows_core::Result + pub fn MoveOverload(&self, destinationfolder: P0, desirednewname: &windows_core::HSTRING, option: super::NameCollisionOption) -> windows_core::Result where P0: windows_core::Param, { @@ -120,7 +120,7 @@ impl FileInformation { (windows_core::Interface::vtable(this).MoveOverload)(windows_core::Interface::as_raw(this), destinationfolder.param().abi(), core::mem::transmute_copy(desirednewname), option, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn MoveAndReplaceAsync(&self, filetoreplace: P0) -> windows_core::Result + pub fn MoveAndReplaceAsync(&self, filetoreplace: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -130,14 +130,14 @@ impl FileInformation { (windows_core::Interface::vtable(this).MoveAndReplaceAsync)(windows_core::Interface::as_raw(this), filetoreplace.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn OpenWithOptionsAsync(&self, accessmode: super::FileAccessMode, options: super::StorageOpenOptions) -> windows_core::Result> { + pub fn OpenWithOptionsAsync(&self, accessmode: super::FileAccessMode, options: super::StorageOpenOptions) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).OpenWithOptionsAsync)(windows_core::Interface::as_raw(this), accessmode, options, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn OpenTransactedWriteWithOptionsAsync(&self, options: super::StorageOpenOptions) -> windows_core::Result> { + pub fn OpenTransactedWriteWithOptionsAsync(&self, options: super::StorageOpenOptions) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -151,28 +151,28 @@ impl FileInformation { (windows_core::Interface::vtable(this).IsAvailable)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn RenameAsyncOverloadDefaultOptions(&self, desiredname: &windows_core::HSTRING) -> windows_core::Result { + pub fn RenameAsyncOverloadDefaultOptions(&self, desiredname: &windows_core::HSTRING) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RenameAsyncOverloadDefaultOptions)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(desiredname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RenameAsync(&self, desiredname: &windows_core::HSTRING, option: super::NameCollisionOption) -> windows_core::Result { + pub fn RenameAsync(&self, desiredname: &windows_core::HSTRING, option: super::NameCollisionOption) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RenameAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(desiredname), option, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAsyncOverloadDefaultOptions(&self) -> windows_core::Result { + pub fn DeleteAsyncOverloadDefaultOptions(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeleteAsyncOverloadDefaultOptions)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAsync(&self, option: super::StorageDeleteOption) -> windows_core::Result { + pub fn DeleteAsync(&self, option: super::StorageDeleteOption) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -180,7 +180,7 @@ impl FileInformation { } } #[cfg(feature = "Storage_FileProperties")] - pub fn GetBasicPropertiesAsync(&self) -> windows_core::Result> { + pub fn GetBasicPropertiesAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -223,7 +223,7 @@ impl FileInformation { } } #[cfg(feature = "Storage_Search")] - pub fn GetParentAsync(&self) -> windows_core::Result> { + pub fn GetParentAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -317,7 +317,7 @@ impl FileInformation { unsafe { (windows_core::Interface::vtable(this).RemovePropertiesUpdated)(windows_core::Interface::as_raw(this), eventcookie).ok() } } #[cfg(feature = "Storage_FileProperties")] - pub fn GetThumbnailAsyncOverloadDefaultSizeDefaultOptions(&self, mode: super::FileProperties::ThumbnailMode) -> windows_core::Result> { + pub fn GetThumbnailAsyncOverloadDefaultSizeDefaultOptions(&self, mode: super::FileProperties::ThumbnailMode) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -325,7 +325,7 @@ impl FileInformation { } } #[cfg(feature = "Storage_FileProperties")] - pub fn GetThumbnailAsyncOverloadDefaultOptions(&self, mode: super::FileProperties::ThumbnailMode, requestedsize: u32) -> windows_core::Result> { + pub fn GetThumbnailAsyncOverloadDefaultOptions(&self, mode: super::FileProperties::ThumbnailMode, requestedsize: u32) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -333,7 +333,7 @@ impl FileInformation { } } #[cfg(feature = "Storage_FileProperties")] - pub fn GetThumbnailAsync(&self, mode: super::FileProperties::ThumbnailMode, requestedsize: u32, options: super::FileProperties::ThumbnailOptions) -> windows_core::Result> { + pub fn GetThumbnailAsync(&self, mode: super::FileProperties::ThumbnailMode, requestedsize: u32, options: super::FileProperties::ThumbnailOptions) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -395,14 +395,14 @@ impl windows_core::RuntimeName for FileInformation { pub struct FileInformationFactory(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(FileInformationFactory, windows_core::IUnknown, windows_core::IInspectable); impl FileInformationFactory { - pub fn GetItemsAsync(&self, startindex: u32, maxitemstoretrieve: u32) -> windows_core::Result>> { + pub fn GetItemsAsync(&self, startindex: u32, maxitemstoretrieve: u32) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetItemsAsync)(windows_core::Interface::as_raw(this), startindex, maxitemstoretrieve, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetItemsAsyncDefaultStartAndCount(&self) -> windows_core::Result>> { + pub fn GetItemsAsyncDefaultStartAndCount(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -410,7 +410,7 @@ impl FileInformationFactory { } } #[cfg(feature = "Storage_Streams")] - pub fn GetFilesAsync(&self, startindex: u32, maxitemstoretrieve: u32) -> windows_core::Result>> { + pub fn GetFilesAsync(&self, startindex: u32, maxitemstoretrieve: u32) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -418,7 +418,7 @@ impl FileInformationFactory { } } #[cfg(feature = "Storage_Streams")] - pub fn GetFilesAsyncDefaultStartAndCount(&self) -> windows_core::Result>> { + pub fn GetFilesAsyncDefaultStartAndCount(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -426,7 +426,7 @@ impl FileInformationFactory { } } #[cfg(feature = "Storage_Search")] - pub fn GetFoldersAsync(&self, startindex: u32, maxitemstoretrieve: u32) -> windows_core::Result>> { + pub fn GetFoldersAsync(&self, startindex: u32, maxitemstoretrieve: u32) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -434,7 +434,7 @@ impl FileInformationFactory { } } #[cfg(feature = "Storage_Search")] - pub fn GetFoldersAsyncDefaultStartAndCount(&self) -> windows_core::Result>> { + pub fn GetFoldersAsyncDefaultStartAndCount(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -530,7 +530,7 @@ windows_core::imp::required_hierarchy!(FolderInformation, super::IStorageFolder, #[cfg(feature = "Storage_Search")] impl FolderInformation { #[cfg(feature = "Storage_Streams")] - pub fn CreateFileAsyncOverloadDefaultOptions(&self, desiredname: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CreateFileAsyncOverloadDefaultOptions(&self, desiredname: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -538,21 +538,21 @@ impl FolderInformation { } } #[cfg(feature = "Storage_Streams")] - pub fn CreateFileAsync(&self, desiredname: &windows_core::HSTRING, options: super::CreationCollisionOption) -> windows_core::Result> { + pub fn CreateFileAsync(&self, desiredname: &windows_core::HSTRING, options: super::CreationCollisionOption) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreateFileAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(desiredname), options, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateFolderAsyncOverloadDefaultOptions(&self, desiredname: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CreateFolderAsyncOverloadDefaultOptions(&self, desiredname: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreateFolderAsyncOverloadDefaultOptions)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(desiredname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateFolderAsync(&self, desiredname: &windows_core::HSTRING, options: super::CreationCollisionOption) -> windows_core::Result> { + pub fn CreateFolderAsync(&self, desiredname: &windows_core::HSTRING, options: super::CreationCollisionOption) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -560,21 +560,21 @@ impl FolderInformation { } } #[cfg(feature = "Storage_Streams")] - pub fn GetFileAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetFileAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFileAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(name), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetFolderAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetFolderAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFolderAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(name), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetItemAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetItemAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -582,35 +582,35 @@ impl FolderInformation { } } #[cfg(feature = "Storage_Streams")] - pub fn GetFilesAsyncOverloadDefaultOptionsStartAndCount(&self) -> windows_core::Result>> { + pub fn GetFilesAsyncOverloadDefaultOptionsStartAndCount(&self) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFilesAsyncOverloadDefaultOptionsStartAndCount)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetFoldersAsyncOverloadDefaultOptionsStartAndCount(&self) -> windows_core::Result>> { + pub fn GetFoldersAsyncOverloadDefaultOptionsStartAndCount(&self) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFoldersAsyncOverloadDefaultOptionsStartAndCount)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetItemsAsyncOverloadDefaultStartAndCount(&self) -> windows_core::Result>> { + pub fn GetItemsAsyncOverloadDefaultStartAndCount(&self) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetItemsAsyncOverloadDefaultStartAndCount)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryGetItemAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { + pub fn TryGetItemAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryGetItemAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(name), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetIndexedStateAsync(&self) -> windows_core::Result> { + pub fn GetIndexedStateAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -683,7 +683,7 @@ impl FolderInformation { } } #[cfg(feature = "Storage_Streams")] - pub fn GetFilesAsync(&self, query: super::Search::CommonFileQuery, startindex: u32, maxitemstoretrieve: u32) -> windows_core::Result>> { + pub fn GetFilesAsync(&self, query: super::Search::CommonFileQuery, startindex: u32, maxitemstoretrieve: u32) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -691,28 +691,28 @@ impl FolderInformation { } } #[cfg(feature = "Storage_Streams")] - pub fn GetFilesAsyncOverloadDefaultStartAndCount(&self, query: super::Search::CommonFileQuery) -> windows_core::Result>> { + pub fn GetFilesAsyncOverloadDefaultStartAndCount(&self, query: super::Search::CommonFileQuery) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFilesAsyncOverloadDefaultStartAndCount)(windows_core::Interface::as_raw(this), query, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetFoldersAsync(&self, query: super::Search::CommonFolderQuery, startindex: u32, maxitemstoretrieve: u32) -> windows_core::Result>> { + pub fn GetFoldersAsync(&self, query: super::Search::CommonFolderQuery, startindex: u32, maxitemstoretrieve: u32) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFoldersAsync)(windows_core::Interface::as_raw(this), query, startindex, maxitemstoretrieve, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetFoldersAsyncOverloadDefaultStartAndCount(&self, query: super::Search::CommonFolderQuery) -> windows_core::Result>> { + pub fn GetFoldersAsyncOverloadDefaultStartAndCount(&self, query: super::Search::CommonFolderQuery) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFoldersAsyncOverloadDefaultStartAndCount)(windows_core::Interface::as_raw(this), query, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetItemsAsync(&self, startindex: u32, maxitemstoretrieve: u32) -> windows_core::Result>> { + pub fn GetItemsAsync(&self, startindex: u32, maxitemstoretrieve: u32) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -743,28 +743,28 @@ impl FolderInformation { (windows_core::Interface::vtable(this).IsCommonFileQuerySupported)(windows_core::Interface::as_raw(this), query, &mut result__).map(|| result__) } } - pub fn RenameAsyncOverloadDefaultOptions(&self, desiredname: &windows_core::HSTRING) -> windows_core::Result { + pub fn RenameAsyncOverloadDefaultOptions(&self, desiredname: &windows_core::HSTRING) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RenameAsyncOverloadDefaultOptions)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(desiredname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RenameAsync(&self, desiredname: &windows_core::HSTRING, option: super::NameCollisionOption) -> windows_core::Result { + pub fn RenameAsync(&self, desiredname: &windows_core::HSTRING, option: super::NameCollisionOption) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RenameAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(desiredname), option, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAsyncOverloadDefaultOptions(&self) -> windows_core::Result { + pub fn DeleteAsyncOverloadDefaultOptions(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeleteAsyncOverloadDefaultOptions)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAsync(&self, option: super::StorageDeleteOption) -> windows_core::Result { + pub fn DeleteAsync(&self, option: super::StorageDeleteOption) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -772,7 +772,7 @@ impl FolderInformation { } } #[cfg(feature = "Storage_FileProperties")] - pub fn GetBasicPropertiesAsync(&self) -> windows_core::Result> { + pub fn GetBasicPropertiesAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -814,7 +814,7 @@ impl FolderInformation { (windows_core::Interface::vtable(this).IsOfType)(windows_core::Interface::as_raw(this), r#type, &mut result__).map(|| result__) } } - pub fn GetParentAsync(&self) -> windows_core::Result> { + pub fn GetParentAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -908,7 +908,7 @@ impl FolderInformation { unsafe { (windows_core::Interface::vtable(this).RemovePropertiesUpdated)(windows_core::Interface::as_raw(this), eventcookie).ok() } } #[cfg(all(feature = "Storage_FileProperties", feature = "Storage_Streams"))] - pub fn GetThumbnailAsyncOverloadDefaultSizeDefaultOptions(&self, mode: super::FileProperties::ThumbnailMode) -> windows_core::Result> { + pub fn GetThumbnailAsyncOverloadDefaultSizeDefaultOptions(&self, mode: super::FileProperties::ThumbnailMode) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -916,7 +916,7 @@ impl FolderInformation { } } #[cfg(all(feature = "Storage_FileProperties", feature = "Storage_Streams"))] - pub fn GetThumbnailAsyncOverloadDefaultOptions(&self, mode: super::FileProperties::ThumbnailMode, requestedsize: u32) -> windows_core::Result> { + pub fn GetThumbnailAsyncOverloadDefaultOptions(&self, mode: super::FileProperties::ThumbnailMode, requestedsize: u32) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -924,7 +924,7 @@ impl FolderInformation { } } #[cfg(all(feature = "Storage_FileProperties", feature = "Storage_Streams"))] - pub fn GetThumbnailAsync(&self, mode: super::FileProperties::ThumbnailMode, requestedsize: u32, options: super::FileProperties::ThumbnailOptions) -> windows_core::Result> { + pub fn GetThumbnailAsync(&self, mode: super::FileProperties::ThumbnailMode, requestedsize: u32, options: super::FileProperties::ThumbnailOptions) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Storage/Compression/mod.rs b/crates/libs/windows/src/Windows/Storage/Compression/mod.rs index 7c00098fdd..07509c3953 100644 --- a/crates/libs/windows/src/Windows/Storage/Compression/mod.rs +++ b/crates/libs/windows/src/Windows/Storage/Compression/mod.rs @@ -29,7 +29,7 @@ impl Compressor { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).Close)(windows_core::Interface::as_raw(this)).ok() } } - pub fn FinishAsync(&self) -> windows_core::Result> { + pub fn FinishAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -61,7 +61,7 @@ impl Compressor { (windows_core::Interface::vtable(this).CreateCompressorEx)(windows_core::Interface::as_raw(this), underlyingstream.param().abi(), algorithm, blocksize, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn WriteAsync(&self, buffer: P0) -> windows_core::Result> + pub fn WriteAsync(&self, buffer: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -71,7 +71,7 @@ impl Compressor { (windows_core::Interface::vtable(this).WriteAsync)(windows_core::Interface::as_raw(this), buffer.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FlushAsync(&self) -> windows_core::Result> { + pub fn FlushAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -130,7 +130,7 @@ impl Decompressor { (windows_core::Interface::vtable(this).CreateDecompressor)(windows_core::Interface::as_raw(this), underlyingstream.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn ReadAsync(&self, buffer: P0, count: u32, options: super::Streams::InputStreamOptions) -> windows_core::Result> + pub fn ReadAsync(&self, buffer: P0, count: u32, options: super::Streams::InputStreamOptions) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Storage/FileProperties/mod.rs b/crates/libs/windows/src/Windows/Storage/FileProperties/mod.rs index 7d982e30bd..01c1ac9a12 100644 --- a/crates/libs/windows/src/Windows/Storage/FileProperties/mod.rs +++ b/crates/libs/windows/src/Windows/Storage/FileProperties/mod.rs @@ -25,7 +25,7 @@ impl BasicProperties { (windows_core::Interface::vtable(this).ItemDate)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn RetrievePropertiesAsync(&self, propertiestoretrieve: P0) -> windows_core::Result>> + pub fn RetrievePropertiesAsync(&self, propertiestoretrieve: P0) -> windows_core::Result>> where P0: windows_core::Param>, { @@ -35,7 +35,7 @@ impl BasicProperties { (windows_core::Interface::vtable(this).RetrievePropertiesAsync)(windows_core::Interface::as_raw(this), propertiestoretrieve.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SavePropertiesAsync(&self, propertiestosave: P0) -> windows_core::Result + pub fn SavePropertiesAsync(&self, propertiestosave: P0) -> windows_core::Result where P0: windows_core::Param>>, { @@ -45,7 +45,7 @@ impl BasicProperties { (windows_core::Interface::vtable(this).SavePropertiesAsync)(windows_core::Interface::as_raw(this), propertiestosave.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SavePropertiesAsyncOverloadDefault(&self) -> windows_core::Result { + pub fn SavePropertiesAsyncOverloadDefault(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -105,7 +105,7 @@ impl DocumentProperties { let this = self; unsafe { (windows_core::Interface::vtable(this).SetComment)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(value)).ok() } } - pub fn RetrievePropertiesAsync(&self, propertiestoretrieve: P0) -> windows_core::Result>> + pub fn RetrievePropertiesAsync(&self, propertiestoretrieve: P0) -> windows_core::Result>> where P0: windows_core::Param>, { @@ -115,7 +115,7 @@ impl DocumentProperties { (windows_core::Interface::vtable(this).RetrievePropertiesAsync)(windows_core::Interface::as_raw(this), propertiestoretrieve.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SavePropertiesAsync(&self, propertiestosave: P0) -> windows_core::Result + pub fn SavePropertiesAsync(&self, propertiestosave: P0) -> windows_core::Result where P0: windows_core::Param>>, { @@ -125,7 +125,7 @@ impl DocumentProperties { (windows_core::Interface::vtable(this).SavePropertiesAsync)(windows_core::Interface::as_raw(this), propertiestosave.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SavePropertiesAsyncOverloadDefault(&self) -> windows_core::Result { + pub fn SavePropertiesAsyncOverloadDefault(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -146,7 +146,7 @@ impl windows_core::RuntimeName for DocumentProperties { pub struct GeotagHelper; impl GeotagHelper { #[cfg(all(feature = "Devices_Geolocation", feature = "Storage_Streams"))] - pub fn GetGeotagAsync(file: P0) -> windows_core::Result> + pub fn GetGeotagAsync(file: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -156,7 +156,7 @@ impl GeotagHelper { }) } #[cfg(all(feature = "Devices_Geolocation", feature = "Storage_Streams"))] - pub fn SetGeotagFromGeolocatorAsync(file: P0, geolocator: P1) -> windows_core::Result + pub fn SetGeotagFromGeolocatorAsync(file: P0, geolocator: P1) -> windows_core::Result where P0: windows_core::Param, P1: windows_core::Param, @@ -167,7 +167,7 @@ impl GeotagHelper { }) } #[cfg(all(feature = "Devices_Geolocation", feature = "Storage_Streams"))] - pub fn SetGeotagAsync(file: P0, geopoint: P1) -> windows_core::Result + pub fn SetGeotagAsync(file: P0, geopoint: P1) -> windows_core::Result where P0: windows_core::Param, P1: windows_core::Param, @@ -306,7 +306,7 @@ impl windows_core::RuntimeType for IStorageItemExtraProperties { } windows_core::imp::interface_hierarchy!(IStorageItemExtraProperties, windows_core::IUnknown, windows_core::IInspectable); impl IStorageItemExtraProperties { - pub fn RetrievePropertiesAsync(&self, propertiestoretrieve: P0) -> windows_core::Result>> + pub fn RetrievePropertiesAsync(&self, propertiestoretrieve: P0) -> windows_core::Result>> where P0: windows_core::Param>, { @@ -316,7 +316,7 @@ impl IStorageItemExtraProperties { (windows_core::Interface::vtable(this).RetrievePropertiesAsync)(windows_core::Interface::as_raw(this), propertiestoretrieve.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SavePropertiesAsync(&self, propertiestosave: P0) -> windows_core::Result + pub fn SavePropertiesAsync(&self, propertiestosave: P0) -> windows_core::Result where P0: windows_core::Param>>, { @@ -326,7 +326,7 @@ impl IStorageItemExtraProperties { (windows_core::Interface::vtable(this).SavePropertiesAsync)(windows_core::Interface::as_raw(this), propertiestosave.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SavePropertiesAsyncOverloadDefault(&self) -> windows_core::Result { + pub fn SavePropertiesAsyncOverloadDefault(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -338,9 +338,9 @@ impl windows_core::RuntimeName for IStorageItemExtraProperties { const NAME: &'static str = "Windows.Storage.FileProperties.IStorageItemExtraProperties"; } pub trait IStorageItemExtraProperties_Impl: windows_core::IUnknownImpl { - fn RetrievePropertiesAsync(&self, propertiesToRetrieve: windows_core::Ref<'_, windows_collections::IIterable>) -> windows_core::Result>>; - fn SavePropertiesAsync(&self, propertiesToSave: windows_core::Ref<'_, windows_collections::IIterable>>) -> windows_core::Result; - fn SavePropertiesAsyncOverloadDefault(&self) -> windows_core::Result; + fn RetrievePropertiesAsync(&self, propertiesToRetrieve: windows_core::Ref<'_, windows_collections::IIterable>) -> windows_core::Result>>; + fn SavePropertiesAsync(&self, propertiesToSave: windows_core::Ref<'_, windows_collections::IIterable>>) -> windows_core::Result; + fn SavePropertiesAsyncOverloadDefault(&self) -> windows_core::Result; } impl IStorageItemExtraProperties_Vtbl { pub const fn new() -> Self { @@ -552,7 +552,7 @@ impl ImageProperties { (windows_core::Interface::vtable(this).PeopleNames)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RetrievePropertiesAsync(&self, propertiestoretrieve: P0) -> windows_core::Result>> + pub fn RetrievePropertiesAsync(&self, propertiestoretrieve: P0) -> windows_core::Result>> where P0: windows_core::Param>, { @@ -562,7 +562,7 @@ impl ImageProperties { (windows_core::Interface::vtable(this).RetrievePropertiesAsync)(windows_core::Interface::as_raw(this), propertiestoretrieve.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SavePropertiesAsync(&self, propertiestosave: P0) -> windows_core::Result + pub fn SavePropertiesAsync(&self, propertiestosave: P0) -> windows_core::Result where P0: windows_core::Param>>, { @@ -572,7 +572,7 @@ impl ImageProperties { (windows_core::Interface::vtable(this).SavePropertiesAsync)(windows_core::Interface::as_raw(this), propertiestosave.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SavePropertiesAsyncOverloadDefault(&self) -> windows_core::Result { + pub fn SavePropertiesAsyncOverloadDefault(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -744,7 +744,7 @@ impl MusicProperties { let this = self; unsafe { (windows_core::Interface::vtable(this).SetYear)(windows_core::Interface::as_raw(this), value).ok() } } - pub fn RetrievePropertiesAsync(&self, propertiestoretrieve: P0) -> windows_core::Result>> + pub fn RetrievePropertiesAsync(&self, propertiestoretrieve: P0) -> windows_core::Result>> where P0: windows_core::Param>, { @@ -754,7 +754,7 @@ impl MusicProperties { (windows_core::Interface::vtable(this).RetrievePropertiesAsync)(windows_core::Interface::as_raw(this), propertiestoretrieve.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SavePropertiesAsync(&self, propertiestosave: P0) -> windows_core::Result + pub fn SavePropertiesAsync(&self, propertiestosave: P0) -> windows_core::Result where P0: windows_core::Param>>, { @@ -764,7 +764,7 @@ impl MusicProperties { (windows_core::Interface::vtable(this).SavePropertiesAsync)(windows_core::Interface::as_raw(this), propertiestosave.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SavePropertiesAsyncOverloadDefault(&self) -> windows_core::Result { + pub fn SavePropertiesAsyncOverloadDefault(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -858,35 +858,35 @@ pub struct StorageItemContentProperties(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(StorageItemContentProperties, windows_core::IUnknown, windows_core::IInspectable); windows_core::imp::required_hierarchy!(StorageItemContentProperties, IStorageItemExtraProperties); impl StorageItemContentProperties { - pub fn GetMusicPropertiesAsync(&self) -> windows_core::Result> { + pub fn GetMusicPropertiesAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetMusicPropertiesAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetVideoPropertiesAsync(&self) -> windows_core::Result> { + pub fn GetVideoPropertiesAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetVideoPropertiesAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetImagePropertiesAsync(&self) -> windows_core::Result> { + pub fn GetImagePropertiesAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetImagePropertiesAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetDocumentPropertiesAsync(&self) -> windows_core::Result> { + pub fn GetDocumentPropertiesAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetDocumentPropertiesAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RetrievePropertiesAsync(&self, propertiestoretrieve: P0) -> windows_core::Result>> + pub fn RetrievePropertiesAsync(&self, propertiestoretrieve: P0) -> windows_core::Result>> where P0: windows_core::Param>, { @@ -896,7 +896,7 @@ impl StorageItemContentProperties { (windows_core::Interface::vtable(this).RetrievePropertiesAsync)(windows_core::Interface::as_raw(this), propertiestoretrieve.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SavePropertiesAsync(&self, propertiestosave: P0) -> windows_core::Result + pub fn SavePropertiesAsync(&self, propertiestosave: P0) -> windows_core::Result where P0: windows_core::Param>>, { @@ -906,7 +906,7 @@ impl StorageItemContentProperties { (windows_core::Interface::vtable(this).SavePropertiesAsync)(windows_core::Interface::as_raw(this), propertiestosave.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SavePropertiesAsyncOverloadDefault(&self) -> windows_core::Result { + pub fn SavePropertiesAsyncOverloadDefault(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -945,7 +945,7 @@ impl StorageItemThumbnail { (windows_core::Interface::vtable(this).ContentType)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn ReadAsync(&self, buffer: P0, count: u32, options: super::Streams::InputStreamOptions) -> windows_core::Result> + pub fn ReadAsync(&self, buffer: P0, count: u32, options: super::Streams::InputStreamOptions) -> windows_core::Result> where P0: windows_core::Param, { @@ -955,7 +955,7 @@ impl StorageItemThumbnail { (windows_core::Interface::vtable(this).ReadAsync)(windows_core::Interface::as_raw(this), buffer.param().abi(), count, options, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn WriteAsync(&self, buffer: P0) -> windows_core::Result> + pub fn WriteAsync(&self, buffer: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -965,7 +965,7 @@ impl StorageItemThumbnail { (windows_core::Interface::vtable(this).WriteAsync)(windows_core::Interface::as_raw(this), buffer.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FlushAsync(&self) -> windows_core::Result> { + pub fn FlushAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1170,7 +1170,7 @@ pub struct VideoProperties(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(VideoProperties, windows_core::IUnknown, windows_core::IInspectable); windows_core::imp::required_hierarchy!(VideoProperties, IStorageItemExtraProperties); impl VideoProperties { - pub fn RetrievePropertiesAsync(&self, propertiestoretrieve: P0) -> windows_core::Result>> + pub fn RetrievePropertiesAsync(&self, propertiestoretrieve: P0) -> windows_core::Result>> where P0: windows_core::Param>, { @@ -1180,7 +1180,7 @@ impl VideoProperties { (windows_core::Interface::vtable(this).RetrievePropertiesAsync)(windows_core::Interface::as_raw(this), propertiestoretrieve.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SavePropertiesAsync(&self, propertiestosave: P0) -> windows_core::Result + pub fn SavePropertiesAsync(&self, propertiestosave: P0) -> windows_core::Result where P0: windows_core::Param>>, { @@ -1190,7 +1190,7 @@ impl VideoProperties { (windows_core::Interface::vtable(this).SavePropertiesAsync)(windows_core::Interface::as_raw(this), propertiestosave.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SavePropertiesAsyncOverloadDefault(&self) -> windows_core::Result { + pub fn SavePropertiesAsyncOverloadDefault(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Storage/Pickers/mod.rs b/crates/libs/windows/src/Windows/Storage/Pickers/mod.rs index 3547c5f42b..3e651f2f4d 100644 --- a/crates/libs/windows/src/Windows/Storage/Pickers/mod.rs +++ b/crates/libs/windows/src/Windows/Storage/Pickers/mod.rs @@ -167,7 +167,7 @@ impl FileOpenPicker { } } #[cfg(feature = "Storage_Streams")] - pub fn PickSingleFileAsync(&self) -> windows_core::Result> { + pub fn PickSingleFileAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -175,7 +175,7 @@ impl FileOpenPicker { } } #[cfg(feature = "Storage_Streams")] - pub fn PickMultipleFilesAsync(&self) -> windows_core::Result>> { + pub fn PickMultipleFilesAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -209,7 +209,7 @@ impl FileOpenPicker { } } #[cfg(all(feature = "Storage_Streams", feature = "deprecated"))] - pub fn ResumePickSingleFileAsync() -> windows_core::Result> { + pub fn ResumePickSingleFileAsync() -> windows_core::Result> { Self::IFileOpenPickerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ResumePickSingleFileAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -226,7 +226,7 @@ impl FileOpenPicker { }) } #[cfg(feature = "Storage_Streams")] - pub fn PickSingleFileAsync2(&self, pickeroperationid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn PickSingleFileAsync2(&self, pickeroperationid: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -513,7 +513,7 @@ impl FileSavePicker { unsafe { (windows_core::Interface::vtable(this).SetSuggestedFileName)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(value)).ok() } } #[cfg(feature = "Storage_Streams")] - pub fn PickSaveFileAsync(&self) -> windows_core::Result> { + pub fn PickSaveFileAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -643,7 +643,7 @@ impl FolderPicker { } } #[cfg(feature = "Storage_Search")] - pub fn PickSingleFolderAsync(&self) -> windows_core::Result> { + pub fn PickSingleFolderAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Storage/Provider/mod.rs b/crates/libs/windows/src/Windows/Storage/Provider/mod.rs index 3374ac0db5..d894e26403 100644 --- a/crates/libs/windows/src/Windows/Storage/Provider/mod.rs +++ b/crates/libs/windows/src/Windows/Storage/Provider/mod.rs @@ -764,7 +764,7 @@ impl windows_core::RuntimeType for IStorageProviderShareLinkSource { } windows_core::imp::interface_hierarchy!(IStorageProviderShareLinkSource, windows_core::IUnknown, windows_core::IInspectable); impl IStorageProviderShareLinkSource { - pub fn CreateLinkAsync(&self, storageitemlist: P0) -> windows_core::Result> + pub fn CreateLinkAsync(&self, storageitemlist: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -774,7 +774,7 @@ impl IStorageProviderShareLinkSource { (windows_core::Interface::vtable(this).CreateLinkAsync)(windows_core::Interface::as_raw(this), storageitemlist.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetDefaultAccessControlStringAsync(&self, storageitemlist: P0) -> windows_core::Result> + pub fn GetDefaultAccessControlStringAsync(&self, storageitemlist: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -784,7 +784,7 @@ impl IStorageProviderShareLinkSource { (windows_core::Interface::vtable(this).GetDefaultAccessControlStringAsync)(windows_core::Interface::as_raw(this), storageitemlist.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetState(&self, storageitemlist: P0) -> windows_core::Result> + pub fn GetState(&self, storageitemlist: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -799,9 +799,9 @@ impl windows_core::RuntimeName for IStorageProviderShareLinkSource { const NAME: &'static str = "Windows.Storage.Provider.IStorageProviderShareLinkSource"; } pub trait IStorageProviderShareLinkSource_Impl: windows_core::IUnknownImpl { - fn CreateLinkAsync(&self, storageItemList: windows_core::Ref<'_, windows_collections::IVectorView>) -> windows_core::Result>; - fn GetDefaultAccessControlStringAsync(&self, storageItemList: windows_core::Ref<'_, windows_collections::IVectorView>) -> windows_core::Result>; - fn GetState(&self, storageItemList: windows_core::Ref<'_, windows_collections::IVectorView>) -> windows_core::Result>; + fn CreateLinkAsync(&self, storageItemList: windows_core::Ref<'_, windows_collections::IVectorView>) -> windows_core::Result>; + fn GetDefaultAccessControlStringAsync(&self, storageItemList: windows_core::Ref<'_, windows_collections::IVectorView>) -> windows_core::Result>; + fn GetState(&self, storageItemList: windows_core::Ref<'_, windows_collections::IVectorView>) -> windows_core::Result>; } impl IStorageProviderShareLinkSource_Vtbl { pub const fn new() -> Self { @@ -1624,7 +1624,7 @@ impl core::ops::Not for StorageProviderInSyncPolicy { } pub struct StorageProviderItemProperties; impl StorageProviderItemProperties { - pub fn SetAsync(item: P0, itemproperties: P1) -> windows_core::Result + pub fn SetAsync(item: P0, itemproperties: P1) -> windows_core::Result where P0: windows_core::Param, P1: windows_core::Param>, diff --git a/crates/libs/windows/src/Windows/Storage/Search/mod.rs b/crates/libs/windows/src/Windows/Storage/Search/mod.rs index 19685d78e5..e52c156b05 100644 --- a/crates/libs/windows/src/Windows/Storage/Search/mod.rs +++ b/crates/libs/windows/src/Windows/Storage/Search/mod.rs @@ -44,7 +44,7 @@ impl windows_core::RuntimeType for CommonFolderQuery { pub struct ContentIndexer(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(ContentIndexer, windows_core::IUnknown, windows_core::IInspectable); impl ContentIndexer { - pub fn AddAsync(&self, indexablecontent: P0) -> windows_core::Result + pub fn AddAsync(&self, indexablecontent: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -54,7 +54,7 @@ impl ContentIndexer { (windows_core::Interface::vtable(this).AddAsync)(windows_core::Interface::as_raw(this), indexablecontent.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn UpdateAsync(&self, indexablecontent: P0) -> windows_core::Result + pub fn UpdateAsync(&self, indexablecontent: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -64,14 +64,14 @@ impl ContentIndexer { (windows_core::Interface::vtable(this).UpdateAsync)(windows_core::Interface::as_raw(this), indexablecontent.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAsync(&self, contentid: &windows_core::HSTRING) -> windows_core::Result { + pub fn DeleteAsync(&self, contentid: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeleteAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(contentid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteMultipleAsync(&self, contentids: P0) -> windows_core::Result + pub fn DeleteMultipleAsync(&self, contentids: P0) -> windows_core::Result where P0: windows_core::Param>, { @@ -81,14 +81,14 @@ impl ContentIndexer { (windows_core::Interface::vtable(this).DeleteMultipleAsync)(windows_core::Interface::as_raw(this), contentids.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAllAsync(&self) -> windows_core::Result { + pub fn DeleteAllAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeleteAllAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RetrievePropertiesAsync(&self, contentid: &windows_core::HSTRING, propertiestoretrieve: P1) -> windows_core::Result>> + pub fn RetrievePropertiesAsync(&self, contentid: &windows_core::HSTRING, propertiestoretrieve: P1) -> windows_core::Result>> where P1: windows_core::Param>, { @@ -171,35 +171,35 @@ unsafe impl Sync for ContentIndexer {} pub struct ContentIndexerQuery(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(ContentIndexerQuery, windows_core::IUnknown, windows_core::IInspectable); impl ContentIndexerQuery { - pub fn GetCountAsync(&self) -> windows_core::Result> { + pub fn GetCountAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetCountAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetPropertiesAsync(&self) -> windows_core::Result>>> { + pub fn GetPropertiesAsync(&self) -> windows_core::Result>>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetPropertiesAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetPropertiesRangeAsync(&self, startindex: u32, maxitems: u32) -> windows_core::Result>>> { + pub fn GetPropertiesRangeAsync(&self, startindex: u32, maxitems: u32) -> windows_core::Result>>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetPropertiesRangeAsync)(windows_core::Interface::as_raw(this), startindex, maxitems, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAsync(&self) -> windows_core::Result>> { + pub fn GetAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetRangeAsync(&self, startindex: u32, maxitems: u32) -> windows_core::Result>> { + pub fn GetRangeAsync(&self, startindex: u32, maxitems: u32) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -559,7 +559,7 @@ impl windows_core::RuntimeType for IStorageFolderQueryOperations { } windows_core::imp::interface_hierarchy!(IStorageFolderQueryOperations, windows_core::IUnknown, windows_core::IInspectable); impl IStorageFolderQueryOperations { - pub fn GetIndexedStateAsync(&self) -> windows_core::Result> { + pub fn GetIndexedStateAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -632,7 +632,7 @@ impl IStorageFolderQueryOperations { } } #[cfg(feature = "Storage_Streams")] - pub fn GetFilesAsync(&self, query: CommonFileQuery, startindex: u32, maxitemstoretrieve: u32) -> windows_core::Result>> { + pub fn GetFilesAsync(&self, query: CommonFileQuery, startindex: u32, maxitemstoretrieve: u32) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -640,28 +640,28 @@ impl IStorageFolderQueryOperations { } } #[cfg(feature = "Storage_Streams")] - pub fn GetFilesAsyncOverloadDefaultStartAndCount(&self, query: CommonFileQuery) -> windows_core::Result>> { + pub fn GetFilesAsyncOverloadDefaultStartAndCount(&self, query: CommonFileQuery) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFilesAsyncOverloadDefaultStartAndCount)(windows_core::Interface::as_raw(this), query, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetFoldersAsync(&self, query: CommonFolderQuery, startindex: u32, maxitemstoretrieve: u32) -> windows_core::Result>> { + pub fn GetFoldersAsync(&self, query: CommonFolderQuery, startindex: u32, maxitemstoretrieve: u32) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFoldersAsync)(windows_core::Interface::as_raw(this), query, startindex, maxitemstoretrieve, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetFoldersAsyncOverloadDefaultStartAndCount(&self, query: CommonFolderQuery) -> windows_core::Result>> { + pub fn GetFoldersAsyncOverloadDefaultStartAndCount(&self, query: CommonFolderQuery) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFoldersAsyncOverloadDefaultStartAndCount)(windows_core::Interface::as_raw(this), query, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetItemsAsync(&self, startindex: u32, maxitemstoretrieve: u32) -> windows_core::Result>> { + pub fn GetItemsAsync(&self, startindex: u32, maxitemstoretrieve: u32) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -699,7 +699,7 @@ impl windows_core::RuntimeName for IStorageFolderQueryOperations { } #[cfg(feature = "Storage_Streams")] pub trait IStorageFolderQueryOperations_Impl: windows_core::IUnknownImpl { - fn GetIndexedStateAsync(&self) -> windows_core::Result>; + fn GetIndexedStateAsync(&self) -> windows_core::Result>; fn CreateFileQueryOverloadDefault(&self) -> windows_core::Result; fn CreateFileQuery(&self, query: CommonFileQuery) -> windows_core::Result; fn CreateFileQueryWithOptions(&self, queryOptions: windows_core::Ref<'_, QueryOptions>) -> windows_core::Result; @@ -708,11 +708,11 @@ pub trait IStorageFolderQueryOperations_Impl: windows_core::IUnknownImpl { fn CreateFolderQueryWithOptions(&self, queryOptions: windows_core::Ref<'_, QueryOptions>) -> windows_core::Result; fn CreateItemQuery(&self) -> windows_core::Result; fn CreateItemQueryWithOptions(&self, queryOptions: windows_core::Ref<'_, QueryOptions>) -> windows_core::Result; - fn GetFilesAsync(&self, query: CommonFileQuery, startIndex: u32, maxItemsToRetrieve: u32) -> windows_core::Result>>; - fn GetFilesAsyncOverloadDefaultStartAndCount(&self, query: CommonFileQuery) -> windows_core::Result>>; - fn GetFoldersAsync(&self, query: CommonFolderQuery, startIndex: u32, maxItemsToRetrieve: u32) -> windows_core::Result>>; - fn GetFoldersAsyncOverloadDefaultStartAndCount(&self, query: CommonFolderQuery) -> windows_core::Result>>; - fn GetItemsAsync(&self, startIndex: u32, maxItemsToRetrieve: u32) -> windows_core::Result>>; + fn GetFilesAsync(&self, query: CommonFileQuery, startIndex: u32, maxItemsToRetrieve: u32) -> windows_core::Result>>; + fn GetFilesAsyncOverloadDefaultStartAndCount(&self, query: CommonFileQuery) -> windows_core::Result>>; + fn GetFoldersAsync(&self, query: CommonFolderQuery, startIndex: u32, maxItemsToRetrieve: u32) -> windows_core::Result>>; + fn GetFoldersAsyncOverloadDefaultStartAndCount(&self, query: CommonFolderQuery) -> windows_core::Result>>; + fn GetItemsAsync(&self, startIndex: u32, maxItemsToRetrieve: u32) -> windows_core::Result>>; fn AreQueryOptionsSupported(&self, queryOptions: windows_core::Ref<'_, QueryOptions>) -> windows_core::Result; fn IsCommonFolderQuerySupported(&self, query: CommonFolderQuery) -> windows_core::Result; fn IsCommonFileQuerySupported(&self, query: CommonFileQuery) -> windows_core::Result; @@ -1036,7 +1036,7 @@ impl windows_core::RuntimeType for IStorageQueryResultBase { } windows_core::imp::interface_hierarchy!(IStorageQueryResultBase, windows_core::IUnknown, windows_core::IInspectable); impl IStorageQueryResultBase { - pub fn GetItemCountAsync(&self) -> windows_core::Result> { + pub fn GetItemCountAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1078,7 +1078,7 @@ impl IStorageQueryResultBase { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveOptionsChanged)(windows_core::Interface::as_raw(this), eventcookie).ok() } } - pub fn FindStartIndexAsync(&self, value: P0) -> windows_core::Result> + pub fn FindStartIndexAsync(&self, value: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1107,13 +1107,13 @@ impl windows_core::RuntimeName for IStorageQueryResultBase { const NAME: &'static str = "Windows.Storage.Search.IStorageQueryResultBase"; } pub trait IStorageQueryResultBase_Impl: windows_core::IUnknownImpl { - fn GetItemCountAsync(&self) -> windows_core::Result>; + fn GetItemCountAsync(&self) -> windows_core::Result>; fn Folder(&self) -> windows_core::Result; fn ContentsChanged(&self, handler: windows_core::Ref<'_, super::super::Foundation::TypedEventHandler>) -> windows_core::Result; fn RemoveContentsChanged(&self, eventCookie: i64) -> windows_core::Result<()>; fn OptionsChanged(&self, changedHandler: windows_core::Ref<'_, super::super::Foundation::TypedEventHandler>) -> windows_core::Result; fn RemoveOptionsChanged(&self, eventCookie: i64) -> windows_core::Result<()>; - fn FindStartIndexAsync(&self, value: windows_core::Ref<'_, windows_core::IInspectable>) -> windows_core::Result>; + fn FindStartIndexAsync(&self, value: windows_core::Ref<'_, windows_core::IInspectable>) -> windows_core::Result>; fn GetCurrentQueryOptions(&self) -> windows_core::Result; fn ApplyNewQueryOptions(&self, newQueryOptions: windows_core::Ref<'_, QueryOptions>) -> windows_core::Result<()>; } @@ -1633,7 +1633,7 @@ windows_core::imp::interface_hierarchy!(StorageFileQueryResult, windows_core::IU windows_core::imp::required_hierarchy!(StorageFileQueryResult, IStorageQueryResultBase); impl StorageFileQueryResult { #[cfg(feature = "Storage_Streams")] - pub fn GetFilesAsync(&self, startindex: u32, maxnumberofitems: u32) -> windows_core::Result>> { + pub fn GetFilesAsync(&self, startindex: u32, maxnumberofitems: u32) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1641,7 +1641,7 @@ impl StorageFileQueryResult { } } #[cfg(feature = "Storage_Streams")] - pub fn GetFilesAsyncDefaultStartAndCount(&self) -> windows_core::Result>> { + pub fn GetFilesAsyncDefaultStartAndCount(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1659,7 +1659,7 @@ impl StorageFileQueryResult { (windows_core::Interface::vtable(this).GetMatchingPropertiesWithRanges)(windows_core::Interface::as_raw(this), file.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetItemCountAsync(&self) -> windows_core::Result> { + pub fn GetItemCountAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1701,7 +1701,7 @@ impl StorageFileQueryResult { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).RemoveOptionsChanged)(windows_core::Interface::as_raw(this), eventcookie).ok() } } - pub fn FindStartIndexAsync(&self, value: P0) -> windows_core::Result> + pub fn FindStartIndexAsync(&self, value: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1742,21 +1742,21 @@ pub struct StorageFolderQueryResult(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(StorageFolderQueryResult, windows_core::IUnknown, windows_core::IInspectable); windows_core::imp::required_hierarchy!(StorageFolderQueryResult, IStorageQueryResultBase); impl StorageFolderQueryResult { - pub fn GetFoldersAsync(&self, startindex: u32, maxnumberofitems: u32) -> windows_core::Result>> { + pub fn GetFoldersAsync(&self, startindex: u32, maxnumberofitems: u32) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFoldersAsync)(windows_core::Interface::as_raw(this), startindex, maxnumberofitems, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetFoldersAsyncDefaultStartAndCount(&self) -> windows_core::Result>> { + pub fn GetFoldersAsyncDefaultStartAndCount(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFoldersAsyncDefaultStartAndCount)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetItemCountAsync(&self) -> windows_core::Result> { + pub fn GetItemCountAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1798,7 +1798,7 @@ impl StorageFolderQueryResult { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).RemoveOptionsChanged)(windows_core::Interface::as_raw(this), eventcookie).ok() } } - pub fn FindStartIndexAsync(&self, value: P0) -> windows_core::Result> + pub fn FindStartIndexAsync(&self, value: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1839,21 +1839,21 @@ pub struct StorageItemQueryResult(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(StorageItemQueryResult, windows_core::IUnknown, windows_core::IInspectable); windows_core::imp::required_hierarchy!(StorageItemQueryResult, IStorageQueryResultBase); impl StorageItemQueryResult { - pub fn GetItemsAsync(&self, startindex: u32, maxnumberofitems: u32) -> windows_core::Result>> { + pub fn GetItemsAsync(&self, startindex: u32, maxnumberofitems: u32) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetItemsAsync)(windows_core::Interface::as_raw(this), startindex, maxnumberofitems, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetItemsAsyncDefaultStartAndCount(&self) -> windows_core::Result>> { + pub fn GetItemsAsyncDefaultStartAndCount(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetItemsAsyncDefaultStartAndCount)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetItemCountAsync(&self) -> windows_core::Result> { + pub fn GetItemCountAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1895,7 +1895,7 @@ impl StorageItemQueryResult { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).RemoveOptionsChanged)(windows_core::Interface::as_raw(this), eventcookie).ok() } } - pub fn FindStartIndexAsync(&self, value: P0) -> windows_core::Result> + pub fn FindStartIndexAsync(&self, value: P0) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Storage/Streams/mod.rs b/crates/libs/windows/src/Windows/Storage/Streams/mod.rs index 267b23e359..ef34ca14a8 100644 --- a/crates/libs/windows/src/Windows/Storage/Streams/mod.rs +++ b/crates/libs/windows/src/Windows/Storage/Streams/mod.rs @@ -298,7 +298,7 @@ impl windows_core::RuntimeName for DataReader { } unsafe impl Send for DataReader {} unsafe impl Sync for DataReader {} -pub type DataReaderLoadOperation = windows_async::IAsyncOperation; +pub type DataReaderLoadOperation = windows_future::IAsyncOperation; #[repr(transparent)] #[derive(Clone, Debug, Eq, PartialEq)] pub struct DataWriter(windows_core::IUnknown); @@ -436,7 +436,7 @@ impl DataWriter { (windows_core::Interface::vtable(this).StoreAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FlushAsync(&self) -> windows_core::Result> { + pub fn FlushAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -483,7 +483,7 @@ impl windows_core::RuntimeName for DataWriter { } unsafe impl Send for DataWriter {} unsafe impl Sync for DataWriter {} -pub type DataWriterStoreOperation = windows_async::IAsyncOperation; +pub type DataWriterStoreOperation = windows_future::IAsyncOperation; #[repr(transparent)] #[derive(Clone, Debug, Eq, PartialEq)] pub struct FileInputStream(windows_core::IUnknown); @@ -494,7 +494,7 @@ impl FileInputStream { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).Close)(windows_core::Interface::as_raw(this)).ok() } } - pub fn ReadAsync(&self, buffer: P0, count: u32, options: InputStreamOptions) -> windows_core::Result> + pub fn ReadAsync(&self, buffer: P0, count: u32, options: InputStreamOptions) -> windows_core::Result> where P0: windows_core::Param, { @@ -543,7 +543,7 @@ impl FileOutputStream { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).Close)(windows_core::Interface::as_raw(this)).ok() } } - pub fn WriteAsync(&self, buffer: P0) -> windows_core::Result> + pub fn WriteAsync(&self, buffer: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -553,7 +553,7 @@ impl FileOutputStream { (windows_core::Interface::vtable(this).WriteAsync)(windows_core::Interface::as_raw(this), buffer.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FlushAsync(&self) -> windows_core::Result> { + pub fn FlushAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -583,32 +583,32 @@ impl FileRandomAccessStream { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).Close)(windows_core::Interface::as_raw(this)).ok() } } - pub fn OpenAsync(filepath: &windows_core::HSTRING, accessmode: super::FileAccessMode) -> windows_core::Result> { + pub fn OpenAsync(filepath: &windows_core::HSTRING, accessmode: super::FileAccessMode) -> windows_core::Result> { Self::IFileRandomAccessStreamStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).OpenAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(filepath), accessmode, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn OpenWithOptionsAsync(filepath: &windows_core::HSTRING, accessmode: super::FileAccessMode, sharingoptions: super::StorageOpenOptions, opendisposition: FileOpenDisposition) -> windows_core::Result> { + pub fn OpenWithOptionsAsync(filepath: &windows_core::HSTRING, accessmode: super::FileAccessMode, sharingoptions: super::StorageOpenOptions, opendisposition: FileOpenDisposition) -> windows_core::Result> { Self::IFileRandomAccessStreamStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).OpenWithOptionsAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(filepath), accessmode, sharingoptions, opendisposition, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn OpenTransactedWriteAsync(filepath: &windows_core::HSTRING) -> windows_core::Result> { + pub fn OpenTransactedWriteAsync(filepath: &windows_core::HSTRING) -> windows_core::Result> { Self::IFileRandomAccessStreamStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).OpenTransactedWriteAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(filepath), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn OpenTransactedWriteWithOptionsAsync(filepath: &windows_core::HSTRING, openoptions: super::StorageOpenOptions, opendisposition: FileOpenDisposition) -> windows_core::Result> { + pub fn OpenTransactedWriteWithOptionsAsync(filepath: &windows_core::HSTRING, openoptions: super::StorageOpenOptions, opendisposition: FileOpenDisposition) -> windows_core::Result> { Self::IFileRandomAccessStreamStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).OpenTransactedWriteWithOptionsAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(filepath), openoptions, opendisposition, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "System")] - pub fn OpenForUserAsync(user: P0, filepath: &windows_core::HSTRING, accessmode: super::FileAccessMode) -> windows_core::Result> + pub fn OpenForUserAsync(user: P0, filepath: &windows_core::HSTRING, accessmode: super::FileAccessMode) -> windows_core::Result> where P0: windows_core::Param, { @@ -618,7 +618,7 @@ impl FileRandomAccessStream { }) } #[cfg(feature = "System")] - pub fn OpenForUserWithOptionsAsync(user: P0, filepath: &windows_core::HSTRING, accessmode: super::FileAccessMode, sharingoptions: super::StorageOpenOptions, opendisposition: FileOpenDisposition) -> windows_core::Result> + pub fn OpenForUserWithOptionsAsync(user: P0, filepath: &windows_core::HSTRING, accessmode: super::FileAccessMode, sharingoptions: super::StorageOpenOptions, opendisposition: FileOpenDisposition) -> windows_core::Result> where P0: windows_core::Param, { @@ -628,7 +628,7 @@ impl FileRandomAccessStream { }) } #[cfg(feature = "System")] - pub fn OpenTransactedWriteForUserAsync(user: P0, filepath: &windows_core::HSTRING) -> windows_core::Result> + pub fn OpenTransactedWriteForUserAsync(user: P0, filepath: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -638,7 +638,7 @@ impl FileRandomAccessStream { }) } #[cfg(feature = "System")] - pub fn OpenTransactedWriteForUserWithOptionsAsync(user: P0, filepath: &windows_core::HSTRING, openoptions: super::StorageOpenOptions, opendisposition: FileOpenDisposition) -> windows_core::Result> + pub fn OpenTransactedWriteForUserWithOptionsAsync(user: P0, filepath: &windows_core::HSTRING, openoptions: super::StorageOpenOptions, opendisposition: FileOpenDisposition) -> windows_core::Result> where P0: windows_core::Param, { @@ -647,7 +647,7 @@ impl FileRandomAccessStream { (windows_core::Interface::vtable(this).OpenTransactedWriteForUserWithOptionsAsync)(windows_core::Interface::as_raw(this), user.param().abi(), core::mem::transmute_copy(filepath), openoptions, opendisposition, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn ReadAsync(&self, buffer: P0, count: u32, options: InputStreamOptions) -> windows_core::Result> + pub fn ReadAsync(&self, buffer: P0, count: u32, options: InputStreamOptions) -> windows_core::Result> where P0: windows_core::Param, { @@ -657,7 +657,7 @@ impl FileRandomAccessStream { (windows_core::Interface::vtable(this).ReadAsync)(windows_core::Interface::as_raw(this), buffer.param().abi(), count, options, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn WriteAsync(&self, buffer: P0) -> windows_core::Result> + pub fn WriteAsync(&self, buffer: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -667,7 +667,7 @@ impl FileRandomAccessStream { (windows_core::Interface::vtable(this).WriteAsync)(windows_core::Interface::as_raw(this), buffer.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FlushAsync(&self) -> windows_core::Result> { + pub fn FlushAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1607,7 +1607,7 @@ impl IDataWriter { (windows_core::Interface::vtable(this).StoreAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FlushAsync(&self) -> windows_core::Result> { + pub fn FlushAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1657,7 +1657,7 @@ pub trait IDataWriter_Impl: windows_core::IUnknownImpl { fn WriteString(&self, value: &windows_core::HSTRING) -> windows_core::Result; fn MeasureString(&self, value: &windows_core::HSTRING) -> windows_core::Result; fn StoreAsync(&self) -> windows_core::Result; - fn FlushAsync(&self) -> windows_core::Result>; + fn FlushAsync(&self) -> windows_core::Result>; fn DetachBuffer(&self) -> windows_core::Result; fn DetachStream(&self) -> windows_core::Result; } @@ -1993,7 +1993,7 @@ impl windows_core::RuntimeType for IInputStream { windows_core::imp::interface_hierarchy!(IInputStream, windows_core::IUnknown, windows_core::IInspectable); windows_core::imp::required_hierarchy!(IInputStream, super::super::Foundation::IClosable); impl IInputStream { - pub fn ReadAsync(&self, buffer: P0, count: u32, options: InputStreamOptions) -> windows_core::Result> + pub fn ReadAsync(&self, buffer: P0, count: u32, options: InputStreamOptions) -> windows_core::Result> where P0: windows_core::Param, { @@ -2012,7 +2012,7 @@ impl windows_core::RuntimeName for IInputStream { const NAME: &'static str = "Windows.Storage.Streams.IInputStream"; } pub trait IInputStream_Impl: super::super::Foundation::IClosable_Impl { - fn ReadAsync(&self, buffer: windows_core::Ref<'_, IBuffer>, count: u32, options: InputStreamOptions) -> windows_core::Result>; + fn ReadAsync(&self, buffer: windows_core::Ref<'_, IBuffer>, count: u32, options: InputStreamOptions) -> windows_core::Result>; } impl IInputStream_Vtbl { pub const fn new() -> Self { @@ -2046,7 +2046,7 @@ impl windows_core::RuntimeType for IInputStreamReference { } windows_core::imp::interface_hierarchy!(IInputStreamReference, windows_core::IUnknown, windows_core::IInspectable); impl IInputStreamReference { - pub fn OpenSequentialReadAsync(&self) -> windows_core::Result> { + pub fn OpenSequentialReadAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2058,7 +2058,7 @@ impl windows_core::RuntimeName for IInputStreamReference { const NAME: &'static str = "Windows.Storage.Streams.IInputStreamReference"; } pub trait IInputStreamReference_Impl: windows_core::IUnknownImpl { - fn OpenSequentialReadAsync(&self) -> windows_core::Result>; + fn OpenSequentialReadAsync(&self) -> windows_core::Result>; } impl IInputStreamReference_Vtbl { pub const fn new() -> Self { @@ -2096,7 +2096,7 @@ impl windows_core::RuntimeType for IOutputStream { windows_core::imp::interface_hierarchy!(IOutputStream, windows_core::IUnknown, windows_core::IInspectable); windows_core::imp::required_hierarchy!(IOutputStream, super::super::Foundation::IClosable); impl IOutputStream { - pub fn WriteAsync(&self, buffer: P0) -> windows_core::Result> + pub fn WriteAsync(&self, buffer: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2106,7 +2106,7 @@ impl IOutputStream { (windows_core::Interface::vtable(this).WriteAsync)(windows_core::Interface::as_raw(this), buffer.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FlushAsync(&self) -> windows_core::Result> { + pub fn FlushAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2122,8 +2122,8 @@ impl windows_core::RuntimeName for IOutputStream { const NAME: &'static str = "Windows.Storage.Streams.IOutputStream"; } pub trait IOutputStream_Impl: super::super::Foundation::IClosable_Impl { - fn WriteAsync(&self, buffer: windows_core::Ref<'_, IBuffer>) -> windows_core::Result>; - fn FlushAsync(&self) -> windows_core::Result>; + fn WriteAsync(&self, buffer: windows_core::Ref<'_, IBuffer>) -> windows_core::Result>; + fn FlushAsync(&self) -> windows_core::Result>; } impl IOutputStream_Vtbl { pub const fn new() -> Self { @@ -2317,7 +2317,7 @@ impl IRandomAccessStream { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).Close)(windows_core::Interface::as_raw(this)).ok() } } - pub fn ReadAsync(&self, buffer: P0, count: u32, options: InputStreamOptions) -> windows_core::Result> + pub fn ReadAsync(&self, buffer: P0, count: u32, options: InputStreamOptions) -> windows_core::Result> where P0: windows_core::Param, { @@ -2327,7 +2327,7 @@ impl IRandomAccessStream { (windows_core::Interface::vtable(this).ReadAsync)(windows_core::Interface::as_raw(this), buffer.param().abi(), count, options, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn WriteAsync(&self, buffer: P0) -> windows_core::Result> + pub fn WriteAsync(&self, buffer: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2337,7 +2337,7 @@ impl IRandomAccessStream { (windows_core::Interface::vtable(this).WriteAsync)(windows_core::Interface::as_raw(this), buffer.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FlushAsync(&self) -> windows_core::Result> { + pub fn FlushAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -2496,7 +2496,7 @@ impl windows_core::RuntimeType for IRandomAccessStreamReference { } windows_core::imp::interface_hierarchy!(IRandomAccessStreamReference, windows_core::IUnknown, windows_core::IInspectable); impl IRandomAccessStreamReference { - pub fn OpenReadAsync(&self) -> windows_core::Result> { + pub fn OpenReadAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2508,7 +2508,7 @@ impl windows_core::RuntimeName for IRandomAccessStreamReference { const NAME: &'static str = "Windows.Storage.Streams.IRandomAccessStreamReference"; } pub trait IRandomAccessStreamReference_Impl: windows_core::IUnknownImpl { - fn OpenReadAsync(&self) -> windows_core::Result>; + fn OpenReadAsync(&self) -> windows_core::Result>; } impl IRandomAccessStreamReference_Vtbl { pub const fn new() -> Self { @@ -2579,7 +2579,7 @@ impl IRandomAccessStreamWithContentType { (windows_core::Interface::vtable(this).ContentType)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn ReadAsync(&self, buffer: P0, count: u32, options: InputStreamOptions) -> windows_core::Result> + pub fn ReadAsync(&self, buffer: P0, count: u32, options: InputStreamOptions) -> windows_core::Result> where P0: windows_core::Param, { @@ -2589,7 +2589,7 @@ impl IRandomAccessStreamWithContentType { (windows_core::Interface::vtable(this).ReadAsync)(windows_core::Interface::as_raw(this), buffer.param().abi(), count, options, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn WriteAsync(&self, buffer: P0) -> windows_core::Result> + pub fn WriteAsync(&self, buffer: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2599,7 +2599,7 @@ impl IRandomAccessStreamWithContentType { (windows_core::Interface::vtable(this).WriteAsync)(windows_core::Interface::as_raw(this), buffer.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FlushAsync(&self) -> windows_core::Result> { + pub fn FlushAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -2697,7 +2697,7 @@ impl InMemoryRandomAccessStream { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).Close)(windows_core::Interface::as_raw(this)).ok() } } - pub fn ReadAsync(&self, buffer: P0, count: u32, options: InputStreamOptions) -> windows_core::Result> + pub fn ReadAsync(&self, buffer: P0, count: u32, options: InputStreamOptions) -> windows_core::Result> where P0: windows_core::Param, { @@ -2707,7 +2707,7 @@ impl InMemoryRandomAccessStream { (windows_core::Interface::vtable(this).ReadAsync)(windows_core::Interface::as_raw(this), buffer.param().abi(), count, options, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn WriteAsync(&self, buffer: P0) -> windows_core::Result> + pub fn WriteAsync(&self, buffer: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2717,7 +2717,7 @@ impl InMemoryRandomAccessStream { (windows_core::Interface::vtable(this).WriteAsync)(windows_core::Interface::as_raw(this), buffer.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FlushAsync(&self) -> windows_core::Result> { + pub fn FlushAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -2851,7 +2851,7 @@ impl InputStreamOverStream { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).Close)(windows_core::Interface::as_raw(this)).ok() } } - pub fn ReadAsync(&self, buffer: P0, count: u32, options: InputStreamOptions) -> windows_core::Result> + pub fn ReadAsync(&self, buffer: P0, count: u32, options: InputStreamOptions) -> windows_core::Result> where P0: windows_core::Param, { @@ -2884,7 +2884,7 @@ impl OutputStreamOverStream { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).Close)(windows_core::Interface::as_raw(this)).ok() } } - pub fn WriteAsync(&self, buffer: P0) -> windows_core::Result> + pub fn WriteAsync(&self, buffer: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2894,7 +2894,7 @@ impl OutputStreamOverStream { (windows_core::Interface::vtable(this).WriteAsync)(windows_core::Interface::as_raw(this), buffer.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FlushAsync(&self) -> windows_core::Result> { + pub fn FlushAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2916,7 +2916,7 @@ unsafe impl Send for OutputStreamOverStream {} unsafe impl Sync for OutputStreamOverStream {} pub struct RandomAccessStream; impl RandomAccessStream { - pub fn CopyAsync(source: P0, destination: P1) -> windows_core::Result> + pub fn CopyAsync(source: P0, destination: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -2926,7 +2926,7 @@ impl RandomAccessStream { (windows_core::Interface::vtable(this).CopyAsync)(windows_core::Interface::as_raw(this), source.param().abi(), destination.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn CopySizeAsync(source: P0, destination: P1, bytestocopy: u64) -> windows_core::Result> + pub fn CopySizeAsync(source: P0, destination: P1, bytestocopy: u64) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -2936,7 +2936,7 @@ impl RandomAccessStream { (windows_core::Interface::vtable(this).CopySizeAsync)(windows_core::Interface::as_raw(this), source.param().abi(), destination.param().abi(), bytestocopy, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn CopyAndCloseAsync(source: P0, destination: P1) -> windows_core::Result> + pub fn CopyAndCloseAsync(source: P0, destination: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -2964,7 +2964,7 @@ impl RandomAccessStreamOverStream { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).Close)(windows_core::Interface::as_raw(this)).ok() } } - pub fn ReadAsync(&self, buffer: P0, count: u32, options: InputStreamOptions) -> windows_core::Result> + pub fn ReadAsync(&self, buffer: P0, count: u32, options: InputStreamOptions) -> windows_core::Result> where P0: windows_core::Param, { @@ -2974,7 +2974,7 @@ impl RandomAccessStreamOverStream { (windows_core::Interface::vtable(this).ReadAsync)(windows_core::Interface::as_raw(this), buffer.param().abi(), count, options, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn WriteAsync(&self, buffer: P0) -> windows_core::Result> + pub fn WriteAsync(&self, buffer: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2984,7 +2984,7 @@ impl RandomAccessStreamOverStream { (windows_core::Interface::vtable(this).WriteAsync)(windows_core::Interface::as_raw(this), buffer.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FlushAsync(&self) -> windows_core::Result> { + pub fn FlushAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -3066,7 +3066,7 @@ unsafe impl Sync for RandomAccessStreamOverStream {} pub struct RandomAccessStreamReference(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(RandomAccessStreamReference, windows_core::IUnknown, windows_core::IInspectable, IRandomAccessStreamReference); impl RandomAccessStreamReference { - pub fn OpenReadAsync(&self) -> windows_core::Result> { + pub fn OpenReadAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Storage/mod.rs b/crates/libs/windows/src/Windows/Storage/mod.rs index 36d464741a..0ce7ee8626 100644 --- a/crates/libs/windows/src/Windows/Storage/mod.rs +++ b/crates/libs/windows/src/Windows/Storage/mod.rs @@ -128,7 +128,7 @@ impl ApplicationData { (windows_core::Interface::vtable(this).Version)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn SetVersionAsync(&self, desiredversion: u32, handler: P1) -> windows_core::Result + pub fn SetVersionAsync(&self, desiredversion: u32, handler: P1) -> windows_core::Result where P1: windows_core::Param, { @@ -138,14 +138,14 @@ impl ApplicationData { (windows_core::Interface::vtable(this).SetVersionAsync)(windows_core::Interface::as_raw(this), desiredversion, handler.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ClearAllAsync(&self) -> windows_core::Result { + pub fn ClearAllAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ClearAllAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ClearAsync(&self, locality: ApplicationDataLocality) -> windows_core::Result { + pub fn ClearAsync(&self, locality: ApplicationDataLocality) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -231,7 +231,7 @@ impl ApplicationData { (windows_core::Interface::vtable(this).GetPublisherCacheFolder)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(foldername), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ClearPublisherCacheFolderAsync(&self, foldername: &windows_core::HSTRING) -> windows_core::Result { + pub fn ClearPublisherCacheFolderAsync(&self, foldername: &windows_core::HSTRING) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -253,7 +253,7 @@ impl ApplicationData { }) } #[cfg(feature = "System")] - pub fn GetForUserAsync(user: P0) -> windows_core::Result> + pub fn GetForUserAsync(user: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -686,7 +686,7 @@ impl CachedFileManager { Self::ICachedFileManagerStatics(|this| unsafe { (windows_core::Interface::vtable(this).DeferUpdates)(windows_core::Interface::as_raw(this), file.param().abi()).ok() }) } #[cfg(all(feature = "Storage_Provider", feature = "Storage_Streams"))] - pub fn CompleteUpdatesAsync(file: P0) -> windows_core::Result> + pub fn CompleteUpdatesAsync(file: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -721,35 +721,35 @@ impl windows_core::RuntimeType for CreationCollisionOption { pub struct DownloadsFolder; impl DownloadsFolder { #[cfg(feature = "Storage_Streams")] - pub fn CreateFileAsync(desiredname: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CreateFileAsync(desiredname: &windows_core::HSTRING) -> windows_core::Result> { Self::IDownloadsFolderStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreateFileAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(desiredname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "Storage_Search")] - pub fn CreateFolderAsync(desiredname: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CreateFolderAsync(desiredname: &windows_core::HSTRING) -> windows_core::Result> { Self::IDownloadsFolderStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreateFolderAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(desiredname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "Storage_Streams")] - pub fn CreateFileWithCollisionOptionAsync(desiredname: &windows_core::HSTRING, option: CreationCollisionOption) -> windows_core::Result> { + pub fn CreateFileWithCollisionOptionAsync(desiredname: &windows_core::HSTRING, option: CreationCollisionOption) -> windows_core::Result> { Self::IDownloadsFolderStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreateFileWithCollisionOptionAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(desiredname), option, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "Storage_Search")] - pub fn CreateFolderWithCollisionOptionAsync(desiredname: &windows_core::HSTRING, option: CreationCollisionOption) -> windows_core::Result> { + pub fn CreateFolderWithCollisionOptionAsync(desiredname: &windows_core::HSTRING, option: CreationCollisionOption) -> windows_core::Result> { Self::IDownloadsFolderStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreateFolderWithCollisionOptionAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(desiredname), option, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(all(feature = "Storage_Streams", feature = "System"))] - pub fn CreateFileForUserAsync(user: P0, desiredname: &windows_core::HSTRING) -> windows_core::Result> + pub fn CreateFileForUserAsync(user: P0, desiredname: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -759,7 +759,7 @@ impl DownloadsFolder { }) } #[cfg(all(feature = "Storage_Search", feature = "System"))] - pub fn CreateFolderForUserAsync(user: P0, desiredname: &windows_core::HSTRING) -> windows_core::Result> + pub fn CreateFolderForUserAsync(user: P0, desiredname: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -769,7 +769,7 @@ impl DownloadsFolder { }) } #[cfg(all(feature = "Storage_Streams", feature = "System"))] - pub fn CreateFileForUserWithCollisionOptionAsync(user: P0, desiredname: &windows_core::HSTRING, option: CreationCollisionOption) -> windows_core::Result> + pub fn CreateFileForUserWithCollisionOptionAsync(user: P0, desiredname: &windows_core::HSTRING, option: CreationCollisionOption) -> windows_core::Result> where P0: windows_core::Param, { @@ -779,7 +779,7 @@ impl DownloadsFolder { }) } #[cfg(all(feature = "Storage_Search", feature = "System"))] - pub fn CreateFolderForUserWithCollisionOptionAsync(user: P0, desiredname: &windows_core::HSTRING, option: CreationCollisionOption) -> windows_core::Result> + pub fn CreateFolderForUserWithCollisionOptionAsync(user: P0, desiredname: &windows_core::HSTRING, option: CreationCollisionOption) -> windows_core::Result> where P0: windows_core::Param, { @@ -866,7 +866,7 @@ impl core::ops::Not for FileAttributes { pub struct FileIO; impl FileIO { #[cfg(feature = "Storage_Streams")] - pub fn ReadTextAsync(file: P0) -> windows_core::Result> + pub fn ReadTextAsync(file: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -876,7 +876,7 @@ impl FileIO { }) } #[cfg(feature = "Storage_Streams")] - pub fn ReadTextWithEncodingAsync(file: P0, encoding: Streams::UnicodeEncoding) -> windows_core::Result> + pub fn ReadTextWithEncodingAsync(file: P0, encoding: Streams::UnicodeEncoding) -> windows_core::Result> where P0: windows_core::Param, { @@ -886,7 +886,7 @@ impl FileIO { }) } #[cfg(feature = "Storage_Streams")] - pub fn WriteTextAsync(file: P0, contents: &windows_core::HSTRING) -> windows_core::Result + pub fn WriteTextAsync(file: P0, contents: &windows_core::HSTRING) -> windows_core::Result where P0: windows_core::Param, { @@ -896,7 +896,7 @@ impl FileIO { }) } #[cfg(feature = "Storage_Streams")] - pub fn WriteTextWithEncodingAsync(file: P0, contents: &windows_core::HSTRING, encoding: Streams::UnicodeEncoding) -> windows_core::Result + pub fn WriteTextWithEncodingAsync(file: P0, contents: &windows_core::HSTRING, encoding: Streams::UnicodeEncoding) -> windows_core::Result where P0: windows_core::Param, { @@ -906,7 +906,7 @@ impl FileIO { }) } #[cfg(feature = "Storage_Streams")] - pub fn AppendTextAsync(file: P0, contents: &windows_core::HSTRING) -> windows_core::Result + pub fn AppendTextAsync(file: P0, contents: &windows_core::HSTRING) -> windows_core::Result where P0: windows_core::Param, { @@ -916,7 +916,7 @@ impl FileIO { }) } #[cfg(feature = "Storage_Streams")] - pub fn AppendTextWithEncodingAsync(file: P0, contents: &windows_core::HSTRING, encoding: Streams::UnicodeEncoding) -> windows_core::Result + pub fn AppendTextWithEncodingAsync(file: P0, contents: &windows_core::HSTRING, encoding: Streams::UnicodeEncoding) -> windows_core::Result where P0: windows_core::Param, { @@ -926,7 +926,7 @@ impl FileIO { }) } #[cfg(feature = "Storage_Streams")] - pub fn ReadLinesAsync(file: P0) -> windows_core::Result>> + pub fn ReadLinesAsync(file: P0) -> windows_core::Result>> where P0: windows_core::Param, { @@ -936,7 +936,7 @@ impl FileIO { }) } #[cfg(feature = "Storage_Streams")] - pub fn ReadLinesWithEncodingAsync(file: P0, encoding: Streams::UnicodeEncoding) -> windows_core::Result>> + pub fn ReadLinesWithEncodingAsync(file: P0, encoding: Streams::UnicodeEncoding) -> windows_core::Result>> where P0: windows_core::Param, { @@ -946,7 +946,7 @@ impl FileIO { }) } #[cfg(feature = "Storage_Streams")] - pub fn WriteLinesAsync(file: P0, lines: P1) -> windows_core::Result + pub fn WriteLinesAsync(file: P0, lines: P1) -> windows_core::Result where P0: windows_core::Param, P1: windows_core::Param>, @@ -957,7 +957,7 @@ impl FileIO { }) } #[cfg(feature = "Storage_Streams")] - pub fn WriteLinesWithEncodingAsync(file: P0, lines: P1, encoding: Streams::UnicodeEncoding) -> windows_core::Result + pub fn WriteLinesWithEncodingAsync(file: P0, lines: P1, encoding: Streams::UnicodeEncoding) -> windows_core::Result where P0: windows_core::Param, P1: windows_core::Param>, @@ -968,7 +968,7 @@ impl FileIO { }) } #[cfg(feature = "Storage_Streams")] - pub fn AppendLinesAsync(file: P0, lines: P1) -> windows_core::Result + pub fn AppendLinesAsync(file: P0, lines: P1) -> windows_core::Result where P0: windows_core::Param, P1: windows_core::Param>, @@ -979,7 +979,7 @@ impl FileIO { }) } #[cfg(feature = "Storage_Streams")] - pub fn AppendLinesWithEncodingAsync(file: P0, lines: P1, encoding: Streams::UnicodeEncoding) -> windows_core::Result + pub fn AppendLinesWithEncodingAsync(file: P0, lines: P1, encoding: Streams::UnicodeEncoding) -> windows_core::Result where P0: windows_core::Param, P1: windows_core::Param>, @@ -990,7 +990,7 @@ impl FileIO { }) } #[cfg(feature = "Storage_Streams")] - pub fn ReadBufferAsync(file: P0) -> windows_core::Result> + pub fn ReadBufferAsync(file: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1000,7 +1000,7 @@ impl FileIO { }) } #[cfg(feature = "Storage_Streams")] - pub fn WriteBufferAsync(file: P0, buffer: P1) -> windows_core::Result + pub fn WriteBufferAsync(file: P0, buffer: P1) -> windows_core::Result where P0: windows_core::Param, P1: windows_core::Param, @@ -1011,7 +1011,7 @@ impl FileIO { }) } #[cfg(feature = "Storage_Streams")] - pub fn WriteBytesAsync(file: P0, buffer: &[u8]) -> windows_core::Result + pub fn WriteBytesAsync(file: P0, buffer: &[u8]) -> windows_core::Result where P0: windows_core::Param, { @@ -1501,21 +1501,21 @@ impl IStorageFile { (windows_core::Interface::vtable(this).ContentType)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn OpenAsync(&self, accessmode: FileAccessMode) -> windows_core::Result> { + pub fn OpenAsync(&self, accessmode: FileAccessMode) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).OpenAsync)(windows_core::Interface::as_raw(this), accessmode, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn OpenTransactedWriteAsync(&self) -> windows_core::Result> { + pub fn OpenTransactedWriteAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).OpenTransactedWriteAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CopyOverloadDefaultNameAndOptions(&self, destinationfolder: P0) -> windows_core::Result> + pub fn CopyOverloadDefaultNameAndOptions(&self, destinationfolder: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1525,7 +1525,7 @@ impl IStorageFile { (windows_core::Interface::vtable(this).CopyOverloadDefaultNameAndOptions)(windows_core::Interface::as_raw(this), destinationfolder.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CopyOverloadDefaultOptions(&self, destinationfolder: P0, desirednewname: &windows_core::HSTRING) -> windows_core::Result> + pub fn CopyOverloadDefaultOptions(&self, destinationfolder: P0, desirednewname: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -1535,7 +1535,7 @@ impl IStorageFile { (windows_core::Interface::vtable(this).CopyOverloadDefaultOptions)(windows_core::Interface::as_raw(this), destinationfolder.param().abi(), core::mem::transmute_copy(desirednewname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CopyOverload(&self, destinationfolder: P0, desirednewname: &windows_core::HSTRING, option: NameCollisionOption) -> windows_core::Result> + pub fn CopyOverload(&self, destinationfolder: P0, desirednewname: &windows_core::HSTRING, option: NameCollisionOption) -> windows_core::Result> where P0: windows_core::Param, { @@ -1545,7 +1545,7 @@ impl IStorageFile { (windows_core::Interface::vtable(this).CopyOverload)(windows_core::Interface::as_raw(this), destinationfolder.param().abi(), core::mem::transmute_copy(desirednewname), option, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CopyAndReplaceAsync(&self, filetoreplace: P0) -> windows_core::Result + pub fn CopyAndReplaceAsync(&self, filetoreplace: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -1555,7 +1555,7 @@ impl IStorageFile { (windows_core::Interface::vtable(this).CopyAndReplaceAsync)(windows_core::Interface::as_raw(this), filetoreplace.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn MoveOverloadDefaultNameAndOptions(&self, destinationfolder: P0) -> windows_core::Result + pub fn MoveOverloadDefaultNameAndOptions(&self, destinationfolder: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -1565,7 +1565,7 @@ impl IStorageFile { (windows_core::Interface::vtable(this).MoveOverloadDefaultNameAndOptions)(windows_core::Interface::as_raw(this), destinationfolder.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn MoveOverloadDefaultOptions(&self, destinationfolder: P0, desirednewname: &windows_core::HSTRING) -> windows_core::Result + pub fn MoveOverloadDefaultOptions(&self, destinationfolder: P0, desirednewname: &windows_core::HSTRING) -> windows_core::Result where P0: windows_core::Param, { @@ -1575,7 +1575,7 @@ impl IStorageFile { (windows_core::Interface::vtable(this).MoveOverloadDefaultOptions)(windows_core::Interface::as_raw(this), destinationfolder.param().abi(), core::mem::transmute_copy(desirednewname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn MoveOverload(&self, destinationfolder: P0, desirednewname: &windows_core::HSTRING, option: NameCollisionOption) -> windows_core::Result + pub fn MoveOverload(&self, destinationfolder: P0, desirednewname: &windows_core::HSTRING, option: NameCollisionOption) -> windows_core::Result where P0: windows_core::Param, { @@ -1585,7 +1585,7 @@ impl IStorageFile { (windows_core::Interface::vtable(this).MoveOverload)(windows_core::Interface::as_raw(this), destinationfolder.param().abi(), core::mem::transmute_copy(desirednewname), option, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn MoveAndReplaceAsync(&self, filetoreplace: P0) -> windows_core::Result + pub fn MoveAndReplaceAsync(&self, filetoreplace: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -1595,42 +1595,42 @@ impl IStorageFile { (windows_core::Interface::vtable(this).MoveAndReplaceAsync)(windows_core::Interface::as_raw(this), filetoreplace.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn OpenSequentialReadAsync(&self) -> windows_core::Result> { + pub fn OpenSequentialReadAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).OpenSequentialReadAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn OpenReadAsync(&self) -> windows_core::Result> { + pub fn OpenReadAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).OpenReadAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RenameAsyncOverloadDefaultOptions(&self, desiredname: &windows_core::HSTRING) -> windows_core::Result { + pub fn RenameAsyncOverloadDefaultOptions(&self, desiredname: &windows_core::HSTRING) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RenameAsyncOverloadDefaultOptions)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(desiredname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RenameAsync(&self, desiredname: &windows_core::HSTRING, option: NameCollisionOption) -> windows_core::Result { + pub fn RenameAsync(&self, desiredname: &windows_core::HSTRING, option: NameCollisionOption) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RenameAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(desiredname), option, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAsyncOverloadDefaultOptions(&self) -> windows_core::Result { + pub fn DeleteAsyncOverloadDefaultOptions(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeleteAsyncOverloadDefaultOptions)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAsync(&self, option: StorageDeleteOption) -> windows_core::Result { + pub fn DeleteAsync(&self, option: StorageDeleteOption) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1638,7 +1638,7 @@ impl IStorageFile { } } #[cfg(feature = "Storage_FileProperties")] - pub fn GetBasicPropertiesAsync(&self) -> windows_core::Result> { + pub fn GetBasicPropertiesAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1689,16 +1689,16 @@ impl windows_core::RuntimeName for IStorageFile { pub trait IStorageFile_Impl: Streams::IInputStreamReference_Impl + Streams::IRandomAccessStreamReference_Impl + IStorageItem_Impl { fn FileType(&self) -> windows_core::Result; fn ContentType(&self) -> windows_core::Result; - fn OpenAsync(&self, accessMode: FileAccessMode) -> windows_core::Result>; - fn OpenTransactedWriteAsync(&self) -> windows_core::Result>; - fn CopyOverloadDefaultNameAndOptions(&self, destinationFolder: windows_core::Ref<'_, IStorageFolder>) -> windows_core::Result>; - fn CopyOverloadDefaultOptions(&self, destinationFolder: windows_core::Ref<'_, IStorageFolder>, desiredNewName: &windows_core::HSTRING) -> windows_core::Result>; - fn CopyOverload(&self, destinationFolder: windows_core::Ref<'_, IStorageFolder>, desiredNewName: &windows_core::HSTRING, option: NameCollisionOption) -> windows_core::Result>; - fn CopyAndReplaceAsync(&self, fileToReplace: windows_core::Ref<'_, IStorageFile>) -> windows_core::Result; - fn MoveOverloadDefaultNameAndOptions(&self, destinationFolder: windows_core::Ref<'_, IStorageFolder>) -> windows_core::Result; - fn MoveOverloadDefaultOptions(&self, destinationFolder: windows_core::Ref<'_, IStorageFolder>, desiredNewName: &windows_core::HSTRING) -> windows_core::Result; - fn MoveOverload(&self, destinationFolder: windows_core::Ref<'_, IStorageFolder>, desiredNewName: &windows_core::HSTRING, option: NameCollisionOption) -> windows_core::Result; - fn MoveAndReplaceAsync(&self, fileToReplace: windows_core::Ref<'_, IStorageFile>) -> windows_core::Result; + fn OpenAsync(&self, accessMode: FileAccessMode) -> windows_core::Result>; + fn OpenTransactedWriteAsync(&self) -> windows_core::Result>; + fn CopyOverloadDefaultNameAndOptions(&self, destinationFolder: windows_core::Ref<'_, IStorageFolder>) -> windows_core::Result>; + fn CopyOverloadDefaultOptions(&self, destinationFolder: windows_core::Ref<'_, IStorageFolder>, desiredNewName: &windows_core::HSTRING) -> windows_core::Result>; + fn CopyOverload(&self, destinationFolder: windows_core::Ref<'_, IStorageFolder>, desiredNewName: &windows_core::HSTRING, option: NameCollisionOption) -> windows_core::Result>; + fn CopyAndReplaceAsync(&self, fileToReplace: windows_core::Ref<'_, IStorageFile>) -> windows_core::Result; + fn MoveOverloadDefaultNameAndOptions(&self, destinationFolder: windows_core::Ref<'_, IStorageFolder>) -> windows_core::Result; + fn MoveOverloadDefaultOptions(&self, destinationFolder: windows_core::Ref<'_, IStorageFolder>, desiredNewName: &windows_core::HSTRING) -> windows_core::Result; + fn MoveOverload(&self, destinationFolder: windows_core::Ref<'_, IStorageFolder>, desiredNewName: &windows_core::HSTRING, option: NameCollisionOption) -> windows_core::Result; + fn MoveAndReplaceAsync(&self, fileToReplace: windows_core::Ref<'_, IStorageFile>) -> windows_core::Result; } #[cfg(all(feature = "Storage_FileProperties", feature = "Storage_Streams"))] impl IStorageFile_Vtbl { @@ -1903,14 +1903,14 @@ impl windows_core::RuntimeType for IStorageFile2 { windows_core::imp::interface_hierarchy!(IStorageFile2, windows_core::IUnknown, windows_core::IInspectable); impl IStorageFile2 { #[cfg(feature = "Storage_Streams")] - pub fn OpenWithOptionsAsync(&self, accessmode: FileAccessMode, options: StorageOpenOptions) -> windows_core::Result> { + pub fn OpenWithOptionsAsync(&self, accessmode: FileAccessMode, options: StorageOpenOptions) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).OpenWithOptionsAsync)(windows_core::Interface::as_raw(this), accessmode, options, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn OpenTransactedWriteWithOptionsAsync(&self, options: StorageOpenOptions) -> windows_core::Result> { + pub fn OpenTransactedWriteWithOptionsAsync(&self, options: StorageOpenOptions) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1924,8 +1924,8 @@ impl windows_core::RuntimeName for IStorageFile2 { } #[cfg(feature = "Storage_Streams")] pub trait IStorageFile2_Impl: windows_core::IUnknownImpl { - fn OpenWithOptionsAsync(&self, accessMode: FileAccessMode, options: StorageOpenOptions) -> windows_core::Result>; - fn OpenTransactedWriteWithOptionsAsync(&self, options: StorageOpenOptions) -> windows_core::Result>; + fn OpenWithOptionsAsync(&self, accessMode: FileAccessMode, options: StorageOpenOptions) -> windows_core::Result>; + fn OpenTransactedWriteWithOptionsAsync(&self, options: StorageOpenOptions) -> windows_core::Result>; } #[cfg(feature = "Storage_Streams")] impl IStorageFile2_Vtbl { @@ -2075,7 +2075,7 @@ windows_core::imp::interface_hierarchy!(IStorageFolder, windows_core::IUnknown, windows_core::imp::required_hierarchy!(IStorageFolder, IStorageItem); impl IStorageFolder { #[cfg(feature = "Storage_Streams")] - pub fn CreateFileAsyncOverloadDefaultOptions(&self, desiredname: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CreateFileAsyncOverloadDefaultOptions(&self, desiredname: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2083,7 +2083,7 @@ impl IStorageFolder { } } #[cfg(feature = "Storage_Streams")] - pub fn CreateFileAsync(&self, desiredname: &windows_core::HSTRING, options: CreationCollisionOption) -> windows_core::Result> { + pub fn CreateFileAsync(&self, desiredname: &windows_core::HSTRING, options: CreationCollisionOption) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2091,7 +2091,7 @@ impl IStorageFolder { } } #[cfg(feature = "Storage_Search")] - pub fn CreateFolderAsyncOverloadDefaultOptions(&self, desiredname: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CreateFolderAsyncOverloadDefaultOptions(&self, desiredname: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2099,7 +2099,7 @@ impl IStorageFolder { } } #[cfg(feature = "Storage_Search")] - pub fn CreateFolderAsync(&self, desiredname: &windows_core::HSTRING, options: CreationCollisionOption) -> windows_core::Result> { + pub fn CreateFolderAsync(&self, desiredname: &windows_core::HSTRING, options: CreationCollisionOption) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2107,7 +2107,7 @@ impl IStorageFolder { } } #[cfg(feature = "Storage_Streams")] - pub fn GetFileAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetFileAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2115,14 +2115,14 @@ impl IStorageFolder { } } #[cfg(feature = "Storage_Search")] - pub fn GetFolderAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetFolderAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFolderAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(name), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetItemAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetItemAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2130,7 +2130,7 @@ impl IStorageFolder { } } #[cfg(feature = "Storage_Streams")] - pub fn GetFilesAsyncOverloadDefaultOptionsStartAndCount(&self) -> windows_core::Result>> { + pub fn GetFilesAsyncOverloadDefaultOptionsStartAndCount(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2138,42 +2138,42 @@ impl IStorageFolder { } } #[cfg(feature = "Storage_Search")] - pub fn GetFoldersAsyncOverloadDefaultOptionsStartAndCount(&self) -> windows_core::Result>> { + pub fn GetFoldersAsyncOverloadDefaultOptionsStartAndCount(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFoldersAsyncOverloadDefaultOptionsStartAndCount)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetItemsAsyncOverloadDefaultStartAndCount(&self) -> windows_core::Result>> { + pub fn GetItemsAsyncOverloadDefaultStartAndCount(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetItemsAsyncOverloadDefaultStartAndCount)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RenameAsyncOverloadDefaultOptions(&self, desiredname: &windows_core::HSTRING) -> windows_core::Result { + pub fn RenameAsyncOverloadDefaultOptions(&self, desiredname: &windows_core::HSTRING) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RenameAsyncOverloadDefaultOptions)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(desiredname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RenameAsync(&self, desiredname: &windows_core::HSTRING, option: NameCollisionOption) -> windows_core::Result { + pub fn RenameAsync(&self, desiredname: &windows_core::HSTRING, option: NameCollisionOption) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RenameAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(desiredname), option, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAsyncOverloadDefaultOptions(&self) -> windows_core::Result { + pub fn DeleteAsyncOverloadDefaultOptions(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeleteAsyncOverloadDefaultOptions)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAsync(&self, option: StorageDeleteOption) -> windows_core::Result { + pub fn DeleteAsync(&self, option: StorageDeleteOption) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -2181,7 +2181,7 @@ impl IStorageFolder { } } #[cfg(feature = "Storage_FileProperties")] - pub fn GetBasicPropertiesAsync(&self) -> windows_core::Result> { + pub fn GetBasicPropertiesAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -2230,16 +2230,16 @@ impl windows_core::RuntimeName for IStorageFolder { } #[cfg(all(feature = "Storage_FileProperties", feature = "Storage_Search", feature = "Storage_Streams"))] pub trait IStorageFolder_Impl: IStorageItem_Impl { - fn CreateFileAsyncOverloadDefaultOptions(&self, desiredName: &windows_core::HSTRING) -> windows_core::Result>; - fn CreateFileAsync(&self, desiredName: &windows_core::HSTRING, options: CreationCollisionOption) -> windows_core::Result>; - fn CreateFolderAsyncOverloadDefaultOptions(&self, desiredName: &windows_core::HSTRING) -> windows_core::Result>; - fn CreateFolderAsync(&self, desiredName: &windows_core::HSTRING, options: CreationCollisionOption) -> windows_core::Result>; - fn GetFileAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result>; - fn GetFolderAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result>; - fn GetItemAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result>; - fn GetFilesAsyncOverloadDefaultOptionsStartAndCount(&self) -> windows_core::Result>>; - fn GetFoldersAsyncOverloadDefaultOptionsStartAndCount(&self) -> windows_core::Result>>; - fn GetItemsAsyncOverloadDefaultStartAndCount(&self) -> windows_core::Result>>; + fn CreateFileAsyncOverloadDefaultOptions(&self, desiredName: &windows_core::HSTRING) -> windows_core::Result>; + fn CreateFileAsync(&self, desiredName: &windows_core::HSTRING, options: CreationCollisionOption) -> windows_core::Result>; + fn CreateFolderAsyncOverloadDefaultOptions(&self, desiredName: &windows_core::HSTRING) -> windows_core::Result>; + fn CreateFolderAsync(&self, desiredName: &windows_core::HSTRING, options: CreationCollisionOption) -> windows_core::Result>; + fn GetFileAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result>; + fn GetFolderAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result>; + fn GetItemAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result>; + fn GetFilesAsyncOverloadDefaultOptionsStartAndCount(&self) -> windows_core::Result>>; + fn GetFoldersAsyncOverloadDefaultOptionsStartAndCount(&self) -> windows_core::Result>>; + fn GetItemsAsyncOverloadDefaultStartAndCount(&self) -> windows_core::Result>>; } #[cfg(all(feature = "Storage_FileProperties", feature = "Storage_Search", feature = "Storage_Streams"))] impl IStorageFolder_Vtbl { @@ -2436,7 +2436,7 @@ impl windows_core::RuntimeType for IStorageFolder2 { } windows_core::imp::interface_hierarchy!(IStorageFolder2, windows_core::IUnknown, windows_core::IInspectable); impl IStorageFolder2 { - pub fn TryGetItemAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { + pub fn TryGetItemAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2448,7 +2448,7 @@ impl windows_core::RuntimeName for IStorageFolder2 { const NAME: &'static str = "Windows.Storage.IStorageFolder2"; } pub trait IStorageFolder2_Impl: windows_core::IUnknownImpl { - fn TryGetItemAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result>; + fn TryGetItemAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result>; } impl IStorageFolder2_Vtbl { pub const fn new() -> Self { @@ -2515,28 +2515,28 @@ impl windows_core::RuntimeType for IStorageItem { } windows_core::imp::interface_hierarchy!(IStorageItem, windows_core::IUnknown, windows_core::IInspectable); impl IStorageItem { - pub fn RenameAsyncOverloadDefaultOptions(&self, desiredname: &windows_core::HSTRING) -> windows_core::Result { + pub fn RenameAsyncOverloadDefaultOptions(&self, desiredname: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RenameAsyncOverloadDefaultOptions)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(desiredname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RenameAsync(&self, desiredname: &windows_core::HSTRING, option: NameCollisionOption) -> windows_core::Result { + pub fn RenameAsync(&self, desiredname: &windows_core::HSTRING, option: NameCollisionOption) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RenameAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(desiredname), option, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAsyncOverloadDefaultOptions(&self) -> windows_core::Result { + pub fn DeleteAsyncOverloadDefaultOptions(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeleteAsyncOverloadDefaultOptions)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAsync(&self, option: StorageDeleteOption) -> windows_core::Result { + pub fn DeleteAsync(&self, option: StorageDeleteOption) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2544,7 +2544,7 @@ impl IStorageItem { } } #[cfg(feature = "Storage_FileProperties")] - pub fn GetBasicPropertiesAsync(&self) -> windows_core::Result> { + pub fn GetBasicPropertiesAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2593,11 +2593,11 @@ impl windows_core::RuntimeName for IStorageItem { } #[cfg(feature = "Storage_FileProperties")] pub trait IStorageItem_Impl: windows_core::IUnknownImpl { - fn RenameAsyncOverloadDefaultOptions(&self, desiredName: &windows_core::HSTRING) -> windows_core::Result; - fn RenameAsync(&self, desiredName: &windows_core::HSTRING, option: NameCollisionOption) -> windows_core::Result; - fn DeleteAsyncOverloadDefaultOptions(&self) -> windows_core::Result; - fn DeleteAsync(&self, option: StorageDeleteOption) -> windows_core::Result; - fn GetBasicPropertiesAsync(&self) -> windows_core::Result>; + fn RenameAsyncOverloadDefaultOptions(&self, desiredName: &windows_core::HSTRING) -> windows_core::Result; + fn RenameAsync(&self, desiredName: &windows_core::HSTRING, option: NameCollisionOption) -> windows_core::Result; + fn DeleteAsyncOverloadDefaultOptions(&self) -> windows_core::Result; + fn DeleteAsync(&self, option: StorageDeleteOption) -> windows_core::Result; + fn GetBasicPropertiesAsync(&self) -> windows_core::Result>; fn Name(&self) -> windows_core::Result; fn Path(&self) -> windows_core::Result; fn Attributes(&self) -> windows_core::Result; @@ -2777,7 +2777,7 @@ windows_core::imp::interface_hierarchy!(IStorageItem2, windows_core::IUnknown, w windows_core::imp::required_hierarchy!(IStorageItem2, IStorageItem); impl IStorageItem2 { #[cfg(feature = "Storage_Search")] - pub fn GetParentAsync(&self) -> windows_core::Result> { + pub fn GetParentAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2794,28 +2794,28 @@ impl IStorageItem2 { (windows_core::Interface::vtable(this).IsEqual)(windows_core::Interface::as_raw(this), item.param().abi(), &mut result__).map(|| result__) } } - pub fn RenameAsyncOverloadDefaultOptions(&self, desiredname: &windows_core::HSTRING) -> windows_core::Result { + pub fn RenameAsyncOverloadDefaultOptions(&self, desiredname: &windows_core::HSTRING) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RenameAsyncOverloadDefaultOptions)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(desiredname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RenameAsync(&self, desiredname: &windows_core::HSTRING, option: NameCollisionOption) -> windows_core::Result { + pub fn RenameAsync(&self, desiredname: &windows_core::HSTRING, option: NameCollisionOption) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RenameAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(desiredname), option, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAsyncOverloadDefaultOptions(&self) -> windows_core::Result { + pub fn DeleteAsyncOverloadDefaultOptions(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeleteAsyncOverloadDefaultOptions)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAsync(&self, option: StorageDeleteOption) -> windows_core::Result { + pub fn DeleteAsync(&self, option: StorageDeleteOption) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -2823,7 +2823,7 @@ impl IStorageItem2 { } } #[cfg(feature = "Storage_FileProperties")] - pub fn GetBasicPropertiesAsync(&self) -> windows_core::Result> { + pub fn GetBasicPropertiesAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -2872,7 +2872,7 @@ impl windows_core::RuntimeName for IStorageItem2 { } #[cfg(all(feature = "Storage_FileProperties", feature = "Storage_Search"))] pub trait IStorageItem2_Impl: IStorageItem_Impl { - fn GetParentAsync(&self) -> windows_core::Result>; + fn GetParentAsync(&self) -> windows_core::Result>; fn IsEqual(&self, item: windows_core::Ref<'_, IStorageItem>) -> windows_core::Result; } #[cfg(all(feature = "Storage_FileProperties", feature = "Storage_Search"))] @@ -2929,7 +2929,7 @@ impl windows_core::RuntimeType for IStorageItemProperties { windows_core::imp::interface_hierarchy!(IStorageItemProperties, windows_core::IUnknown, windows_core::IInspectable); impl IStorageItemProperties { #[cfg(all(feature = "Storage_FileProperties", feature = "Storage_Streams"))] - pub fn GetThumbnailAsyncOverloadDefaultSizeDefaultOptions(&self, mode: FileProperties::ThumbnailMode) -> windows_core::Result> { + pub fn GetThumbnailAsyncOverloadDefaultSizeDefaultOptions(&self, mode: FileProperties::ThumbnailMode) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2937,7 +2937,7 @@ impl IStorageItemProperties { } } #[cfg(all(feature = "Storage_FileProperties", feature = "Storage_Streams"))] - pub fn GetThumbnailAsyncOverloadDefaultOptions(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32) -> windows_core::Result> { + pub fn GetThumbnailAsyncOverloadDefaultOptions(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2945,7 +2945,7 @@ impl IStorageItemProperties { } } #[cfg(all(feature = "Storage_FileProperties", feature = "Storage_Streams"))] - pub fn GetThumbnailAsync(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32, options: FileProperties::ThumbnailOptions) -> windows_core::Result> { + pub fn GetThumbnailAsync(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32, options: FileProperties::ThumbnailOptions) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2988,9 +2988,9 @@ impl windows_core::RuntimeName for IStorageItemProperties { } #[cfg(all(feature = "Storage_FileProperties", feature = "Storage_Streams"))] pub trait IStorageItemProperties_Impl: windows_core::IUnknownImpl { - fn GetThumbnailAsyncOverloadDefaultSizeDefaultOptions(&self, mode: FileProperties::ThumbnailMode) -> windows_core::Result>; - fn GetThumbnailAsyncOverloadDefaultOptions(&self, mode: FileProperties::ThumbnailMode, requestedSize: u32) -> windows_core::Result>; - fn GetThumbnailAsync(&self, mode: FileProperties::ThumbnailMode, requestedSize: u32, options: FileProperties::ThumbnailOptions) -> windows_core::Result>; + fn GetThumbnailAsyncOverloadDefaultSizeDefaultOptions(&self, mode: FileProperties::ThumbnailMode) -> windows_core::Result>; + fn GetThumbnailAsyncOverloadDefaultOptions(&self, mode: FileProperties::ThumbnailMode, requestedSize: u32) -> windows_core::Result>; + fn GetThumbnailAsync(&self, mode: FileProperties::ThumbnailMode, requestedSize: u32, options: FileProperties::ThumbnailOptions) -> windows_core::Result>; fn DisplayName(&self) -> windows_core::Result; fn DisplayType(&self) -> windows_core::Result; fn FolderRelativeId(&self) -> windows_core::Result; @@ -3136,7 +3136,7 @@ windows_core::imp::interface_hierarchy!(IStorageItemProperties2, windows_core::I windows_core::imp::required_hierarchy!(IStorageItemProperties2, IStorageItemProperties); impl IStorageItemProperties2 { #[cfg(all(feature = "Storage_FileProperties", feature = "Storage_Streams"))] - pub fn GetScaledImageAsThumbnailAsyncOverloadDefaultSizeDefaultOptions(&self, mode: FileProperties::ThumbnailMode) -> windows_core::Result> { + pub fn GetScaledImageAsThumbnailAsyncOverloadDefaultSizeDefaultOptions(&self, mode: FileProperties::ThumbnailMode) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -3144,7 +3144,7 @@ impl IStorageItemProperties2 { } } #[cfg(all(feature = "Storage_FileProperties", feature = "Storage_Streams"))] - pub fn GetScaledImageAsThumbnailAsyncOverloadDefaultOptions(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32) -> windows_core::Result> { + pub fn GetScaledImageAsThumbnailAsyncOverloadDefaultOptions(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -3152,7 +3152,7 @@ impl IStorageItemProperties2 { } } #[cfg(all(feature = "Storage_FileProperties", feature = "Storage_Streams"))] - pub fn GetScaledImageAsThumbnailAsync(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32, options: FileProperties::ThumbnailOptions) -> windows_core::Result> { + pub fn GetScaledImageAsThumbnailAsync(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32, options: FileProperties::ThumbnailOptions) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -3160,7 +3160,7 @@ impl IStorageItemProperties2 { } } #[cfg(all(feature = "Storage_FileProperties", feature = "Storage_Streams"))] - pub fn GetThumbnailAsyncOverloadDefaultSizeDefaultOptions(&self, mode: FileProperties::ThumbnailMode) -> windows_core::Result> { + pub fn GetThumbnailAsyncOverloadDefaultSizeDefaultOptions(&self, mode: FileProperties::ThumbnailMode) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -3168,7 +3168,7 @@ impl IStorageItemProperties2 { } } #[cfg(all(feature = "Storage_FileProperties", feature = "Storage_Streams"))] - pub fn GetThumbnailAsyncOverloadDefaultOptions(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32) -> windows_core::Result> { + pub fn GetThumbnailAsyncOverloadDefaultOptions(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -3176,7 +3176,7 @@ impl IStorageItemProperties2 { } } #[cfg(all(feature = "Storage_FileProperties", feature = "Storage_Streams"))] - pub fn GetThumbnailAsync(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32, options: FileProperties::ThumbnailOptions) -> windows_core::Result> { + pub fn GetThumbnailAsync(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32, options: FileProperties::ThumbnailOptions) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -3219,9 +3219,9 @@ impl windows_core::RuntimeName for IStorageItemProperties2 { } #[cfg(all(feature = "Storage_FileProperties", feature = "Storage_Streams"))] pub trait IStorageItemProperties2_Impl: IStorageItemProperties_Impl { - fn GetScaledImageAsThumbnailAsyncOverloadDefaultSizeDefaultOptions(&self, mode: FileProperties::ThumbnailMode) -> windows_core::Result>; - fn GetScaledImageAsThumbnailAsyncOverloadDefaultOptions(&self, mode: FileProperties::ThumbnailMode, requestedSize: u32) -> windows_core::Result>; - fn GetScaledImageAsThumbnailAsync(&self, mode: FileProperties::ThumbnailMode, requestedSize: u32, options: FileProperties::ThumbnailOptions) -> windows_core::Result>; + fn GetScaledImageAsThumbnailAsyncOverloadDefaultSizeDefaultOptions(&self, mode: FileProperties::ThumbnailMode) -> windows_core::Result>; + fn GetScaledImageAsThumbnailAsyncOverloadDefaultOptions(&self, mode: FileProperties::ThumbnailMode, requestedSize: u32) -> windows_core::Result>; + fn GetScaledImageAsThumbnailAsync(&self, mode: FileProperties::ThumbnailMode, requestedSize: u32, options: FileProperties::ThumbnailOptions) -> windows_core::Result>; } #[cfg(all(feature = "Storage_FileProperties", feature = "Storage_Streams"))] impl IStorageItemProperties2_Vtbl { @@ -3307,7 +3307,7 @@ impl IStorageItemPropertiesWithProvider { } } #[cfg(all(feature = "Storage_FileProperties", feature = "Storage_Streams"))] - pub fn GetThumbnailAsyncOverloadDefaultSizeDefaultOptions(&self, mode: FileProperties::ThumbnailMode) -> windows_core::Result> { + pub fn GetThumbnailAsyncOverloadDefaultSizeDefaultOptions(&self, mode: FileProperties::ThumbnailMode) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -3315,7 +3315,7 @@ impl IStorageItemPropertiesWithProvider { } } #[cfg(all(feature = "Storage_FileProperties", feature = "Storage_Streams"))] - pub fn GetThumbnailAsyncOverloadDefaultOptions(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32) -> windows_core::Result> { + pub fn GetThumbnailAsyncOverloadDefaultOptions(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -3323,7 +3323,7 @@ impl IStorageItemPropertiesWithProvider { } } #[cfg(all(feature = "Storage_FileProperties", feature = "Storage_Streams"))] - pub fn GetThumbnailAsync(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32, options: FileProperties::ThumbnailOptions) -> windows_core::Result> { + pub fn GetThumbnailAsync(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32, options: FileProperties::ThumbnailOptions) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -3909,7 +3909,7 @@ impl KnownFolders { }) } #[cfg(all(feature = "Storage_Search", feature = "System"))] - pub fn GetFolderForUserAsync(user: P0, folderid: KnownFolderId) -> windows_core::Result> + pub fn GetFolderForUserAsync(user: P0, folderid: KnownFolderId) -> windows_core::Result> where P0: windows_core::Param, { @@ -3918,14 +3918,14 @@ impl KnownFolders { (windows_core::Interface::vtable(this).GetFolderForUserAsync)(windows_core::Interface::as_raw(this), user.param().abi(), folderid, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RequestAccessAsync(folderid: KnownFolderId) -> windows_core::Result> { + pub fn RequestAccessAsync(folderid: KnownFolderId) -> windows_core::Result> { Self::IKnownFoldersStatics4(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestAccessAsync)(windows_core::Interface::as_raw(this), folderid, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "System")] - pub fn RequestAccessForUserAsync(user: P0, folderid: KnownFolderId) -> windows_core::Result> + pub fn RequestAccessForUserAsync(user: P0, folderid: KnownFolderId) -> windows_core::Result> where P0: windows_core::Param, { @@ -3935,7 +3935,7 @@ impl KnownFolders { }) } #[cfg(feature = "Storage_Search")] - pub fn GetFolderAsync(folderid: KnownFolderId) -> windows_core::Result> { + pub fn GetFolderAsync(folderid: KnownFolderId) -> windows_core::Result> { Self::IKnownFoldersStatics4(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFolderAsync)(windows_core::Interface::as_raw(this), folderid, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -4021,59 +4021,59 @@ impl windows_core::RuntimeType for NameCollisionOption { } pub struct PathIO; impl PathIO { - pub fn ReadTextAsync(absolutepath: &windows_core::HSTRING) -> windows_core::Result> { + pub fn ReadTextAsync(absolutepath: &windows_core::HSTRING) -> windows_core::Result> { Self::IPathIOStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReadTextAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(absolutepath), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "Storage_Streams")] - pub fn ReadTextWithEncodingAsync(absolutepath: &windows_core::HSTRING, encoding: Streams::UnicodeEncoding) -> windows_core::Result> { + pub fn ReadTextWithEncodingAsync(absolutepath: &windows_core::HSTRING, encoding: Streams::UnicodeEncoding) -> windows_core::Result> { Self::IPathIOStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReadTextWithEncodingAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(absolutepath), encoding, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn WriteTextAsync(absolutepath: &windows_core::HSTRING, contents: &windows_core::HSTRING) -> windows_core::Result { + pub fn WriteTextAsync(absolutepath: &windows_core::HSTRING, contents: &windows_core::HSTRING) -> windows_core::Result { Self::IPathIOStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).WriteTextAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(absolutepath), core::mem::transmute_copy(contents), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "Storage_Streams")] - pub fn WriteTextWithEncodingAsync(absolutepath: &windows_core::HSTRING, contents: &windows_core::HSTRING, encoding: Streams::UnicodeEncoding) -> windows_core::Result { + pub fn WriteTextWithEncodingAsync(absolutepath: &windows_core::HSTRING, contents: &windows_core::HSTRING, encoding: Streams::UnicodeEncoding) -> windows_core::Result { Self::IPathIOStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).WriteTextWithEncodingAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(absolutepath), core::mem::transmute_copy(contents), encoding, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn AppendTextAsync(absolutepath: &windows_core::HSTRING, contents: &windows_core::HSTRING) -> windows_core::Result { + pub fn AppendTextAsync(absolutepath: &windows_core::HSTRING, contents: &windows_core::HSTRING) -> windows_core::Result { Self::IPathIOStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).AppendTextAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(absolutepath), core::mem::transmute_copy(contents), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "Storage_Streams")] - pub fn AppendTextWithEncodingAsync(absolutepath: &windows_core::HSTRING, contents: &windows_core::HSTRING, encoding: Streams::UnicodeEncoding) -> windows_core::Result { + pub fn AppendTextWithEncodingAsync(absolutepath: &windows_core::HSTRING, contents: &windows_core::HSTRING, encoding: Streams::UnicodeEncoding) -> windows_core::Result { Self::IPathIOStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).AppendTextWithEncodingAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(absolutepath), core::mem::transmute_copy(contents), encoding, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn ReadLinesAsync(absolutepath: &windows_core::HSTRING) -> windows_core::Result>> { + pub fn ReadLinesAsync(absolutepath: &windows_core::HSTRING) -> windows_core::Result>> { Self::IPathIOStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReadLinesAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(absolutepath), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "Storage_Streams")] - pub fn ReadLinesWithEncodingAsync(absolutepath: &windows_core::HSTRING, encoding: Streams::UnicodeEncoding) -> windows_core::Result>> { + pub fn ReadLinesWithEncodingAsync(absolutepath: &windows_core::HSTRING, encoding: Streams::UnicodeEncoding) -> windows_core::Result>> { Self::IPathIOStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReadLinesWithEncodingAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(absolutepath), encoding, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn WriteLinesAsync(absolutepath: &windows_core::HSTRING, lines: P1) -> windows_core::Result + pub fn WriteLinesAsync(absolutepath: &windows_core::HSTRING, lines: P1) -> windows_core::Result where P1: windows_core::Param>, { @@ -4083,7 +4083,7 @@ impl PathIO { }) } #[cfg(feature = "Storage_Streams")] - pub fn WriteLinesWithEncodingAsync(absolutepath: &windows_core::HSTRING, lines: P1, encoding: Streams::UnicodeEncoding) -> windows_core::Result + pub fn WriteLinesWithEncodingAsync(absolutepath: &windows_core::HSTRING, lines: P1, encoding: Streams::UnicodeEncoding) -> windows_core::Result where P1: windows_core::Param>, { @@ -4092,7 +4092,7 @@ impl PathIO { (windows_core::Interface::vtable(this).WriteLinesWithEncodingAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(absolutepath), lines.param().abi(), encoding, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn AppendLinesAsync(absolutepath: &windows_core::HSTRING, lines: P1) -> windows_core::Result + pub fn AppendLinesAsync(absolutepath: &windows_core::HSTRING, lines: P1) -> windows_core::Result where P1: windows_core::Param>, { @@ -4102,7 +4102,7 @@ impl PathIO { }) } #[cfg(feature = "Storage_Streams")] - pub fn AppendLinesWithEncodingAsync(absolutepath: &windows_core::HSTRING, lines: P1, encoding: Streams::UnicodeEncoding) -> windows_core::Result + pub fn AppendLinesWithEncodingAsync(absolutepath: &windows_core::HSTRING, lines: P1, encoding: Streams::UnicodeEncoding) -> windows_core::Result where P1: windows_core::Param>, { @@ -4112,14 +4112,14 @@ impl PathIO { }) } #[cfg(feature = "Storage_Streams")] - pub fn ReadBufferAsync(absolutepath: &windows_core::HSTRING) -> windows_core::Result> { + pub fn ReadBufferAsync(absolutepath: &windows_core::HSTRING) -> windows_core::Result> { Self::IPathIOStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReadBufferAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(absolutepath), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "Storage_Streams")] - pub fn WriteBufferAsync(absolutepath: &windows_core::HSTRING, buffer: P1) -> windows_core::Result + pub fn WriteBufferAsync(absolutepath: &windows_core::HSTRING, buffer: P1) -> windows_core::Result where P1: windows_core::Param, { @@ -4128,7 +4128,7 @@ impl PathIO { (windows_core::Interface::vtable(this).WriteBufferAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(absolutepath), buffer.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn WriteBytesAsync(absolutepath: &windows_core::HSTRING, buffer: &[u8]) -> windows_core::Result { + pub fn WriteBytesAsync(absolutepath: &windows_core::HSTRING, buffer: &[u8]) -> windows_core::Result { Self::IPathIOStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).WriteBytesAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(absolutepath), buffer.len().try_into().unwrap(), buffer.as_ptr(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -4226,14 +4226,14 @@ windows_core::imp::interface_hierarchy!(StorageFile, windows_core::IUnknown, win windows_core::imp::required_hierarchy!(StorageFile, Streams::IInputStreamReference, Streams::IRandomAccessStreamReference, IStorageFile2, IStorageFilePropertiesWithAvailability, IStorageItem, IStorageItem2, IStorageItemProperties, IStorageItemProperties2, IStorageItemPropertiesWithProvider); #[cfg(feature = "Storage_Streams")] impl StorageFile { - pub fn OpenSequentialReadAsync(&self) -> windows_core::Result> { + pub fn OpenSequentialReadAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).OpenSequentialReadAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn OpenReadAsync(&self) -> windows_core::Result> { + pub fn OpenReadAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -4254,21 +4254,21 @@ impl StorageFile { (windows_core::Interface::vtable(this).ContentType)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn OpenAsync(&self, accessmode: FileAccessMode) -> windows_core::Result> { + pub fn OpenAsync(&self, accessmode: FileAccessMode) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).OpenAsync)(windows_core::Interface::as_raw(this), accessmode, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn OpenTransactedWriteAsync(&self) -> windows_core::Result> { + pub fn OpenTransactedWriteAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).OpenTransactedWriteAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CopyOverloadDefaultNameAndOptions(&self, destinationfolder: P0) -> windows_core::Result> + pub fn CopyOverloadDefaultNameAndOptions(&self, destinationfolder: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -4278,7 +4278,7 @@ impl StorageFile { (windows_core::Interface::vtable(this).CopyOverloadDefaultNameAndOptions)(windows_core::Interface::as_raw(this), destinationfolder.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CopyOverloadDefaultOptions(&self, destinationfolder: P0, desirednewname: &windows_core::HSTRING) -> windows_core::Result> + pub fn CopyOverloadDefaultOptions(&self, destinationfolder: P0, desirednewname: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -4288,7 +4288,7 @@ impl StorageFile { (windows_core::Interface::vtable(this).CopyOverloadDefaultOptions)(windows_core::Interface::as_raw(this), destinationfolder.param().abi(), core::mem::transmute_copy(desirednewname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CopyOverload(&self, destinationfolder: P0, desirednewname: &windows_core::HSTRING, option: NameCollisionOption) -> windows_core::Result> + pub fn CopyOverload(&self, destinationfolder: P0, desirednewname: &windows_core::HSTRING, option: NameCollisionOption) -> windows_core::Result> where P0: windows_core::Param, { @@ -4298,7 +4298,7 @@ impl StorageFile { (windows_core::Interface::vtable(this).CopyOverload)(windows_core::Interface::as_raw(this), destinationfolder.param().abi(), core::mem::transmute_copy(desirednewname), option, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CopyAndReplaceAsync(&self, filetoreplace: P0) -> windows_core::Result + pub fn CopyAndReplaceAsync(&self, filetoreplace: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -4308,7 +4308,7 @@ impl StorageFile { (windows_core::Interface::vtable(this).CopyAndReplaceAsync)(windows_core::Interface::as_raw(this), filetoreplace.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn MoveOverloadDefaultNameAndOptions(&self, destinationfolder: P0) -> windows_core::Result + pub fn MoveOverloadDefaultNameAndOptions(&self, destinationfolder: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -4318,7 +4318,7 @@ impl StorageFile { (windows_core::Interface::vtable(this).MoveOverloadDefaultNameAndOptions)(windows_core::Interface::as_raw(this), destinationfolder.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn MoveOverloadDefaultOptions(&self, destinationfolder: P0, desirednewname: &windows_core::HSTRING) -> windows_core::Result + pub fn MoveOverloadDefaultOptions(&self, destinationfolder: P0, desirednewname: &windows_core::HSTRING) -> windows_core::Result where P0: windows_core::Param, { @@ -4328,7 +4328,7 @@ impl StorageFile { (windows_core::Interface::vtable(this).MoveOverloadDefaultOptions)(windows_core::Interface::as_raw(this), destinationfolder.param().abi(), core::mem::transmute_copy(desirednewname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn MoveOverload(&self, destinationfolder: P0, desirednewname: &windows_core::HSTRING, option: NameCollisionOption) -> windows_core::Result + pub fn MoveOverload(&self, destinationfolder: P0, desirednewname: &windows_core::HSTRING, option: NameCollisionOption) -> windows_core::Result where P0: windows_core::Param, { @@ -4338,7 +4338,7 @@ impl StorageFile { (windows_core::Interface::vtable(this).MoveOverload)(windows_core::Interface::as_raw(this), destinationfolder.param().abi(), core::mem::transmute_copy(desirednewname), option, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn MoveAndReplaceAsync(&self, filetoreplace: P0) -> windows_core::Result + pub fn MoveAndReplaceAsync(&self, filetoreplace: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -4348,14 +4348,14 @@ impl StorageFile { (windows_core::Interface::vtable(this).MoveAndReplaceAsync)(windows_core::Interface::as_raw(this), filetoreplace.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn OpenWithOptionsAsync(&self, accessmode: FileAccessMode, options: StorageOpenOptions) -> windows_core::Result> { + pub fn OpenWithOptionsAsync(&self, accessmode: FileAccessMode, options: StorageOpenOptions) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).OpenWithOptionsAsync)(windows_core::Interface::as_raw(this), accessmode, options, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn OpenTransactedWriteWithOptionsAsync(&self, options: StorageOpenOptions) -> windows_core::Result> { + pub fn OpenTransactedWriteWithOptionsAsync(&self, options: StorageOpenOptions) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -4369,13 +4369,13 @@ impl StorageFile { (windows_core::Interface::vtable(this).IsAvailable)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn GetFileFromPathAsync(path: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetFileFromPathAsync(path: &windows_core::HSTRING) -> windows_core::Result> { Self::IStorageFileStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFileFromPathAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(path), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetFileFromApplicationUriAsync(uri: P0) -> windows_core::Result> + pub fn GetFileFromApplicationUriAsync(uri: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -4384,7 +4384,7 @@ impl StorageFile { (windows_core::Interface::vtable(this).GetFileFromApplicationUriAsync)(windows_core::Interface::as_raw(this), uri.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn CreateStreamedFileAsync(displaynamewithextension: &windows_core::HSTRING, datarequested: P1, thumbnail: P2) -> windows_core::Result> + pub fn CreateStreamedFileAsync(displaynamewithextension: &windows_core::HSTRING, datarequested: P1, thumbnail: P2) -> windows_core::Result> where P1: windows_core::Param, P2: windows_core::Param, @@ -4394,7 +4394,7 @@ impl StorageFile { (windows_core::Interface::vtable(this).CreateStreamedFileAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(displaynamewithextension), datarequested.param().abi(), thumbnail.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn ReplaceWithStreamedFileAsync(filetoreplace: P0, datarequested: P1, thumbnail: P2) -> windows_core::Result> + pub fn ReplaceWithStreamedFileAsync(filetoreplace: P0, datarequested: P1, thumbnail: P2) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -4405,7 +4405,7 @@ impl StorageFile { (windows_core::Interface::vtable(this).ReplaceWithStreamedFileAsync)(windows_core::Interface::as_raw(this), filetoreplace.param().abi(), datarequested.param().abi(), thumbnail.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn CreateStreamedFileFromUriAsync(displaynamewithextension: &windows_core::HSTRING, uri: P1, thumbnail: P2) -> windows_core::Result> + pub fn CreateStreamedFileFromUriAsync(displaynamewithextension: &windows_core::HSTRING, uri: P1, thumbnail: P2) -> windows_core::Result> where P1: windows_core::Param, P2: windows_core::Param, @@ -4415,7 +4415,7 @@ impl StorageFile { (windows_core::Interface::vtable(this).CreateStreamedFileFromUriAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(displaynamewithextension), uri.param().abi(), thumbnail.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn ReplaceWithStreamedFileFromUriAsync(filetoreplace: P0, uri: P1, thumbnail: P2) -> windows_core::Result> + pub fn ReplaceWithStreamedFileFromUriAsync(filetoreplace: P0, uri: P1, thumbnail: P2) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -4427,7 +4427,7 @@ impl StorageFile { }) } #[cfg(feature = "System")] - pub fn GetFileFromPathForUserAsync(user: P0, path: &windows_core::HSTRING) -> windows_core::Result> + pub fn GetFileFromPathForUserAsync(user: P0, path: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -4436,28 +4436,28 @@ impl StorageFile { (windows_core::Interface::vtable(this).GetFileFromPathForUserAsync)(windows_core::Interface::as_raw(this), user.param().abi(), core::mem::transmute_copy(path), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RenameAsyncOverloadDefaultOptions(&self, desiredname: &windows_core::HSTRING) -> windows_core::Result { + pub fn RenameAsyncOverloadDefaultOptions(&self, desiredname: &windows_core::HSTRING) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RenameAsyncOverloadDefaultOptions)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(desiredname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RenameAsync(&self, desiredname: &windows_core::HSTRING, option: NameCollisionOption) -> windows_core::Result { + pub fn RenameAsync(&self, desiredname: &windows_core::HSTRING, option: NameCollisionOption) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RenameAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(desiredname), option, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAsyncOverloadDefaultOptions(&self) -> windows_core::Result { + pub fn DeleteAsyncOverloadDefaultOptions(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeleteAsyncOverloadDefaultOptions)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAsync(&self, option: StorageDeleteOption) -> windows_core::Result { + pub fn DeleteAsync(&self, option: StorageDeleteOption) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -4465,7 +4465,7 @@ impl StorageFile { } } #[cfg(feature = "Storage_FileProperties")] - pub fn GetBasicPropertiesAsync(&self) -> windows_core::Result> { + pub fn GetBasicPropertiesAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -4508,7 +4508,7 @@ impl StorageFile { } } #[cfg(feature = "Storage_Search")] - pub fn GetParentAsync(&self) -> windows_core::Result> { + pub fn GetParentAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -4526,7 +4526,7 @@ impl StorageFile { } } #[cfg(feature = "Storage_FileProperties")] - pub fn GetThumbnailAsyncOverloadDefaultSizeDefaultOptions(&self, mode: FileProperties::ThumbnailMode) -> windows_core::Result> { + pub fn GetThumbnailAsyncOverloadDefaultSizeDefaultOptions(&self, mode: FileProperties::ThumbnailMode) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -4534,7 +4534,7 @@ impl StorageFile { } } #[cfg(feature = "Storage_FileProperties")] - pub fn GetThumbnailAsyncOverloadDefaultOptions(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32) -> windows_core::Result> { + pub fn GetThumbnailAsyncOverloadDefaultOptions(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -4542,7 +4542,7 @@ impl StorageFile { } } #[cfg(feature = "Storage_FileProperties")] - pub fn GetThumbnailAsync(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32, options: FileProperties::ThumbnailOptions) -> windows_core::Result> { + pub fn GetThumbnailAsync(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32, options: FileProperties::ThumbnailOptions) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -4579,7 +4579,7 @@ impl StorageFile { } } #[cfg(feature = "Storage_FileProperties")] - pub fn GetScaledImageAsThumbnailAsyncOverloadDefaultSizeDefaultOptions(&self, mode: FileProperties::ThumbnailMode) -> windows_core::Result> { + pub fn GetScaledImageAsThumbnailAsyncOverloadDefaultSizeDefaultOptions(&self, mode: FileProperties::ThumbnailMode) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -4587,7 +4587,7 @@ impl StorageFile { } } #[cfg(feature = "Storage_FileProperties")] - pub fn GetScaledImageAsThumbnailAsyncOverloadDefaultOptions(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32) -> windows_core::Result> { + pub fn GetScaledImageAsThumbnailAsyncOverloadDefaultOptions(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -4595,7 +4595,7 @@ impl StorageFile { } } #[cfg(feature = "Storage_FileProperties")] - pub fn GetScaledImageAsThumbnailAsync(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32, options: FileProperties::ThumbnailOptions) -> windows_core::Result> { + pub fn GetScaledImageAsThumbnailAsync(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32, options: FileProperties::ThumbnailOptions) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -4642,7 +4642,7 @@ windows_core::imp::required_hierarchy!(StorageFolder, IStorageFolder2, Search::I #[cfg(feature = "Storage_Search")] impl StorageFolder { #[cfg(feature = "Storage_Streams")] - pub fn CreateFileAsyncOverloadDefaultOptions(&self, desiredname: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CreateFileAsyncOverloadDefaultOptions(&self, desiredname: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -4650,21 +4650,21 @@ impl StorageFolder { } } #[cfg(feature = "Storage_Streams")] - pub fn CreateFileAsync(&self, desiredname: &windows_core::HSTRING, options: CreationCollisionOption) -> windows_core::Result> { + pub fn CreateFileAsync(&self, desiredname: &windows_core::HSTRING, options: CreationCollisionOption) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreateFileAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(desiredname), options, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateFolderAsyncOverloadDefaultOptions(&self, desiredname: &windows_core::HSTRING) -> windows_core::Result> { + pub fn CreateFolderAsyncOverloadDefaultOptions(&self, desiredname: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreateFolderAsyncOverloadDefaultOptions)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(desiredname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateFolderAsync(&self, desiredname: &windows_core::HSTRING, options: CreationCollisionOption) -> windows_core::Result> { + pub fn CreateFolderAsync(&self, desiredname: &windows_core::HSTRING, options: CreationCollisionOption) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -4672,21 +4672,21 @@ impl StorageFolder { } } #[cfg(feature = "Storage_Streams")] - pub fn GetFileAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetFileAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFileAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(name), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetFolderAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetFolderAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFolderAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(name), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetItemAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetItemAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -4694,28 +4694,28 @@ impl StorageFolder { } } #[cfg(feature = "Storage_Streams")] - pub fn GetFilesAsyncOverloadDefaultOptionsStartAndCount(&self) -> windows_core::Result>> { + pub fn GetFilesAsyncOverloadDefaultOptionsStartAndCount(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFilesAsyncOverloadDefaultOptionsStartAndCount)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetFoldersAsyncOverloadDefaultOptionsStartAndCount(&self) -> windows_core::Result>> { + pub fn GetFoldersAsyncOverloadDefaultOptionsStartAndCount(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFoldersAsyncOverloadDefaultOptionsStartAndCount)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetItemsAsyncOverloadDefaultStartAndCount(&self) -> windows_core::Result>> { + pub fn GetItemsAsyncOverloadDefaultStartAndCount(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetItemsAsyncOverloadDefaultStartAndCount)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryGetItemAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { + pub fn TryGetItemAsync(&self, name: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -4729,7 +4729,7 @@ impl StorageFolder { (windows_core::Interface::vtable(this).TryGetChangeTracker)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetIndexedStateAsync(&self) -> windows_core::Result> { + pub fn GetIndexedStateAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -4802,7 +4802,7 @@ impl StorageFolder { } } #[cfg(feature = "Storage_Streams")] - pub fn GetFilesAsync(&self, query: Search::CommonFileQuery, startindex: u32, maxitemstoretrieve: u32) -> windows_core::Result>> { + pub fn GetFilesAsync(&self, query: Search::CommonFileQuery, startindex: u32, maxitemstoretrieve: u32) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -4810,28 +4810,28 @@ impl StorageFolder { } } #[cfg(feature = "Storage_Streams")] - pub fn GetFilesAsyncOverloadDefaultStartAndCount(&self, query: Search::CommonFileQuery) -> windows_core::Result>> { + pub fn GetFilesAsyncOverloadDefaultStartAndCount(&self, query: Search::CommonFileQuery) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFilesAsyncOverloadDefaultStartAndCount)(windows_core::Interface::as_raw(this), query, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetFoldersAsync(&self, query: Search::CommonFolderQuery, startindex: u32, maxitemstoretrieve: u32) -> windows_core::Result>> { + pub fn GetFoldersAsync(&self, query: Search::CommonFolderQuery, startindex: u32, maxitemstoretrieve: u32) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFoldersAsync)(windows_core::Interface::as_raw(this), query, startindex, maxitemstoretrieve, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetFoldersAsyncOverloadDefaultStartAndCount(&self, query: Search::CommonFolderQuery) -> windows_core::Result>> { + pub fn GetFoldersAsyncOverloadDefaultStartAndCount(&self, query: Search::CommonFolderQuery) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFoldersAsyncOverloadDefaultStartAndCount)(windows_core::Interface::as_raw(this), query, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetItemsAsync(&self, startindex: u32, maxitemstoretrieve: u32) -> windows_core::Result>> { + pub fn GetItemsAsync(&self, startindex: u32, maxitemstoretrieve: u32) -> windows_core::Result>> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -4862,14 +4862,14 @@ impl StorageFolder { (windows_core::Interface::vtable(this).IsCommonFileQuerySupported)(windows_core::Interface::as_raw(this), query, &mut result__).map(|| result__) } } - pub fn GetFolderFromPathAsync(path: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetFolderFromPathAsync(path: &windows_core::HSTRING) -> windows_core::Result> { Self::IStorageFolderStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFolderFromPathAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(path), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "System")] - pub fn GetFolderFromPathForUserAsync(user: P0, path: &windows_core::HSTRING) -> windows_core::Result> + pub fn GetFolderFromPathForUserAsync(user: P0, path: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -4878,28 +4878,28 @@ impl StorageFolder { (windows_core::Interface::vtable(this).GetFolderFromPathForUserAsync)(windows_core::Interface::as_raw(this), user.param().abi(), core::mem::transmute_copy(path), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RenameAsyncOverloadDefaultOptions(&self, desiredname: &windows_core::HSTRING) -> windows_core::Result { + pub fn RenameAsyncOverloadDefaultOptions(&self, desiredname: &windows_core::HSTRING) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RenameAsyncOverloadDefaultOptions)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(desiredname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RenameAsync(&self, desiredname: &windows_core::HSTRING, option: NameCollisionOption) -> windows_core::Result { + pub fn RenameAsync(&self, desiredname: &windows_core::HSTRING, option: NameCollisionOption) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RenameAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(desiredname), option, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAsyncOverloadDefaultOptions(&self) -> windows_core::Result { + pub fn DeleteAsyncOverloadDefaultOptions(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).DeleteAsyncOverloadDefaultOptions)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteAsync(&self, option: StorageDeleteOption) -> windows_core::Result { + pub fn DeleteAsync(&self, option: StorageDeleteOption) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -4907,7 +4907,7 @@ impl StorageFolder { } } #[cfg(feature = "Storage_FileProperties")] - pub fn GetBasicPropertiesAsync(&self) -> windows_core::Result> { + pub fn GetBasicPropertiesAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -4949,7 +4949,7 @@ impl StorageFolder { (windows_core::Interface::vtable(this).IsOfType)(windows_core::Interface::as_raw(this), r#type, &mut result__).map(|| result__) } } - pub fn GetParentAsync(&self) -> windows_core::Result> { + pub fn GetParentAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -4967,7 +4967,7 @@ impl StorageFolder { } } #[cfg(all(feature = "Storage_FileProperties", feature = "Storage_Streams"))] - pub fn GetThumbnailAsyncOverloadDefaultSizeDefaultOptions(&self, mode: FileProperties::ThumbnailMode) -> windows_core::Result> { + pub fn GetThumbnailAsyncOverloadDefaultSizeDefaultOptions(&self, mode: FileProperties::ThumbnailMode) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -4975,7 +4975,7 @@ impl StorageFolder { } } #[cfg(all(feature = "Storage_FileProperties", feature = "Storage_Streams"))] - pub fn GetThumbnailAsyncOverloadDefaultOptions(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32) -> windows_core::Result> { + pub fn GetThumbnailAsyncOverloadDefaultOptions(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -4983,7 +4983,7 @@ impl StorageFolder { } } #[cfg(all(feature = "Storage_FileProperties", feature = "Storage_Streams"))] - pub fn GetThumbnailAsync(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32, options: FileProperties::ThumbnailOptions) -> windows_core::Result> { + pub fn GetThumbnailAsync(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32, options: FileProperties::ThumbnailOptions) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -5020,7 +5020,7 @@ impl StorageFolder { } } #[cfg(all(feature = "Storage_FileProperties", feature = "Storage_Streams"))] - pub fn GetScaledImageAsThumbnailAsyncOverloadDefaultSizeDefaultOptions(&self, mode: FileProperties::ThumbnailMode) -> windows_core::Result> { + pub fn GetScaledImageAsThumbnailAsyncOverloadDefaultSizeDefaultOptions(&self, mode: FileProperties::ThumbnailMode) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -5028,7 +5028,7 @@ impl StorageFolder { } } #[cfg(all(feature = "Storage_FileProperties", feature = "Storage_Streams"))] - pub fn GetScaledImageAsThumbnailAsyncOverloadDefaultOptions(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32) -> windows_core::Result> { + pub fn GetScaledImageAsThumbnailAsyncOverloadDefaultOptions(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -5036,7 +5036,7 @@ impl StorageFolder { } } #[cfg(all(feature = "Storage_FileProperties", feature = "Storage_Streams"))] - pub fn GetScaledImageAsThumbnailAsync(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32, options: FileProperties::ThumbnailOptions) -> windows_core::Result> { + pub fn GetScaledImageAsThumbnailAsync(&self, mode: FileProperties::ThumbnailMode, requestedsize: u32, options: FileProperties::ThumbnailOptions) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -5125,7 +5125,7 @@ pub struct StorageLibrary(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(StorageLibrary, windows_core::IUnknown, windows_core::IInspectable); impl StorageLibrary { #[cfg(feature = "Storage_Search")] - pub fn RequestAddFolderAsync(&self) -> windows_core::Result> { + pub fn RequestAddFolderAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -5133,7 +5133,7 @@ impl StorageLibrary { } } #[cfg(feature = "Storage_Search")] - pub fn RequestRemoveFolderAsync(&self, folder: P0) -> windows_core::Result> + pub fn RequestRemoveFolderAsync(&self, folder: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -5180,21 +5180,21 @@ impl StorageLibrary { (windows_core::Interface::vtable(this).ChangeTracker)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn AreFolderSuggestionsAvailableAsync(&self) -> windows_core::Result> { + pub fn AreFolderSuggestionsAvailableAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).AreFolderSuggestionsAvailableAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetLibraryAsync(libraryid: KnownLibraryId) -> windows_core::Result> { + pub fn GetLibraryAsync(libraryid: KnownLibraryId) -> windows_core::Result> { Self::IStorageLibraryStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetLibraryAsync)(windows_core::Interface::as_raw(this), libraryid, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "System")] - pub fn GetLibraryForUserAsync(user: P0, libraryid: KnownLibraryId) -> windows_core::Result> + pub fn GetLibraryForUserAsync(user: P0, libraryid: KnownLibraryId) -> windows_core::Result> where P0: windows_core::Param, { @@ -5255,7 +5255,7 @@ impl StorageLibraryChange { (windows_core::Interface::vtable(this).IsOfType)(windows_core::Interface::as_raw(this), r#type, &mut result__).map(|| result__) } } - pub fn GetStorageItemAsync(&self) -> windows_core::Result> { + pub fn GetStorageItemAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -5280,14 +5280,14 @@ unsafe impl Sync for StorageLibraryChange {} pub struct StorageLibraryChangeReader(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(StorageLibraryChangeReader, windows_core::IUnknown, windows_core::IInspectable); impl StorageLibraryChangeReader { - pub fn ReadBatchAsync(&self) -> windows_core::Result>> { + pub fn ReadBatchAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReadBatchAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn AcceptChangesAsync(&self) -> windows_core::Result { + pub fn AcceptChangesAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -5509,7 +5509,7 @@ impl StorageProvider { (windows_core::Interface::vtable(this).DisplayName)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn IsPropertySupportedForPartialFileAsync(&self, propertycanonicalname: &windows_core::HSTRING) -> windows_core::Result> { + pub fn IsPropertySupportedForPartialFileAsync(&self, propertycanonicalname: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -5545,7 +5545,7 @@ impl StorageStreamTransaction { (windows_core::Interface::vtable(this).Stream)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CommitAsync(&self) -> windows_core::Result { + pub fn CommitAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -5577,7 +5577,7 @@ impl StreamedFileDataRequest { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).Close)(windows_core::Interface::as_raw(this)).ok() } } - pub fn WriteAsync(&self, buffer: P0) -> windows_core::Result> + pub fn WriteAsync(&self, buffer: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -5587,7 +5587,7 @@ impl StreamedFileDataRequest { (windows_core::Interface::vtable(this).WriteAsync)(windows_core::Interface::as_raw(this), buffer.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FlushAsync(&self) -> windows_core::Result> { + pub fn FlushAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/System/Diagnostics/mod.rs b/crates/libs/windows/src/Windows/System/Diagnostics/mod.rs index 00338ddc74..56abee6945 100644 --- a/crates/libs/windows/src/Windows/System/Diagnostics/mod.rs +++ b/crates/libs/windows/src/Windows/System/Diagnostics/mod.rs @@ -61,7 +61,7 @@ pub struct DiagnosticInvoker(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(DiagnosticInvoker, windows_core::IUnknown, windows_core::IInspectable); impl DiagnosticInvoker { #[cfg(feature = "Data_Json")] - pub fn RunDiagnosticActionAsync(&self, context: P0) -> windows_core::Result> + pub fn RunDiagnosticActionAsync(&self, context: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -71,7 +71,7 @@ impl DiagnosticInvoker { (windows_core::Interface::vtable(this).RunDiagnosticActionAsync)(windows_core::Interface::as_raw(this), context.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RunDiagnosticActionFromStringAsync(&self, context: &windows_core::HSTRING) -> windows_core::Result> { + pub fn RunDiagnosticActionFromStringAsync(&self, context: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/System/Implementation/FileExplorer/mod.rs b/crates/libs/windows/src/Windows/System/Implementation/FileExplorer/mod.rs index 4b308fde19..6180387751 100644 --- a/crates/libs/windows/src/Windows/System/Implementation/FileExplorer/mod.rs +++ b/crates/libs/windows/src/Windows/System/Implementation/FileExplorer/mod.rs @@ -159,7 +159,7 @@ impl windows_core::RuntimeType for ISysStorageProviderHttpRequestProvider { windows_core::imp::interface_hierarchy!(ISysStorageProviderHttpRequestProvider, windows_core::IUnknown, windows_core::IInspectable); impl ISysStorageProviderHttpRequestProvider { #[cfg(feature = "Web_Http")] - pub fn SendRequestAsync(&self, request: P0) -> windows_core::Result> + pub fn SendRequestAsync(&self, request: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -176,7 +176,7 @@ impl windows_core::RuntimeName for ISysStorageProviderHttpRequestProvider { } #[cfg(feature = "Web_Http")] pub trait ISysStorageProviderHttpRequestProvider_Impl: windows_core::IUnknownImpl { - fn SendRequestAsync(&self, request: windows_core::Ref<'_, super::super::super::Web::Http::HttpRequestMessage>) -> windows_core::Result>; + fn SendRequestAsync(&self, request: windows_core::Ref<'_, super::super::super::Web::Http::HttpRequestMessage>) -> windows_core::Result>; } #[cfg(feature = "Web_Http")] impl ISysStorageProviderHttpRequestProvider_Vtbl { diff --git a/crates/libs/windows/src/Windows/System/Inventory/mod.rs b/crates/libs/windows/src/Windows/System/Inventory/mod.rs index 39f62a7578..2f2284f38a 100644 --- a/crates/libs/windows/src/Windows/System/Inventory/mod.rs +++ b/crates/libs/windows/src/Windows/System/Inventory/mod.rs @@ -53,7 +53,7 @@ impl InstalledDesktopApp { (windows_core::Interface::vtable(this).DisplayVersion)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn GetInventoryAsync() -> windows_core::Result>> { + pub fn GetInventoryAsync() -> windows_core::Result>> { Self::IInstalledDesktopAppStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetInventoryAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/System/Profile/mod.rs b/crates/libs/windows/src/Windows/System/Profile/mod.rs index 95a2c65a48..6de6b52b8d 100644 --- a/crates/libs/windows/src/Windows/System/Profile/mod.rs +++ b/crates/libs/windows/src/Windows/System/Profile/mod.rs @@ -14,7 +14,7 @@ impl AnalyticsInfo { (windows_core::Interface::vtable(this).DeviceForm)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) }) } - pub fn GetSystemPropertiesAsync(attributenames: P0) -> windows_core::Result>> + pub fn GetSystemPropertiesAsync(attributenames: P0) -> windows_core::Result>> where P0: windows_core::Param>, { diff --git a/crates/libs/windows/src/Windows/System/RemoteSystems/mod.rs b/crates/libs/windows/src/Windows/System/RemoteSystems/mod.rs index 601307c1bc..81358928e7 100644 --- a/crates/libs/windows/src/Windows/System/RemoteSystems/mod.rs +++ b/crates/libs/windows/src/Windows/System/RemoteSystems/mod.rs @@ -810,7 +810,7 @@ impl RemoteSystem { (windows_core::Interface::vtable(this).IsAvailableBySpatialProximity)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn GetCapabilitySupportedAsync(&self, capabilityname: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetCapabilitySupportedAsync(&self, capabilityname: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -853,7 +853,7 @@ impl RemoteSystem { } } #[cfg(feature = "Networking")] - pub fn FindByHostNameAsync(hostname: P0) -> windows_core::Result> + pub fn FindByHostNameAsync(hostname: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -877,7 +877,7 @@ impl RemoteSystem { (windows_core::Interface::vtable(this).CreateWatcherWithFilters)(windows_core::Interface::as_raw(this), filters.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RequestAccessAsync() -> windows_core::Result> { + pub fn RequestAccessAsync() -> windows_core::Result> { Self::IRemoteSystemStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestAccessAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -1059,7 +1059,7 @@ impl RemoteSystemAppRegistration { (windows_core::Interface::vtable(this).Attributes)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SaveAsync(&self) -> windows_core::Result> { + pub fn SaveAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1532,7 +1532,7 @@ impl RemoteSystemSession { (windows_core::Interface::vtable(this).CreateParticipantWatcher)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SendInvitationAsync(&self, invitee: P0) -> windows_core::Result> + pub fn SendInvitationAsync(&self, invitee: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1609,7 +1609,7 @@ impl RemoteSystemSessionController { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveJoinRequested)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn RemoveParticipantAsync(&self, pparticipant: P0) -> windows_core::Result> + pub fn RemoveParticipantAsync(&self, pparticipant: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1619,7 +1619,7 @@ impl RemoteSystemSessionController { (windows_core::Interface::vtable(this).RemoveParticipantAsync)(windows_core::Interface::as_raw(this), pparticipant.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateSessionAsync(&self) -> windows_core::Result> { + pub fn CreateSessionAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1762,7 +1762,7 @@ impl RemoteSystemSessionInfo { (windows_core::Interface::vtable(this).ControllerDisplayName)(windows_core::Interface::as_raw(this), &mut result__).map(|| core::mem::transmute(result__)) } } - pub fn JoinAsync(&self) -> windows_core::Result> { + pub fn JoinAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2000,7 +2000,7 @@ impl RemoteSystemSessionMessageChannel { } } #[cfg(feature = "Foundation_Collections")] - pub fn BroadcastValueSetAsync(&self, messagedata: P0) -> windows_core::Result> + pub fn BroadcastValueSetAsync(&self, messagedata: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2011,7 +2011,7 @@ impl RemoteSystemSessionMessageChannel { } } #[cfg(feature = "Foundation_Collections")] - pub fn SendValueSetAsync(&self, messagedata: P0, participant: P1) -> windows_core::Result> + pub fn SendValueSetAsync(&self, messagedata: P0, participant: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -2023,7 +2023,7 @@ impl RemoteSystemSessionMessageChannel { } } #[cfg(feature = "Foundation_Collections")] - pub fn SendValueSetToParticipantsAsync(&self, messagedata: P0, participants: P1) -> windows_core::Result> + pub fn SendValueSetToParticipantsAsync(&self, messagedata: P0, participants: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param>, diff --git a/crates/libs/windows/src/Windows/System/Threading/Core/mod.rs b/crates/libs/windows/src/Windows/System/Threading/Core/mod.rs index e1a8795bdf..008c6acefe 100644 --- a/crates/libs/windows/src/Windows/System/Threading/Core/mod.rs +++ b/crates/libs/windows/src/Windows/System/Threading/Core/mod.rs @@ -45,7 +45,7 @@ pub struct ISignalNotifierStatics_Vtbl { pub struct PreallocatedWorkItem(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(PreallocatedWorkItem, windows_core::IUnknown, windows_core::IInspectable); impl PreallocatedWorkItem { - pub fn RunAsync(&self) -> windows_core::Result { + pub fn RunAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/System/Threading/mod.rs b/crates/libs/windows/src/Windows/System/Threading/mod.rs index a0dac60215..88674a0d00 100644 --- a/crates/libs/windows/src/Windows/System/Threading/mod.rs +++ b/crates/libs/windows/src/Windows/System/Threading/mod.rs @@ -36,7 +36,7 @@ pub struct IThreadPoolTimerStatics_Vtbl { } pub struct ThreadPool; impl ThreadPool { - pub fn RunAsync(handler: P0) -> windows_core::Result + pub fn RunAsync(handler: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -45,7 +45,7 @@ impl ThreadPool { (windows_core::Interface::vtable(this).RunAsync)(windows_core::Interface::as_raw(this), handler.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RunWithPriorityAsync(handler: P0, priority: WorkItemPriority) -> windows_core::Result + pub fn RunWithPriorityAsync(handler: P0, priority: WorkItemPriority) -> windows_core::Result where P0: windows_core::Param, { @@ -54,7 +54,7 @@ impl ThreadPool { (windows_core::Interface::vtable(this).RunWithPriorityAsync)(windows_core::Interface::as_raw(this), handler.param().abi(), priority, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RunWithPriorityAndOptionsAsync(handler: P0, priority: WorkItemPriority, options: WorkItemOptions) -> windows_core::Result + pub fn RunWithPriorityAndOptionsAsync(handler: P0, priority: WorkItemPriority, options: WorkItemOptions) -> windows_core::Result where P0: windows_core::Param, { @@ -290,13 +290,13 @@ impl windows_core::RuntimeType for WorkItemHandler { const SIGNATURE: windows_core::imp::ConstBuffer = windows_core::imp::ConstBuffer::for_interface::(); } impl WorkItemHandler { - pub fn new) -> windows_core::Result<()> + Send + 'static>(invoke: F) -> Self { + pub fn new) -> windows_core::Result<()> + Send + 'static>(invoke: F) -> Self { let com = WorkItemHandlerBox { vtable: &WorkItemHandlerBox::::VTABLE, count: windows_core::imp::RefCount::new(1), invoke }; unsafe { core::mem::transmute(windows_core::imp::Box::new(com)) } } pub fn Invoke(&self, operation: P0) -> windows_core::Result<()> where - P0: windows_core::Param, + P0: windows_core::Param, { let this = self; unsafe { (windows_core::Interface::vtable(this).Invoke)(windows_core::Interface::as_raw(this), operation.param().abi()).ok() } @@ -308,12 +308,12 @@ pub struct WorkItemHandler_Vtbl { Invoke: unsafe extern "system" fn(this: *mut core::ffi::c_void, operation: *mut core::ffi::c_void) -> windows_core::HRESULT, } #[repr(C)] -struct WorkItemHandlerBox) -> windows_core::Result<()> + Send + 'static> { +struct WorkItemHandlerBox) -> windows_core::Result<()> + Send + 'static> { vtable: *const WorkItemHandler_Vtbl, invoke: F, count: windows_core::imp::RefCount, } -impl) -> windows_core::Result<()> + Send + 'static> WorkItemHandlerBox { +impl) -> windows_core::Result<()> + Send + 'static> WorkItemHandlerBox { const VTABLE: WorkItemHandler_Vtbl = WorkItemHandler_Vtbl { base__: windows_core::IUnknown_Vtbl { QueryInterface: Self::QueryInterface, AddRef: Self::AddRef, Release: Self::Release }, Invoke: Self::Invoke }; unsafe extern "system" fn QueryInterface(this: *mut core::ffi::c_void, iid: *const windows_core::GUID, interface: *mut *mut core::ffi::c_void) -> windows_core::HRESULT { unsafe { diff --git a/crates/libs/windows/src/Windows/System/Update/mod.rs b/crates/libs/windows/src/Windows/System/Update/mod.rs index ca0b9043f1..fd8238335f 100644 --- a/crates/libs/windows/src/Windows/System/Update/mod.rs +++ b/crates/libs/windows/src/Windows/System/Update/mod.rs @@ -292,13 +292,13 @@ impl SystemUpdateManager { (windows_core::Interface::vtable(this).GetAutomaticRebootBlockIds)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn BlockAutomaticRebootAsync(lockid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn BlockAutomaticRebootAsync(lockid: &windows_core::HSTRING) -> windows_core::Result> { Self::ISystemUpdateManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).BlockAutomaticRebootAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(lockid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn UnblockAutomaticRebootAsync(lockid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn UnblockAutomaticRebootAsync(lockid: &windows_core::HSTRING) -> windows_core::Result> { Self::ISystemUpdateManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).UnblockAutomaticRebootAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(lockid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/System/UserProfile/mod.rs b/crates/libs/windows/src/Windows/System/UserProfile/mod.rs index 553480353e..488a7fe25a 100644 --- a/crates/libs/windows/src/Windows/System/UserProfile/mod.rs +++ b/crates/libs/windows/src/Windows/System/UserProfile/mod.rs @@ -644,7 +644,7 @@ pub struct IUserProfilePersonalizationSettingsStatics_Vtbl { } pub struct LockScreen; impl LockScreen { - pub fn RequestSetImageFeedAsync(syndicationfeeduri: P0) -> windows_core::Result> + pub fn RequestSetImageFeedAsync(syndicationfeeduri: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -673,7 +673,7 @@ impl LockScreen { }) } #[cfg(feature = "Storage_Streams")] - pub fn SetImageFileAsync(value: P0) -> windows_core::Result + pub fn SetImageFileAsync(value: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -683,7 +683,7 @@ impl LockScreen { }) } #[cfg(feature = "Storage_Streams")] - pub fn SetImageStreamAsync(value: P0) -> windows_core::Result + pub fn SetImageStreamAsync(value: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -759,7 +759,7 @@ impl UserInformation { }) } #[cfg(feature = "Storage_Streams")] - pub fn SetAccountPictureAsync(image: P0) -> windows_core::Result> + pub fn SetAccountPictureAsync(image: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -769,7 +769,7 @@ impl UserInformation { }) } #[cfg(feature = "Storage_Streams")] - pub fn SetAccountPicturesAsync(smallimage: P0, largeimage: P1, video: P2) -> windows_core::Result> + pub fn SetAccountPicturesAsync(smallimage: P0, largeimage: P1, video: P2) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -781,7 +781,7 @@ impl UserInformation { }) } #[cfg(feature = "Storage_Streams")] - pub fn SetAccountPictureFromStreamAsync(image: P0) -> windows_core::Result> + pub fn SetAccountPictureFromStreamAsync(image: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -791,7 +791,7 @@ impl UserInformation { }) } #[cfg(feature = "Storage_Streams")] - pub fn SetAccountPicturesFromStreamsAsync(smallimage: P0, largeimage: P1, video: P2) -> windows_core::Result> + pub fn SetAccountPicturesFromStreamsAsync(smallimage: P0, largeimage: P1, video: P2) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -814,37 +814,37 @@ impl UserInformation { pub fn RemoveAccountPictureChanged(token: i64) -> windows_core::Result<()> { Self::IUserInformationStatics(|this| unsafe { (windows_core::Interface::vtable(this).RemoveAccountPictureChanged)(windows_core::Interface::as_raw(this), token).ok() }) } - pub fn GetDisplayNameAsync() -> windows_core::Result> { + pub fn GetDisplayNameAsync() -> windows_core::Result> { Self::IUserInformationStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetDisplayNameAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetFirstNameAsync() -> windows_core::Result> { + pub fn GetFirstNameAsync() -> windows_core::Result> { Self::IUserInformationStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetFirstNameAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetLastNameAsync() -> windows_core::Result> { + pub fn GetLastNameAsync() -> windows_core::Result> { Self::IUserInformationStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetLastNameAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetPrincipalNameAsync() -> windows_core::Result> { + pub fn GetPrincipalNameAsync() -> windows_core::Result> { Self::IUserInformationStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetPrincipalNameAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetSessionInitiationProtocolUriAsync() -> windows_core::Result> { + pub fn GetSessionInitiationProtocolUriAsync() -> windows_core::Result> { Self::IUserInformationStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetSessionInitiationProtocolUriAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn GetDomainNameAsync() -> windows_core::Result> { + pub fn GetDomainNameAsync() -> windows_core::Result> { Self::IUserInformationStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetDomainNameAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -865,7 +865,7 @@ pub struct UserProfilePersonalizationSettings(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(UserProfilePersonalizationSettings, windows_core::IUnknown, windows_core::IInspectable); impl UserProfilePersonalizationSettings { #[cfg(feature = "Storage_Streams")] - pub fn TrySetLockScreenImageAsync(&self, imagefile: P0) -> windows_core::Result> + pub fn TrySetLockScreenImageAsync(&self, imagefile: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -876,7 +876,7 @@ impl UserProfilePersonalizationSettings { } } #[cfg(feature = "Storage_Streams")] - pub fn TrySetWallpaperImageAsync(&self, imagefile: P0) -> windows_core::Result> + pub fn TrySetWallpaperImageAsync(&self, imagefile: P0) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/System/mod.rs b/crates/libs/windows/src/Windows/System/mod.rs index 306051f47b..4e0741aca8 100644 --- a/crates/libs/windows/src/Windows/System/mod.rs +++ b/crates/libs/windows/src/Windows/System/mod.rs @@ -79,14 +79,14 @@ impl AppDiagnosticInfo { (windows_core::Interface::vtable(this).CreateResourceGroupWatcher)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn LaunchAsync(&self) -> windows_core::Result> { + pub fn LaunchAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).LaunchAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestInfoAsync() -> windows_core::Result>> { + pub fn RequestInfoAsync() -> windows_core::Result>> { Self::IAppDiagnosticInfoStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestInfoAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -98,25 +98,25 @@ impl AppDiagnosticInfo { (windows_core::Interface::vtable(this).CreateWatcher)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RequestAccessAsync() -> windows_core::Result> { + pub fn RequestAccessAsync() -> windows_core::Result> { Self::IAppDiagnosticInfoStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestAccessAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RequestInfoForPackageAsync(packagefamilyname: &windows_core::HSTRING) -> windows_core::Result>> { + pub fn RequestInfoForPackageAsync(packagefamilyname: &windows_core::HSTRING) -> windows_core::Result>> { Self::IAppDiagnosticInfoStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestInfoForPackageAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(packagefamilyname), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RequestInfoForAppAsync() -> windows_core::Result>> { + pub fn RequestInfoForAppAsync() -> windows_core::Result>> { Self::IAppDiagnosticInfoStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestInfoForAppAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RequestInfoForAppUserModelId(appusermodelid: &windows_core::HSTRING) -> windows_core::Result>> { + pub fn RequestInfoForAppUserModelId(appusermodelid: &windows_core::HSTRING) -> windows_core::Result>> { Self::IAppDiagnosticInfoStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestInfoForAppUserModelId)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(appusermodelid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -523,21 +523,21 @@ impl AppResourceGroupInfo { (windows_core::Interface::vtable(this).GetStateReport)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StartSuspendAsync(&self) -> windows_core::Result> { + pub fn StartSuspendAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).StartSuspendAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StartResumeAsync(&self) -> windows_core::Result> { + pub fn StartResumeAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).StartResumeAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn StartTerminateAsync(&self) -> windows_core::Result> { + pub fn StartTerminateAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -895,14 +895,14 @@ impl AppUriHandlerRegistration { (windows_core::Interface::vtable(this).User)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAppAddedHostsAsync(&self) -> windows_core::Result>> { + pub fn GetAppAddedHostsAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetAppAddedHostsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SetAppAddedHostsAsync(&self, hosts: P0) -> windows_core::Result + pub fn SetAppAddedHostsAsync(&self, hosts: P0) -> windows_core::Result where P0: windows_core::Param>, { @@ -1167,7 +1167,7 @@ impl DispatcherQueueController { (windows_core::Interface::vtable(this).DispatcherQueue)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ShutdownQueueAsync(&self) -> windows_core::Result { + pub fn ShutdownQueueAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2669,7 +2669,7 @@ impl windows_core::RuntimeType for LaunchUriStatus { pub struct Launcher; impl Launcher { #[cfg(feature = "Storage_Streams")] - pub fn LaunchFileAsync(file: P0) -> windows_core::Result> + pub fn LaunchFileAsync(file: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2679,7 +2679,7 @@ impl Launcher { }) } #[cfg(feature = "Storage_Streams")] - pub fn LaunchFileWithOptionsAsync(file: P0, options: P1) -> windows_core::Result> + pub fn LaunchFileWithOptionsAsync(file: P0, options: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -2689,7 +2689,7 @@ impl Launcher { (windows_core::Interface::vtable(this).LaunchFileWithOptionsAsync)(windows_core::Interface::as_raw(this), file.param().abi(), options.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn LaunchUriAsync(uri: P0) -> windows_core::Result> + pub fn LaunchUriAsync(uri: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2698,7 +2698,7 @@ impl Launcher { (windows_core::Interface::vtable(this).LaunchUriAsync)(windows_core::Interface::as_raw(this), uri.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn LaunchUriWithOptionsAsync(uri: P0, options: P1) -> windows_core::Result> + pub fn LaunchUriWithOptionsAsync(uri: P0, options: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -2708,7 +2708,7 @@ impl Launcher { (windows_core::Interface::vtable(this).LaunchUriWithOptionsAsync)(windows_core::Interface::as_raw(this), uri.param().abi(), options.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn LaunchUriForResultsAsync(uri: P0, options: P1) -> windows_core::Result> + pub fn LaunchUriForResultsAsync(uri: P0, options: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -2719,7 +2719,7 @@ impl Launcher { }) } #[cfg(feature = "Foundation_Collections")] - pub fn LaunchUriForResultsWithDataAsync(uri: P0, options: P1, inputdata: P2) -> windows_core::Result> + pub fn LaunchUriForResultsWithDataAsync(uri: P0, options: P1, inputdata: P2) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -2731,7 +2731,7 @@ impl Launcher { }) } #[cfg(feature = "Foundation_Collections")] - pub fn LaunchUriWithDataAsync(uri: P0, options: P1, inputdata: P2) -> windows_core::Result> + pub fn LaunchUriWithDataAsync(uri: P0, options: P1, inputdata: P2) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -2742,7 +2742,7 @@ impl Launcher { (windows_core::Interface::vtable(this).LaunchUriWithDataAsync)(windows_core::Interface::as_raw(this), uri.param().abi(), options.param().abi(), inputdata.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn QueryUriSupportAsync(uri: P0, launchquerysupporttype: LaunchQuerySupportType) -> windows_core::Result> + pub fn QueryUriSupportAsync(uri: P0, launchquerysupporttype: LaunchQuerySupportType) -> windows_core::Result> where P0: windows_core::Param, { @@ -2751,7 +2751,7 @@ impl Launcher { (windows_core::Interface::vtable(this).QueryUriSupportAsync)(windows_core::Interface::as_raw(this), uri.param().abi(), launchquerysupporttype, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn QueryUriSupportWithPackageFamilyNameAsync(uri: P0, launchquerysupporttype: LaunchQuerySupportType, packagefamilyname: &windows_core::HSTRING) -> windows_core::Result> + pub fn QueryUriSupportWithPackageFamilyNameAsync(uri: P0, launchquerysupporttype: LaunchQuerySupportType, packagefamilyname: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -2761,7 +2761,7 @@ impl Launcher { }) } #[cfg(feature = "Storage_Streams")] - pub fn QueryFileSupportAsync(file: P0) -> windows_core::Result> + pub fn QueryFileSupportAsync(file: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2771,7 +2771,7 @@ impl Launcher { }) } #[cfg(feature = "Storage_Streams")] - pub fn QueryFileSupportWithPackageFamilyNameAsync(file: P0, packagefamilyname: &windows_core::HSTRING) -> windows_core::Result> + pub fn QueryFileSupportWithPackageFamilyNameAsync(file: P0, packagefamilyname: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -2781,28 +2781,28 @@ impl Launcher { }) } #[cfg(feature = "ApplicationModel")] - pub fn FindUriSchemeHandlersAsync(scheme: &windows_core::HSTRING) -> windows_core::Result>> { + pub fn FindUriSchemeHandlersAsync(scheme: &windows_core::HSTRING) -> windows_core::Result>> { Self::ILauncherStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindUriSchemeHandlersAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(scheme), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "ApplicationModel")] - pub fn FindUriSchemeHandlersWithLaunchUriTypeAsync(scheme: &windows_core::HSTRING, launchquerysupporttype: LaunchQuerySupportType) -> windows_core::Result>> { + pub fn FindUriSchemeHandlersWithLaunchUriTypeAsync(scheme: &windows_core::HSTRING, launchquerysupporttype: LaunchQuerySupportType) -> windows_core::Result>> { Self::ILauncherStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindUriSchemeHandlersWithLaunchUriTypeAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(scheme), launchquerysupporttype, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "ApplicationModel")] - pub fn FindFileHandlersAsync(extension: &windows_core::HSTRING) -> windows_core::Result>> { + pub fn FindFileHandlersAsync(extension: &windows_core::HSTRING) -> windows_core::Result>> { Self::ILauncherStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindFileHandlersAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(extension), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "Storage")] - pub fn LaunchFolderAsync(folder: P0) -> windows_core::Result> + pub fn LaunchFolderAsync(folder: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2812,7 +2812,7 @@ impl Launcher { }) } #[cfg(feature = "Storage")] - pub fn LaunchFolderWithOptionsAsync(folder: P0, options: P1) -> windows_core::Result> + pub fn LaunchFolderWithOptionsAsync(folder: P0, options: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -2822,7 +2822,7 @@ impl Launcher { (windows_core::Interface::vtable(this).LaunchFolderWithOptionsAsync)(windows_core::Interface::as_raw(this), folder.param().abi(), options.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn QueryAppUriSupportAsync(uri: P0) -> windows_core::Result> + pub fn QueryAppUriSupportAsync(uri: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2831,7 +2831,7 @@ impl Launcher { (windows_core::Interface::vtable(this).QueryAppUriSupportAsync)(windows_core::Interface::as_raw(this), uri.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn QueryAppUriSupportWithPackageFamilyNameAsync(uri: P0, packagefamilyname: &windows_core::HSTRING) -> windows_core::Result> + pub fn QueryAppUriSupportWithPackageFamilyNameAsync(uri: P0, packagefamilyname: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -2841,7 +2841,7 @@ impl Launcher { }) } #[cfg(feature = "ApplicationModel")] - pub fn FindAppUriHandlersAsync(uri: P0) -> windows_core::Result>> + pub fn FindAppUriHandlersAsync(uri: P0) -> windows_core::Result>> where P0: windows_core::Param, { @@ -2850,7 +2850,7 @@ impl Launcher { (windows_core::Interface::vtable(this).FindAppUriHandlersAsync)(windows_core::Interface::as_raw(this), uri.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn LaunchUriForUserAsync(user: P0, uri: P1) -> windows_core::Result> + pub fn LaunchUriForUserAsync(user: P0, uri: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -2860,7 +2860,7 @@ impl Launcher { (windows_core::Interface::vtable(this).LaunchUriForUserAsync)(windows_core::Interface::as_raw(this), user.param().abi(), uri.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn LaunchUriWithOptionsForUserAsync(user: P0, uri: P1, options: P2) -> windows_core::Result> + pub fn LaunchUriWithOptionsForUserAsync(user: P0, uri: P1, options: P2) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -2872,7 +2872,7 @@ impl Launcher { }) } #[cfg(feature = "Foundation_Collections")] - pub fn LaunchUriWithDataForUserAsync(user: P0, uri: P1, options: P2, inputdata: P3) -> windows_core::Result> + pub fn LaunchUriWithDataForUserAsync(user: P0, uri: P1, options: P2, inputdata: P3) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -2884,7 +2884,7 @@ impl Launcher { (windows_core::Interface::vtable(this).LaunchUriWithDataForUserAsync)(windows_core::Interface::as_raw(this), user.param().abi(), uri.param().abi(), options.param().abi(), inputdata.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn LaunchUriForResultsForUserAsync(user: P0, uri: P1, options: P2) -> windows_core::Result> + pub fn LaunchUriForResultsForUserAsync(user: P0, uri: P1, options: P2) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -2896,7 +2896,7 @@ impl Launcher { }) } #[cfg(feature = "Foundation_Collections")] - pub fn LaunchUriForResultsWithDataForUserAsync(user: P0, uri: P1, options: P2, inputdata: P3) -> windows_core::Result> + pub fn LaunchUriForResultsWithDataForUserAsync(user: P0, uri: P1, options: P2, inputdata: P3) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -2908,13 +2908,13 @@ impl Launcher { (windows_core::Interface::vtable(this).LaunchUriForResultsWithDataForUserAsync)(windows_core::Interface::as_raw(this), user.param().abi(), uri.param().abi(), options.param().abi(), inputdata.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn LaunchFolderPathAsync(path: &windows_core::HSTRING) -> windows_core::Result> { + pub fn LaunchFolderPathAsync(path: &windows_core::HSTRING) -> windows_core::Result> { Self::ILauncherStatics5(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).LaunchFolderPathAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(path), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn LaunchFolderPathWithOptionsAsync(path: &windows_core::HSTRING, options: P1) -> windows_core::Result> + pub fn LaunchFolderPathWithOptionsAsync(path: &windows_core::HSTRING, options: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -2923,7 +2923,7 @@ impl Launcher { (windows_core::Interface::vtable(this).LaunchFolderPathWithOptionsAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(path), options.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn LaunchFolderPathForUserAsync(user: P0, path: &windows_core::HSTRING) -> windows_core::Result> + pub fn LaunchFolderPathForUserAsync(user: P0, path: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -2932,7 +2932,7 @@ impl Launcher { (windows_core::Interface::vtable(this).LaunchFolderPathForUserAsync)(windows_core::Interface::as_raw(this), user.param().abi(), core::mem::transmute_copy(path), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn LaunchFolderPathWithOptionsForUserAsync(user: P0, path: &windows_core::HSTRING, options: P2) -> windows_core::Result> + pub fn LaunchFolderPathWithOptionsForUserAsync(user: P0, path: &windows_core::HSTRING, options: P2) -> windows_core::Result> where P0: windows_core::Param, P2: windows_core::Param, @@ -3304,13 +3304,13 @@ impl windows_core::RuntimeType for PowerState { } pub struct ProcessLauncher; impl ProcessLauncher { - pub fn RunToCompletionAsync(filename: &windows_core::HSTRING, args: &windows_core::HSTRING) -> windows_core::Result> { + pub fn RunToCompletionAsync(filename: &windows_core::HSTRING, args: &windows_core::HSTRING) -> windows_core::Result> { Self::IProcessLauncherStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RunToCompletionAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(filename), core::mem::transmute_copy(args), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RunToCompletionAsyncWithOptions(filename: &windows_core::HSTRING, args: &windows_core::HSTRING, options: P2) -> windows_core::Result> + pub fn RunToCompletionAsyncWithOptions(filename: &windows_core::HSTRING, args: &windows_core::HSTRING, options: P2) -> windows_core::Result> where P2: windows_core::Param, { @@ -3534,7 +3534,7 @@ impl windows_core::RuntimeType for RemoteLaunchUriStatus { pub struct RemoteLauncher; impl RemoteLauncher { #[cfg(feature = "System_RemoteSystems")] - pub fn LaunchUriAsync(remotesystemconnectionrequest: P0, uri: P1) -> windows_core::Result> + pub fn LaunchUriAsync(remotesystemconnectionrequest: P0, uri: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -3545,7 +3545,7 @@ impl RemoteLauncher { }) } #[cfg(feature = "System_RemoteSystems")] - pub fn LaunchUriWithOptionsAsync(remotesystemconnectionrequest: P0, uri: P1, options: P2) -> windows_core::Result> + pub fn LaunchUriWithOptionsAsync(remotesystemconnectionrequest: P0, uri: P1, options: P2) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -3557,7 +3557,7 @@ impl RemoteLauncher { }) } #[cfg(all(feature = "Foundation_Collections", feature = "System_RemoteSystems"))] - pub fn LaunchUriWithDataAsync(remotesystemconnectionrequest: P0, uri: P1, options: P2, inputdata: P3) -> windows_core::Result> + pub fn LaunchUriWithDataAsync(remotesystemconnectionrequest: P0, uri: P1, options: P2, inputdata: P3) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -3691,7 +3691,7 @@ impl TimeZoneSettings { pub fn ChangeTimeZoneByDisplayName(timezonedisplayname: &windows_core::HSTRING) -> windows_core::Result<()> { Self::ITimeZoneSettingsStatics(|this| unsafe { (windows_core::Interface::vtable(this).ChangeTimeZoneByDisplayName)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(timezonedisplayname)).ok() }) } - pub fn AutoUpdateTimeZoneAsync(timeout: super::Foundation::TimeSpan) -> windows_core::Result> { + pub fn AutoUpdateTimeZoneAsync(timeout: super::Foundation::TimeSpan) -> windows_core::Result> { Self::ITimeZoneSettingsStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).AutoUpdateTimeZoneAsync)(windows_core::Interface::as_raw(this), timeout, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -3735,7 +3735,7 @@ impl User { (windows_core::Interface::vtable(this).Type)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn GetPropertyAsync(&self, value: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetPropertyAsync(&self, value: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -3743,7 +3743,7 @@ impl User { } } #[cfg(feature = "Foundation_Collections")] - pub fn GetPropertiesAsync(&self, values: P0) -> windows_core::Result> + pub fn GetPropertiesAsync(&self, values: P0) -> windows_core::Result> where P0: windows_core::Param>, { @@ -3754,14 +3754,14 @@ impl User { } } #[cfg(feature = "Storage_Streams")] - pub fn GetPictureAsync(&self, desiredsize: UserPictureSize) -> windows_core::Result> { + pub fn GetPictureAsync(&self, desiredsize: UserPictureSize) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetPictureAsync)(windows_core::Interface::as_raw(this), desiredsize, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CheckUserAgeConsentGroupAsync(&self, consentgroup: UserAgeConsentGroup) -> windows_core::Result> { + pub fn CheckUserAgeConsentGroupAsync(&self, consentgroup: UserAgeConsentGroup) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -3774,21 +3774,21 @@ impl User { (windows_core::Interface::vtable(this).CreateWatcher)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn FindAllAsync() -> windows_core::Result>> { + pub fn FindAllAsync() -> windows_core::Result>> { Self::IUserStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAllAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "deprecated")] - pub fn FindAllAsyncByType(r#type: UserType) -> windows_core::Result>> { + pub fn FindAllAsyncByType(r#type: UserType) -> windows_core::Result>> { Self::IUserStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAllAsyncByType)(windows_core::Interface::as_raw(this), r#type, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "deprecated")] - pub fn FindAllAsyncByTypeAndStatus(r#type: UserType, status: UserAuthenticationStatus) -> windows_core::Result>> { + pub fn FindAllAsyncByTypeAndStatus(r#type: UserType, status: UserAuthenticationStatus) -> windows_core::Result>> { Self::IUserStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAllAsyncByTypeAndStatus)(windows_core::Interface::as_raw(this), r#type, status, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -4075,7 +4075,7 @@ impl UserPicker { let this = self; unsafe { (windows_core::Interface::vtable(this).SetSuggestedSelectedUser)(windows_core::Interface::as_raw(this), value.param().abi()).ok() } } - pub fn PickSingleUserAsync(&self) -> windows_core::Result> { + pub fn PickSingleUserAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/UI/ApplicationSettings/mod.rs b/crates/libs/windows/src/Windows/UI/ApplicationSettings/mod.rs index a3ab34e95f..f0e03d8eb2 100644 --- a/crates/libs/windows/src/Windows/UI/ApplicationSettings/mod.rs +++ b/crates/libs/windows/src/Windows/UI/ApplicationSettings/mod.rs @@ -26,20 +26,20 @@ impl AccountsSettingsPane { pub fn Show() -> windows_core::Result<()> { Self::IAccountsSettingsPaneStatics(|this| unsafe { (windows_core::Interface::vtable(this).Show)(windows_core::Interface::as_raw(this)).ok() }) } - pub fn ShowManageAccountsAsync() -> windows_core::Result { + pub fn ShowManageAccountsAsync() -> windows_core::Result { Self::IAccountsSettingsPaneStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ShowManageAccountsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn ShowAddAccountAsync() -> windows_core::Result { + pub fn ShowAddAccountAsync() -> windows_core::Result { Self::IAccountsSettingsPaneStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ShowAddAccountAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "System")] - pub fn ShowManageAccountsForUserAsync(user: P0) -> windows_core::Result + pub fn ShowManageAccountsForUserAsync(user: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -49,7 +49,7 @@ impl AccountsSettingsPane { }) } #[cfg(feature = "System")] - pub fn ShowAddAccountForUserAsync(user: P0) -> windows_core::Result + pub fn ShowAddAccountForUserAsync(user: P0) -> windows_core::Result where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/UI/Composition/Core/mod.rs b/crates/libs/windows/src/Windows/UI/Composition/Core/mod.rs index f7ccfefaa0..cc6e57a4dc 100644 --- a/crates/libs/windows/src/Windows/UI/Composition/Core/mod.rs +++ b/crates/libs/windows/src/Windows/UI/Composition/Core/mod.rs @@ -26,7 +26,7 @@ impl CompositorController { let this = self; unsafe { (windows_core::Interface::vtable(this).Commit)(windows_core::Interface::as_raw(this)).ok() } } - pub fn EnsurePreviousCommitCompletedAsync(&self) -> windows_core::Result { + pub fn EnsurePreviousCommitCompletedAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/UI/Composition/mod.rs b/crates/libs/windows/src/Windows/UI/Composition/mod.rs index fa8f5c9878..56ce92edd9 100644 --- a/crates/libs/windows/src/Windows/UI/Composition/mod.rs +++ b/crates/libs/windows/src/Windows/UI/Composition/mod.rs @@ -6093,7 +6093,7 @@ impl CompositionGraphicsDevice { unsafe { (windows_core::Interface::vtable(this).Trim)(windows_core::Interface::as_raw(this)).ok() } } #[cfg(feature = "Graphics_DirectX")] - pub fn CaptureAsync(&self, capturevisual: P0, size: super::super::Graphics::SizeInt32, pixelformat: super::super::Graphics::DirectX::DirectXPixelFormat, alphamode: super::super::Graphics::DirectX::DirectXAlphaMode, sdrboost: f32) -> windows_core::Result> + pub fn CaptureAsync(&self, capturevisual: P0, size: super::super::Graphics::SizeInt32, pixelformat: super::super::Graphics::DirectX::DirectXPixelFormat, alphamode: super::super::Graphics::DirectX::DirectXAlphaMode, sdrboost: f32) -> windows_core::Result> where P0: windows_core::Param, { @@ -12452,7 +12452,7 @@ impl Compositor { (windows_core::Interface::vtable(this).CreateViewBox)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestCommitAsync(&self) -> windows_core::Result { + pub fn RequestCommitAsync(&self) -> windows_core::Result { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/UI/Core/mod.rs b/crates/libs/windows/src/Windows/UI/Core/mod.rs index f3dcb01c3b..01a2fd548e 100644 --- a/crates/libs/windows/src/Windows/UI/Core/mod.rs +++ b/crates/libs/windows/src/Windows/UI/Core/mod.rs @@ -694,7 +694,7 @@ impl CoreDispatcher { let this = self; unsafe { (windows_core::Interface::vtable(this).ProcessEvents)(windows_core::Interface::as_raw(this), options).ok() } } - pub fn RunAsync(&self, priority: CoreDispatcherPriority, agilecallback: P1) -> windows_core::Result + pub fn RunAsync(&self, priority: CoreDispatcherPriority, agilecallback: P1) -> windows_core::Result where P1: windows_core::Param, { @@ -704,7 +704,7 @@ impl CoreDispatcher { (windows_core::Interface::vtable(this).RunAsync)(windows_core::Interface::as_raw(this), priority, agilecallback.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RunIdleAsync(&self, agilecallback: P0) -> windows_core::Result + pub fn RunIdleAsync(&self, agilecallback: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -714,7 +714,7 @@ impl CoreDispatcher { (windows_core::Interface::vtable(this).RunIdleAsync)(windows_core::Interface::as_raw(this), agilecallback.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryRunAsync(&self, priority: CoreDispatcherPriority, agilecallback: P1) -> windows_core::Result> + pub fn TryRunAsync(&self, priority: CoreDispatcherPriority, agilecallback: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -724,7 +724,7 @@ impl CoreDispatcher { (windows_core::Interface::vtable(this).TryRunAsync)(windows_core::Interface::as_raw(this), priority, agilecallback.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryRunIdleAsync(&self, agilecallback: P0) -> windows_core::Result> + pub fn TryRunIdleAsync(&self, agilecallback: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1942,7 +1942,7 @@ impl CoreWindowDialog { unsafe { (windows_core::Interface::vtable(this).SetBackButtonCommand)(windows_core::Interface::as_raw(this), value.param().abi()).ok() } } #[cfg(feature = "UI_Popups")] - pub fn ShowAsync(&self) -> windows_core::Result> { + pub fn ShowAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2101,7 +2101,7 @@ impl CoreWindowFlyout { unsafe { (windows_core::Interface::vtable(this).SetBackButtonCommand)(windows_core::Interface::as_raw(this), value.param().abi()).ok() } } #[cfg(feature = "UI_Popups")] - pub fn ShowAsync(&self) -> windows_core::Result> { + pub fn ShowAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/UI/Input/Inking/Analysis/mod.rs b/crates/libs/windows/src/Windows/UI/Input/Inking/Analysis/mod.rs index 9aeb6c56a5..c6203f7172 100644 --- a/crates/libs/windows/src/Windows/UI/Input/Inking/Analysis/mod.rs +++ b/crates/libs/windows/src/Windows/UI/Input/Inking/Analysis/mod.rs @@ -1198,7 +1198,7 @@ impl InkAnalyzer { let this = self; unsafe { (windows_core::Interface::vtable(this).SetStrokeDataKind)(windows_core::Interface::as_raw(this), strokeid, strokekind).ok() } } - pub fn AnalyzeAsync(&self) -> windows_core::Result> { + pub fn AnalyzeAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/UI/Input/Inking/mod.rs b/crates/libs/windows/src/Windows/UI/Input/Inking/mod.rs index 068199930e..ee108987b1 100644 --- a/crates/libs/windows/src/Windows/UI/Input/Inking/mod.rs +++ b/crates/libs/windows/src/Windows/UI/Input/Inking/mod.rs @@ -618,7 +618,7 @@ impl IInkRecognizerContainer { let this = self; unsafe { (windows_core::Interface::vtable(this).SetDefaultRecognizer)(windows_core::Interface::as_raw(this), recognizer.param().abi()).ok() } } - pub fn RecognizeAsync(&self, strokecollection: P0, recognitiontarget: InkRecognitionTarget) -> windows_core::Result>> + pub fn RecognizeAsync(&self, strokecollection: P0, recognitiontarget: InkRecognitionTarget) -> windows_core::Result>> where P0: windows_core::Param, { @@ -641,7 +641,7 @@ impl windows_core::RuntimeName for IInkRecognizerContainer { } pub trait IInkRecognizerContainer_Impl: windows_core::IUnknownImpl { fn SetDefaultRecognizer(&self, recognizer: windows_core::Ref<'_, InkRecognizer>) -> windows_core::Result<()>; - fn RecognizeAsync(&self, strokeCollection: windows_core::Ref<'_, InkStrokeContainer>, recognitionTarget: InkRecognitionTarget) -> windows_core::Result>>; + fn RecognizeAsync(&self, strokeCollection: windows_core::Ref<'_, InkStrokeContainer>, recognitionTarget: InkRecognitionTarget) -> windows_core::Result>>; fn GetRecognizers(&self) -> windows_core::Result>; } impl IInkRecognizerContainer_Vtbl { @@ -846,7 +846,7 @@ impl IInkStrokeContainer { } } #[cfg(feature = "Storage_Streams")] - pub fn LoadAsync(&self, inputstream: P0) -> windows_core::Result> + pub fn LoadAsync(&self, inputstream: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -857,7 +857,7 @@ impl IInkStrokeContainer { } } #[cfg(feature = "Storage_Streams")] - pub fn SaveAsync(&self, outputstream: P0) -> windows_core::Result> + pub fn SaveAsync(&self, outputstream: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -904,8 +904,8 @@ pub trait IInkStrokeContainer_Impl: windows_core::IUnknownImpl { fn CopySelectedToClipboard(&self) -> windows_core::Result<()>; fn PasteFromClipboard(&self, position: &super::super::super::Foundation::Point) -> windows_core::Result; fn CanPasteFromClipboard(&self) -> windows_core::Result; - fn LoadAsync(&self, inputStream: windows_core::Ref<'_, super::super::super::Storage::Streams::IInputStream>) -> windows_core::Result>; - fn SaveAsync(&self, outputStream: windows_core::Ref<'_, super::super::super::Storage::Streams::IOutputStream>) -> windows_core::Result>; + fn LoadAsync(&self, inputStream: windows_core::Ref<'_, super::super::super::Storage::Streams::IInputStream>) -> windows_core::Result>; + fn SaveAsync(&self, outputStream: windows_core::Ref<'_, super::super::super::Storage::Streams::IOutputStream>) -> windows_core::Result>; fn UpdateRecognitionResults(&self, recognitionResults: windows_core::Ref<'_, windows_collections::IVectorView>) -> windows_core::Result<()>; fn GetStrokes(&self) -> windows_core::Result>; fn GetRecognitionResults(&self) -> windows_core::Result>; @@ -1660,7 +1660,7 @@ impl InkManager { let this = self; unsafe { (windows_core::Interface::vtable(this).SetDefaultDrawingAttributes)(windows_core::Interface::as_raw(this), drawingattributes.param().abi()).ok() } } - pub fn RecognizeAsync(&self, recognitiontarget: InkRecognitionTarget) -> windows_core::Result>> { + pub fn RecognizeAsync(&self, recognitiontarget: InkRecognitionTarget) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1674,7 +1674,7 @@ impl InkManager { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).SetDefaultRecognizer)(windows_core::Interface::as_raw(this), recognizer.param().abi()).ok() } } - pub fn RecognizeAsync2(&self, strokecollection: P0, recognitiontarget: InkRecognitionTarget) -> windows_core::Result>> + pub fn RecognizeAsync2(&self, strokecollection: P0, recognitiontarget: InkRecognitionTarget) -> windows_core::Result>> where P0: windows_core::Param, { @@ -1755,7 +1755,7 @@ impl InkManager { } } #[cfg(feature = "Storage_Streams")] - pub fn LoadAsync(&self, inputstream: P0) -> windows_core::Result> + pub fn LoadAsync(&self, inputstream: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1766,7 +1766,7 @@ impl InkManager { } } #[cfg(feature = "Storage_Streams")] - pub fn SaveAsync(&self, outputstream: P0) -> windows_core::Result> + pub fn SaveAsync(&self, outputstream: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2517,7 +2517,7 @@ impl InkRecognizerContainer { let this = self; unsafe { (windows_core::Interface::vtable(this).SetDefaultRecognizer)(windows_core::Interface::as_raw(this), recognizer.param().abi()).ok() } } - pub fn RecognizeAsync(&self, strokecollection: P0, recognitiontarget: InkRecognitionTarget) -> windows_core::Result>> + pub fn RecognizeAsync(&self, strokecollection: P0, recognitiontarget: InkRecognitionTarget) -> windows_core::Result>> where P0: windows_core::Param, { @@ -2841,7 +2841,7 @@ impl InkStrokeContainer { } } #[cfg(feature = "Storage_Streams")] - pub fn LoadAsync(&self, inputstream: P0) -> windows_core::Result> + pub fn LoadAsync(&self, inputstream: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2852,7 +2852,7 @@ impl InkStrokeContainer { } } #[cfg(feature = "Storage_Streams")] - pub fn SaveAsync(&self, outputstream: P0) -> windows_core::Result> + pub fn SaveAsync(&self, outputstream: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2895,7 +2895,7 @@ impl InkStrokeContainer { unsafe { (windows_core::Interface::vtable(this).Clear)(windows_core::Interface::as_raw(this)).ok() } } #[cfg(feature = "Storage_Streams")] - pub fn SaveWithFormatAsync(&self, outputstream: P0, inkpersistenceformat: InkPersistenceFormat) -> windows_core::Result> + pub fn SaveWithFormatAsync(&self, outputstream: P0, inkpersistenceformat: InkPersistenceFormat) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/UI/Input/Spatial/mod.rs b/crates/libs/windows/src/Windows/UI/Input/Spatial/mod.rs index 7376a91d19..f67ec8f94d 100644 --- a/crates/libs/windows/src/Windows/UI/Input/Spatial/mod.rs +++ b/crates/libs/windows/src/Windows/UI/Input/Spatial/mod.rs @@ -1048,7 +1048,7 @@ impl SpatialInteractionController { } } #[cfg(feature = "Storage_Streams")] - pub fn TryGetRenderableModelAsync(&self) -> windows_core::Result> { + pub fn TryGetRenderableModelAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -1417,7 +1417,7 @@ impl SpatialInteractionSource { } } #[cfg(feature = "Perception_People")] - pub fn TryCreateHandMeshObserverAsync(&self) -> windows_core::Result> { + pub fn TryCreateHandMeshObserverAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/UI/Notifications/Management/mod.rs b/crates/libs/windows/src/Windows/UI/Notifications/Management/mod.rs index fd3f242b63..9168ecd199 100644 --- a/crates/libs/windows/src/Windows/UI/Notifications/Management/mod.rs +++ b/crates/libs/windows/src/Windows/UI/Notifications/Management/mod.rs @@ -28,7 +28,7 @@ pub struct IUserNotificationListenerStatics_Vtbl { pub struct UserNotificationListener(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(UserNotificationListener, windows_core::IUnknown, windows_core::IInspectable); impl UserNotificationListener { - pub fn RequestAccessAsync(&self) -> windows_core::Result> { + pub fn RequestAccessAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -56,7 +56,7 @@ impl UserNotificationListener { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveNotificationChanged)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn GetNotificationsAsync(&self, kinds: super::NotificationKinds) -> windows_core::Result>> { + pub fn GetNotificationsAsync(&self, kinds: super::NotificationKinds) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/UI/Notifications/mod.rs b/crates/libs/windows/src/Windows/UI/Notifications/mod.rs index 0adfc6473c..2900e03c85 100644 --- a/crates/libs/windows/src/Windows/UI/Notifications/mod.rs +++ b/crates/libs/windows/src/Windows/UI/Notifications/mod.rs @@ -2669,7 +2669,7 @@ unsafe impl Sync for ToastCollection {} pub struct ToastCollectionManager(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(ToastCollectionManager, windows_core::IUnknown, windows_core::IInspectable); impl ToastCollectionManager { - pub fn SaveToastCollectionAsync(&self, collection: P0) -> windows_core::Result + pub fn SaveToastCollectionAsync(&self, collection: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -2679,28 +2679,28 @@ impl ToastCollectionManager { (windows_core::Interface::vtable(this).SaveToastCollectionAsync)(windows_core::Interface::as_raw(this), collection.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn FindAllToastCollectionsAsync(&self) -> windows_core::Result>> { + pub fn FindAllToastCollectionsAsync(&self) -> windows_core::Result>> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAllToastCollectionsAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetToastCollectionAsync(&self, collectionid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetToastCollectionAsync(&self, collectionid: &windows_core::HSTRING) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetToastCollectionAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(collectionid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RemoveToastCollectionAsync(&self, collectionid: &windows_core::HSTRING) -> windows_core::Result { + pub fn RemoveToastCollectionAsync(&self, collectionid: &windows_core::HSTRING) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RemoveToastCollectionAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(collectionid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RemoveAllToastCollectionsAsync(&self) -> windows_core::Result { + pub fn RemoveAllToastCollectionsAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -3220,14 +3220,14 @@ impl ToastNotificationManagerForUser { (windows_core::Interface::vtable(this).User)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetToastNotifierForToastCollectionIdAsync(&self, collectionid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetToastNotifierForToastCollectionIdAsync(&self, collectionid: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).GetToastNotifierForToastCollectionIdAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(collectionid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetHistoryForToastCollectionIdAsync(&self, collectionid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn GetHistoryForToastCollectionIdAsync(&self, collectionid: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/UI/Popups/mod.rs b/crates/libs/windows/src/Windows/UI/Popups/mod.rs index 6fd10e3ea2..a36d3ea058 100644 --- a/crates/libs/windows/src/Windows/UI/Popups/mod.rs +++ b/crates/libs/windows/src/Windows/UI/Popups/mod.rs @@ -247,7 +247,7 @@ impl MessageDialog { let this = self; unsafe { (windows_core::Interface::vtable(this).SetContent)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(value)).ok() } } - pub fn ShowAsync(&self) -> windows_core::Result> { + pub fn ShowAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -373,21 +373,21 @@ impl PopupMenu { (windows_core::Interface::vtable(this).Commands)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ShowAsync(&self, invocationpoint: super::super::Foundation::Point) -> windows_core::Result> { + pub fn ShowAsync(&self, invocationpoint: super::super::Foundation::Point) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ShowAsync)(windows_core::Interface::as_raw(this), invocationpoint, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ShowAsyncWithRect(&self, selection: super::super::Foundation::Rect) -> windows_core::Result> { + pub fn ShowAsyncWithRect(&self, selection: super::super::Foundation::Rect) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ShowAsyncWithRect)(windows_core::Interface::as_raw(this), selection, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ShowAsyncWithRectAndPlacement(&self, selection: super::super::Foundation::Rect, preferredplacement: Placement) -> windows_core::Result> { + pub fn ShowAsyncWithRectAndPlacement(&self, selection: super::super::Foundation::Rect, preferredplacement: Placement) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/UI/Shell/mod.rs b/crates/libs/windows/src/Windows/UI/Shell/mod.rs index 6bc303d87e..3f216524b5 100644 --- a/crates/libs/windows/src/Windows/UI/Shell/mod.rs +++ b/crates/libs/windows/src/Windows/UI/Shell/mod.rs @@ -717,7 +717,7 @@ impl TaskbarManager { (windows_core::Interface::vtable(this).IsPinningAllowed)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn IsCurrentAppPinnedAsync(&self) -> windows_core::Result> { + pub fn IsCurrentAppPinnedAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -725,7 +725,7 @@ impl TaskbarManager { } } #[cfg(feature = "ApplicationModel_Core")] - pub fn IsAppListEntryPinnedAsync(&self, applistentry: P0) -> windows_core::Result> + pub fn IsAppListEntryPinnedAsync(&self, applistentry: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -735,7 +735,7 @@ impl TaskbarManager { (windows_core::Interface::vtable(this).IsAppListEntryPinnedAsync)(windows_core::Interface::as_raw(this), applistentry.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestPinCurrentAppAsync(&self) -> windows_core::Result> { + pub fn RequestPinCurrentAppAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -743,7 +743,7 @@ impl TaskbarManager { } } #[cfg(feature = "ApplicationModel_Core")] - pub fn RequestPinAppListEntryAsync(&self, applistentry: P0) -> windows_core::Result> + pub fn RequestPinAppListEntryAsync(&self, applistentry: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -753,7 +753,7 @@ impl TaskbarManager { (windows_core::Interface::vtable(this).RequestPinAppListEntryAsync)(windows_core::Interface::as_raw(this), applistentry.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn IsSecondaryTilePinnedAsync(&self, tileid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn IsSecondaryTilePinnedAsync(&self, tileid: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -761,7 +761,7 @@ impl TaskbarManager { } } #[cfg(feature = "UI_StartScreen")] - pub fn RequestPinSecondaryTileAsync(&self, secondarytile: P0) -> windows_core::Result> + pub fn RequestPinSecondaryTileAsync(&self, secondarytile: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -771,7 +771,7 @@ impl TaskbarManager { (windows_core::Interface::vtable(this).RequestPinSecondaryTileAsync)(windows_core::Interface::as_raw(this), secondarytile.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryUnpinSecondaryTileAsync(&self, tileid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn TryUnpinSecondaryTileAsync(&self, tileid: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/UI/StartScreen/mod.rs b/crates/libs/windows/src/Windows/UI/StartScreen/mod.rs index 7d43a5cbf4..db39257eda 100644 --- a/crates/libs/windows/src/Windows/UI/StartScreen/mod.rs +++ b/crates/libs/windows/src/Windows/UI/StartScreen/mod.rs @@ -401,14 +401,14 @@ impl JumpList { let this = self; unsafe { (windows_core::Interface::vtable(this).SetSystemGroupKind)(windows_core::Interface::as_raw(this), value).ok() } } - pub fn SaveAsync(&self) -> windows_core::Result { + pub fn SaveAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).SaveAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn LoadCurrentAsync() -> windows_core::Result> { + pub fn LoadCurrentAsync() -> windows_core::Result> { Self::IJumpListStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).LoadCurrentAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -736,21 +736,21 @@ impl SecondaryTile { (windows_core::Interface::vtable(this).BackgroundColor)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn RequestCreateAsync(&self) -> windows_core::Result> { + pub fn RequestCreateAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestCreateAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestCreateAsyncWithPoint(&self, invocationpoint: super::super::Foundation::Point) -> windows_core::Result> { + pub fn RequestCreateAsyncWithPoint(&self, invocationpoint: super::super::Foundation::Point) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestCreateAsyncWithPoint)(windows_core::Interface::as_raw(this), invocationpoint, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestCreateAsyncWithRect(&self, selection: super::super::Foundation::Rect) -> windows_core::Result> { + pub fn RequestCreateAsyncWithRect(&self, selection: super::super::Foundation::Rect) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -758,28 +758,28 @@ impl SecondaryTile { } } #[cfg(feature = "UI_Popups")] - pub fn RequestCreateAsyncWithRectAndPlacement(&self, selection: super::super::Foundation::Rect, preferredplacement: super::Popups::Placement) -> windows_core::Result> { + pub fn RequestCreateAsyncWithRectAndPlacement(&self, selection: super::super::Foundation::Rect, preferredplacement: super::Popups::Placement) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestCreateAsyncWithRectAndPlacement)(windows_core::Interface::as_raw(this), selection, preferredplacement, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestDeleteAsync(&self) -> windows_core::Result> { + pub fn RequestDeleteAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestDeleteAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestDeleteAsyncWithPoint(&self, invocationpoint: super::super::Foundation::Point) -> windows_core::Result> { + pub fn RequestDeleteAsyncWithPoint(&self, invocationpoint: super::super::Foundation::Point) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestDeleteAsyncWithPoint)(windows_core::Interface::as_raw(this), invocationpoint, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RequestDeleteAsyncWithRect(&self, selection: super::super::Foundation::Rect) -> windows_core::Result> { + pub fn RequestDeleteAsyncWithRect(&self, selection: super::super::Foundation::Rect) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -787,14 +787,14 @@ impl SecondaryTile { } } #[cfg(feature = "UI_Popups")] - pub fn RequestDeleteAsyncWithRectAndPlacement(&self, selection: super::super::Foundation::Rect, preferredplacement: super::Popups::Placement) -> windows_core::Result> { + pub fn RequestDeleteAsyncWithRectAndPlacement(&self, selection: super::super::Foundation::Rect, preferredplacement: super::Popups::Placement) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestDeleteAsyncWithRectAndPlacement)(windows_core::Interface::as_raw(this), selection, preferredplacement, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn UpdateAsync(&self) -> windows_core::Result> { + pub fn UpdateAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -886,19 +886,19 @@ impl SecondaryTile { (windows_core::Interface::vtable(this).Exists)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(tileid), &mut result__).map(|| result__) }) } - pub fn FindAllAsync() -> windows_core::Result>> { + pub fn FindAllAsync() -> windows_core::Result>> { Self::ISecondaryTileStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAllAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn FindAllForApplicationAsync(applicationid: &windows_core::HSTRING) -> windows_core::Result>> { + pub fn FindAllForApplicationAsync(applicationid: &windows_core::HSTRING) -> windows_core::Result>> { Self::ISecondaryTileStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAllForApplicationAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(applicationid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn FindAllForPackageAsync() -> windows_core::Result>> { + pub fn FindAllForPackageAsync() -> windows_core::Result>> { Self::ISecondaryTileStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).FindAllForPackageAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -1136,7 +1136,7 @@ impl StartScreenManager { } } #[cfg(feature = "ApplicationModel_Core")] - pub fn ContainsAppListEntryAsync(&self, applistentry: P0) -> windows_core::Result> + pub fn ContainsAppListEntryAsync(&self, applistentry: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1147,7 +1147,7 @@ impl StartScreenManager { } } #[cfg(feature = "ApplicationModel_Core")] - pub fn RequestAddAppListEntryAsync(&self, applistentry: P0) -> windows_core::Result> + pub fn RequestAddAppListEntryAsync(&self, applistentry: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1157,14 +1157,14 @@ impl StartScreenManager { (windows_core::Interface::vtable(this).RequestAddAppListEntryAsync)(windows_core::Interface::as_raw(this), applistentry.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ContainsSecondaryTileAsync(&self, tileid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn ContainsSecondaryTileAsync(&self, tileid: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ContainsSecondaryTileAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(tileid), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryRemoveSecondaryTileAsync(&self, tileid: &windows_core::HSTRING) -> windows_core::Result> { + pub fn TryRemoveSecondaryTileAsync(&self, tileid: &windows_core::HSTRING) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/UI/UIAutomation/Core/mod.rs b/crates/libs/windows/src/Windows/UI/UIAutomation/Core/mod.rs index 39be8e4ce3..397746baf2 100644 --- a/crates/libs/windows/src/Windows/UI/UIAutomation/Core/mod.rs +++ b/crates/libs/windows/src/Windows/UI/UIAutomation/Core/mod.rs @@ -454,7 +454,7 @@ impl RemoteAutomationClientSession { let this = self; unsafe { (windows_core::Interface::vtable(this).Stop)(windows_core::Interface::as_raw(this)).ok() } } - pub fn CreateWindowAsync(&self, remotewindowid: u64, remoteprocessid: u32, parentautomationelement: P2) -> windows_core::Result> + pub fn CreateWindowAsync(&self, remotewindowid: u64, remoteprocessid: u32, parentautomationelement: P2) -> windows_core::Result> where P2: windows_core::Param, { @@ -610,7 +610,7 @@ impl RemoteAutomationWindow { (windows_core::Interface::vtable(this).AutomationProvider)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn UnregisterAsync(&self) -> windows_core::Result { + pub fn UnregisterAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/UI/ViewManagement/Core/mod.rs b/crates/libs/windows/src/Windows/UI/ViewManagement/Core/mod.rs index 4b1672ac03..2fc706da81 100644 --- a/crates/libs/windows/src/Windows/UI/ViewManagement/Core/mod.rs +++ b/crates/libs/windows/src/Windows/UI/ViewManagement/Core/mod.rs @@ -826,7 +826,7 @@ impl UISettingsController { let this = self; unsafe { (windows_core::Interface::vtable(this).SetTextScaleFactor)(windows_core::Interface::as_raw(this), value).ok() } } - pub fn RequestDefaultAsync() -> windows_core::Result> { + pub fn RequestDefaultAsync() -> windows_core::Result> { Self::IUISettingsControllerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestDefaultAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/UI/ViewManagement/mod.rs b/crates/libs/windows/src/Windows/UI/ViewManagement/mod.rs index c2ef353ec4..8cb4a15666 100644 --- a/crates/libs/windows/src/Windows/UI/ViewManagement/mod.rs +++ b/crates/libs/windows/src/Windows/UI/ViewManagement/mod.rs @@ -58,14 +58,14 @@ unsafe impl Sync for AccessibilitySettings {} pub struct ActivationViewSwitcher(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(ActivationViewSwitcher, windows_core::IUnknown, windows_core::IInspectable); impl ActivationViewSwitcher { - pub fn ShowAsStandaloneAsync(&self, viewid: i32) -> windows_core::Result { + pub fn ShowAsStandaloneAsync(&self, viewid: i32) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ShowAsStandaloneAsync)(windows_core::Interface::as_raw(this), viewid, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ShowAsStandaloneWithSizePreferenceAsync(&self, viewid: i32, sizepreference: ViewSizePreference) -> windows_core::Result { + pub fn ShowAsStandaloneWithSizePreferenceAsync(&self, viewid: i32, sizepreference: ViewSizePreference) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -289,14 +289,14 @@ impl ApplicationView { (windows_core::Interface::vtable(this).IsViewModeSupported)(windows_core::Interface::as_raw(this), viewmode, &mut result__).map(|| result__) } } - pub fn TryEnterViewModeAsync(&self, viewmode: ApplicationViewMode) -> windows_core::Result> { + pub fn TryEnterViewModeAsync(&self, viewmode: ApplicationViewMode) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryEnterViewModeAsync)(windows_core::Interface::as_raw(this), viewmode, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryEnterViewModeWithPreferencesAsync(&self, viewmode: ApplicationViewMode, viewmodepreferences: P1) -> windows_core::Result> + pub fn TryEnterViewModeWithPreferencesAsync(&self, viewmode: ApplicationViewMode, viewmodepreferences: P1) -> windows_core::Result> where P1: windows_core::Param, { @@ -306,7 +306,7 @@ impl ApplicationView { (windows_core::Interface::vtable(this).TryEnterViewModeWithPreferencesAsync)(windows_core::Interface::as_raw(this), viewmode, viewmodepreferences.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryConsolidateAsync(&self) -> windows_core::Result> { + pub fn TryConsolidateAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); @@ -579,43 +579,43 @@ impl ApplicationViewSwitcher { pub fn DisableShowingMainViewOnActivation() -> windows_core::Result<()> { Self::IApplicationViewSwitcherStatics(|this| unsafe { (windows_core::Interface::vtable(this).DisableShowingMainViewOnActivation)(windows_core::Interface::as_raw(this)).ok() }) } - pub fn TryShowAsStandaloneAsync(viewid: i32) -> windows_core::Result> { + pub fn TryShowAsStandaloneAsync(viewid: i32) -> windows_core::Result> { Self::IApplicationViewSwitcherStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryShowAsStandaloneAsync)(windows_core::Interface::as_raw(this), viewid, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn TryShowAsStandaloneWithSizePreferenceAsync(viewid: i32, sizepreference: ViewSizePreference) -> windows_core::Result> { + pub fn TryShowAsStandaloneWithSizePreferenceAsync(viewid: i32, sizepreference: ViewSizePreference) -> windows_core::Result> { Self::IApplicationViewSwitcherStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryShowAsStandaloneWithSizePreferenceAsync)(windows_core::Interface::as_raw(this), viewid, sizepreference, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn TryShowAsStandaloneWithAnchorViewAndSizePreferenceAsync(viewid: i32, sizepreference: ViewSizePreference, anchorviewid: i32, anchorsizepreference: ViewSizePreference) -> windows_core::Result> { + pub fn TryShowAsStandaloneWithAnchorViewAndSizePreferenceAsync(viewid: i32, sizepreference: ViewSizePreference, anchorviewid: i32, anchorsizepreference: ViewSizePreference) -> windows_core::Result> { Self::IApplicationViewSwitcherStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryShowAsStandaloneWithAnchorViewAndSizePreferenceAsync)(windows_core::Interface::as_raw(this), viewid, sizepreference, anchorviewid, anchorsizepreference, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn SwitchAsync(viewid: i32) -> windows_core::Result { + pub fn SwitchAsync(viewid: i32) -> windows_core::Result { Self::IApplicationViewSwitcherStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).SwitchAsync)(windows_core::Interface::as_raw(this), viewid, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn SwitchFromViewAsync(toviewid: i32, fromviewid: i32) -> windows_core::Result { + pub fn SwitchFromViewAsync(toviewid: i32, fromviewid: i32) -> windows_core::Result { Self::IApplicationViewSwitcherStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).SwitchFromViewAsync)(windows_core::Interface::as_raw(this), toviewid, fromviewid, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn SwitchFromViewWithOptionsAsync(toviewid: i32, fromviewid: i32, options: ApplicationViewSwitchingOptions) -> windows_core::Result { + pub fn SwitchFromViewWithOptionsAsync(toviewid: i32, fromviewid: i32, options: ApplicationViewSwitchingOptions) -> windows_core::Result { Self::IApplicationViewSwitcherStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).SwitchFromViewWithOptionsAsync)(windows_core::Interface::as_raw(this), toviewid, fromviewid, options, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn PrepareForCustomAnimatedSwitchAsync(toviewid: i32, fromviewid: i32, options: ApplicationViewSwitchingOptions) -> windows_core::Result> { + pub fn PrepareForCustomAnimatedSwitchAsync(toviewid: i32, fromviewid: i32, options: ApplicationViewSwitchingOptions) -> windows_core::Result> { Self::IApplicationViewSwitcherStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).PrepareForCustomAnimatedSwitchAsync)(windows_core::Interface::as_raw(this), toviewid, fromviewid, options, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -624,13 +624,13 @@ impl ApplicationViewSwitcher { pub fn DisableSystemViewActivationPolicy() -> windows_core::Result<()> { Self::IApplicationViewSwitcherStatics2(|this| unsafe { (windows_core::Interface::vtable(this).DisableSystemViewActivationPolicy)(windows_core::Interface::as_raw(this)).ok() }) } - pub fn TryShowAsViewModeAsync(viewid: i32, viewmode: ApplicationViewMode) -> windows_core::Result> { + pub fn TryShowAsViewModeAsync(viewid: i32, viewmode: ApplicationViewMode) -> windows_core::Result> { Self::IApplicationViewSwitcherStatics3(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryShowAsViewModeAsync)(windows_core::Interface::as_raw(this), viewid, viewmode, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn TryShowAsViewModeWithPreferencesAsync(viewid: i32, viewmode: ApplicationViewMode, viewmodepreferences: P2) -> windows_core::Result> + pub fn TryShowAsViewModeWithPreferencesAsync(viewid: i32, viewmode: ApplicationViewMode, viewmodepreferences: P2) -> windows_core::Result> where P2: windows_core::Param, { @@ -1712,19 +1712,19 @@ impl windows_core::RuntimeName for InputPaneVisibilityEventArgs { } pub struct ProjectionManager; impl ProjectionManager { - pub fn StartProjectingAsync(projectionviewid: i32, anchorviewid: i32) -> windows_core::Result { + pub fn StartProjectingAsync(projectionviewid: i32, anchorviewid: i32) -> windows_core::Result { Self::IProjectionManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).StartProjectingAsync)(windows_core::Interface::as_raw(this), projectionviewid, anchorviewid, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn SwapDisplaysForViewsAsync(projectionviewid: i32, anchorviewid: i32) -> windows_core::Result { + pub fn SwapDisplaysForViewsAsync(projectionviewid: i32, anchorviewid: i32) -> windows_core::Result { Self::IProjectionManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).SwapDisplaysForViewsAsync)(windows_core::Interface::as_raw(this), projectionviewid, anchorviewid, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn StopProjectingAsync(projectionviewid: i32, anchorviewid: i32) -> windows_core::Result { + pub fn StopProjectingAsync(projectionviewid: i32, anchorviewid: i32) -> windows_core::Result { Self::IProjectionManagerStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).StopProjectingAsync)(windows_core::Interface::as_raw(this), projectionviewid, anchorviewid, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -1749,7 +1749,7 @@ impl ProjectionManager { Self::IProjectionManagerStatics(|this| unsafe { (windows_core::Interface::vtable(this).RemoveProjectionDisplayAvailableChanged)(windows_core::Interface::as_raw(this), token).ok() }) } #[cfg(feature = "Devices_Enumeration")] - pub fn StartProjectingWithDeviceInfoAsync(projectionviewid: i32, anchorviewid: i32, displaydeviceinfo: P2) -> windows_core::Result + pub fn StartProjectingWithDeviceInfoAsync(projectionviewid: i32, anchorviewid: i32, displaydeviceinfo: P2) -> windows_core::Result where P2: windows_core::Param, { @@ -1758,14 +1758,14 @@ impl ProjectionManager { (windows_core::Interface::vtable(this).StartProjectingWithDeviceInfoAsync)(windows_core::Interface::as_raw(this), projectionviewid, anchorviewid, displaydeviceinfo.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn RequestStartProjectingAsync(projectionviewid: i32, anchorviewid: i32, selection: super::super::Foundation::Rect) -> windows_core::Result> { + pub fn RequestStartProjectingAsync(projectionviewid: i32, anchorviewid: i32, selection: super::super::Foundation::Rect) -> windows_core::Result> { Self::IProjectionManagerStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestStartProjectingAsync)(windows_core::Interface::as_raw(this), projectionviewid, anchorviewid, selection, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(feature = "UI_Popups")] - pub fn RequestStartProjectingWithPlacementAsync(projectionviewid: i32, anchorviewid: i32, selection: super::super::Foundation::Rect, prefferedplacement: super::Popups::Placement) -> windows_core::Result> { + pub fn RequestStartProjectingWithPlacementAsync(projectionviewid: i32, anchorviewid: i32, selection: super::super::Foundation::Rect, prefferedplacement: super::Popups::Placement) -> windows_core::Result> { Self::IProjectionManagerStatics2(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestStartProjectingWithPlacementAsync)(windows_core::Interface::as_raw(this), projectionviewid, anchorviewid, selection, prefferedplacement, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) @@ -1807,14 +1807,14 @@ impl windows_core::RuntimeType for ScreenCaptureDisabledBehavior { pub struct StatusBar(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(StatusBar, windows_core::IUnknown, windows_core::IInspectable); impl StatusBar { - pub fn ShowAsync(&self) -> windows_core::Result { + pub fn ShowAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ShowAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn HideAsync(&self) -> windows_core::Result { + pub fn HideAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1930,14 +1930,14 @@ unsafe impl Sync for StatusBar {} pub struct StatusBarProgressIndicator(windows_core::IUnknown); windows_core::imp::interface_hierarchy!(StatusBarProgressIndicator, windows_core::IUnknown, windows_core::IInspectable); impl StatusBarProgressIndicator { - pub fn ShowAsync(&self) -> windows_core::Result { + pub fn ShowAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ShowAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn HideAsync(&self) -> windows_core::Result { + pub fn HideAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/UI/WebUI/mod.rs b/crates/libs/windows/src/Windows/UI/WebUI/mod.rs index f11128e6cc..a31a2a0e6e 100644 --- a/crates/libs/windows/src/Windows/UI/WebUI/mod.rs +++ b/crates/libs/windows/src/Windows/UI/WebUI/mod.rs @@ -1383,14 +1383,14 @@ impl WebUIApplication { Self::IWebUIActivationStatics2(|this| unsafe { (windows_core::Interface::vtable(this).EnablePrelaunch)(windows_core::Interface::as_raw(this), value).ok() }) } #[cfg(feature = "ApplicationModel_Core")] - pub fn RequestRestartAsync(launcharguments: &windows_core::HSTRING) -> windows_core::Result> { + pub fn RequestRestartAsync(launcharguments: &windows_core::HSTRING) -> windows_core::Result> { Self::IWebUIActivationStatics3(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).RequestRestartAsync)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(launcharguments), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } #[cfg(all(feature = "ApplicationModel_Core", feature = "System"))] - pub fn RequestRestartForUserAsync(user: P0, launcharguments: &windows_core::HSTRING) -> windows_core::Result> + pub fn RequestRestartForUserAsync(user: P0, launcharguments: &windows_core::HSTRING) -> windows_core::Result> where P0: windows_core::Param, { @@ -4752,13 +4752,13 @@ impl WebUIView { let this = self; unsafe { (windows_core::Interface::vtable(this).SetIgnoreApplicationContentUriRulesNavigationRestrictions)(windows_core::Interface::as_raw(this), value).ok() } } - pub fn CreateAsync() -> windows_core::Result> { + pub fn CreateAsync() -> windows_core::Result> { Self::IWebUIViewStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).CreateAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn CreateWithUriAsync(uri: P0) -> windows_core::Result> + pub fn CreateWithUriAsync(uri: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -4878,7 +4878,7 @@ impl WebUIView { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).NavigateWithHttpRequestMessage)(windows_core::Interface::as_raw(this), requestmessage.param().abi()).ok() } } - pub fn InvokeScriptAsync(&self, scriptname: &windows_core::HSTRING, arguments: P1) -> windows_core::Result> + pub fn InvokeScriptAsync(&self, scriptname: &windows_core::HSTRING, arguments: P1) -> windows_core::Result> where P1: windows_core::Param>, { @@ -4889,7 +4889,7 @@ impl WebUIView { } } #[cfg(feature = "Storage_Streams")] - pub fn CapturePreviewToStreamAsync(&self, stream: P0) -> windows_core::Result + pub fn CapturePreviewToStreamAsync(&self, stream: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -4900,7 +4900,7 @@ impl WebUIView { } } #[cfg(feature = "ApplicationModel_DataTransfer")] - pub fn CaptureSelectedContentToDataPackageAsync(&self) -> windows_core::Result> { + pub fn CaptureSelectedContentToDataPackageAsync(&self) -> windows_core::Result> { let this = &windows_core::Interface::cast::(self)?; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/UI/WindowManagement/mod.rs b/crates/libs/windows/src/Windows/UI/WindowManagement/mod.rs index e5a0c7c574..2e6ac7eae2 100644 --- a/crates/libs/windows/src/Windows/UI/WindowManagement/mod.rs +++ b/crates/libs/windows/src/Windows/UI/WindowManagement/mod.rs @@ -84,7 +84,7 @@ impl AppWindow { (windows_core::Interface::vtable(this).WindowingEnvironment)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CloseAsync(&self) -> windows_core::Result { + pub fn CloseAsync(&self) -> windows_core::Result { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -145,7 +145,7 @@ impl AppWindow { let this = self; unsafe { (windows_core::Interface::vtable(this).RequestSize)(windows_core::Interface::as_raw(this), framesize).ok() } } - pub fn TryShowAsync(&self) -> windows_core::Result> { + pub fn TryShowAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -194,7 +194,7 @@ impl AppWindow { let this = self; unsafe { (windows_core::Interface::vtable(this).RemoveCloseRequested)(windows_core::Interface::as_raw(this), token).ok() } } - pub fn TryCreateAsync() -> windows_core::Result> { + pub fn TryCreateAsync() -> windows_core::Result> { Self::IAppWindowStatics(|this| unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).TryCreateAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) diff --git a/crates/libs/windows/src/Windows/Web/AtomPub/mod.rs b/crates/libs/windows/src/Windows/Web/AtomPub/mod.rs index 61d9e5c679..7bbc14dcc5 100644 --- a/crates/libs/windows/src/Windows/Web/AtomPub/mod.rs +++ b/crates/libs/windows/src/Windows/Web/AtomPub/mod.rs @@ -15,7 +15,7 @@ impl AtomPubClient { static SHARED: windows_core::imp::FactoryCache = windows_core::imp::FactoryCache::new(); SHARED.call(callback) } - pub fn RetrieveServiceDocumentAsync(&self, uri: P0) -> windows_core::Result> + pub fn RetrieveServiceDocumentAsync(&self, uri: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -26,7 +26,7 @@ impl AtomPubClient { } } #[cfg(feature = "Storage_Streams")] - pub fn RetrieveMediaResourceAsync(&self, uri: P0) -> windows_core::Result> + pub fn RetrieveMediaResourceAsync(&self, uri: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -36,7 +36,7 @@ impl AtomPubClient { (windows_core::Interface::vtable(this).RetrieveMediaResourceAsync)(windows_core::Interface::as_raw(this), uri.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn RetrieveResourceAsync(&self, uri: P0) -> windows_core::Result> + pub fn RetrieveResourceAsync(&self, uri: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -46,7 +46,7 @@ impl AtomPubClient { (windows_core::Interface::vtable(this).RetrieveResourceAsync)(windows_core::Interface::as_raw(this), uri.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn CreateResourceAsync(&self, uri: P0, description: &windows_core::HSTRING, item: P2) -> windows_core::Result> + pub fn CreateResourceAsync(&self, uri: P0, description: &windows_core::HSTRING, item: P2) -> windows_core::Result> where P0: windows_core::Param, P2: windows_core::Param, @@ -58,7 +58,7 @@ impl AtomPubClient { } } #[cfg(feature = "Storage_Streams")] - pub fn CreateMediaResourceAsync(&self, uri: P0, mediatype: &windows_core::HSTRING, description: &windows_core::HSTRING, mediastream: P3) -> windows_core::Result> + pub fn CreateMediaResourceAsync(&self, uri: P0, mediatype: &windows_core::HSTRING, description: &windows_core::HSTRING, mediastream: P3) -> windows_core::Result> where P0: windows_core::Param, P3: windows_core::Param, @@ -70,7 +70,7 @@ impl AtomPubClient { } } #[cfg(feature = "Storage_Streams")] - pub fn UpdateMediaResourceAsync(&self, uri: P0, mediatype: &windows_core::HSTRING, mediastream: P2) -> windows_core::Result> + pub fn UpdateMediaResourceAsync(&self, uri: P0, mediatype: &windows_core::HSTRING, mediastream: P2) -> windows_core::Result> where P0: windows_core::Param, P2: windows_core::Param, @@ -81,7 +81,7 @@ impl AtomPubClient { (windows_core::Interface::vtable(this).UpdateMediaResourceAsync)(windows_core::Interface::as_raw(this), uri.param().abi(), core::mem::transmute_copy(mediatype), mediastream.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn UpdateResourceAsync(&self, uri: P0, item: P1) -> windows_core::Result> + pub fn UpdateResourceAsync(&self, uri: P0, item: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -92,7 +92,7 @@ impl AtomPubClient { (windows_core::Interface::vtable(this).UpdateResourceAsync)(windows_core::Interface::as_raw(this), uri.param().abi(), item.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn UpdateResourceItemAsync(&self, item: P0) -> windows_core::Result> + pub fn UpdateResourceItemAsync(&self, item: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -102,7 +102,7 @@ impl AtomPubClient { (windows_core::Interface::vtable(this).UpdateResourceItemAsync)(windows_core::Interface::as_raw(this), item.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteResourceAsync(&self, uri: P0) -> windows_core::Result> + pub fn DeleteResourceAsync(&self, uri: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -112,7 +112,7 @@ impl AtomPubClient { (windows_core::Interface::vtable(this).DeleteResourceAsync)(windows_core::Interface::as_raw(this), uri.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn DeleteResourceItemAsync(&self, item: P0) -> windows_core::Result> + pub fn DeleteResourceItemAsync(&self, item: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -205,7 +205,7 @@ impl AtomPubClient { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).SetRequestHeader)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(name), core::mem::transmute_copy(value)).ok() } } - pub fn RetrieveFeedAsync(&self, uri: P0) -> windows_core::Result> + pub fn RetrieveFeedAsync(&self, uri: P0) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Web/Http/Filters/mod.rs b/crates/libs/windows/src/Windows/Web/Http/Filters/mod.rs index b900b7df3e..8eedef2357 100644 --- a/crates/libs/windows/src/Windows/Web/Http/Filters/mod.rs +++ b/crates/libs/windows/src/Windows/Web/Http/Filters/mod.rs @@ -198,7 +198,7 @@ impl HttpBaseProtocolFilter { (windows_core::Interface::vtable(this).CreateForUser)(windows_core::Interface::as_raw(this), user.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) }) } - pub fn SendRequestAsync(&self, request: P0) -> windows_core::Result> + pub fn SendRequestAsync(&self, request: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -496,7 +496,7 @@ impl windows_core::RuntimeType for IHttpFilter { windows_core::imp::interface_hierarchy!(IHttpFilter, windows_core::IUnknown, windows_core::IInspectable); windows_core::imp::required_hierarchy!(IHttpFilter, super::super::super::Foundation::IClosable); impl IHttpFilter { - pub fn SendRequestAsync(&self, request: P0) -> windows_core::Result> + pub fn SendRequestAsync(&self, request: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -515,7 +515,7 @@ impl windows_core::RuntimeName for IHttpFilter { const NAME: &'static str = "Windows.Web.Http.Filters.IHttpFilter"; } pub trait IHttpFilter_Impl: super::super::super::Foundation::IClosable_Impl { - fn SendRequestAsync(&self, request: windows_core::Ref<'_, super::HttpRequestMessage>) -> windows_core::Result>; + fn SendRequestAsync(&self, request: windows_core::Ref<'_, super::HttpRequestMessage>) -> windows_core::Result>; } impl IHttpFilter_Vtbl { pub const fn new() -> Self { diff --git a/crates/libs/windows/src/Windows/Web/Http/mod.rs b/crates/libs/windows/src/Windows/Web/Http/mod.rs index 5933a0219a..d1a78d6a8d 100644 --- a/crates/libs/windows/src/Windows/Web/Http/mod.rs +++ b/crates/libs/windows/src/Windows/Web/Http/mod.rs @@ -42,7 +42,7 @@ impl HttpBufferContent { (windows_core::Interface::vtable(this).Headers)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn BufferAllAsync(&self) -> windows_core::Result> { + pub fn BufferAllAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -50,7 +50,7 @@ impl HttpBufferContent { } } #[cfg(feature = "Storage_Streams")] - pub fn ReadAsBufferAsync(&self) -> windows_core::Result> { + pub fn ReadAsBufferAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -58,14 +58,14 @@ impl HttpBufferContent { } } #[cfg(feature = "Storage_Streams")] - pub fn ReadAsInputStreamAsync(&self) -> windows_core::Result> { + pub fn ReadAsInputStreamAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReadAsInputStreamAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReadAsStringAsync(&self) -> windows_core::Result> { + pub fn ReadAsStringAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -80,7 +80,7 @@ impl HttpBufferContent { } } #[cfg(feature = "Storage_Streams")] - pub fn WriteToStreamAsync(&self, outputstream: P0) -> windows_core::Result> + pub fn WriteToStreamAsync(&self, outputstream: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -131,7 +131,7 @@ impl HttpClient { let this = &windows_core::Interface::cast::(self)?; unsafe { (windows_core::Interface::vtable(this).Close)(windows_core::Interface::as_raw(this)).ok() } } - pub fn DeleteAsync(&self, uri: P0) -> windows_core::Result> + pub fn DeleteAsync(&self, uri: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -141,7 +141,7 @@ impl HttpClient { (windows_core::Interface::vtable(this).DeleteAsync)(windows_core::Interface::as_raw(this), uri.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetAsync(&self, uri: P0) -> windows_core::Result> + pub fn GetAsync(&self, uri: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -151,7 +151,7 @@ impl HttpClient { (windows_core::Interface::vtable(this).GetAsync)(windows_core::Interface::as_raw(this), uri.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetWithOptionAsync(&self, uri: P0, completionoption: HttpCompletionOption) -> windows_core::Result> + pub fn GetWithOptionAsync(&self, uri: P0, completionoption: HttpCompletionOption) -> windows_core::Result> where P0: windows_core::Param, { @@ -162,7 +162,7 @@ impl HttpClient { } } #[cfg(feature = "Storage_Streams")] - pub fn GetBufferAsync(&self, uri: P0) -> windows_core::Result> + pub fn GetBufferAsync(&self, uri: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -173,7 +173,7 @@ impl HttpClient { } } #[cfg(feature = "Storage_Streams")] - pub fn GetInputStreamAsync(&self, uri: P0) -> windows_core::Result> + pub fn GetInputStreamAsync(&self, uri: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -183,7 +183,7 @@ impl HttpClient { (windows_core::Interface::vtable(this).GetInputStreamAsync)(windows_core::Interface::as_raw(this), uri.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn GetStringAsync(&self, uri: P0) -> windows_core::Result> + pub fn GetStringAsync(&self, uri: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -193,7 +193,7 @@ impl HttpClient { (windows_core::Interface::vtable(this).GetStringAsync)(windows_core::Interface::as_raw(this), uri.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn PostAsync(&self, uri: P0, content: P1) -> windows_core::Result> + pub fn PostAsync(&self, uri: P0, content: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -204,7 +204,7 @@ impl HttpClient { (windows_core::Interface::vtable(this).PostAsync)(windows_core::Interface::as_raw(this), uri.param().abi(), content.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn PutAsync(&self, uri: P0, content: P1) -> windows_core::Result> + pub fn PutAsync(&self, uri: P0, content: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -215,7 +215,7 @@ impl HttpClient { (windows_core::Interface::vtable(this).PutAsync)(windows_core::Interface::as_raw(this), uri.param().abi(), content.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SendRequestAsync(&self, request: P0) -> windows_core::Result> + pub fn SendRequestAsync(&self, request: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -225,7 +225,7 @@ impl HttpClient { (windows_core::Interface::vtable(this).SendRequestAsync)(windows_core::Interface::as_raw(this), request.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn SendRequestWithOptionAsync(&self, request: P0, completionoption: HttpCompletionOption) -> windows_core::Result> + pub fn SendRequestWithOptionAsync(&self, request: P0, completionoption: HttpCompletionOption) -> windows_core::Result> where P0: windows_core::Param, { @@ -243,7 +243,7 @@ impl HttpClient { (windows_core::Interface::vtable(this).DefaultRequestHeaders)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryDeleteAsync(&self, uri: P0) -> windows_core::Result> + pub fn TryDeleteAsync(&self, uri: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -253,7 +253,7 @@ impl HttpClient { (windows_core::Interface::vtable(this).TryDeleteAsync)(windows_core::Interface::as_raw(this), uri.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryGetAsync(&self, uri: P0) -> windows_core::Result> + pub fn TryGetAsync(&self, uri: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -263,7 +263,7 @@ impl HttpClient { (windows_core::Interface::vtable(this).TryGetAsync)(windows_core::Interface::as_raw(this), uri.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryGetAsync2(&self, uri: P0, completionoption: HttpCompletionOption) -> windows_core::Result> + pub fn TryGetAsync2(&self, uri: P0, completionoption: HttpCompletionOption) -> windows_core::Result> where P0: windows_core::Param, { @@ -273,7 +273,7 @@ impl HttpClient { (windows_core::Interface::vtable(this).TryGetAsync2)(windows_core::Interface::as_raw(this), uri.param().abi(), completionoption, &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryGetBufferAsync(&self, uri: P0) -> windows_core::Result> + pub fn TryGetBufferAsync(&self, uri: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -283,7 +283,7 @@ impl HttpClient { (windows_core::Interface::vtable(this).TryGetBufferAsync)(windows_core::Interface::as_raw(this), uri.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryGetInputStreamAsync(&self, uri: P0) -> windows_core::Result> + pub fn TryGetInputStreamAsync(&self, uri: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -293,7 +293,7 @@ impl HttpClient { (windows_core::Interface::vtable(this).TryGetInputStreamAsync)(windows_core::Interface::as_raw(this), uri.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryGetStringAsync(&self, uri: P0) -> windows_core::Result> + pub fn TryGetStringAsync(&self, uri: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -303,7 +303,7 @@ impl HttpClient { (windows_core::Interface::vtable(this).TryGetStringAsync)(windows_core::Interface::as_raw(this), uri.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryPostAsync(&self, uri: P0, content: P1) -> windows_core::Result> + pub fn TryPostAsync(&self, uri: P0, content: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -314,7 +314,7 @@ impl HttpClient { (windows_core::Interface::vtable(this).TryPostAsync)(windows_core::Interface::as_raw(this), uri.param().abi(), content.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TryPutAsync(&self, uri: P0, content: P1) -> windows_core::Result> + pub fn TryPutAsync(&self, uri: P0, content: P1) -> windows_core::Result> where P0: windows_core::Param, P1: windows_core::Param, @@ -325,7 +325,7 @@ impl HttpClient { (windows_core::Interface::vtable(this).TryPutAsync)(windows_core::Interface::as_raw(this), uri.param().abi(), content.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TrySendRequestAsync(&self, request: P0) -> windows_core::Result> + pub fn TrySendRequestAsync(&self, request: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -335,7 +335,7 @@ impl HttpClient { (windows_core::Interface::vtable(this).TrySendRequestAsync)(windows_core::Interface::as_raw(this), request.param().abi(), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn TrySendRequestAsync2(&self, request: P0, completionoption: HttpCompletionOption) -> windows_core::Result> + pub fn TrySendRequestAsync2(&self, request: P0, completionoption: HttpCompletionOption) -> windows_core::Result> where P0: windows_core::Param, { @@ -651,7 +651,7 @@ impl HttpFormUrlEncodedContent { (windows_core::Interface::vtable(this).Headers)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn BufferAllAsync(&self) -> windows_core::Result> { + pub fn BufferAllAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -659,7 +659,7 @@ impl HttpFormUrlEncodedContent { } } #[cfg(feature = "Storage_Streams")] - pub fn ReadAsBufferAsync(&self) -> windows_core::Result> { + pub fn ReadAsBufferAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -667,14 +667,14 @@ impl HttpFormUrlEncodedContent { } } #[cfg(feature = "Storage_Streams")] - pub fn ReadAsInputStreamAsync(&self) -> windows_core::Result> { + pub fn ReadAsInputStreamAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReadAsInputStreamAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReadAsStringAsync(&self) -> windows_core::Result> { + pub fn ReadAsStringAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -689,7 +689,7 @@ impl HttpFormUrlEncodedContent { } } #[cfg(feature = "Storage_Streams")] - pub fn WriteToStreamAsync(&self, outputstream: P0) -> windows_core::Result> + pub fn WriteToStreamAsync(&self, outputstream: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1043,7 +1043,7 @@ impl HttpMultipartContent { (windows_core::Interface::vtable(this).Headers)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn BufferAllAsync(&self) -> windows_core::Result> { + pub fn BufferAllAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1051,7 +1051,7 @@ impl HttpMultipartContent { } } #[cfg(feature = "Storage_Streams")] - pub fn ReadAsBufferAsync(&self) -> windows_core::Result> { + pub fn ReadAsBufferAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1059,14 +1059,14 @@ impl HttpMultipartContent { } } #[cfg(feature = "Storage_Streams")] - pub fn ReadAsInputStreamAsync(&self) -> windows_core::Result> { + pub fn ReadAsInputStreamAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReadAsInputStreamAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReadAsStringAsync(&self) -> windows_core::Result> { + pub fn ReadAsStringAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1081,7 +1081,7 @@ impl HttpMultipartContent { } } #[cfg(feature = "Storage_Streams")] - pub fn WriteToStreamAsync(&self, outputstream: P0) -> windows_core::Result> + pub fn WriteToStreamAsync(&self, outputstream: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1180,7 +1180,7 @@ impl HttpMultipartFormDataContent { (windows_core::Interface::vtable(this).Headers)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn BufferAllAsync(&self) -> windows_core::Result> { + pub fn BufferAllAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1188,7 +1188,7 @@ impl HttpMultipartFormDataContent { } } #[cfg(feature = "Storage_Streams")] - pub fn ReadAsBufferAsync(&self) -> windows_core::Result> { + pub fn ReadAsBufferAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1196,14 +1196,14 @@ impl HttpMultipartFormDataContent { } } #[cfg(feature = "Storage_Streams")] - pub fn ReadAsInputStreamAsync(&self) -> windows_core::Result> { + pub fn ReadAsInputStreamAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReadAsInputStreamAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReadAsStringAsync(&self) -> windows_core::Result> { + pub fn ReadAsStringAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1218,7 +1218,7 @@ impl HttpMultipartFormDataContent { } } #[cfg(feature = "Storage_Streams")] - pub fn WriteToStreamAsync(&self, outputstream: P0) -> windows_core::Result> + pub fn WriteToStreamAsync(&self, outputstream: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1763,7 +1763,7 @@ impl HttpStreamContent { (windows_core::Interface::vtable(this).Headers)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn BufferAllAsync(&self) -> windows_core::Result> { + pub fn BufferAllAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1771,7 +1771,7 @@ impl HttpStreamContent { } } #[cfg(feature = "Storage_Streams")] - pub fn ReadAsBufferAsync(&self) -> windows_core::Result> { + pub fn ReadAsBufferAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1779,14 +1779,14 @@ impl HttpStreamContent { } } #[cfg(feature = "Storage_Streams")] - pub fn ReadAsInputStreamAsync(&self) -> windows_core::Result> { + pub fn ReadAsInputStreamAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReadAsInputStreamAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReadAsStringAsync(&self) -> windows_core::Result> { + pub fn ReadAsStringAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1801,7 +1801,7 @@ impl HttpStreamContent { } } #[cfg(feature = "Storage_Streams")] - pub fn WriteToStreamAsync(&self, outputstream: P0) -> windows_core::Result> + pub fn WriteToStreamAsync(&self, outputstream: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -1863,7 +1863,7 @@ impl HttpStringContent { (windows_core::Interface::vtable(this).Headers)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn BufferAllAsync(&self) -> windows_core::Result> { + pub fn BufferAllAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1871,7 +1871,7 @@ impl HttpStringContent { } } #[cfg(feature = "Storage_Streams")] - pub fn ReadAsBufferAsync(&self) -> windows_core::Result> { + pub fn ReadAsBufferAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1879,14 +1879,14 @@ impl HttpStringContent { } } #[cfg(feature = "Storage_Streams")] - pub fn ReadAsInputStreamAsync(&self) -> windows_core::Result> { + pub fn ReadAsInputStreamAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReadAsInputStreamAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReadAsStringAsync(&self) -> windows_core::Result> { + pub fn ReadAsStringAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -1901,7 +1901,7 @@ impl HttpStringContent { } } #[cfg(feature = "Storage_Streams")] - pub fn WriteToStreamAsync(&self, outputstream: P0) -> windows_core::Result> + pub fn WriteToStreamAsync(&self, outputstream: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2127,7 +2127,7 @@ impl IHttpContent { (windows_core::Interface::vtable(this).Headers)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn BufferAllAsync(&self) -> windows_core::Result> { + pub fn BufferAllAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2135,7 +2135,7 @@ impl IHttpContent { } } #[cfg(feature = "Storage_Streams")] - pub fn ReadAsBufferAsync(&self) -> windows_core::Result> { + pub fn ReadAsBufferAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2143,14 +2143,14 @@ impl IHttpContent { } } #[cfg(feature = "Storage_Streams")] - pub fn ReadAsInputStreamAsync(&self) -> windows_core::Result> { + pub fn ReadAsInputStreamAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); (windows_core::Interface::vtable(this).ReadAsInputStreamAsync)(windows_core::Interface::as_raw(this), &mut result__).and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn ReadAsStringAsync(&self) -> windows_core::Result> { + pub fn ReadAsStringAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -2165,7 +2165,7 @@ impl IHttpContent { } } #[cfg(feature = "Storage_Streams")] - pub fn WriteToStreamAsync(&self, outputstream: P0) -> windows_core::Result> + pub fn WriteToStreamAsync(&self, outputstream: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -2187,12 +2187,12 @@ impl windows_core::RuntimeName for IHttpContent { #[cfg(all(feature = "Storage_Streams", feature = "Web_Http_Headers"))] pub trait IHttpContent_Impl: super::super::Foundation::IClosable_Impl { fn Headers(&self) -> windows_core::Result; - fn BufferAllAsync(&self) -> windows_core::Result>; - fn ReadAsBufferAsync(&self) -> windows_core::Result>; - fn ReadAsInputStreamAsync(&self) -> windows_core::Result>; - fn ReadAsStringAsync(&self) -> windows_core::Result>; + fn BufferAllAsync(&self) -> windows_core::Result>; + fn ReadAsBufferAsync(&self) -> windows_core::Result>; + fn ReadAsInputStreamAsync(&self) -> windows_core::Result>; + fn ReadAsStringAsync(&self) -> windows_core::Result>; fn TryComputeLength(&self, length: &mut u64) -> windows_core::Result; - fn WriteToStreamAsync(&self, outputStream: windows_core::Ref<'_, super::super::Storage::Streams::IOutputStream>) -> windows_core::Result>; + fn WriteToStreamAsync(&self, outputStream: windows_core::Ref<'_, super::super::Storage::Streams::IOutputStream>) -> windows_core::Result>; } #[cfg(all(feature = "Storage_Streams", feature = "Web_Http_Headers"))] impl IHttpContent_Vtbl { diff --git a/crates/libs/windows/src/Windows/Web/Syndication/mod.rs b/crates/libs/windows/src/Windows/Web/Syndication/mod.rs index 8653a2489f..b8db385c31 100644 --- a/crates/libs/windows/src/Windows/Web/Syndication/mod.rs +++ b/crates/libs/windows/src/Windows/Web/Syndication/mod.rs @@ -120,7 +120,7 @@ impl ISyndicationClient { let this = self; unsafe { (windows_core::Interface::vtable(this).SetRequestHeader)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(name), core::mem::transmute_copy(value)).ok() } } - pub fn RetrieveFeedAsync(&self, uri: P0) -> windows_core::Result> + pub fn RetrieveFeedAsync(&self, uri: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -148,7 +148,7 @@ pub trait ISyndicationClient_Impl: windows_core::IUnknownImpl { fn BypassCacheOnRetrieve(&self) -> windows_core::Result; fn SetBypassCacheOnRetrieve(&self, value: bool) -> windows_core::Result<()>; fn SetRequestHeader(&self, name: &windows_core::HSTRING, value: &windows_core::HSTRING) -> windows_core::Result<()>; - fn RetrieveFeedAsync(&self, uri: windows_core::Ref<'_, super::super::Foundation::Uri>) -> windows_core::Result>; + fn RetrieveFeedAsync(&self, uri: windows_core::Ref<'_, super::super::Foundation::Uri>) -> windows_core::Result>; } #[cfg(feature = "Security_Credentials")] impl ISyndicationClient_Vtbl { @@ -1375,7 +1375,7 @@ impl SyndicationClient { let this = self; unsafe { (windows_core::Interface::vtable(this).SetRequestHeader)(windows_core::Interface::as_raw(this), core::mem::transmute_copy(name), core::mem::transmute_copy(value)).ok() } } - pub fn RetrieveFeedAsync(&self, uri: P0) -> windows_core::Result> + pub fn RetrieveFeedAsync(&self, uri: P0) -> windows_core::Result> where P0: windows_core::Param, { diff --git a/crates/libs/windows/src/Windows/Web/UI/Interop/mod.rs b/crates/libs/windows/src/Windows/Web/UI/Interop/mod.rs index cac4e89d8e..870283fcf2 100644 --- a/crates/libs/windows/src/Windows/Web/UI/Interop/mod.rs +++ b/crates/libs/windows/src/Windows/Web/UI/Interop/mod.rs @@ -218,7 +218,7 @@ impl WebViewControl { let this = self; unsafe { (windows_core::Interface::vtable(this).NavigateWithHttpRequestMessage)(windows_core::Interface::as_raw(this), requestmessage.param().abi()).ok() } } - pub fn InvokeScriptAsync(&self, scriptname: &windows_core::HSTRING, arguments: P1) -> windows_core::Result> + pub fn InvokeScriptAsync(&self, scriptname: &windows_core::HSTRING, arguments: P1) -> windows_core::Result> where P1: windows_core::Param>, { @@ -229,7 +229,7 @@ impl WebViewControl { } } #[cfg(feature = "Storage_Streams")] - pub fn CapturePreviewToStreamAsync(&self, stream: P0) -> windows_core::Result + pub fn CapturePreviewToStreamAsync(&self, stream: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -240,7 +240,7 @@ impl WebViewControl { } } #[cfg(feature = "ApplicationModel_DataTransfer")] - pub fn CaptureSelectedContentToDataPackageAsync(&self) -> windows_core::Result> { + pub fn CaptureSelectedContentToDataPackageAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -756,7 +756,7 @@ impl WebViewControlProcess { (windows_core::Interface::vtable(this).IsPrivateNetworkClientServerCapabilityEnabled)(windows_core::Interface::as_raw(this), &mut result__).map(|| result__) } } - pub fn CreateWebViewControlAsync(&self, hostwindowhandle: i64, bounds: super::super::super::Foundation::Rect) -> windows_core::Result> { + pub fn CreateWebViewControlAsync(&self, hostwindowhandle: i64, bounds: super::super::super::Foundation::Rect) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Web/UI/mod.rs b/crates/libs/windows/src/Windows/Web/UI/mod.rs index a808d55ff8..1a6a850d37 100644 --- a/crates/libs/windows/src/Windows/Web/UI/mod.rs +++ b/crates/libs/windows/src/Windows/Web/UI/mod.rs @@ -118,7 +118,7 @@ impl IWebViewControl { let this = self; unsafe { (windows_core::Interface::vtable(this).NavigateWithHttpRequestMessage)(windows_core::Interface::as_raw(this), requestmessage.param().abi()).ok() } } - pub fn InvokeScriptAsync(&self, scriptname: &windows_core::HSTRING, arguments: P1) -> windows_core::Result> + pub fn InvokeScriptAsync(&self, scriptname: &windows_core::HSTRING, arguments: P1) -> windows_core::Result> where P1: windows_core::Param>, { @@ -129,7 +129,7 @@ impl IWebViewControl { } } #[cfg(feature = "Storage_Streams")] - pub fn CapturePreviewToStreamAsync(&self, stream: P0) -> windows_core::Result + pub fn CapturePreviewToStreamAsync(&self, stream: P0) -> windows_core::Result where P0: windows_core::Param, { @@ -140,7 +140,7 @@ impl IWebViewControl { } } #[cfg(feature = "ApplicationModel_DataTransfer")] - pub fn CaptureSelectedContentToDataPackageAsync(&self) -> windows_core::Result> { + pub fn CaptureSelectedContentToDataPackageAsync(&self) -> windows_core::Result> { let this = self; unsafe { let mut result__ = core::mem::zeroed(); @@ -421,9 +421,9 @@ pub trait IWebViewControl_Impl: windows_core::IUnknownImpl { fn NavigateToString(&self, text: &windows_core::HSTRING) -> windows_core::Result<()>; fn NavigateToLocalStreamUri(&self, source: windows_core::Ref<'_, super::super::Foundation::Uri>, streamResolver: windows_core::Ref<'_, super::IUriToStreamResolver>) -> windows_core::Result<()>; fn NavigateWithHttpRequestMessage(&self, requestMessage: windows_core::Ref<'_, super::Http::HttpRequestMessage>) -> windows_core::Result<()>; - fn InvokeScriptAsync(&self, scriptName: &windows_core::HSTRING, arguments: windows_core::Ref<'_, windows_collections::IIterable>) -> windows_core::Result>; - fn CapturePreviewToStreamAsync(&self, stream: windows_core::Ref<'_, super::super::Storage::Streams::IRandomAccessStream>) -> windows_core::Result; - fn CaptureSelectedContentToDataPackageAsync(&self) -> windows_core::Result>; + fn InvokeScriptAsync(&self, scriptName: &windows_core::HSTRING, arguments: windows_core::Ref<'_, windows_collections::IIterable>) -> windows_core::Result>; + fn CapturePreviewToStreamAsync(&self, stream: windows_core::Ref<'_, super::super::Storage::Streams::IRandomAccessStream>) -> windows_core::Result; + fn CaptureSelectedContentToDataPackageAsync(&self) -> windows_core::Result>; fn BuildLocalStreamUri(&self, contentIdentifier: &windows_core::HSTRING, relativePath: &windows_core::HSTRING) -> windows_core::Result; fn GetDeferredPermissionRequestById(&self, id: u32, result: windows_core::OutRef<'_, WebViewControlDeferredPermissionRequest>) -> windows_core::Result<()>; fn NavigationStarting(&self, handler: windows_core::Ref<'_, super::super::Foundation::TypedEventHandler>) -> windows_core::Result; diff --git a/crates/libs/windows/src/Windows/Web/mod.rs b/crates/libs/windows/src/Windows/Web/mod.rs index 8530d2c3c6..247851c73e 100644 --- a/crates/libs/windows/src/Windows/Web/mod.rs +++ b/crates/libs/windows/src/Windows/Web/mod.rs @@ -13,7 +13,7 @@ impl windows_core::RuntimeType for IUriToStreamResolver { windows_core::imp::interface_hierarchy!(IUriToStreamResolver, windows_core::IUnknown, windows_core::IInspectable); impl IUriToStreamResolver { #[cfg(feature = "Storage_Streams")] - pub fn UriToStreamAsync(&self, uri: P0) -> windows_core::Result> + pub fn UriToStreamAsync(&self, uri: P0) -> windows_core::Result> where P0: windows_core::Param, { @@ -30,7 +30,7 @@ impl windows_core::RuntimeName for IUriToStreamResolver { } #[cfg(feature = "Storage_Streams")] pub trait IUriToStreamResolver_Impl: windows_core::IUnknownImpl { - fn UriToStreamAsync(&self, uri: windows_core::Ref<'_, super::Foundation::Uri>) -> windows_core::Result>; + fn UriToStreamAsync(&self, uri: windows_core::Ref<'_, super::Foundation::Uri>) -> windows_core::Result>; } #[cfg(feature = "Storage_Streams")] impl IUriToStreamResolver_Vtbl { diff --git a/crates/samples/windows/consent/Cargo.toml b/crates/samples/windows/consent/Cargo.toml index dfd9b46f2f..6f37f8d8d3 100644 --- a/crates/samples/windows/consent/Cargo.toml +++ b/crates/samples/windows/consent/Cargo.toml @@ -11,5 +11,5 @@ features = [ "Win32_System_WinRT", ] -[dependencies.windows-async] +[dependencies.windows-future] workspace = true diff --git a/crates/samples/windows/consent/src/main.rs b/crates/samples/windows/consent/src/main.rs index b430884225..b349d7bc0a 100644 --- a/crates/samples/windows/consent/src/main.rs +++ b/crates/samples/windows/consent/src/main.rs @@ -2,7 +2,7 @@ use windows::{ core::*, Security::Credentials::UI::*, Win32::Foundation::*, Win32::System::WinRT::*, }; -use windows_async::*; +use windows_future::*; fn main() -> Result<()> { unsafe { diff --git a/crates/tests/misc/async/Cargo.toml b/crates/tests/misc/async/Cargo.toml index e278e0a963..281f361f8d 100644 --- a/crates/tests/misc/async/Cargo.toml +++ b/crates/tests/misc/async/Cargo.toml @@ -16,7 +16,7 @@ features = [ "Win32_Foundation", ] -[dependencies.windows-async] +[dependencies.windows-future] workspace = true [dev-dependencies] diff --git a/crates/tests/misc/async/tests/agile.rs b/crates/tests/misc/async/tests/agile.rs index 755fcc36ad..ec0cd5e8b2 100644 --- a/crates/tests/misc/async/tests/agile.rs +++ b/crates/tests/misc/async/tests/agile.rs @@ -1,4 +1,4 @@ -use windows_async::*; +use windows_future::*; fn send(_: Option) {} fn sync(_: Option) {} diff --git a/crates/tests/misc/async/tests/async_info.rs b/crates/tests/misc/async/tests/async_info.rs index bcdd2a49db..6c176235de 100644 --- a/crates/tests/misc/async/tests/async_info.rs +++ b/crates/tests/misc/async/tests/async_info.rs @@ -2,7 +2,7 @@ // but the remaining methods are tested just to confirm stable behavior. use windows::core::*; -use windows_async::*; +use windows_future::*; #[test] fn test() -> Result<()> { diff --git a/crates/tests/misc/async/tests/completed_finished.rs b/crates/tests/misc/async/tests/completed_finished.rs index 06e3e2d752..ceaeb4e31e 100644 --- a/crates/tests/misc/async/tests/completed_finished.rs +++ b/crates/tests/misc/async/tests/completed_finished.rs @@ -4,7 +4,7 @@ use std::sync::mpsc::channel; use std::thread; use windows::core::*; -use windows_async::*; +use windows_future::*; #[test] fn action() -> Result<()> { diff --git a/crates/tests/misc/async/tests/completed_get.rs b/crates/tests/misc/async/tests/completed_get.rs index 7bf9834ef9..a68957caa6 100644 --- a/crates/tests/misc/async/tests/completed_get.rs +++ b/crates/tests/misc/async/tests/completed_get.rs @@ -2,7 +2,7 @@ // that they do not store the `Completed` handler for consistency. use windows::core::*; -use windows_async::*; +use windows_future::*; #[test] fn test() -> Result<()> { diff --git a/crates/tests/misc/async/tests/completed_once.rs b/crates/tests/misc/async/tests/completed_once.rs index 2a28649853..44b8e71d9f 100644 --- a/crates/tests/misc/async/tests/completed_once.rs +++ b/crates/tests/misc/async/tests/completed_once.rs @@ -2,7 +2,7 @@ // Also tests that any error from the handler is ignored by the implementation. use windows::{core::*, Win32::Foundation::*}; -use windows_async::*; +use windows_future::*; #[test] fn action_ready() -> Result<()> { diff --git a/crates/tests/misc/async/tests/completed_started.rs b/crates/tests/misc/async/tests/completed_started.rs index d60a1c6bc4..19bba0c3e6 100644 --- a/crates/tests/misc/async/tests/completed_started.rs +++ b/crates/tests/misc/async/tests/completed_started.rs @@ -4,7 +4,7 @@ use std::sync::mpsc::channel; use std::thread; use windows::core::*; -use windows_async::*; +use windows_future::*; #[test] fn action() -> Result<()> { diff --git a/crates/tests/misc/async/tests/dropped.rs b/crates/tests/misc/async/tests/dropped.rs index 32e384652b..2ff0840d58 100644 --- a/crates/tests/misc/async/tests/dropped.rs +++ b/crates/tests/misc/async/tests/dropped.rs @@ -3,7 +3,7 @@ use std::sync::mpsc::channel; use windows::core::*; -use windows_async::*; +use windows_future::*; #[test] fn action() -> Result<()> { diff --git a/crates/tests/misc/async/tests/error.rs b/crates/tests/misc/async/tests/error.rs index 8a8f97b3a0..222d6ca3d1 100644 --- a/crates/tests/misc/async/tests/error.rs +++ b/crates/tests/misc/async/tests/error.rs @@ -3,7 +3,7 @@ // as well. use windows::{core::*, Win32::Foundation::*}; -use windows_async::*; +use windows_future::*; #[test] fn action_ready() -> Result<()> { diff --git a/crates/tests/misc/async/tests/progress.rs b/crates/tests/misc/async/tests/progress.rs index 0ac99e6644..c5bbe3b0e9 100644 --- a/crates/tests/misc/async/tests/progress.rs +++ b/crates/tests/misc/async/tests/progress.rs @@ -1,7 +1,7 @@ // All stock implementations don't support progress notifications. use windows::core::*; -use windows_async::*; +use windows_future::*; #[test] fn test() -> Result<()> { diff --git a/crates/tests/misc/async/tests/started.rs b/crates/tests/misc/async/tests/started.rs index 17eaf03b84..978991dc9e 100644 --- a/crates/tests/misc/async/tests/started.rs +++ b/crates/tests/misc/async/tests/started.rs @@ -3,7 +3,7 @@ // The `GetResults` method may not be called in this state. use windows::{core::*, Win32::Foundation::*}; -use windows_async::*; +use windows_future::*; #[test] fn action() -> Result<()> { diff --git a/crates/tests/misc/implement/Cargo.toml b/crates/tests/misc/implement/Cargo.toml index cb8bedc980..99accf007d 100644 --- a/crates/tests/misc/implement/Cargo.toml +++ b/crates/tests/misc/implement/Cargo.toml @@ -31,7 +31,7 @@ workspace = true [dependencies.windows-collections] workspace = true -[dependencies.windows-async] +[dependencies.windows-future] workspace = true [dependencies] diff --git a/crates/tests/misc/implement/tests/as_interface_param.rs b/crates/tests/misc/implement/tests/as_interface_param.rs index 6512690126..0934b8aec1 100644 --- a/crates/tests/misc/implement/tests/as_interface_param.rs +++ b/crates/tests/misc/implement/tests/as_interface_param.rs @@ -1,5 +1,5 @@ use windows::core::*; -use windows_async::*; +use windows_future::*; #[implement(IAsyncAction)] struct Async; diff --git a/crates/tests/misc/match/Cargo.toml b/crates/tests/misc/match/Cargo.toml index 643d0871c2..9827a517c7 100644 --- a/crates/tests/misc/match/Cargo.toml +++ b/crates/tests/misc/match/Cargo.toml @@ -15,5 +15,5 @@ features = [ "Win32_Foundation", ] -[dependencies.windows-async] +[dependencies.windows-future] workspace = true diff --git a/crates/tests/misc/match/tests/tests.rs b/crates/tests/misc/match/tests/tests.rs index 73abe24a19..6143cadcc7 100644 --- a/crates/tests/misc/match/tests/tests.rs +++ b/crates/tests/misc/match/tests/tests.rs @@ -1,5 +1,5 @@ use windows::Win32::Foundation::*; -use windows_async::*; +use windows_future::*; #[test] fn test() { diff --git a/crates/tests/misc/no_std/Cargo.toml b/crates/tests/misc/no_std/Cargo.toml index 193ea8cc95..2d04dd9e77 100644 --- a/crates/tests/misc/no_std/Cargo.toml +++ b/crates/tests/misc/no_std/Cargo.toml @@ -41,8 +41,8 @@ default-features = false path = "../../../libs/numerics" default-features = false -[dependencies.windows-async] -path = "../../../libs/async" +[dependencies.windows-future] +path = "../../../libs/future" default-features = false [dependencies.windows-version] diff --git a/crates/tests/misc/no_std/src/lib.rs b/crates/tests/misc/no_std/src/lib.rs index 4612a45f03..e9105cf947 100644 --- a/crates/tests/misc/no_std/src/lib.rs +++ b/crates/tests/misc/no_std/src/lib.rs @@ -24,7 +24,7 @@ fn _test() { let _ = windows_strings::s!("hello"); let _ = windows_strings::w!("hello"); let _: Option> = None; - let _: Option> = None; + let _: Option> = None; let _ = windows_numerics::Vector2::new(0.0, 0.0); } diff --git a/crates/tests/winrt/old/Cargo.toml b/crates/tests/winrt/old/Cargo.toml index cf63b21a5b..cb3cfb590e 100644 --- a/crates/tests/winrt/old/Cargo.toml +++ b/crates/tests/winrt/old/Cargo.toml @@ -14,7 +14,7 @@ workspace = true [dependencies.windows-numerics] workspace = true -[dependencies.windows-async] +[dependencies.windows-future] workspace = true [dependencies.windows] diff --git a/crates/tests/winrt/old/tests/delegates.rs b/crates/tests/winrt/old/tests/delegates.rs index 719d4293ed..ae4d5cf2fc 100644 --- a/crates/tests/winrt/old/tests/delegates.rs +++ b/crates/tests/winrt/old/tests/delegates.rs @@ -2,7 +2,7 @@ use core::convert::*; use windows::core::Interface; use windows::{Foundation::Collections::*, Foundation::*}; -use windows_async::*; +use windows_future::*; #[test] fn non_generic() -> windows::core::Result<()> { diff --git a/crates/tests/winrt/old/tests/enum.rs b/crates/tests/winrt/old/tests/enum.rs index b9e797bd42..f9023a6641 100644 --- a/crates/tests/winrt/old/tests/enum.rs +++ b/crates/tests/winrt/old/tests/enum.rs @@ -1,5 +1,5 @@ use windows::ApplicationModel::Appointments::AppointmentDaysOfWeek; -use windows_async::*; +use windows_future::*; #[test] fn signed_enum() { diff --git a/crates/tests/winrt/old/tests/generic_guids.rs b/crates/tests/winrt/old/tests/generic_guids.rs index 0f7a222a5e..724e0dd292 100644 --- a/crates/tests/winrt/old/tests/generic_guids.rs +++ b/crates/tests/winrt/old/tests/generic_guids.rs @@ -1,5 +1,5 @@ use windows::{core::*, Devices::Enumeration::*, Foundation::Collections::*, Foundation::*}; -use windows_async::*; +use windows_future::*; use windows_collections::*; #[test] diff --git a/crates/tests/winrt/old/tests/send_sync.rs b/crates/tests/winrt/old/tests/send_sync.rs index 13ddb0701b..06a62f64cd 100644 --- a/crates/tests/winrt/old/tests/send_sync.rs +++ b/crates/tests/winrt/old/tests/send_sync.rs @@ -2,7 +2,7 @@ use std::thread; use windows::core::{Interface, HRESULT, HSTRING}; use windows::Foundation::*; use windows::Storage::Streams::*; -use windows_async::*; +use windows_future::*; // Simple test to validate that types with MarshalingType.Agile are marked Send and Sync // (if this compiles it worked) diff --git a/crates/tools/bindings/src/async.txt b/crates/tools/bindings/src/async.txt index 22a56f5a87..8a4611567a 100644 --- a/crates/tools/bindings/src/async.txt +++ b/crates/tools/bindings/src/async.txt @@ -1,4 +1,4 @@ ---out crates/libs/async/src/bindings.rs +--out crates/libs/future/src/bindings.rs --flat --no-comment --no-allow diff --git a/crates/tools/bindings/src/async_impl.txt b/crates/tools/bindings/src/async_impl.txt index 91713b243d..d3f73afb2c 100644 --- a/crates/tools/bindings/src/async_impl.txt +++ b/crates/tools/bindings/src/async_impl.txt @@ -1,4 +1,4 @@ ---out crates/libs/async/src/bindings_impl.rs +--out crates/libs/future/src/bindings_impl.rs --flat --no-comment --no-allow diff --git a/crates/tools/bindings/src/windows.txt b/crates/tools/bindings/src/windows.txt index d05522e7a9..e46b7ec832 100644 --- a/crates/tools/bindings/src/windows.txt +++ b/crates/tools/bindings/src/windows.txt @@ -6,7 +6,7 @@ --reference windows_collections,flat,Windows.Foundation.Collections windows_numerics,flat,Windows.Foundation.Numerics - windows_async,flat,Windows.Foundation + windows_future,flat,Windows.Foundation --filter Windows From 64147cbfd1e659b04833a047d34057e2b79a4b23 Mon Sep 17 00:00:00 2001 From: Kenny Kerr Date: Fri, 14 Feb 2025 13:05:15 -0600 Subject: [PATCH 9/9] fmt --- crates/tests/winrt/old/tests/generic_guids.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/tests/winrt/old/tests/generic_guids.rs b/crates/tests/winrt/old/tests/generic_guids.rs index 724e0dd292..3ebfac38e7 100644 --- a/crates/tests/winrt/old/tests/generic_guids.rs +++ b/crates/tests/winrt/old/tests/generic_guids.rs @@ -1,6 +1,6 @@ use windows::{core::*, Devices::Enumeration::*, Foundation::Collections::*, Foundation::*}; -use windows_future::*; use windows_collections::*; +use windows_future::*; #[test] fn signatures() {