154 lines
3.7 KiB
Rust
154 lines
3.7 KiB
Rust
use std::{marker::Unsize, mem::MaybeUninit, ops::CoerceUnsized, sync::mpsc::Sender};
|
|
|
|
use crate::{
|
|
HasUi, Widget,
|
|
util::{RefCounter, SlotId},
|
|
};
|
|
|
|
pub type WidgetId = SlotId;
|
|
|
|
/// An identifier for a widget that can index a UI or event ctx to get it.
|
|
/// This is a strong handle that does not impl Clone, and when it is dropped,
|
|
/// a signal is sent to the owning UI to clean up the resources.
|
|
///
|
|
/// TODO: ergonomic clones when they get put in rust-analyzer & don't cause ICEs?
|
|
pub struct WidgetHandle<W: ?Sized = dyn Widget> {
|
|
pub(super) id: WidgetId,
|
|
counter: RefCounter,
|
|
send: Sender<WidgetId>,
|
|
ty: *const W,
|
|
}
|
|
|
|
/// A weak handle to a widget.
|
|
/// Will not keep it alive, but can still be used for indexing like WidgetHandle.
|
|
pub struct WidgetRef<W: ?Sized = dyn Widget> {
|
|
pub(super) id: WidgetId,
|
|
#[allow(unused)]
|
|
ty: *const W,
|
|
}
|
|
|
|
pub struct WidgetHandles<W: ?Sized = dyn Widget> {
|
|
pub h: WidgetHandle<W>,
|
|
pub r: WidgetRef<W>,
|
|
}
|
|
|
|
impl<W: Widget + ?Sized + Unsize<dyn Widget>> WidgetHandle<W> {
|
|
pub fn any(self) -> WidgetHandle<dyn Widget> {
|
|
self
|
|
}
|
|
}
|
|
|
|
impl<W: ?Sized> WidgetHandle<W> {
|
|
pub(crate) fn new(id: WidgetId, send: Sender<WidgetId>) -> Self {
|
|
Self {
|
|
id,
|
|
counter: RefCounter::new(),
|
|
send,
|
|
ty: unsafe { MaybeUninit::zeroed().assume_init() },
|
|
}
|
|
}
|
|
|
|
pub fn id(&self) -> WidgetId {
|
|
self.id
|
|
}
|
|
|
|
pub fn refs(&self) -> u32 {
|
|
self.counter.refs()
|
|
}
|
|
|
|
pub fn weak(&self) -> WidgetRef<W> {
|
|
let Self { ty, id, .. } = *self;
|
|
WidgetRef { ty, id }
|
|
}
|
|
|
|
pub fn handles(self) -> WidgetHandles<W> {
|
|
let r = self.weak();
|
|
WidgetHandles { h: self, r }
|
|
}
|
|
}
|
|
|
|
impl<W: ?Sized> WidgetRef<W> {
|
|
pub fn id(&self) -> WidgetId {
|
|
self.id
|
|
}
|
|
}
|
|
|
|
impl<W: ?Sized> Drop for WidgetHandle<W> {
|
|
fn drop(&mut self) {
|
|
if self.counter.drop() {
|
|
let _ = self.send.send(self.id);
|
|
}
|
|
}
|
|
}
|
|
|
|
pub trait WidgetIdFn<State, W: ?Sized = dyn Widget>: FnOnce(&mut State) -> WidgetHandle<W> {}
|
|
impl<State, W: ?Sized, F: FnOnce(&mut State) -> WidgetHandle<W>> WidgetIdFn<State, W> for F {}
|
|
|
|
pub trait IdLike {
|
|
type Widget: Widget + ?Sized + 'static;
|
|
fn id(&self) -> WidgetId;
|
|
}
|
|
|
|
impl<W: Widget + ?Sized> IdLike for &WidgetHandle<W> {
|
|
type Widget = W;
|
|
fn id(&self) -> WidgetId {
|
|
self.id
|
|
}
|
|
}
|
|
|
|
impl<W: Widget + ?Sized> IdLike for WidgetHandle<W> {
|
|
type Widget = W;
|
|
fn id(&self) -> WidgetId {
|
|
self.id
|
|
}
|
|
}
|
|
|
|
impl<W: Widget + ?Sized> IdLike for WidgetRef<W> {
|
|
type Widget = W;
|
|
fn id(&self) -> WidgetId {
|
|
self.id
|
|
}
|
|
}
|
|
|
|
impl IdLike for WidgetId {
|
|
type Widget = dyn Widget;
|
|
fn id(&self) -> WidgetId {
|
|
*self
|
|
}
|
|
}
|
|
|
|
impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<WidgetHandle<U>> for WidgetHandle<T> {}
|
|
impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<WidgetRef<U>> for WidgetRef<T> {}
|
|
|
|
impl<W: ?Sized> Clone for WidgetRef<W> {
|
|
fn clone(&self) -> Self {
|
|
*self
|
|
}
|
|
}
|
|
impl<W: ?Sized> Copy for WidgetRef<W> {}
|
|
impl<W: ?Sized> PartialEq for WidgetRef<W> {
|
|
fn eq(&self, other: &Self) -> bool {
|
|
self.id == other.id
|
|
}
|
|
}
|
|
|
|
impl<W> PartialEq for WidgetHandle<W> {
|
|
fn eq(&self, other: &Self) -> bool {
|
|
self.id == other.id
|
|
}
|
|
}
|
|
|
|
impl<W> std::fmt::Debug for WidgetHandle<W> {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
self.id.fmt(f)
|
|
}
|
|
}
|
|
|
|
impl<'a, W: Widget + 'a, State: HasUi> FnOnce<(&'a mut State,)> for WidgetRef<W> {
|
|
type Output = &'a mut W;
|
|
|
|
extern "rust-call" fn call_once(self, args: (&'a mut State,)) -> Self::Output {
|
|
&mut args.0.ui_mut()[self]
|
|
}
|
|
}
|