#![doc = include_str!("../README.md")]
#![deny(missing_docs)]
#![allow(clippy::type_complexity)] #![allow(clippy::collapsible_else_if)] #![allow(unused_mut)]
extern crate self as wgpui;
#[macro_use]
mod action;
mod a11y;
mod app;
mod arena;
mod asset_cache;
mod assets;
mod bounds_tree;
mod color;
pub mod default_colors;
mod element;
mod elements;
mod executor;
mod gestures;
mod platform_scheduler;
pub(crate) use platform_scheduler::PlatformScheduler;
mod geometry;
mod global;
mod input;
mod inspector;
mod interactive;
mod key_dispatch;
mod keymap;
mod path_builder;
mod platform;
pub mod prelude;
pub mod profiler;
mod queue;
mod scene;
#[allow(missing_docs)]
pub mod scheduler;
mod shared_string;
mod shared_uri;
mod spring;
mod style;
mod styled;
mod subscription;
mod svg_renderer;
mod tab_stop;
mod taffy;
#[cfg(any(test, feature = "test-support"))]
pub mod test;
mod text_system;
mod util;
mod view;
mod window;
#[cfg(doc)]
pub mod _ownership_and_data_flow;
#[doc(hidden)]
pub mod private {
pub use anyhow;
#[cfg(feature = "bench-support")]
pub use criterion;
pub use ctor;
pub use inventory;
pub use schemars;
pub use serde;
pub use serde_json;
}
mod seal {
pub trait Sealed {}
}
pub use a11y::{A11yActionListener, A11ySubtreeBuilder, AriaProperties};
pub use accesskit;
pub use accesskit::Action as AccessibleAction;
pub use accesskit::{Orientation, Role, Toggled};
pub use action::*;
pub use anyhow::Result;
pub use app::*;
pub(crate) use arena::*;
pub use asset_cache::*;
pub use assets::*;
pub use color::*;
pub use default_colors::*;
pub use element::*;
pub use elements::*;
pub use executor::*;
pub use geometry::*;
pub use gestures::*;
pub use global::*;
pub use http_client;
pub use input::*;
pub use inspector::*;
pub use interactive::*;
use key_dispatch::*;
pub use keymap::*;
pub use path_builder::*;
pub use platform::*;
pub use profiler::*;
pub(crate) use queue::{PriorityQueueReceiver, PriorityQueueSender};
pub use refineable::*;
pub use scene::*;
pub use wgpui_derive::{AppContext, IntoElement, Render, VisualContext, register_action, test};
pub use wgpui_derive::{bench, ctor};
pub use scheduler::{Clock, Instant, RunnableMeta, Scheduler, SessionId, Timer};
#[cfg(any(test, feature = "test-support"))]
pub use scheduler::{SharedRng, TestScheduler, TestSchedulerConfig, Yield};
pub use shared_string::*;
pub use shared_uri::*;
pub use spring::*;
use std::{any::Any, future::Future};
pub use style::*;
pub use styled::*;
pub use subscription::*;
pub use svg_renderer::*;
pub(crate) use tab_stop::*;
use taffy::TaffyLayoutEngine;
pub use taffy::{AvailableSpace, LayoutId};
#[cfg(any(test, feature = "test-support"))]
pub use test::*;
pub use text_system::*;
#[cfg(any(test, feature = "test-support"))]
pub use util::smol_timeout;
pub use util::{FutureExt, Timeout, arc_cow::ArcCow};
pub use view::*;
pub use window::*;
pub trait AppContext {
type Result<T>;
#[expect(
clippy::wrong_self_convention,
reason = "`App::new` is an ubiquitous function for creating entities"
)]
fn new<T: 'static>(
&mut self,
build_entity: impl FnOnce(&mut Context<T>) -> T,
) -> Self::Result<Entity<T>>;
fn reserve_entity<T: 'static>(&mut self) -> Self::Result<Reservation<T>>;
fn insert_entity<T: 'static>(
&mut self,
reservation: Reservation<T>,
build_entity: impl FnOnce(&mut Context<T>) -> T,
) -> Self::Result<Entity<T>>;
fn update_entity<T, R>(
&mut self,
handle: &Entity<T>,
update: impl FnOnce(&mut T, &mut Context<T>) -> R,
) -> Self::Result<R>
where
T: 'static;
fn as_mut<'a, T>(&'a mut self, handle: &Entity<T>) -> Self::Result<GpuiBorrow<'a, T>>
where
T: 'static;
fn read_entity<T, R>(
&self,
handle: &Entity<T>,
read: impl FnOnce(&T, &App) -> R,
) -> Self::Result<R>
where
T: 'static;
fn update_window<T, F>(&mut self, window: AnyWindowHandle, f: F) -> Result<T>
where
F: FnOnce(AnyView, &mut Window, &mut App) -> T;
fn read_window<T, R>(
&self,
window: &WindowHandle<T>,
read: impl FnOnce(Entity<T>, &App) -> R,
) -> Result<R>
where
T: 'static;
fn background_spawn<R>(&self, future: impl Future<Output = R> + Send + 'static) -> Task<R>
where
R: Send + 'static;
fn read_global<G, R>(&self, callback: impl FnOnce(&G, &App) -> R) -> Self::Result<R>
where
G: Global;
}
pub struct Reservation<T>(pub(crate) Slot<T>);
impl<T: 'static> Reservation<T> {
pub fn entity_id(&self) -> EntityId {
self.0.entity_id()
}
}
pub trait VisualContext: AppContext {
fn window_handle(&self) -> AnyWindowHandle;
fn update_window_entity<T: 'static, R>(
&mut self,
entity: &Entity<T>,
update: impl FnOnce(&mut T, &mut Window, &mut Context<T>) -> R,
) -> Self::Result<R>;
fn new_window_entity<T: 'static>(
&mut self,
build_entity: impl FnOnce(&mut Window, &mut Context<T>) -> T,
) -> Self::Result<Entity<T>>;
fn replace_root_view<V>(
&mut self,
build_view: impl FnOnce(&mut Window, &mut Context<V>) -> V,
) -> Self::Result<Entity<V>>
where
V: 'static + Render;
fn focus<V>(&mut self, entity: &Entity<V>) -> Self::Result<()>
where
V: Focusable;
}
pub trait EventEmitter<E: Any>: 'static {}
pub trait BorrowAppContext {
fn set_global<T: Global>(&mut self, global: T);
fn update_global<G, R>(&mut self, f: impl FnOnce(&mut G, &mut Self) -> R) -> R
where
G: Global;
fn update_default_global<G, R>(&mut self, f: impl FnOnce(&mut G, &mut Self) -> R) -> R
where
G: Global + Default;
}
impl<C> BorrowAppContext for C
where
C: std::borrow::BorrowMut<App>,
{
fn set_global<G: Global>(&mut self, global: G) {
self.borrow_mut().set_global(global)
}
#[track_caller]
fn update_global<G, R>(&mut self, f: impl FnOnce(&mut G, &mut Self) -> R) -> R
where
G: Global,
{
let mut global = self.borrow_mut().lease_global::<G>();
let result = f(&mut global, self);
self.borrow_mut().end_global_lease(global);
result
}
fn update_default_global<G, R>(&mut self, f: impl FnOnce(&mut G, &mut Self) -> R) -> R
where
G: Global + Default,
{
self.borrow_mut().default_global::<G>();
self.update_global(f)
}
}
pub trait Flatten<T> {
fn flatten(self) -> Result<T>;
}
impl<T> Flatten<T> for Result<Result<T>> {
fn flatten(self) -> Result<T> {
self?
}
}
impl<T> Flatten<T> for Result<T> {
fn flatten(self) -> Result<T> {
self
}
}
#[derive(Default, Debug, serde::Serialize, serde::Deserialize, Clone)]
pub struct GpuSpecs {
pub is_software_emulated: bool,
pub device_name: String,
pub driver_name: String,
pub driver_info: String,
}
#[cfg(feature = "bench-support")]
#[macro_export]
macro_rules! bench_group {
($name:ident, $($benchmark:path),+ $(,)?) => {
fn $name(criterion: &mut $crate::private::criterion::Criterion) {
$($benchmark(criterion);)+
}
};
}
#[cfg(feature = "bench-support")]
#[macro_export]
macro_rules! bench_main {
($($group:path),+ $(,)?) => {
fn main() {
let mut criterion = $crate::private::criterion::Criterion::default().configure_from_args();
$($group(&mut criterion);)+
criterion.final_summary();
}
};
}
#[derive(Clone, Debug)]
pub struct FrameCapture {
pub width: u32,
pub height: u32,
pub format: wgpu::TextureFormat,
pub bytes: Vec<u8>,
}
#[derive(Debug)]
pub enum FrameCaptureError {
UnsupportedUsage,
Busy,
InvalidDimensions,
UnsupportedFormat(wgpu::TextureFormat),
BufferMap,
DevicePoll(wgpu::PollError),
}
impl std::fmt::Display for FrameCaptureError {
fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::UnsupportedUsage => {
formatter.write_str("surface does not support frame capture copies")
}
Self::Busy => formatter.write_str("a frame capture is already in flight"),
Self::InvalidDimensions => {
formatter.write_str("frame capture dimensions must be non-zero")
}
Self::UnsupportedFormat(format) => {
write!(formatter, "unsupported frame capture format: {format:?}")
}
Self::BufferMap => formatter.write_str("frame capture buffer mapping failed"),
Self::DevicePoll(error) => write!(formatter, "frame capture GPU poll failed: {error}"),
}
}
}
impl std::error::Error for FrameCaptureError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match self {
Self::DevicePoll(error) => Some(error),
Self::InvalidDimensions
| Self::UnsupportedFormat(_)
| Self::BufferMap
| Self::UnsupportedUsage
| Self::Busy => None,
}
}
}