diff options
| author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-19 00:47:55 +0000 |
|---|---|---|
| committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-19 00:47:55 +0000 |
| commit | 26a029d407be480d791972afb5975cf62c9360a6 (patch) | |
| tree | f435a8308119effd964b339f76abb83a57c29483 /third_party/rust/raw-window-handle | |
| parent | Initial commit. (diff) | |
| download | firefox-26a029d407be480d791972afb5975cf62c9360a6.tar.xz firefox-26a029d407be480d791972afb5975cf62c9360a6.zip | |
Adding upstream version 124.0.1.upstream/124.0.1
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'third_party/rust/raw-window-handle')
18 files changed, 1951 insertions, 0 deletions
diff --git a/third_party/rust/raw-window-handle/.cargo-checksum.json b/third_party/rust/raw-window-handle/.cargo-checksum.json new file mode 100644 index 0000000000..b64138d217 --- /dev/null +++ b/third_party/rust/raw-window-handle/.cargo-checksum.json @@ -0,0 +1 @@ +{"files":{"CHANGELOG.md":"3a4761b97d2990673686dd5662002286127324a8aa50e58405c207e721b759d2","Cargo.toml":"1eb654aa4e123f7308799b5e15db67e1a1cd84e9bceca8af51b6c96cb5f034ab","LICENSE-APACHE.md":"eb3d7b5485466acbd81f2b496f595ab637d2792e268206b27d99e793bdb67549","LICENSE-MIT.md":"3215e5f26be4ea74caa50a7880b5864955e6de989fc5ac36d292e68daba0298d","LICENSE-ZLIB.md":"1b3ec12650e16a7796aa270d0513130262a1ae7fe4b10e91d2d41f0a04d48012","README.md":"efe94e83aecf02a7975d56f2f160a9d18485ed76dcb8009c210355343a08d806","rustfmt.toml":"251cf464bd3611e21efab1aee7ffc4f53cb0b6e69997c8df9131177caf4dc31b","src/android.rs":"9930225299f496f42780af7b39aa723697a07f98d5cae1c4774b35c89eb364a6","src/appkit.rs":"8f82ce0db226d344bebd7868cef7e1d858261ea3b412e6e1920fb794447f0724","src/borrowed.rs":"24cdb91b1fd52ca8f7ac02806675d7ca2d2cd79238307de4fc28bc6aa47c4300","src/haiku.rs":"29d78ba6f8fb608d2057c3a837b4806fd9b3d8c5405f9dfc1add75374192ae43","src/lib.rs":"dbe2bbcce0f91c007c5082b3070e6f98ebe981d9d97bb81edb2bd72e2afd5bfb","src/redox.rs":"38ee2f525804868c7d944bd44afe4816885cc17ce34a82f59ea6ba97c16e035e","src/uikit.rs":"b7bc50987b7ed77b279673b1b4c3ea896f011ca149760def438230f7e28451db","src/unix.rs":"f2a82be3fd84b3b6f3016368dd12f21084411e08b2ce9a90e341915ff1b9ed39","src/web.rs":"c37c71e3c1a42813305271f5e17a8122346bfbc41e5b7513636a4fd51932b8a3","src/windows.rs":"115ce2c337e7adf7ec0a4dc37a107ae85910bfb4d1752242d83e57fd0bf1dc3e"},"package":"42a9830a0e1b9fb145ebb365b8bc4ccd75f290f98c0247deafbbe2c75cefb544"}
\ No newline at end of file diff --git a/third_party/rust/raw-window-handle/CHANGELOG.md b/third_party/rust/raw-window-handle/CHANGELOG.md new file mode 100644 index 0000000000..4d6ab0ffd9 --- /dev/null +++ b/third_party/rust/raw-window-handle/CHANGELOG.md @@ -0,0 +1,103 @@ +# Changelog
+
+## 0.6.0 (2023-09-30)
+
+* **Breaking:** Raw pointer handles now use `NonNull` where appropriate, to avoid null pointer dereferences.
+* **Breaking:** Renamed `empty` methods to `new`, and take parameters in most of those, to better match normal Rust semantics.
+* **Breaking:** `HasRaw(Display/Window)Handle::raw_(display/window)_handle` returns a result indicating if fetching the window handle failed (#122).
+* **Breaking:** Remove the `Active/ActiveHandle` types from the public API (#126).
+* **Breaking:** Remove `AppKitWindowHandle::ns_window` and `UiKitWindowHandle::ui_window` since they can be retrieved from the view (#129).
+* **Breaking:** Remove `Copy` derive from `RawWindowHandle` and `WindowHandle` (#140).
+* Implement `PartialEq`, `Eq` and `Hash` for `WindowHandle` too. (#128)
+* Implement the relevant traits for `&mut T where T: <trait>`. (#130)
+* Add web handles for `wasm-bindgen` v0.2. They are locked behind the `wasm-bindgen-0-2` feature. (#134)
+* Deprecate the raw window/display handle traits. They will be removed at the next stable release. (#139)
+
+## 0.5.2 (2023-03-31)
+
+* Add several types for using raw window handles safely, including `HasWindowHandle`, `WindowHandle`, `HasDisplayHandle`, `DisplayHandle` and `Active` (#110).
+
+## 0.5.1 (2023-03-07)
+
+* Add the `rust-version` field (`1.64`).
+* Implemented `From` for `RawWindowHandle` and `RawDisplayHandle`
+
+## 0.5.0 (2022-07-14)
+
+* **Breaking:** The `RawWindowHandle` variants were split into `RawDisplayHandle` and `RawWindowHandle`.
+* The X11 screen is now present in new `XlibDisplayHandle` and `XcbDisplayHandle`.
+- Add GBM support.
+
+## 0.4.3 (2022-03-29)
+
+* [Add visual IDs to X11 handles](https://github.com/rust-windowing/raw-window-handle/pull/83)
+* [Add a link to the MDN page for data attributes in the documentation for WebHandle](https://github.com/rust-windowing/raw-window-handle/pull/86)
+* [add haiku support](https://github.com/rust-windowing/raw-window-handle/pull/88)
+
+## 0.4.2 (2021-11-24)
+
+* Also implement `HasRawWindowHandle` for `Rc<T>`, and `Arc<T>` where `T: ?Sized`.
+
+## 0.4.1 (2021-11-19)
+
+* Added an impl of `HasRawWindowHandle` for `&T`, `Rc<T>`, and `Arc<T>`. The impls for `Rc<T>` and `Arc<T>` require the `alloc` feature.
+
+## 0.4.0 (2021-11-15)
+
+* **Breaking:** Remove `_do_not_use` tags to use `#[non_exhaustive]` macro
+* **Breaking:** `RawWindowHandle` variants are no longer cfg-guarded by platform.
+* **Breaking:** Rename `IOS` to `UiKit`.
+* **Breaking:** Rename `MacOS` to `AppKit`.
+* **Breaking:** Rename `Windows` to `Win32`.
+* **Breaking:** Rename `Redox` to `Orbital`.
+* **Breaking:** Rename `Android` to `AndroidNdk`.
+* **Breaking:** Inner window handle structs are now exported at crate root.
+* Added Windows `WinRt` handle.
+
+# 0.3.4 (2021-11-27)
+
+* Add `HasRawWindowHandle` implementation for `HasRawWindowHandle` in the
+ newer `v0.4`.
+ This allows "provider" crates that implement `HasRawWindowHandle` (like
+ `winit`, `sdl2`, `glfw`, `fltk`, ...) to upgrade to `v0.4` without a
+ breaking change.
+ Afterwards "consumer" crates (like `gfx`, `wgpu`, `rfd`, ...) can start
+ upgrading with minimal breakage for their users.
+
+## 0.3.3 (2019-12-1)
+
+* Add missing `Hash` implementation for `AndroidHandle`.
+
+## 0.3.2 (2019-11-29)
+
+* Add `Hash` implementation for `RawWindowHandle`.
+
+## 0.3.1 (2019-10-27)
+
+* Remove `RawWindowHandle`'s `HasRawWindowHandle` implementation, as it was unsound (see [#35](https://github.com/rust-windowing/raw-window-handle/issues/35))
+* Explicitly require that handles within `RawWindowHandle` be valid for the lifetime of the `HasRawWindowHandle` implementation that provided them.
+
+## 0.3.0 (2019-10-5)
+
+* **Breaking:** Rename `XLib.surface` to `XLib.window`, as that more accurately represents the underlying type.
+* Implement `HasRawWindowHandle` for `RawWindowHandle`
+* Add `HINSTANCE` field to `WindowsHandle`.
+
+## 0.2.0 (2019-09-26)
+
+* **Breaking:** Rename `X11` to `XLib`.
+* Add XCB support.
+* Add Web support.
+* Add Android support.
+
+## 0.1.2 (2019-08-13)
+
+* Fix use of private `_non_exhaustive` field in platform handle structs preventing structs from getting initialized.
+
+## 0.1.1 (2019-08-13)
+
+* Flesh out Cargo.toml, adding crates.io info rendering tags.
+
+## 0.1.0 (2019-08-13)
+
+* Initial release.
diff --git a/third_party/rust/raw-window-handle/Cargo.toml b/third_party/rust/raw-window-handle/Cargo.toml new file mode 100644 index 0000000000..7af2d07716 --- /dev/null +++ b/third_party/rust/raw-window-handle/Cargo.toml @@ -0,0 +1,44 @@ +# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO +# +# When uploading crates to the registry Cargo will automatically +# "normalize" Cargo.toml files for maximal compatibility +# with all versions of Cargo and also rewrite `path` dependencies +# to registry (e.g., crates.io) dependencies. +# +# If you are reading this file be aware that the original Cargo.toml +# will likely look very different (and much more reasonable). +# See Cargo.toml.orig for the original contents. + +[package] +edition = "2021" +rust-version = "1.64" +name = "raw-window-handle" +version = "0.6.0" +authors = ["Osspial <osspial@gmail.com>"] +description = "Interoperability library for Rust Windowing applications." +documentation = "https://docs.rs/raw-window-handle" +readme = "README.md" +keywords = ["windowing"] +license = "MIT OR Apache-2.0 OR Zlib" +repository = "https://github.com/rust-windowing/raw-window-handle" + +[package.metadata.docs.rs] +all-features = true +rustdoc-args = [ + "--cfg", + "docsrs", +] + +[features] +alloc = [] +std = ["alloc"] +wasm-bindgen-0-2 = [ + "wasm-bindgen", + "std", +] + +[target."cfg(target_family = \"wasm\")".dependencies.wasm-bindgen] +version = "0.2.87" +features = ["std"] +optional = true +default-features = false diff --git a/third_party/rust/raw-window-handle/LICENSE-APACHE.md b/third_party/rust/raw-window-handle/LICENSE-APACHE.md new file mode 100644 index 0000000000..ade750b16b --- /dev/null +++ b/third_party/rust/raw-window-handle/LICENSE-APACHE.md @@ -0,0 +1,177 @@ +
+ 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
diff --git a/third_party/rust/raw-window-handle/LICENSE-MIT.md b/third_party/rust/raw-window-handle/LICENSE-MIT.md new file mode 100644 index 0000000000..a5c5627c11 --- /dev/null +++ b/third_party/rust/raw-window-handle/LICENSE-MIT.md @@ -0,0 +1,21 @@ +MIT License
+
+Copyright (c) 2019 Osspial
+
+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/third_party/rust/raw-window-handle/LICENSE-ZLIB.md b/third_party/rust/raw-window-handle/LICENSE-ZLIB.md new file mode 100644 index 0000000000..9df657b2dc --- /dev/null +++ b/third_party/rust/raw-window-handle/LICENSE-ZLIB.md @@ -0,0 +1,11 @@ +Copyright (c) 2020 Osspial
+
+This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+
+3. This notice may not be removed or altered from any source distribution.
diff --git a/third_party/rust/raw-window-handle/README.md b/third_party/rust/raw-window-handle/README.md new file mode 100644 index 0000000000..6e29b069d1 --- /dev/null +++ b/third_party/rust/raw-window-handle/README.md @@ -0,0 +1,11 @@ +# `raw-window-handle`: A common windowing interoperability library for Rust
+
+[](https://crates.io/crates/raw-window-handle)
+[](https://docs.rs/raw-window-handle)
+[](https://github.com/rust-windowing/raw-window-handle/actions)
+
+This library provides standard types for accessing a window's platform-specific
+raw window handle and display's platform-specific raw display handle. This does
+not provide any utilities for creating and managing windows; instead, it
+provides a common interface that window creation libraries (e.g. Winit, SDL)
+can use to easily talk with graphics libraries (e.g. gfx-hal).
diff --git a/third_party/rust/raw-window-handle/rustfmt.toml b/third_party/rust/raw-window-handle/rustfmt.toml new file mode 100644 index 0000000000..201baff6f6 --- /dev/null +++ b/third_party/rust/raw-window-handle/rustfmt.toml @@ -0,0 +1 @@ +use_field_init_shorthand=true
diff --git a/third_party/rust/raw-window-handle/src/android.rs b/third_party/rust/raw-window-handle/src/android.rs new file mode 100644 index 0000000000..4987c0017c --- /dev/null +++ b/third_party/rust/raw-window-handle/src/android.rs @@ -0,0 +1,50 @@ +use core::ffi::c_void;
+use core::ptr::NonNull;
+
+/// Raw display handle for Android.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct AndroidDisplayHandle {}
+
+impl AndroidDisplayHandle {
+ /// Create a new empty display handle.
+ ///
+ ///
+ /// # Example
+ ///
+ /// ```
+ /// # use raw_window_handle::AndroidDisplayHandle;
+ /// let handle = AndroidDisplayHandle::new();
+ /// ```
+ pub fn new() -> Self {
+ Self {}
+ }
+}
+
+/// Raw window handle for Android NDK.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct AndroidNdkWindowHandle {
+ /// A pointer to an `ANativeWindow`.
+ pub a_native_window: NonNull<c_void>,
+}
+
+impl AndroidNdkWindowHandle {
+ /// Create a new handle to an `ANativeWindow`.
+ ///
+ ///
+ /// # Example
+ ///
+ /// ```
+ /// # use core::ptr::NonNull;
+ /// # use raw_window_handle::AndroidNdkWindowHandle;
+ /// # type ANativeWindow = ();
+ /// #
+ /// let ptr: NonNull<ANativeWindow>;
+ /// # ptr = NonNull::from(&());
+ /// let handle = AndroidNdkWindowHandle::new(ptr.cast());
+ /// ```
+ pub fn new(a_native_window: NonNull<c_void>) -> Self {
+ Self { a_native_window }
+ }
+}
diff --git a/third_party/rust/raw-window-handle/src/appkit.rs b/third_party/rust/raw-window-handle/src/appkit.rs new file mode 100644 index 0000000000..974afe0421 --- /dev/null +++ b/third_party/rust/raw-window-handle/src/appkit.rs @@ -0,0 +1,50 @@ +use core::ffi::c_void;
+use core::ptr::NonNull;
+
+/// Raw display handle for AppKit.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct AppKitDisplayHandle {}
+
+impl AppKitDisplayHandle {
+ /// Create a new empty display handle.
+ ///
+ ///
+ /// # Example
+ ///
+ /// ```
+ /// # use raw_window_handle::AppKitDisplayHandle;
+ /// let handle = AppKitDisplayHandle::new();
+ /// ```
+ pub fn new() -> Self {
+ Self {}
+ }
+}
+
+/// Raw window handle for AppKit.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct AppKitWindowHandle {
+ /// A pointer to an `NSView` object.
+ pub ns_view: NonNull<c_void>,
+}
+
+impl AppKitWindowHandle {
+ /// Create a new handle to a view.
+ ///
+ ///
+ /// # Example
+ ///
+ /// ```
+ /// # use core::ptr::NonNull;
+ /// # use raw_window_handle::AppKitWindowHandle;
+ /// # type NSView = ();
+ /// #
+ /// let view: &NSView;
+ /// # view = &();
+ /// let handle = AppKitWindowHandle::new(NonNull::from(view).cast());
+ /// ```
+ pub fn new(ns_view: NonNull<c_void>) -> Self {
+ Self { ns_view }
+ }
+}
diff --git a/third_party/rust/raw-window-handle/src/borrowed.rs b/third_party/rust/raw-window-handle/src/borrowed.rs new file mode 100644 index 0000000000..8b9697bb60 --- /dev/null +++ b/third_party/rust/raw-window-handle/src/borrowed.rs @@ -0,0 +1,290 @@ +//! Borrowable window handles based on the ones in this crate.
+//!
+//! These should be 100% safe to pass around and use, no possibility of dangling or invalidity.
+
+use core::borrow::Borrow;
+use core::fmt;
+use core::marker::PhantomData;
+
+use crate::{HandleError, RawDisplayHandle, RawWindowHandle};
+
+/// A display that acts as a wrapper around a display handle.
+///
+/// Objects that implement this trait should be able to return a [`DisplayHandle`] for the display
+/// that they are associated with. This handle should last for the lifetime of the object, and should
+/// return an error if the application is inactive.
+///
+/// Implementors of this trait will be windowing systems, like [`winit`] and [`sdl2`]. These windowing
+/// systems should implement this trait on types that represent the top-level display server. It
+/// should be implemented by tying the lifetime of the [`DisplayHandle`] to the lifetime of the
+/// display object.
+///
+/// Users of this trait will include graphics libraries, like [`wgpu`] and [`glutin`]. These APIs
+/// should be generic over a type that implements `HasDisplayHandle`, and should use the
+/// [`DisplayHandle`] type to access the display handle.
+///
+/// Note that these requirements are not enforced on `HasDisplayHandle`, rather, they are enforced on the
+/// constructors of [`DisplayHandle`]. This is because the `HasDisplayHandle` trait is safe to implement.
+///
+/// [`winit`]: https://crates.io/crates/winit
+/// [`sdl2`]: https://crates.io/crates/sdl2
+/// [`wgpu`]: https://crates.io/crates/wgpu
+/// [`glutin`]: https://crates.io/crates/glutin
+pub trait HasDisplayHandle {
+ /// Get a handle to the display controller of the windowing system.
+ fn display_handle(&self) -> Result<DisplayHandle<'_>, HandleError>;
+}
+
+impl<H: HasDisplayHandle + ?Sized> HasDisplayHandle for &H {
+ fn display_handle(&self) -> Result<DisplayHandle<'_>, HandleError> {
+ (**self).display_handle()
+ }
+}
+
+impl<H: HasDisplayHandle + ?Sized> HasDisplayHandle for &mut H {
+ fn display_handle(&self) -> Result<DisplayHandle<'_>, HandleError> {
+ (**self).display_handle()
+ }
+}
+
+#[cfg(feature = "alloc")]
+#[cfg_attr(docsrs, doc(cfg(feature = "alloc")))]
+impl<H: HasDisplayHandle + ?Sized> HasDisplayHandle for alloc::boxed::Box<H> {
+ fn display_handle(&self) -> Result<DisplayHandle<'_>, HandleError> {
+ (**self).display_handle()
+ }
+}
+
+#[cfg(feature = "alloc")]
+#[cfg_attr(docsrs, doc(cfg(feature = "alloc")))]
+impl<H: HasDisplayHandle + ?Sized> HasDisplayHandle for alloc::rc::Rc<H> {
+ fn display_handle(&self) -> Result<DisplayHandle<'_>, HandleError> {
+ (**self).display_handle()
+ }
+}
+
+#[cfg(feature = "alloc")]
+#[cfg_attr(docsrs, doc(cfg(feature = "alloc")))]
+impl<H: HasDisplayHandle + ?Sized> HasDisplayHandle for alloc::sync::Arc<H> {
+ fn display_handle(&self) -> Result<DisplayHandle<'_>, HandleError> {
+ (**self).display_handle()
+ }
+}
+
+/// The handle to the display controller of the windowing system.
+///
+/// This is the primary return type of the [`HasDisplayHandle`] trait. It is guaranteed to contain
+/// a valid platform-specific display handle for its lifetime.
+#[repr(transparent)]
+#[derive(PartialEq, Eq, Hash, Copy, Clone)]
+pub struct DisplayHandle<'a> {
+ raw: RawDisplayHandle,
+ _marker: PhantomData<&'a *const ()>,
+}
+
+impl fmt::Debug for DisplayHandle<'_> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ f.debug_tuple("DisplayHandle").field(&self.raw).finish()
+ }
+}
+
+impl<'a> DisplayHandle<'a> {
+ /// Create a `DisplayHandle` from a [`RawDisplayHandle`].
+ ///
+ /// # Safety
+ ///
+ /// Users can safely assume that non-`null`/`0` fields are valid handles, and it is up to the
+ /// implementer of this trait to ensure that condition is upheld.
+ ///
+ /// Despite that qualification, implementors should still make a best-effort attempt to fill in all
+ /// available fields. If an implementation doesn't, and a downstream user needs the field, it should
+ /// try to derive the field from other fields the implementer *does* provide via whatever methods the
+ /// platform provides.
+ ///
+ /// It is not possible to invalidate a [`DisplayHandle`] on any platform without additional unsafe code.
+ pub unsafe fn borrow_raw(raw: RawDisplayHandle) -> Self {
+ Self {
+ raw,
+ _marker: PhantomData,
+ }
+ }
+
+ /// Get the underlying raw display handle.
+ pub fn as_raw(&self) -> RawDisplayHandle {
+ self.raw
+ }
+}
+
+impl AsRef<RawDisplayHandle> for DisplayHandle<'_> {
+ fn as_ref(&self) -> &RawDisplayHandle {
+ &self.raw
+ }
+}
+
+impl Borrow<RawDisplayHandle> for DisplayHandle<'_> {
+ fn borrow(&self) -> &RawDisplayHandle {
+ &self.raw
+ }
+}
+
+impl From<DisplayHandle<'_>> for RawDisplayHandle {
+ fn from(handle: DisplayHandle<'_>) -> Self {
+ handle.raw
+ }
+}
+
+impl<'a> HasDisplayHandle for DisplayHandle<'a> {
+ fn display_handle(&self) -> Result<DisplayHandle<'_>, HandleError> {
+ Ok(*self)
+ }
+}
+
+/// A handle to a window.
+///
+/// Objects that implement this trait should be able to return a [`WindowHandle`] for the window
+/// that they are associated with. This handle should last for the lifetime of the object, and should
+/// return an error if the application is inactive.
+///
+/// Implementors of this trait will be windowing systems, like [`winit`] and [`sdl2`]. These windowing
+/// systems should implement this trait on types that represent windows.
+///
+/// Users of this trait will include graphics libraries, like [`wgpu`] and [`glutin`]. These APIs
+/// should be generic over a type that implements `HasWindowHandle`, and should use the
+/// [`WindowHandle`] type to access the window handle. The window handle should be acquired and held
+/// while the window is being used, in order to ensure that the window is not deleted while it is in
+/// use.
+///
+/// [`winit`]: https://crates.io/crates/winit
+/// [`sdl2`]: https://crates.io/crates/sdl2
+/// [`wgpu`]: https://crates.io/crates/wgpu
+/// [`glutin`]: https://crates.io/crates/glutin
+pub trait HasWindowHandle {
+ /// Get a handle to the window.
+ fn window_handle(&self) -> Result<WindowHandle<'_>, HandleError>;
+}
+
+impl<H: HasWindowHandle + ?Sized> HasWindowHandle for &H {
+ fn window_handle(&self) -> Result<WindowHandle<'_>, HandleError> {
+ (**self).window_handle()
+ }
+}
+
+impl<H: HasWindowHandle + ?Sized> HasWindowHandle for &mut H {
+ fn window_handle(&self) -> Result<WindowHandle<'_>, HandleError> {
+ (**self).window_handle()
+ }
+}
+
+#[cfg(feature = "alloc")]
+#[cfg_attr(docsrs, doc(cfg(feature = "alloc")))]
+impl<H: HasWindowHandle + ?Sized> HasWindowHandle for alloc::boxed::Box<H> {
+ fn window_handle(&self) -> Result<WindowHandle<'_>, HandleError> {
+ (**self).window_handle()
+ }
+}
+
+#[cfg(feature = "alloc")]
+#[cfg_attr(docsrs, doc(cfg(feature = "alloc")))]
+impl<H: HasWindowHandle + ?Sized> HasWindowHandle for alloc::rc::Rc<H> {
+ fn window_handle(&self) -> Result<WindowHandle<'_>, HandleError> {
+ (**self).window_handle()
+ }
+}
+
+#[cfg(feature = "alloc")]
+#[cfg_attr(docsrs, doc(cfg(feature = "alloc")))]
+impl<H: HasWindowHandle + ?Sized> HasWindowHandle for alloc::sync::Arc<H> {
+ fn window_handle(&self) -> Result<WindowHandle<'_>, HandleError> {
+ (**self).window_handle()
+ }
+}
+
+/// The handle to a window.
+///
+/// This is the primary return type of the [`HasWindowHandle`] trait. All *pointers* within this type
+/// are guaranteed to be valid and not dangling for the lifetime of the handle. This excludes window IDs
+/// like XIDs and the window ID for web platforms. See the documentation on the [`HasWindowHandle`]
+/// trait for more information about these safety requirements.
+///
+/// This handle is guaranteed to be safe and valid.
+#[derive(PartialEq, Eq, Hash, Copy, Clone)]
+pub struct WindowHandle<'a> {
+ raw: RawWindowHandle,
+ _marker: PhantomData<&'a *const ()>,
+}
+
+impl fmt::Debug for WindowHandle<'_> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ f.debug_tuple("WindowHandle").field(&self.raw).finish()
+ }
+}
+
+impl<'a> WindowHandle<'a> {
+ /// Borrow a `WindowHandle` from a [`RawWindowHandle`].
+ ///
+ /// # Safety
+ ///
+ /// Users can safely assume that non-`null`/`0` fields are valid handles, and it is up to the
+ /// implementer of this trait to ensure that condition is upheld.
+ ///
+ /// Despite that qualification, implementers should still make a best-effort attempt to fill in all
+ /// available fields. If an implementation doesn't, and a downstream user needs the field, it should
+ /// try to derive the field from other fields the implementer *does* provide via whatever methods the
+ /// platform provides.
+ ///
+ /// Note that this guarantee only applies to *pointers*, and not any window ID types in the handle.
+ /// This includes Window IDs (XIDs) from X11 and the window ID for web platforms. There is no way for
+ /// Rust to enforce any kind of invariant on these types, since:
+ ///
+ /// - For all three listed platforms, it is possible for safe code in the same process to delete
+ /// the window.
+ /// - For X11, it is possible for code in a different process to delete the window. In fact, it is
+ /// possible for code on a different *machine* to delete the window.
+ ///
+ /// It is *also* possible for the window to be replaced with another, valid-but-different window. User
+ /// code should be aware of this possibility, and should be ready to soundly handle the possible error
+ /// conditions that can arise from this.
+ pub unsafe fn borrow_raw(raw: RawWindowHandle) -> Self {
+ Self {
+ raw,
+ _marker: PhantomData,
+ }
+ }
+
+ /// Get the underlying raw window handle.
+ pub fn as_raw(&self) -> RawWindowHandle {
+ self.raw.clone()
+ }
+}
+
+impl AsRef<RawWindowHandle> for WindowHandle<'_> {
+ fn as_ref(&self) -> &RawWindowHandle {
+ &self.raw
+ }
+}
+
+impl Borrow<RawWindowHandle> for WindowHandle<'_> {
+ fn borrow(&self) -> &RawWindowHandle {
+ &self.raw
+ }
+}
+
+impl From<WindowHandle<'_>> for RawWindowHandle {
+ fn from(handle: WindowHandle<'_>) -> Self {
+ handle.raw
+ }
+}
+
+impl HasWindowHandle for WindowHandle<'_> {
+ fn window_handle(&self) -> Result<Self, HandleError> {
+ Ok(*self)
+ }
+}
+
+/// ```compile_fail
+/// use raw_window_handle::{DisplayHandle, WindowHandle};
+/// fn _assert<T: Send + Sync>() {}
+/// _assert::<DisplayHandle<'static>>();
+/// _assert::<WindowHandle<'static>>();
+/// ```
+fn _not_send_or_sync() {}
diff --git a/third_party/rust/raw-window-handle/src/haiku.rs b/third_party/rust/raw-window-handle/src/haiku.rs new file mode 100644 index 0000000000..98a56e0e53 --- /dev/null +++ b/third_party/rust/raw-window-handle/src/haiku.rs @@ -0,0 +1,57 @@ +use core::ffi::c_void;
+use core::ptr::NonNull;
+
+/// Raw display handle for Haiku.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct HaikuDisplayHandle {}
+
+impl HaikuDisplayHandle {
+ /// Create a new empty display handle.
+ ///
+ ///
+ /// # Example
+ ///
+ /// ```
+ /// # use raw_window_handle::HaikuDisplayHandle;
+ /// let handle = HaikuDisplayHandle::new();
+ /// ```
+ pub fn new() -> Self {
+ Self {}
+ }
+}
+
+/// Raw window handle for Haiku.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct HaikuWindowHandle {
+ /// A pointer to a BWindow object
+ pub b_window: NonNull<c_void>,
+ /// A pointer to a BDirectWindow object that might be null
+ pub b_direct_window: Option<NonNull<c_void>>,
+}
+
+impl HaikuWindowHandle {
+ /// Create a new handle to a window.
+ ///
+ ///
+ /// # Example
+ ///
+ /// ```
+ /// # use core::ptr::NonNull;
+ /// # use raw_window_handle::HaikuWindowHandle;
+ /// # type BWindow = ();
+ /// #
+ /// let b_window: NonNull<BWindow>;
+ /// # b_window = NonNull::from(&());
+ /// let mut handle = HaikuWindowHandle::new(b_window.cast());
+ /// // Optionally set `b_direct_window`.
+ /// handle.b_direct_window = None;
+ /// ```
+ pub fn new(b_window: NonNull<c_void>) -> Self {
+ Self {
+ b_window,
+ b_direct_window: None,
+ }
+ }
+}
diff --git a/third_party/rust/raw-window-handle/src/lib.rs b/third_party/rust/raw-window-handle/src/lib.rs new file mode 100644 index 0000000000..2fa35f971b --- /dev/null +++ b/third_party/rust/raw-window-handle/src/lib.rs @@ -0,0 +1,422 @@ +#![no_std]
+#![cfg_attr(docsrs, feature(doc_cfg))]
+#![allow(clippy::new_without_default)]
+#![deny(unsafe_op_in_unsafe_fn)]
+
+//! Interoperability library for Rust Windowing applications.
+//!
+//! This library provides standard types for accessing a window's platform-specific raw window
+//! handle and platforms display handle. This does not provide any utilities for creating and
+//! managing windows; instead, it provides a common interface that window creation libraries (e.g.
+//! Winit, SDL) can use to easily talk with graphics libraries (e.g. gfx-hal).
+//!
+//! ## Safety guarantees
+//!
+//! Please see the docs of [`HasWindowHandle`] and [`HasDisplayHandle`].
+//!
+//! ## Platform handle initialization
+//!
+//! Each platform handle struct is purposefully non-exhaustive, so that additional fields may be
+//! added without breaking backwards compatibility. Each struct provides an `empty` method that may
+//! be used along with the struct update syntax to construct it. See each specific struct for
+//! examples.
+//!
+//! ## Display Handles
+//!
+//! Some windowing systems use a separate display handle for some operations. The display usually
+//! represents a connection to some display server, but it is not necessarily tied to a particular
+//! window. See [`RawDisplayHandle`] for more details.
+
+#[cfg(feature = "alloc")]
+extern crate alloc;
+
+#[cfg(feature = "std")]
+extern crate std;
+
+mod android;
+mod appkit;
+mod borrowed;
+mod haiku;
+mod redox;
+mod uikit;
+mod unix;
+mod web;
+mod windows;
+
+pub use android::{AndroidDisplayHandle, AndroidNdkWindowHandle};
+pub use appkit::{AppKitDisplayHandle, AppKitWindowHandle};
+pub use borrowed::{DisplayHandle, HasDisplayHandle, HasWindowHandle, WindowHandle};
+pub use haiku::{HaikuDisplayHandle, HaikuWindowHandle};
+pub use redox::{OrbitalDisplayHandle, OrbitalWindowHandle};
+pub use uikit::{UiKitDisplayHandle, UiKitWindowHandle};
+pub use unix::{
+ DrmDisplayHandle, DrmWindowHandle, GbmDisplayHandle, GbmWindowHandle, WaylandDisplayHandle,
+ WaylandWindowHandle, XcbDisplayHandle, XcbWindowHandle, XlibDisplayHandle, XlibWindowHandle,
+};
+pub use web::{
+ WebCanvasWindowHandle, WebDisplayHandle, WebOffscreenCanvasWindowHandle, WebWindowHandle,
+};
+pub use windows::{Win32WindowHandle, WinRtWindowHandle, WindowsDisplayHandle};
+
+use core::fmt;
+
+/// Window that wraps around a raw window handle.
+///
+/// # Safety
+///
+/// Users can safely assume that pointers and non-zero fields are valid, and it is up to the
+/// implementer of this trait to ensure that condition is upheld.
+///
+/// Despite that qualification, implementers should still make a best-effort attempt to fill in all
+/// available fields. If an implementation doesn't, and a downstream user needs the field, it should
+/// try to derive the field from other fields the implementer *does* provide via whatever methods the
+/// platform provides.
+///
+/// The exact handles returned by `raw_window_handle` must remain consistent between multiple calls
+/// to `raw_window_handle` as long as not indicated otherwise by platform specific events.
+#[deprecated = "Use `HasWindowHandle` instead"]
+pub unsafe trait HasRawWindowHandle {
+ fn raw_window_handle(&self) -> Result<RawWindowHandle, HandleError>;
+}
+
+#[allow(deprecated)]
+unsafe impl<T: HasWindowHandle + ?Sized> HasRawWindowHandle for T {
+ fn raw_window_handle(&self) -> Result<RawWindowHandle, HandleError> {
+ self.window_handle().map(Into::into)
+ }
+}
+
+/// A window handle for a particular windowing system.
+///
+/// Each variant contains a struct with fields specific to that windowing system
+/// (e.g. [`Win32WindowHandle`] will include a [HWND], [`WaylandWindowHandle`] uses [wl_surface],
+/// etc.)
+///
+/// [HWND]: https://learn.microsoft.com/en-us/windows/win32/winmsg/about-windows#window-handle
+/// [wl_surface]: https://wayland.freedesktop.org/docs/html/apa.html#protocol-spec-wl_surface
+///
+/// # Variant Availability
+///
+/// Note that all variants are present on all targets (none are disabled behind
+/// `#[cfg]`s), but see the "Availability Hints" section on each variant for
+/// some hints on where this variant might be expected.
+///
+/// Note that these "Availability Hints" are not normative. That is to say, a
+/// [`HasWindowHandle`] implementor is completely allowed to return something
+/// unexpected. (For example, it's legal for someone to return a
+/// [`RawWindowHandle::Xlib`] on macOS, it would just be weird, and probably
+/// requires something like XQuartz be used).
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum RawWindowHandle {
+ /// A raw window handle for UIKit (Apple's non-macOS windowing library).
+ ///
+ /// ## Availability Hints
+ /// This variant is likely to be used on iOS, tvOS, (in theory) watchOS, and
+ /// Mac Catalyst (`$arch-apple-ios-macabi` targets, which can notably use
+ /// UIKit *or* AppKit), as these are the targets that (currently) support
+ /// UIKit.
+ UiKit(UiKitWindowHandle),
+ /// A raw window handle for AppKit.
+ ///
+ /// ## Availability Hints
+ /// This variant is likely to be used on macOS, although Mac Catalyst
+ /// (`$arch-apple-ios-macabi` targets, which can notably use UIKit *or*
+ /// AppKit) can also use it despite being `target_os = "ios"`.
+ AppKit(AppKitWindowHandle),
+ /// A raw window handle for the Redox operating system.
+ ///
+ /// ## Availability Hints
+ /// This variant is used by the Orbital Windowing System in the Redox
+ /// operating system.
+ Orbital(OrbitalWindowHandle),
+ /// A raw window handle for Xlib.
+ ///
+ /// ## Availability Hints
+ /// This variant is likely to show up anywhere someone manages to get X11
+ /// working that Xlib can be built for, which is to say, most (but not all)
+ /// Unix systems.
+ Xlib(XlibWindowHandle),
+ /// A raw window handle for Xcb.
+ ///
+ /// ## Availability Hints
+ /// This variant is likely to show up anywhere someone manages to get X11
+ /// working that XCB can be built for, which is to say, most (but not all)
+ /// Unix systems.
+ Xcb(XcbWindowHandle),
+ /// A raw window handle for Wayland.
+ ///
+ /// ## Availability Hints
+ /// This variant should be expected anywhere Wayland works, which is
+ /// currently some subset of unix systems.
+ Wayland(WaylandWindowHandle),
+ /// A raw window handle for the Linux Kernel Mode Set/Direct Rendering Manager
+ ///
+ /// ## Availability Hints
+ /// This variant is used on Linux when neither X nor Wayland are available
+ Drm(DrmWindowHandle),
+ /// A raw window handle for the Linux Generic Buffer Manager.
+ ///
+ /// ## Availability Hints
+ /// This variant is present regardless of windowing backend and likely to be used with
+ /// EGL_MESA_platfrom_gbm or EGL_KHR_platfrom_gbm.
+ Gbm(GbmWindowHandle),
+ /// A raw window handle for Win32.
+ ///
+ /// ## Availability Hints
+ /// This variant is used on Windows systems.
+ Win32(Win32WindowHandle),
+ /// A raw window handle for WinRT.
+ ///
+ /// ## Availability Hints
+ /// This variant is used on Windows systems.
+ WinRt(WinRtWindowHandle),
+ /// A raw window handle for the Web.
+ ///
+ /// ## Availability Hints
+ /// This variant is used on Wasm or asm.js targets when targeting the Web/HTML5.
+ Web(WebWindowHandle),
+ /// A raw window handle for a Web canvas registered via [`wasm-bindgen`].
+ ///
+ /// ## Availability Hints
+ /// This variant is used on Wasm or asm.js targets when targeting the Web/HTML5.
+ ///
+ /// [`wasm-bindgen`]: https://crates.io/crates/wasm-bindgen
+ WebCanvas(WebCanvasWindowHandle),
+ /// A raw window handle for a Web offscreen canvas registered via [`wasm-bindgen`].
+ ///
+ /// ## Availability Hints
+ /// This variant is used on Wasm or asm.js targets when targeting the Web/HTML5.
+ ///
+ /// [`wasm-bindgen`]: https://crates.io/crates/wasm-bindgen
+ WebOffscreenCanvas(WebOffscreenCanvasWindowHandle),
+ /// A raw window handle for Android NDK.
+ ///
+ /// ## Availability Hints
+ /// This variant is used on Android targets.
+ AndroidNdk(AndroidNdkWindowHandle),
+ /// A raw window handle for Haiku.
+ ///
+ /// ## Availability Hints
+ /// This variant is used on HaikuOS.
+ Haiku(HaikuWindowHandle),
+}
+
+/// Display that wraps around a raw display handle.
+///
+/// # Safety
+///
+/// Users can safely assume that pointers and non-zero fields are valid, and it is up to the
+/// implementer of this trait to ensure that condition is upheld.
+///
+/// Despite that qualification, implementers should still make a best-effort attempt to fill in all
+/// available fields. If an implementation doesn't, and a downstream user needs the field, it should
+/// try to derive the field from other fields the implementer *does* provide via whatever methods the
+/// platform provides.
+///
+/// The exact handles returned by `raw_display_handle` must remain consistent between multiple calls
+/// to `raw_display_handle` as long as not indicated otherwise by platform specific events.
+#[deprecated = "Use `HasDisplayHandle` instead"]
+pub unsafe trait HasRawDisplayHandle {
+ fn raw_display_handle(&self) -> Result<RawDisplayHandle, HandleError>;
+}
+
+#[allow(deprecated)]
+unsafe impl<T: HasDisplayHandle + ?Sized> HasRawDisplayHandle for T {
+ fn raw_display_handle(&self) -> Result<RawDisplayHandle, HandleError> {
+ self.display_handle().map(Into::into)
+ }
+}
+
+/// A display server handle for a particular windowing system.
+///
+/// The display usually represents a connection to some display server, but it is not necessarily
+/// tied to a particular window. Some APIs can use the display handle without ever creating a window
+/// handle (e.g. offscreen rendering, headless event handling).
+///
+/// Each variant contains a struct with fields specific to that windowing system
+/// (e.g. [`XlibDisplayHandle`] contains a [Display] connection to an X Server,
+/// [`WaylandDisplayHandle`] uses [wl_display] to connect to a compositor). Not all windowing
+/// systems have a separate display handle (or they haven't been implemented yet) and their variants
+/// contain empty structs.
+///
+/// [Display]: https://www.x.org/releases/current/doc/libX11/libX11/libX11.html#Display_Functions
+/// [wl_display]: https://wayland.freedesktop.org/docs/html/apb.html#Client-classwl__display
+///
+/// # Variant Availability
+///
+/// Note that all variants are present on all targets (none are disabled behind
+/// `#[cfg]`s), but see the "Availability Hints" section on each variant for
+/// some hints on where this variant might be expected.
+///
+/// Note that these "Availability Hints" are not normative. That is to say, a
+/// [`HasDisplayHandle`] implementor is completely allowed to return something
+/// unexpected. (For example, it's legal for someone to return a
+/// [`RawDisplayHandle::Xlib`] on macOS, it would just be weird, and probably
+/// requires something like XQuartz be used).
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum RawDisplayHandle {
+ /// A raw display handle for UIKit (Apple's non-macOS windowing library).
+ ///
+ /// ## Availability Hints
+ /// This variant is likely to be used on iOS, tvOS, (in theory) watchOS, and
+ /// Mac Catalyst (`$arch-apple-ios-macabi` targets, which can notably use
+ /// UIKit *or* AppKit), as these are the targets that (currently) support
+ /// UIKit.
+ UiKit(UiKitDisplayHandle),
+ /// A raw display handle for AppKit.
+ ///
+ /// ## Availability Hints
+ /// This variant is likely to be used on macOS, although Mac Catalyst
+ /// (`$arch-apple-ios-macabi` targets, which can notably use UIKit *or*
+ /// AppKit) can also use it despite being `target_os = "ios"`.
+ AppKit(AppKitDisplayHandle),
+ /// A raw display handle for the Redox operating system.
+ ///
+ /// ## Availability Hints
+ /// This variant is used by the Orbital Windowing System in the Redox
+ /// operating system.
+ Orbital(OrbitalDisplayHandle),
+ /// A raw display handle for Xlib.
+ ///
+ /// ## Availability Hints
+ /// This variant is likely to show up anywhere someone manages to get X11
+ /// working that Xlib can be built for, which is to say, most (but not all)
+ /// Unix systems.
+ Xlib(XlibDisplayHandle),
+ /// A raw display handle for Xcb.
+ ///
+ /// ## Availability Hints
+ /// This variant is likely to show up anywhere someone manages to get X11
+ /// working that XCB can be built for, which is to say, most (but not all)
+ /// Unix systems.
+ Xcb(XcbDisplayHandle),
+ /// A raw display handle for Wayland.
+ ///
+ /// ## Availability Hints
+ /// This variant should be expected anywhere Wayland works, which is
+ /// currently some subset of unix systems.
+ Wayland(WaylandDisplayHandle),
+ /// A raw display handle for the Linux Kernel Mode Set/Direct Rendering Manager
+ ///
+ /// ## Availability Hints
+ /// This variant is used on Linux when neither X nor Wayland are available
+ Drm(DrmDisplayHandle),
+ /// A raw display handle for the Linux Generic Buffer Manager.
+ ///
+ /// ## Availability Hints
+ /// This variant is present regardless of windowing backend and likely to be used with
+ /// EGL_MESA_platform_gbm or EGL_KHR_platform_gbm.
+ Gbm(GbmDisplayHandle),
+ /// A raw display handle for Win32.
+ ///
+ /// ## Availability Hints
+ /// This variant is used on Windows systems.
+ Windows(WindowsDisplayHandle),
+ /// A raw display handle for the Web.
+ ///
+ /// ## Availability Hints
+ /// This variant is used on Wasm or asm.js targets when targeting the Web/HTML5.
+ Web(WebDisplayHandle),
+ /// A raw display handle for Android NDK.
+ ///
+ /// ## Availability Hints
+ /// This variant is used on Android targets.
+ Android(AndroidDisplayHandle),
+ /// A raw display handle for Haiku.
+ ///
+ /// ## Availability Hints
+ /// This variant is used on HaikuOS.
+ Haiku(HaikuDisplayHandle),
+}
+
+/// An error that can occur while fetching a display or window handle.
+#[derive(Debug, Clone)]
+#[non_exhaustive]
+pub enum HandleError {
+ /// The underlying handle cannot be represented using the types in this crate.
+ ///
+ /// This may be returned if the underlying window system does not support any of the
+ /// representative C window handles in this crate. For instance, if you were using a pure Rust
+ /// library to set up X11 (like [`x11rb`]), you would not be able to use any of the
+ /// [`RawWindowHandle`] variants, as they all represent C types.
+ ///
+ /// Another example would be a system that isn't supported by `raw-window-handle` yet,
+ /// like some game consoles.
+ ///
+ /// In the event that this error is returned, you should try to use the underlying window
+ /// system's native API to get the handle you need.
+ ///
+ /// [`x11rb`]: https://crates.io/crates/x11rb
+ NotSupported,
+
+ /// The underlying handle is not available.
+ ///
+ /// In some cases the underlying window handle may become temporarily unusable. For example, on
+ /// Android, the native window pointer can arbitrarily be replaced or removed by the system. In
+ /// this case, returning a window handle would be disingenuous, as it would not be usable. A
+ /// similar situation can occur on Wayland for the layer shell windows.
+ ///
+ /// In the event that this error is returned, you should wait until the handle becomes available
+ /// again.
+ Unavailable,
+}
+
+impl fmt::Display for HandleError {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ match self {
+ Self::NotSupported => write!(
+ f,
+ "the underlying handle cannot be represented using the types in this crate"
+ ),
+ Self::Unavailable => write!(f, "the underlying handle is not available"),
+ }
+ }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for HandleError {}
+
+macro_rules! from_impl {
+ ($($to:ident, $enum:ident, $from:ty)*) => ($(
+ impl From<$from> for $to {
+ fn from(value: $from) -> Self {
+ $to::$enum(value)
+ }
+ }
+ )*)
+}
+
+from_impl!(RawDisplayHandle, UiKit, UiKitDisplayHandle);
+from_impl!(RawDisplayHandle, AppKit, AppKitDisplayHandle);
+from_impl!(RawDisplayHandle, Orbital, OrbitalDisplayHandle);
+from_impl!(RawDisplayHandle, Xlib, XlibDisplayHandle);
+from_impl!(RawDisplayHandle, Xcb, XcbDisplayHandle);
+from_impl!(RawDisplayHandle, Wayland, WaylandDisplayHandle);
+from_impl!(RawDisplayHandle, Drm, DrmDisplayHandle);
+from_impl!(RawDisplayHandle, Gbm, GbmDisplayHandle);
+from_impl!(RawDisplayHandle, Windows, WindowsDisplayHandle);
+from_impl!(RawDisplayHandle, Web, WebDisplayHandle);
+from_impl!(RawDisplayHandle, Android, AndroidDisplayHandle);
+from_impl!(RawDisplayHandle, Haiku, HaikuDisplayHandle);
+
+from_impl!(RawWindowHandle, UiKit, UiKitWindowHandle);
+from_impl!(RawWindowHandle, AppKit, AppKitWindowHandle);
+from_impl!(RawWindowHandle, Orbital, OrbitalWindowHandle);
+from_impl!(RawWindowHandle, Xlib, XlibWindowHandle);
+from_impl!(RawWindowHandle, Xcb, XcbWindowHandle);
+from_impl!(RawWindowHandle, Wayland, WaylandWindowHandle);
+from_impl!(RawWindowHandle, Drm, DrmWindowHandle);
+from_impl!(RawWindowHandle, Gbm, GbmWindowHandle);
+from_impl!(RawWindowHandle, Win32, Win32WindowHandle);
+from_impl!(RawWindowHandle, WinRt, WinRtWindowHandle);
+from_impl!(RawWindowHandle, Web, WebWindowHandle);
+from_impl!(RawWindowHandle, WebCanvas, WebCanvasWindowHandle);
+from_impl!(
+ RawWindowHandle,
+ WebOffscreenCanvas,
+ WebOffscreenCanvasWindowHandle
+);
+from_impl!(RawWindowHandle, AndroidNdk, AndroidNdkWindowHandle);
+from_impl!(RawWindowHandle, Haiku, HaikuWindowHandle);
diff --git a/third_party/rust/raw-window-handle/src/redox.rs b/third_party/rust/raw-window-handle/src/redox.rs new file mode 100644 index 0000000000..d853cbb85f --- /dev/null +++ b/third_party/rust/raw-window-handle/src/redox.rs @@ -0,0 +1,52 @@ +use core::ffi::c_void;
+use core::ptr::NonNull;
+
+/// Raw display handle for the Redox operating system.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct OrbitalDisplayHandle {}
+
+impl OrbitalDisplayHandle {
+ /// Create a new empty display handle.
+ ///
+ ///
+ /// # Example
+ ///
+ /// ```
+ /// # use raw_window_handle::OrbitalDisplayHandle;
+ /// let handle = OrbitalDisplayHandle::new();
+ /// ```
+ pub fn new() -> Self {
+ Self {}
+ }
+}
+
+/// Raw window handle for the Redox operating system.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct OrbitalWindowHandle {
+ /// A pointer to an orbclient window.
+ // TODO(madsmtm): I think this is a file descriptor, so perhaps it should
+ // actually use `std::os::fd::RawFd`, or some sort of integer instead?
+ pub window: NonNull<c_void>,
+}
+
+impl OrbitalWindowHandle {
+ /// Create a new handle to a window.
+ ///
+ ///
+ /// # Example
+ ///
+ /// ```
+ /// # use core::ptr::NonNull;
+ /// # use raw_window_handle::OrbitalWindowHandle;
+ /// # type Window = ();
+ /// #
+ /// let window: NonNull<Window>;
+ /// # window = NonNull::from(&());
+ /// let mut handle = OrbitalWindowHandle::new(window.cast());
+ /// ```
+ pub fn new(window: NonNull<c_void>) -> Self {
+ Self { window }
+ }
+}
diff --git a/third_party/rust/raw-window-handle/src/uikit.rs b/third_party/rust/raw-window-handle/src/uikit.rs new file mode 100644 index 0000000000..25356f3f36 --- /dev/null +++ b/third_party/rust/raw-window-handle/src/uikit.rs @@ -0,0 +1,57 @@ +use core::ffi::c_void;
+use core::ptr::NonNull;
+
+/// Raw display handle for UIKit.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct UiKitDisplayHandle {}
+
+impl UiKitDisplayHandle {
+ /// Create a new empty display handle.
+ ///
+ ///
+ /// # Example
+ ///
+ /// ```
+ /// # use raw_window_handle::UiKitDisplayHandle;
+ /// let handle = UiKitDisplayHandle::new();
+ /// ```
+ pub fn new() -> Self {
+ Self {}
+ }
+}
+
+/// Raw window handle for UIKit.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct UiKitWindowHandle {
+ /// A pointer to an `UIView` object.
+ pub ui_view: NonNull<c_void>,
+ /// A pointer to an `UIViewController` object, if the view has one.
+ pub ui_view_controller: Option<NonNull<c_void>>,
+}
+
+impl UiKitWindowHandle {
+ /// Create a new handle to a view.
+ ///
+ ///
+ /// # Example
+ ///
+ /// ```
+ /// # use core::ptr::NonNull;
+ /// # use raw_window_handle::UiKitWindowHandle;
+ /// # type UIView = ();
+ /// #
+ /// let view: &UIView;
+ /// # view = &();
+ /// let mut handle = UiKitWindowHandle::new(NonNull::from(view).cast());
+ /// // Optionally set the view controller.
+ /// handle.ui_view_controller = None;
+ /// ```
+ pub fn new(ui_view: NonNull<c_void>) -> Self {
+ Self {
+ ui_view,
+ ui_view_controller: None,
+ }
+ }
+}
diff --git a/third_party/rust/raw-window-handle/src/unix.rs b/third_party/rust/raw-window-handle/src/unix.rs new file mode 100644 index 0000000000..259fed35b9 --- /dev/null +++ b/third_party/rust/raw-window-handle/src/unix.rs @@ -0,0 +1,316 @@ +use core::ffi::{c_int, c_ulong, c_void};
+use core::num::NonZeroU32;
+use core::ptr::NonNull;
+
+/// Raw display handle for Xlib.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct XlibDisplayHandle {
+ /// A pointer to an Xlib `Display`.
+ ///
+ /// It is strongly recommended to set this value, however it may be set to
+ /// `None` to request the default display when using EGL.
+ pub display: Option<NonNull<c_void>>,
+
+ /// An X11 screen to use with this display handle.
+ ///
+ /// Note, that X11 could have multiple screens, however
+ /// graphics APIs could work only with one screen at the time,
+ /// given that multiple screens usually reside on different GPUs.
+ pub screen: c_int,
+}
+
+impl XlibDisplayHandle {
+ /// Create a new handle to a display.
+ ///
+ ///
+ /// # Example
+ ///
+ /// ```
+ /// # use core::ffi::c_void;
+ /// # use core::ptr::NonNull;
+ /// # use raw_window_handle::XlibDisplayHandle;
+ /// #
+ /// let display: NonNull<c_void>;
+ /// let screen;
+ /// # display = NonNull::from(&()).cast();
+ /// # screen = 0;
+ /// let handle = XlibDisplayHandle::new(Some(display), screen);
+ /// ```
+ pub fn new(display: Option<NonNull<c_void>>, screen: c_int) -> Self {
+ Self { display, screen }
+ }
+}
+
+/// Raw window handle for Xlib.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct XlibWindowHandle {
+ /// An Xlib `Window`.
+ pub window: c_ulong,
+ /// An Xlib visual ID, or 0 if unknown.
+ pub visual_id: c_ulong,
+}
+
+impl XlibWindowHandle {
+ /// Create a new handle to a window.
+ ///
+ ///
+ /// # Example
+ ///
+ /// ```
+ /// # use core::ffi::c_ulong;
+ /// # use raw_window_handle::XlibWindowHandle;
+ /// #
+ /// let window: c_ulong;
+ /// # window = 0;
+ /// let mut handle = XlibWindowHandle::new(window);
+ /// // Optionally set the visual ID.
+ /// handle.visual_id = 0;
+ /// ```
+ pub fn new(window: c_ulong) -> Self {
+ Self {
+ window,
+ visual_id: 0,
+ }
+ }
+}
+
+/// Raw display handle for Xcb.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct XcbDisplayHandle {
+ /// A pointer to an X server `xcb_connection_t`.
+ ///
+ /// It is strongly recommended to set this value, however it may be set to
+ /// `None` to request the default display when using EGL.
+ pub connection: Option<NonNull<c_void>>,
+
+ /// An X11 screen to use with this display handle.
+ ///
+ /// Note, that X11 could have multiple screens, however
+ /// graphics APIs could work only with one screen at the time,
+ /// given that multiple screens usually reside on different GPUs.
+ pub screen: c_int,
+}
+
+impl XcbDisplayHandle {
+ /// Create a new handle to a connection and screen.
+ ///
+ ///
+ /// # Example
+ ///
+ /// ```
+ /// # use core::ffi::c_void;
+ /// # use core::ptr::NonNull;
+ /// # use raw_window_handle::XcbDisplayHandle;
+ /// #
+ /// let connection: NonNull<c_void>;
+ /// let screen;
+ /// # connection = NonNull::from(&()).cast();
+ /// # screen = 0;
+ /// let handle = XcbDisplayHandle::new(Some(connection), screen);
+ /// ```
+ pub fn new(connection: Option<NonNull<c_void>>, screen: c_int) -> Self {
+ Self { connection, screen }
+ }
+}
+
+/// Raw window handle for Xcb.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct XcbWindowHandle {
+ /// An X11 `xcb_window_t`.
+ pub window: NonZeroU32, // Based on xproto.h
+ /// An X11 `xcb_visualid_t`.
+ pub visual_id: Option<NonZeroU32>,
+}
+
+impl XcbWindowHandle {
+ /// Create a new handle to a window.
+ ///
+ ///
+ /// # Example
+ ///
+ /// ```
+ /// # use core::num::NonZeroU32;
+ /// # use raw_window_handle::XcbWindowHandle;
+ /// #
+ /// let window: NonZeroU32;
+ /// # window = NonZeroU32::new(1).unwrap();
+ /// let mut handle = XcbWindowHandle::new(window);
+ /// // Optionally set the visual ID.
+ /// handle.visual_id = None;
+ /// ```
+ pub fn new(window: NonZeroU32) -> Self {
+ Self {
+ window,
+ visual_id: None,
+ }
+ }
+}
+
+/// Raw display handle for Wayland.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct WaylandDisplayHandle {
+ /// A pointer to a `wl_display`.
+ pub display: NonNull<c_void>,
+}
+
+impl WaylandDisplayHandle {
+ /// Create a new display handle.
+ ///
+ ///
+ /// # Example
+ ///
+ /// ```
+ /// # use core::ffi::c_void;
+ /// # use core::ptr::NonNull;
+ /// # use raw_window_handle::WaylandDisplayHandle;
+ /// #
+ /// let display: NonNull<c_void>;
+ /// # display = NonNull::from(&()).cast();
+ /// let handle = WaylandDisplayHandle::new(display);
+ /// ```
+ pub fn new(display: NonNull<c_void>) -> Self {
+ Self { display }
+ }
+}
+
+/// Raw window handle for Wayland.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct WaylandWindowHandle {
+ /// A pointer to a `wl_surface`.
+ pub surface: NonNull<c_void>,
+}
+
+impl WaylandWindowHandle {
+ /// Create a new handle to a surface.
+ ///
+ ///
+ /// # Example
+ ///
+ /// ```
+ /// # use core::ffi::c_void;
+ /// # use core::ptr::NonNull;
+ /// # use raw_window_handle::WaylandWindowHandle;
+ /// #
+ /// let surface: NonNull<c_void>;
+ /// # surface = NonNull::from(&()).cast();
+ /// let handle = WaylandWindowHandle::new(surface);
+ /// ```
+ pub fn new(surface: NonNull<c_void>) -> Self {
+ Self { surface }
+ }
+}
+
+/// Raw display handle for the Linux Kernel Mode Set/Direct Rendering Manager.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct DrmDisplayHandle {
+ /// The drm file descriptor.
+ // TODO: Use `std::os::fd::RawFd`?
+ pub fd: i32,
+}
+
+impl DrmDisplayHandle {
+ /// Create a new handle to a file descriptor.
+ ///
+ ///
+ /// # Example
+ ///
+ /// ```
+ /// # use raw_window_handle::DrmDisplayHandle;
+ /// #
+ /// let fd: i32;
+ /// # fd = 0;
+ /// let handle = DrmDisplayHandle::new(fd);
+ /// ```
+ pub fn new(fd: i32) -> Self {
+ Self { fd }
+ }
+}
+
+/// Raw window handle for the Linux Kernel Mode Set/Direct Rendering Manager.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct DrmWindowHandle {
+ /// The primary drm plane handle.
+ pub plane: u32,
+}
+
+impl DrmWindowHandle {
+ /// Create a new handle to a plane.
+ ///
+ ///
+ /// # Example
+ ///
+ /// ```
+ /// # use raw_window_handle::DrmWindowHandle;
+ /// #
+ /// let plane: u32;
+ /// # plane = 0;
+ /// let handle = DrmWindowHandle::new(plane);
+ /// ```
+ pub fn new(plane: u32) -> Self {
+ Self { plane }
+ }
+}
+
+/// Raw display handle for the Linux Generic Buffer Manager.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct GbmDisplayHandle {
+ /// The gbm device.
+ pub gbm_device: NonNull<c_void>,
+}
+
+impl GbmDisplayHandle {
+ /// Create a new handle to a device.
+ ///
+ ///
+ /// # Example
+ ///
+ /// ```
+ /// # use core::ffi::c_void;
+ /// # use core::ptr::NonNull;
+ /// # use raw_window_handle::GbmDisplayHandle;
+ /// #
+ /// let ptr: NonNull<c_void>;
+ /// # ptr = NonNull::from(&()).cast();
+ /// let handle = GbmDisplayHandle::new(ptr);
+ /// ```
+ pub fn new(gbm_device: NonNull<c_void>) -> Self {
+ Self { gbm_device }
+ }
+}
+
+/// Raw window handle for the Linux Generic Buffer Manager.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct GbmWindowHandle {
+ /// The gbm surface.
+ pub gbm_surface: NonNull<c_void>,
+}
+
+impl GbmWindowHandle {
+ /// Create a new handle to a surface.
+ ///
+ ///
+ /// # Example
+ ///
+ /// ```
+ /// # use core::ffi::c_void;
+ /// # use core::ptr::NonNull;
+ /// # use raw_window_handle::GbmWindowHandle;
+ /// #
+ /// let ptr: NonNull<c_void>;
+ /// # ptr = NonNull::from(&()).cast();
+ /// let handle = GbmWindowHandle::new(ptr);
+ /// ```
+ pub fn new(gbm_surface: NonNull<c_void>) -> Self {
+ Self { gbm_surface }
+ }
+}
diff --git a/third_party/rust/raw-window-handle/src/web.rs b/third_party/rust/raw-window-handle/src/web.rs new file mode 100644 index 0000000000..cb4eaba072 --- /dev/null +++ b/third_party/rust/raw-window-handle/src/web.rs @@ -0,0 +1,197 @@ +use core::ffi::c_void;
+use core::ptr::NonNull;
+
+/// Raw display handle for the Web.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct WebDisplayHandle {}
+
+impl WebDisplayHandle {
+ /// Create a new empty display handle.
+ ///
+ ///
+ /// # Example
+ ///
+ /// ```
+ /// # use raw_window_handle::WebDisplayHandle;
+ /// let handle = WebDisplayHandle::new();
+ /// ```
+ pub fn new() -> Self {
+ Self {}
+ }
+}
+
+/// Raw window handle for the Web.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct WebWindowHandle {
+ /// An ID value inserted into the [data attributes] of the canvas element as '`raw-handle`'.
+ ///
+ /// When accessing from JS, the attribute will automatically be called `rawHandle`.
+ ///
+ /// Each canvas created by the windowing system should be assigned their own unique ID.
+ ///
+ /// [data attributes]: https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/data-*
+ pub id: u32,
+}
+
+impl WebWindowHandle {
+ /// Create a new handle to a canvas element.
+ ///
+ ///
+ /// # Example
+ ///
+ /// ```
+ /// # use raw_window_handle::WebWindowHandle;
+ /// #
+ /// let id: u32 = 0; // canvas.rawHandle;
+ /// let handle = WebWindowHandle::new(id);
+ /// ```
+ pub fn new(id: u32) -> Self {
+ Self { id }
+ }
+}
+
+/// Raw window handle for a Web canvas registered via [`wasm-bindgen`].
+///
+/// [`wasm-bindgen`]: https://crates.io/crates/wasm-bindgen
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct WebCanvasWindowHandle {
+ /// A pointer to the [`JsValue`] of an [`HtmlCanvasElement`].
+ ///
+ /// Note: This uses [`c_void`] to avoid depending on `wasm-bindgen`
+ /// directly.
+ ///
+ /// [`JsValue`]: https://docs.rs/wasm-bindgen/latest/wasm_bindgen/struct.JsValue.html
+ /// [`HtmlCanvasElement`]: https://docs.rs/web-sys/latest/web_sys/struct.HtmlCanvasElement.html
+ //
+ // SAFETY: Not using `JsValue` is sound because `wasm-bindgen` guarantees
+ // that there's only one version of itself in any given binary, and hence
+ // we can't have a type-confusion where e.g. one library used `JsValue`
+ // from `v0.2` of `wasm-bindgen`, and another used `JsValue` from `v1.0`;
+ // the binary will simply fail to compile!
+ //
+ // Reference: TODO
+ pub obj: NonNull<c_void>,
+}
+
+impl WebCanvasWindowHandle {
+ /// Create a new handle from a pointer to [`HtmlCanvasElement`].
+ ///
+ /// [`HtmlCanvasElement`]: https://docs.rs/web-sys/latest/web_sys/struct.HtmlCanvasElement.html
+ ///
+ /// # Example
+ ///
+ /// ```
+ /// # use core::ffi::c_void;
+ /// # use core::ptr::NonNull;
+ /// # use raw_window_handle::WebCanvasWindowHandle;
+ /// # type HtmlCanvasElement = ();
+ /// # type JsValue = ();
+ /// let canvas: &HtmlCanvasElement;
+ /// # canvas = &();
+ /// let value: &JsValue = &canvas; // Deref to `JsValue`
+ /// let obj: NonNull<c_void> = NonNull::from(value).cast();
+ /// let mut handle = WebCanvasWindowHandle::new(obj);
+ /// ```
+ pub fn new(obj: NonNull<c_void>) -> Self {
+ Self { obj }
+ }
+}
+
+#[cfg(all(target_family = "wasm", feature = "wasm-bindgen-0-2"))]
+#[cfg_attr(
+ docsrs,
+ doc(cfg(all(target_family = "wasm", feature = "wasm-bindgen-0-2")))
+)]
+/// These implementations are only available when `wasm-bindgen-0-2` is enabled.
+impl WebCanvasWindowHandle {
+ /// Create a new `WebCanvasWindowHandle` from a [`wasm_bindgen::JsValue`].
+ ///
+ /// The `JsValue` should refer to a `HtmlCanvasElement`, and the lifetime
+ /// of the value should be at least as long as the lifetime of this.
+ pub fn from_wasm_bindgen_0_2(js_value: &wasm_bindgen::JsValue) -> Self {
+ Self::new(NonNull::from(js_value).cast())
+ }
+
+ /// Convert to the underlying [`wasm_bindgen::JsValue`].
+ ///
+ /// # Safety
+ ///
+ /// The inner pointer must be valid. This is ensured if this handle was
+ /// borrowed from [`WindowHandle`][crate::WindowHandle].
+ pub unsafe fn as_wasm_bindgen_0_2(&self) -> &wasm_bindgen::JsValue {
+ unsafe { self.obj.cast().as_ref() }
+ }
+}
+
+/// Raw window handle for a Web offscreen canvas registered via
+/// [`wasm-bindgen`].
+///
+/// [`wasm-bindgen`]: https://crates.io/crates/wasm-bindgen
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct WebOffscreenCanvasWindowHandle {
+ /// A pointer to the [`JsValue`] of an [`OffscreenCanvas`].
+ ///
+ /// Note: This uses [`c_void`] to avoid depending on `wasm-bindgen`
+ /// directly.
+ ///
+ /// [`JsValue`]: https://docs.rs/wasm-bindgen/latest/wasm_bindgen/struct.JsValue.html
+ /// [`OffscreenCanvas`]: https://docs.rs/web-sys/latest/web_sys/struct.OffscreenCanvas.html
+ //
+ // SAFETY: See WebCanvasWindowHandle.
+ pub obj: NonNull<c_void>,
+}
+
+impl WebOffscreenCanvasWindowHandle {
+ /// Create a new handle from a pointer to an [`OffscreenCanvas`].
+ ///
+ /// [`OffscreenCanvas`]: https://docs.rs/web-sys/latest/web_sys/struct.OffscreenCanvas.html
+ ///
+ /// # Example
+ ///
+ /// ```
+ /// # use core::ffi::c_void;
+ /// # use core::ptr::NonNull;
+ /// # use raw_window_handle::WebOffscreenCanvasWindowHandle;
+ /// # type OffscreenCanvas = ();
+ /// # type JsValue = ();
+ /// let canvas: &OffscreenCanvas;
+ /// # canvas = &();
+ /// let value: &JsValue = &canvas; // Deref to `JsValue`
+ /// let obj: NonNull<c_void> = NonNull::from(value).cast();
+ /// let mut handle = WebOffscreenCanvasWindowHandle::new(obj);
+ /// ```
+ pub fn new(obj: NonNull<c_void>) -> Self {
+ Self { obj }
+ }
+}
+
+#[cfg(all(target_family = "wasm", feature = "wasm-bindgen-0-2"))]
+#[cfg_attr(
+ docsrs,
+ doc(cfg(all(target_family = "wasm", feature = "wasm-bindgen-0-2")))
+)]
+/// These implementations are only available when `wasm-bindgen-0-2` is enabled.
+impl WebOffscreenCanvasWindowHandle {
+ /// Create a new `WebOffscreenCanvasWindowHandle` from a
+ /// [`wasm_bindgen::JsValue`].
+ ///
+ /// The `JsValue` should refer to a `HtmlCanvasElement`, and the lifetime
+ /// of the value should be at least as long as the lifetime of this.
+ pub fn from_wasm_bindgen_0_2(js_value: &wasm_bindgen::JsValue) -> Self {
+ Self::new(NonNull::from(js_value).cast())
+ }
+
+ /// Convert to the underlying [`wasm_bindgen::JsValue`].
+ ///
+ /// # Safety
+ ///
+ /// The inner pointer must be valid. This is ensured if this handle was
+ /// borrowed from [`WindowHandle`][crate::WindowHandle].
+ pub unsafe fn as_wasm_bindgen_0_2(&self) -> &wasm_bindgen::JsValue {
+ unsafe { self.obj.cast().as_ref() }
+ }
+}
diff --git a/third_party/rust/raw-window-handle/src/windows.rs b/third_party/rust/raw-window-handle/src/windows.rs new file mode 100644 index 0000000000..f5ea8f22ff --- /dev/null +++ b/third_party/rust/raw-window-handle/src/windows.rs @@ -0,0 +1,91 @@ +use core::ffi::c_void;
+use core::num::NonZeroIsize;
+use core::ptr::NonNull;
+
+/// Raw display handle for Windows.
+///
+/// It can be used regardless of Windows window backend.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct WindowsDisplayHandle {}
+
+impl WindowsDisplayHandle {
+ /// Create a new empty display handle.
+ ///
+ ///
+ /// # Example
+ ///
+ /// ```
+ /// # use raw_window_handle::WindowsDisplayHandle;
+ /// let handle = WindowsDisplayHandle::new();
+ /// ```
+ pub fn new() -> Self {
+ Self {}
+ }
+}
+
+/// Raw window handle for Win32.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct Win32WindowHandle {
+ /// A Win32 `HWND` handle.
+ pub hwnd: NonZeroIsize,
+ /// The `GWLP_HINSTANCE` associated with this type's `HWND`.
+ pub hinstance: Option<NonZeroIsize>,
+}
+
+impl Win32WindowHandle {
+ /// Create a new handle to a window.
+ ///
+ ///
+ /// # Example
+ ///
+ /// ```
+ /// # use core::num::NonZeroIsize;
+ /// # use raw_window_handle::Win32WindowHandle;
+ /// # struct HWND(isize);
+ /// #
+ /// let window: HWND;
+ /// # window = HWND(1);
+ /// let mut handle = Win32WindowHandle::new(NonZeroIsize::new(window.0).unwrap());
+ /// // Optionally set the GWLP_HINSTANCE.
+ /// # #[cfg(only_for_showcase)]
+ /// let hinstance = NonZeroIsize::new(unsafe { GetWindowLongPtrW(window, GWLP_HINSTANCE) }).unwrap();
+ /// # let hinstance = None;
+ /// handle.hinstance = hinstance;
+ /// ```
+ pub fn new(hwnd: NonZeroIsize) -> Self {
+ Self {
+ hwnd,
+ hinstance: None,
+ }
+ }
+}
+
+/// Raw window handle for WinRT.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct WinRtWindowHandle {
+ /// A WinRT `CoreWindow` handle.
+ pub core_window: NonNull<c_void>,
+}
+
+impl WinRtWindowHandle {
+ /// Create a new handle to a window.
+ ///
+ ///
+ /// # Example
+ ///
+ /// ```
+ /// # use core::ptr::NonNull;
+ /// # use raw_window_handle::WinRtWindowHandle;
+ /// # type CoreWindow = ();
+ /// #
+ /// let window: NonNull<CoreWindow>;
+ /// # window = NonNull::from(&());
+ /// let handle = WinRtWindowHandle::new(window.cast());
+ /// ```
+ pub fn new(core_window: NonNull<c_void>) -> Self {
+ Self { core_window }
+ }
+}
|