112 lines
3.0 KiB
Rust
112 lines
3.0 KiB
Rust
use iris_core::{
|
|
UiRsc, WidgetId,
|
|
util::{HashMap, HashSet},
|
|
};
|
|
use iris_core::{WeakWidget, Widget};
|
|
use std::{
|
|
any::{Any, TypeId},
|
|
marker::PhantomData,
|
|
};
|
|
|
|
#[derive(Clone, Copy, PartialEq, Eq, Hash)]
|
|
struct Key {
|
|
id: WidgetId,
|
|
ty: TypeId,
|
|
i: usize,
|
|
}
|
|
|
|
#[derive(Default)]
|
|
pub struct WidgetState {
|
|
widgets: HashMap<WidgetId, HashSet<(TypeId, usize)>>,
|
|
counts: HashMap<(WidgetId, TypeId), usize>,
|
|
map: HashMap<Key, Box<dyn Any>>,
|
|
}
|
|
|
|
impl WidgetState {
|
|
pub fn new() -> Self {
|
|
Self::default()
|
|
}
|
|
pub fn add<T: 'static>(&mut self, id: WidgetId, data: T) -> WeakState<T> {
|
|
let ty = TypeId::of::<T>();
|
|
let count = self.counts.entry((id, ty)).or_default();
|
|
let i = *count;
|
|
let key = Key { ty, i, id };
|
|
self.map.insert(key, Box::new(data));
|
|
self.widgets.entry(id).or_default().insert((ty, i));
|
|
*count += 1;
|
|
WeakState {
|
|
key,
|
|
_pd: PhantomData,
|
|
}
|
|
}
|
|
pub fn remove(&mut self, id: WidgetId) {
|
|
for &(ty, i) in self.widgets.get(&id).into_iter().flatten() {
|
|
self.map.remove(&Key { id, ty, i });
|
|
}
|
|
}
|
|
pub fn get<T: 'static>(&self, state: WeakState<T>) -> &T {
|
|
self.map.get(&state.key).unwrap().downcast_ref().unwrap()
|
|
}
|
|
pub fn get_mut<T: 'static>(&mut self, state: WeakState<T>) -> &mut T {
|
|
self.map
|
|
.get_mut(&state.key)
|
|
.unwrap()
|
|
.downcast_mut()
|
|
.unwrap()
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Copy)]
|
|
pub struct WeakState<T> {
|
|
key: Key,
|
|
_pd: PhantomData<T>,
|
|
}
|
|
|
|
pub trait HasWidgetState {
|
|
fn widget_state(&self) -> &WidgetState;
|
|
fn widget_state_mut(&mut self) -> &mut WidgetState;
|
|
}
|
|
|
|
impl<'a, T: 'static> FnOnce<(&'a mut WidgetState,)> for WeakState<T> {
|
|
type Output = &'a mut T;
|
|
|
|
extern "rust-call" fn call_once(self, (state,): (&'a mut WidgetState,)) -> Self::Output {
|
|
state.get_mut(self)
|
|
}
|
|
}
|
|
|
|
/// What `Rsc[weak_handle]` indexes through -- one impl per kind of handle
|
|
/// (a widget, a piece of per-widget state), shared by both backends' `Rsc`
|
|
/// types since indexing a widget tree has nothing to do with windowing.
|
|
/// `AppRsc` supplies the shared `Index`/`IndexMut` implementation; a blanket
|
|
/// implementation over every possible resource type would conflict.
|
|
pub trait RscIdx<Rsc> {
|
|
type Output;
|
|
fn get(self, rsc: &Rsc) -> &Self::Output;
|
|
fn get_mut(self, rsc: &mut Rsc) -> &mut Self::Output;
|
|
}
|
|
|
|
impl<W: Widget, Rsc: UiRsc> RscIdx<Rsc> for WeakWidget<W> {
|
|
type Output = W;
|
|
|
|
fn get(self, rsc: &Rsc) -> &Self::Output {
|
|
&rsc.ui().widgets[self]
|
|
}
|
|
|
|
fn get_mut(self, rsc: &mut Rsc) -> &mut Self::Output {
|
|
&mut rsc.ui_mut().widgets[self]
|
|
}
|
|
}
|
|
|
|
impl<T: 'static, Rsc: HasWidgetState> RscIdx<Rsc> for WeakState<T> {
|
|
type Output = T;
|
|
|
|
fn get(self, rsc: &Rsc) -> &Self::Output {
|
|
rsc.widget_state().get(self)
|
|
}
|
|
|
|
fn get_mut(self, rsc: &mut Rsc) -> &mut Self::Output {
|
|
rsc.widget_state_mut().get_mut(self)
|
|
}
|
|
}
|