shadowcat/iris
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

FINALLY transition events to global; slow text sending bug tho

Browse Source
This commit is contained in:
shadow cat
2025-12-11 01:21:36 -05:00
parent 2537284372
commit baaeb6b027
21 changed files with 650 additions and 557 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
core/Cargo.toml
View File

@@ -10,4 +10,3 @@ bytemuck ={ workspace = true }
image = { workspace = true }
cosmic-text = { workspace = true }
fxhash = { workspace = true }

327
core/src/layout/event.rs
View File

@@ -1,187 +1,192 @@
use std::{hash::Hash, rc::Rc};
use crate::{
layout::{Ui, UiModule, WidgetId, WidgetRef},
util::HashMap,
layout::{LayerId, UiId, Widget, WidgetId, WidgetInstance, WidgetRef},
util::{Handle, HashMap, RefGuardMut},
};
use std::{
any::{Any, TypeId},
ops::DerefMut,
sync::{Arc, LazyLock, Mutex},
};
pub trait Event: Sized {
type Module<Ctx: 'static>: EventModule<Self, Ctx>;
type Data: Clone;
}
pub trait Async: Send + Sync + 'static {}
impl<T: Send + Sync + 'static> Async for T {}
pub struct EventCtx<'a, Ctx, Data> {
pub ui: &'a mut Ui,
pub state: &'a mut Ctx,
pub data: Data,
}
pub type ECtx<'a, Ctx, Data, W> = EventIdCtx<'a, Ctx, Data, W>;
pub struct EventIdCtx<'a, Ctx, Data, W: ?Sized> {
pub widget: WidgetRef<W>,
pub ui: &'a mut Ui,
pub state: &'a mut Ctx,
pub data: Data,
}
pub trait EventFn<Ctx, Data>: Fn(EventCtx<Ctx, Data>) + 'static {}
impl<F: Fn(EventCtx<Ctx, Data>) + 'static, Ctx, Data> EventFn<Ctx, Data> for F {}
pub trait WidgetEventFn<Ctx, Data, W: ?Sized>: Fn(EventIdCtx<Ctx, Data, W>) + 'static {}
impl<F: Fn(EventIdCtx<Ctx, Data, W>) + 'static, Ctx, Data, W: ?Sized> WidgetEventFn<Ctx, Data, W>
for F
{
}
impl Ui {
pub fn register_event<W: ?Sized, E: Event, Ctx: 'static>(
&mut self,
id: WidgetRef<W>,
event: E,
f: impl EventFn<Ctx, E::Data>,
) {
self.data
.modules
.get_mut::<E::Module<Ctx>>()
.register(id.id(), event, f);
pub trait Event: Sized + Async + Clone {
type Data<'a> = ();
type State: Sync + Send + Default = ();
#[allow(unused_variables)]
fn should_run(&self, data: &mut Self::Data<'_>) -> bool {
true
}
pub fn register_widget_event<W: ?Sized + 'static, E: Event, Ctx: 'static>(
&mut self,
/// THIS SHOULD NOT BE OVERWRITTEN; the default impl runs this event
fn run<Ctx: 'static, W>(id: WidgetRef<W>, data: &mut Self::Data<'_>, state: &mut Ctx) {
Events::<Self, Ctx>::run(id.id(), data, state);
}
}
pub trait EventAlias {
type Event: Event;
fn into_event(self) -> Self::Event;
}
impl<E: Event> EventAlias for E {
type Event = Self;
fn into_event(self) -> Self::Event {
self
}
}
type EventData<E, Ctx> = (E, Arc<dyn for<'a> EventFn<Ctx, <E as Event>::Data<'a>>>);
pub struct Events<E: Event, Ctx> {
active: HashMap<UiId, HashMap<LayerId, HashMap<WidgetId, E::State>>>,
map: HashMap<WidgetId, Vec<EventData<E, Ctx>>>,
}
pub static EVENT_TYPES: LazyLock<Mutex<HashMap<TypeId, Handle<dyn EventManager>>>> =
LazyLock::new(|| Mutex::new(HashMap::default()));
pub trait EventManager: Any + Send + Sync {
fn remove(&mut self, id: WidgetId) -> Box<dyn Any>;
fn draw(&mut self, ui: UiId, inst: &WidgetInstance);
fn undraw(&mut self, ui: UiId, inst: &WidgetInstance);
}
impl<E: Event, Ctx: 'static> EventManager for Events<E, Ctx> {
/// so... there is a deadlock if this is called in WidgetData::drop
/// and some function in here owns another WidgetId
/// so for now you need to drop the lock on self, THEN drop the contents
fn remove(&mut self, id: WidgetId) -> Box<dyn Any> {
let contents = self.map.remove(&id);
for ui in self.active.values_mut() {
for layer in ui.values_mut() {
layer.remove(&id);
}
}
Box::new(contents)
}
fn draw(&mut self, ui: UiId, inst: &WidgetInstance) {
self.active
.entry(ui)
.or_default()
.entry(inst.layer)
.or_default()
.entry(inst.id)
.or_default();
}
fn undraw(&mut self, ui: UiId, inst: &WidgetInstance) {
// rust pls
(|| {
self.active
.get_mut(&ui)?
.get_mut(&inst.layer)?
.remove(&inst.id);
Some(())
})();
}
}
pub type UiActive<State> = HashMap<LayerId, HashMap<WidgetId, State>>;
impl<E: Event, Ctx: 'static> Events<E, Ctx> {
fn id() -> TypeId {
TypeId::of::<Self>()
}
fn new() -> Self {
Self {
map: Default::default(),
active: Default::default(),
}
}
pub fn active(id: UiId) -> impl DerefMut<Target = UiActive<E::State>> {
RefGuardMut::map(Self::get(), |s| s.active.entry(id).or_default())
}
fn register_<W: Widget + ?Sized>(
id: WidgetRef<W>,
event: E,
f: impl WidgetEventFn<Ctx, E::Data, W>,
event: impl Into<E>,
f: impl for<'a> EventFn<Ctx, <E as Event>::Data<'a>>,
) {
self.data
.modules
.get_mut::<E::Module<Ctx>>()
.register(id.id(), event, move |ctx| {
let Some(mut data) = id.data_mut() else {
return;
};
data.event_managers.insert(Self::id());
Self::get()
.map
.entry(id.id())
.or_default()
.push((event.into(), Arc::new(f)));
}
pub fn register<W: Widget + ?Sized + 'static>(
id: WidgetRef<W>,
event: impl Into<E>,
f: impl for<'a> EventIdFn<Ctx, <E as Event>::Data<'a>, W>,
) {
Self::register_(id, event, move |ctx| {
f(EventIdCtx {
widget: id,
ui: ctx.ui,
state: ctx.state,
data: ctx.data,
})
});
}
}
pub trait DefaultEvent: Hash + Eq + 'static {
type Data: Clone;
}
impl<E: DefaultEvent> Event for E {
type Module<Ctx: 'static> = DefaultEventModule<E, Ctx>;
type Data = E::Data;
}
pub trait EventModule<E: Event, Ctx>: UiModule + Default {
fn register(&mut self, id: WidgetId, event: E, f: impl EventFn<Ctx, E::Data>);
fn run<'a>(
&mut self,
id: WidgetId,
event: E,
) -> Option<impl FnOnce(EventCtx<Ctx, E::Data>) + use<'a, Self, Ctx, E>>;
}
type EventFnMap<Ctx, Data> = HashMap<WidgetId, Vec<Rc<dyn EventFn<Ctx, Data>>>>;
pub struct DefaultEventModule<E: Event, Ctx> {
map: HashMap<E, EventFnMap<Ctx, <E as Event>::Data>>,
}
impl<E: Event + 'static, Ctx: 'static> UiModule for DefaultEventModule<E, Ctx> {
fn on_remove(&mut self, id: &WidgetId) {
for map in self.map.values_mut() {
map.remove(id);
}
}
}
pub trait HashableEvent: Event + Hash + Eq + 'static {}
impl<E: Event + Hash + Eq + 'static> HashableEvent for E {}
impl<E: HashableEvent, Ctx: 'static> EventModule<E, Ctx> for DefaultEventModule<E, Ctx> {
fn register(&mut self, id: WidgetId, event: E, f: impl EventFn<Ctx, <E as Event>::Data>) {
self.map
.entry(event)
.or_default()
.entry(id)
.or_default()
.push(Rc::new(f));
}
fn run<'a>(
&mut self,
id: WidgetId,
event: E,
) -> Option<impl FnOnce(EventCtx<Ctx, E::Data>) + use<'a, Ctx, E>> {
if let Some(map) = self.map.get(&event)
&& let Some(fs) = map.get(&id)
{
pub fn run(id: WidgetId, data: &mut E::Data<'_>, state: &mut Ctx) {
let s = Self::get();
if let Some(fs) = s.map.get(&id) {
let fs = fs.clone();
Some(move |ctx: EventCtx<Ctx, <E as Event>::Data>| {
for f in fs {
f(EventCtx {
ui: ctx.ui,
state: ctx.state,
data: ctx.data.clone(),
})
drop(s);
for (e, f) in fs {
if e.should_run(data) {
f(EventCtx { state, data })
}
})
} else {
None
}
}
}
pub fn run_all(data: &mut E::Data<'_>, state: &mut Ctx) {
let s = Self::get();
// TODO: should probably document that added events won't run same frame
let mut map = s.map.clone();
drop(s);
for fs in map.values_mut() {
for (e, f) in fs {
if e.should_run(data) {
f(EventCtx { state, data })
}
}
}
}
/// this some bull
fn get<'a>() -> RefGuardMut<'a, Self> {
let any = EVENT_TYPES
.lock()
.unwrap()
.entry(Self::id())
.or_insert_with(|| Handle::from(Self::new()))
.clone();
unsafe { any.downcast() }.get_take_mut()
}
}
impl<E: HashableEvent, Ctx: 'static> DefaultEventModule<E, Ctx> {
pub fn run_all(&mut self, event: E, ctx: EventCtx<Ctx, E::Data>)
where
E::Data: Clone,
{
if let Some(map) = self.map.get(&event) {
for fs in map.values() {
let fs = fs.clone();
for f in fs {
f(EventCtx {
ui: ctx.ui,
state: ctx.state,
data: ctx.data.clone(),
})
}
}
}
}
pub struct EventCtx<'a, Ctx, Data> {
pub state: &'a mut Ctx,
pub data: &'a mut Data,
}
impl<E: Event + 'static, Ctx: 'static> Default for DefaultEventModule<E, Ctx> {
fn default() -> Self {
Self {
map: Default::default(),
}
}
pub struct EventIdCtx<'a, Ctx, Data, W: ?Sized> {
pub widget: WidgetRef<W>,
pub state: &'a mut Ctx,
pub data: &'a mut Data,
}
impl Ui {
pub fn run_event<E: Event, Ctx: 'static, W: ?Sized>(
&mut self,
ctx: &mut Ctx,
id: WidgetRef<W>,
event: E,
data: E::Data,
) {
if let Some(f) = self
.data
.modules
.get_mut::<E::Module<Ctx>>()
.run(id.id(), event)
{
eprintln!("FIXME");
f(EventCtx {
ui: self,
state: ctx,
data,
});
}
}
}
pub trait EventFn<Ctx, Data>: Fn(EventCtx<Ctx, Data>) + Async {}
impl<F: Fn(EventCtx<Ctx, Data>) + Async, Ctx, Data> EventFn<Ctx, Data> for F {}
pub trait EventIdFn<Ctx, Data, W: ?Sized>: Fn(EventIdCtx<Ctx, Data, W>) + Async {}
impl<F: Fn(EventIdCtx<Ctx, Data, W>) + Async, Ctx, Data, W: ?Sized> EventIdFn<Ctx, Data, W> for F {}

41
core/src/layout/painter.rs
View File

@@ -2,8 +2,8 @@ use std::{marker::Unsize, sync::mpsc::Sender};
use crate::{
layout::{
Axis, Len, Modules, PrimitiveLayers, RenderedText, Size, TextAttrs, TextBuffer, TextData,
TextureHandle, Textures, UiRegion, UiVec2, Vec2, Widget, WidgetHandle, WidgetId,
Axis, LayerId, Len, PrimitiveLayers, RenderedText, Size, TextAttrs, TextBuffer, TextData,
TextureHandle, Textures, UiId, UiRegion, UiVec2, Vec2, Widget, WidgetHandle, WidgetId,
WidgetUpdate,
},
render::{Mask, MaskIdx, Primitive, PrimitiveHandle, PrimitiveInst},
@@ -27,13 +27,13 @@ pub struct Painter<'a, 'c> {
/// context for a painter; lets you draw and redraw widgets
struct PainterCtx<'a> {
ui_id: UiId,
pub active: &'a mut HashMap<WidgetId, WidgetInstance>,
pub layers: &'a mut PrimitiveLayers,
pub textures: &'a mut Textures,
pub masks: &'a mut TrackedArena<Mask, u32>,
pub text: &'a mut TextData,
pub output_size: Vec2,
pub modules: &'a mut Modules,
send: &'a Sender<WidgetUpdate>,
pub cache_width: HashMap<WidgetId, (UiVec2, Len)>,
pub cache_height: HashMap<WidgetId, (UiVec2, Len)>,
@@ -60,32 +60,32 @@ pub struct WidgetInstance {
pub children: Vec<WidgetId>,
pub resize: ResizeRef,
pub mask: MaskIdx,
pub layer: usize,
pub layer: LayerId,
}
/// data to be stored in Ui to create PainterCtxs easily
/// TODO: actually use this LMAO
pub struct PainterData {
ui_id: UiId,
pub active: HashMap<WidgetId, WidgetInstance>,
pub layers: PrimitiveLayers,
pub textures: Textures,
pub text: TextData,
pub output_size: Vec2,
pub modules: Modules,
pub px_dependent: HashSet<WidgetId>,
pub masks: TrackedArena<Mask, u32>,
send: Sender<WidgetUpdate>,
}
impl PainterData {
pub fn new(send: Sender<WidgetUpdate>) -> Self {
pub fn new(ui_id: UiId, send: Sender<WidgetUpdate>) -> Self {
Self {
ui_id,
active: Default::default(),
layers: Default::default(),
textures: Default::default(),
text: Default::default(),
output_size: Default::default(),
modules: Default::default(),
px_dependent: Default::default(),
masks: Default::default(),
send,
@@ -175,7 +175,7 @@ impl<'a> PainterCtx<'a> {
return finish(self, resize);
}
let Some(active) = self.remove(id) else {
let Some(active) = self.remove(id, false) else {
return;
};
@@ -231,7 +231,7 @@ impl<'a> PainterCtx<'a> {
return;
}
// if not, then maintain resize and track old children to remove unneeded
let active = self.remove(id).unwrap();
let active = self.remove(id, false).unwrap();
old_children = active.children;
resize = active.resize;
}
@@ -293,10 +293,10 @@ impl<'a> PainterCtx<'a> {
}
}
// update modules
for m in self.modules.iter_mut() {
m.on_draw(&instance);
}
// run events
id.map_event_managers(|m| {
m.draw(self.ui_id, &instance);
});
self.active.insert(id, instance);
}
@@ -307,9 +307,6 @@ impl<'a> PainterCtx<'a> {
*region = region.outside(&from).within(&to);
}
active.region = active.region.outside(&from).within(&to);
for m in self.modules.iter_mut() {
m.on_move(active);
}
// children will not be changed, so this technically should not be needed
// probably need unsafe
let children = active.children.clone();
@@ -319,7 +316,7 @@ impl<'a> PainterCtx<'a> {
}
/// NOTE: instance textures are cleared and self.textures freed
fn remove(&mut self, id: WidgetId) -> Option<WidgetInstance> {
fn remove(&mut self, id: WidgetId, undraw: bool) -> Option<WidgetInstance> {
let mut inst = self.active.remove(&id);
if let Some(inst) = &mut inst {
for h in &inst.primitives {
@@ -330,15 +327,17 @@ impl<'a> PainterCtx<'a> {
}
inst.textures.clear();
self.textures.free();
for m in self.modules.iter_mut() {
m.on_undraw(inst);
if undraw {
id.map_event_managers(|m| {
m.undraw(self.ui_id, inst);
});
}
}
inst
}
fn remove_rec(&mut self, id: WidgetId) -> Option<WidgetInstance> {
let inst = self.remove(id);
let inst = self.remove(id, true);
if let Some(inst) = &inst {
for c in &inst.children {
self.remove_rec(*c);
@@ -351,12 +350,12 @@ impl<'a> PainterCtx<'a> {
impl PainterData {
fn ctx(&mut self, needs_redraw: HashSet<WidgetId>) -> PainterCtx<'_> {
PainterCtx {
ui_id: self.ui_id,
active: &mut self.active,
layers: &mut self.layers,
textures: &mut self.textures,
text: &mut self.text,
output_size: self.output_size,
modules: &mut self.modules,
masks: &mut self.masks,
send: &self.send,
cache_width: Default::default(),

2
core/src/layout/primitive/layer.rs
View File

@@ -2,6 +2,8 @@ use std::ops::{Index, IndexMut};
use crate::render::{MaskIdx, Primitive, PrimitiveHandle, PrimitiveInst, Primitives};
pub type LayerId = usize;
struct LayerNode<T> {
next: Ptr,
prev: Ptr,

47
core/src/layout/ui.rs
View File

@@ -5,21 +5,27 @@ use crate::{
IdLike, PainterData, PixelRegion, TextureHandle, Vec2, WidgetHandle, WidgetId,
WidgetInstance, WidgetLike, WidgetUpdate,
},
util::HashSet,
util::{HashMap, HashSet, Id, StaticIdTracker},
};
use std::sync::mpsc::{Receiver, channel};
static ID_TRACKER: StaticIdTracker = StaticIdTracker::new();
pub type UiId = Id;
pub struct Ui {
id: UiId,
pub(crate) data: PainterData,
root: Option<WidgetHandle>,
updates: HashSet<WidgetId>,
free: Vec<WidgetId>,
recv: Receiver<WidgetUpdate>,
full_redraw: bool,
resized: bool,
}
impl Ui {
pub fn id(&self) -> UiId {
self.id
}
pub fn set_root<Tag>(&mut self, w: impl WidgetLike<Tag>) {
self.root = Some(w.add(self));
self.full_redraw = true;
@@ -39,10 +45,10 @@ impl Ui {
}
fn redraw_all(&mut self) {
for (_, inst) in self.data.active.drain() {
for m in self.data.modules.iter_mut() {
m.on_undraw(&inst);
}
for (id, inst) in self.data.active.drain() {
id.map_event_managers(|m| {
m.undraw(self.id, &inst);
});
}
// free before bc nothing should exist
self.free();
@@ -52,16 +58,9 @@ impl Ui {
}
pub fn update(&mut self) -> bool {
for update in self.recv.try_iter() {
match update {
WidgetUpdate::Drop(id) => {
self.free.push(id);
}
WidgetUpdate::Mutate(id) => {
for id in self.recv.try_iter() {
self.updates.insert(id);
}
}
}
if self.full_redraw {
self.redraw_all();
self.full_redraw = false;
@@ -85,11 +84,6 @@ impl Ui {
/// free any resources that don't have references anymore
fn free(&mut self) {
for id in self.free.drain(..) {
for m in self.data.modules.iter_mut() {
m.on_remove(&id);
}
}
self.data.textures.free();
}
@@ -101,6 +95,10 @@ impl Ui {
self.data.active.len()
}
pub fn active(&self) -> &HashMap<WidgetId, WidgetInstance> {
&self.data.active
}
pub fn debug_layers(&self) {
for ((idx, depth), primitives) in self.data.layers.iter_depth() {
let indent = " ".repeat(depth * 2);
@@ -141,14 +139,21 @@ impl Ui {
impl Default for Ui {
fn default() -> Self {
let (send, recv) = channel();
let id = ID_TRACKER.next();
Self {
data: PainterData::new(send),
id,
data: PainterData::new(id, send),
root: Default::default(),
updates: Default::default(),
free: Default::default(),
full_redraw: false,
recv,
resized: false,
}
}
}
impl Drop for Ui {
fn drop(&mut self) {
ID_TRACKER.free(self.id);
}
}

40
core/src/layout/widget/data.rs Normal file
View File

@@ -0,0 +1,40 @@
use std::{any::TypeId, sync::mpsc::Sender};
use crate::{
layout::{EVENT_TYPES, EventManager, WIDGETS, WidgetId, WidgetUpdate},
util::{HashSet, RefGuardMut},
};
pub struct WidgetData<W: ?Sized> {
pub id: WidgetId,
pub send: Option<Sender<WidgetUpdate>>,
pub label: String,
pub event_managers: HashSet<TypeId>,
pub widget: W,
}
impl<W: ?Sized> WidgetData<W> {
pub(crate) fn event_managers(&self) -> impl Iterator<Item = RefGuardMut<'_, dyn EventManager>> {
self.event_managers.iter().map(|id| {
EVENT_TYPES
.lock()
.unwrap()
.get_mut(id)
.unwrap()
.clone()
.get_take_mut()
})
}
}
impl<W: ?Sized> Drop for WidgetData<W> {
fn drop(&mut self) {
WIDGETS.remove(self.id);
for mut m in self.event_managers() {
// refer to src/layout/event.rs for why this is like this
let stuff = m.remove(self.id);
drop(m);
drop(stuff);
}
}
}

133
core/src/layout/widget/handle.rs
View File

@@ -1,13 +1,11 @@
use std::{
marker::Unsize,
mem::MaybeUninit,
ops::{CoerceUnsized, Deref, DerefMut},
sync::mpsc::Sender,
};
use std::{marker::Unsize, mem::MaybeUninit, ops::CoerceUnsized};
use crate::{
layout::{IdFnTag, IdTag, Ui, WIDGETS, Widget, WidgetLike},
util::{Handle, Ref, RefMap, RefMapMut, RefMut, WeakHandle},
layout::{EventManager, IdFnTag, IdTag, Ui, WIDGETS, Widget, WidgetData, WidgetLike},
util::{
Handle, MappedRefGuard, MappedRefGuardMut, Ref, RefGuard, RefGuardMut, RefMap, RefMapMut,
RefMut, WeakHandle,
},
};
pub(super) type SlotTy = u32;
@@ -24,17 +22,7 @@ pub struct WidgetHandle<W: ?Sized = dyn Widget>(WidgetId, Handle<WidgetData<W>>)
/// A weak handle to a widget. Implements Copy so you can easily pass into closures
pub struct WidgetRef<W: ?Sized = dyn Widget>(WidgetId, *const W);
pub(crate) struct WidgetData<W: ?Sized> {
pub id: WidgetId,
pub send: Option<Sender<WidgetUpdate>>,
pub label: String,
pub widget: W,
}
pub enum WidgetUpdate {
Drop(WidgetId),
Mutate(WidgetId),
}
pub type WidgetUpdate = WidgetId;
impl<W: Widget> WidgetHandle<W> {
pub(super) fn new(id: WidgetId, widget: W) -> Self {
@@ -49,6 +37,7 @@ impl<W: Widget> WidgetHandle<W> {
widget,
send: None,
label,
event_managers: Default::default(),
}
.into(),
)
@@ -82,16 +71,20 @@ impl<W: ?Sized> WidgetHandle<W> {
pub fn get_mut(&self) -> RefMapMut<'_, W> {
let inner = self.1.get_mut();
if let Some(send) = &inner.send {
let _ = send.send(WidgetUpdate::Mutate(self.0));
let _ = send.send(self.0);
}
RefMut::map(inner, |i| &mut i.widget)
}
pub fn data(&self) -> Ref<'_, WidgetData<W>> {
self.1.get()
}
pub(crate) fn data_mut(&self) -> RefMut<'_, WidgetData<W>> {
self.1.get_mut()
}
pub fn get_mut_quiet(&self) -> RefMapMut<'_, W> {
pub(crate) fn get_mut_quiet(&self) -> RefMapMut<'_, W> {
RefMut::map(self.1.get_mut(), |i| &mut i.widget)
}
@@ -109,65 +102,53 @@ impl<W: ?Sized> WidgetHandle<W> {
}
pub fn weak(&self) -> WidgetRef<W> {
WidgetRef(self.0, null_ptr())
WidgetRef::new(self.0)
}
}
pub type WRef<'a, W> = MappedRefGuard<'a, WidgetData<W>, W>;
pub type WRefMut<'a, W> = MappedRefGuardMut<'a, WidgetData<W>, W>;
impl<W: Widget> WidgetRef<W> {
fn handle(&self) -> Handle<WidgetData<W>> {
WIDGETS.get_type(self.0).unwrap()
}
pub fn get<'a>(&self) -> WRef<'a, W> {
let handle = self.handle();
WRef {
val: unsafe {
std::mem::transmute::<RefMap<'_, W>, RefMap<'_, W>>(Ref::map(handle.get(), |i| {
&mut i.widget
}))
},
_handle: handle,
}
RefGuard::map(self.handle().get_take(), |i| &mut i.widget)
}
pub fn get_mut<'a>(&self) -> WRefMut<'a, W> {
let handle = self.handle();
if let Some(send) = &handle.get().send {
let _ = send.send(WidgetUpdate::Mutate(self.0));
}
WRefMut {
val: unsafe {
std::mem::transmute::<RefMapMut<'_, W>, RefMapMut<'_, W>>(RefMut::map(
handle.get_mut(),
|i| &mut i.widget,
))
},
_handle: handle,
let inner = self.handle().get_take_mut();
if let Some(send) = &inner.send {
let _ = send.send(self.0);
}
RefGuardMut::map(inner, |i| &mut i.widget)
}
}
pub struct WRef<'a, W> {
_handle: Handle<WidgetData<W>>,
val: RefMap<'a, W>,
}
impl<W: ?Sized + Widget> WidgetRef<W> {
pub fn data<'a>(&self) -> Option<RefGuard<'a, WidgetData<dyn Widget>>> {
Some(WIDGETS.get(self.0)?.get_take())
}
pub struct WRefMut<'a, W> {
_handle: Handle<WidgetData<W>>,
val: RefMapMut<'a, W>,
pub(crate) fn data_mut(&self) -> Option<RefGuardMut<'_, WidgetData<dyn Widget>>> {
Some(WIDGETS.get(self.0)?.get_take_mut())
}
}
impl<W: Widget + ?Sized + Unsize<dyn Widget>> WidgetRef<W> {
pub fn any(self) -> WidgetRef<dyn Widget> {
WidgetRef(self.0, null_ptr())
WidgetRef::new(self.0)
}
}
fn null_ptr<T: ?Sized>() -> *const T {
unsafe { MaybeUninit::zeroed().assume_init() }
}
impl<W: ?Sized> WidgetRef<W> {
fn new(id: WidgetId) -> Self {
Self(id, unsafe { MaybeUninit::zeroed().assume_init() })
}
pub fn id(&self) -> WidgetId {
self.0
}
@@ -178,13 +159,17 @@ impl WidgetId {
pub(crate) fn strong(self) -> Option<WidgetHandle> {
Some(WidgetHandle(self, WIDGETS.get(self)?))
}
}
impl<W: ?Sized> Drop for WidgetData<W> {
fn drop(&mut self) {
if let Some(send) = &self.send {
WIDGETS.remove(self.id);
let _ = send.send(WidgetUpdate::Drop(self.id));
pub fn weak(self) -> WidgetRef {
WidgetRef::new(self)
}
pub(crate) fn map_event_managers(&self, f: impl Fn(&mut dyn EventManager)) {
let Some(data) = self.weak().data() else {
return;
};
for mut m in data.event_managers() {
f(&mut *m)
}
}
}
@@ -252,28 +237,8 @@ impl<W: ?Sized> Copy for WidgetRef<W> {}
impl<W: ?Sized> PartialEq for WidgetRef<W> {
fn eq(&self, other: &Self) -> bool {
self.0 == other.0 && self.1 == other.1
}
}
impl<T> Deref for WRef<'_, T> {
type Target = T;
fn deref(&self) -> &Self::Target {
&self.val
}
}
impl<T> Deref for WRefMut<'_, T> {
type Target = T;
fn deref(&self) -> &Self::Target {
&self.val
}
}
impl<T> DerefMut for WRefMut<'_, T> {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.val
self.0 == other.0
}
}
unsafe impl<W: ?Sized> Send for WidgetRef<W> {}
unsafe impl<W: ?Sized> Sync for WidgetRef<W> {}

2
core/src/layout/widget/mod.rs
View File

@@ -1,8 +1,10 @@
mod data;
mod handle;
mod like;
mod tag;
mod widgets;
pub use data::*;
pub use handle::*;
pub use like::*;
pub use tag::*;

12
core/src/layout/widget/widgets.rs
View File

@@ -1,7 +1,4 @@
use std::{
any::Any,
sync::{Mutex, MutexGuard},
};
use std::sync::{Mutex, MutexGuard};
use crate::{
layout::{
@@ -47,12 +44,7 @@ impl Widgets {
if slot.genr != id.genr {
None
} else {
Some(
unsafe { slot.data.clone().downcast() }
.unwrap()
.clone()
.strong()?,
)
Some(unsafe { slot.data.clone().downcast() }.clone().strong()?)
}
}

8
core/src/util/arena.rs
View File

@@ -7,7 +7,7 @@ pub struct Arena<T, I> {
tracker: IdTracker<I>,
}
impl<T, I: IdNum> Arena<T, I> {
impl<T, I: const IdNum> Arena<T, I> {
pub fn new() -> Self {
Self {
data: Vec::new(),
@@ -36,7 +36,7 @@ impl<T, I: IdNum> Arena<T, I> {
}
}
impl<T, I: IdNum> Default for Arena<T, I> {
impl<T, I: const IdNum> Default for Arena<T, I> {
fn default() -> Self {
Self::new()
}
@@ -48,7 +48,7 @@ pub struct TrackedArena<T, I> {
pub changed: bool,
}
impl<T, I: IdNum> TrackedArena<T, I> {
impl<T, I: const IdNum> TrackedArena<T, I> {
pub fn new() -> Self {
Self {
inner: Arena::default(),
@@ -86,7 +86,7 @@ impl<T, I: IdNum> TrackedArena<T, I> {
}
}
impl<T, I: IdNum> Default for TrackedArena<T, I> {
impl<T, I: const IdNum> Default for TrackedArena<T, I> {
fn default() -> Self {
Self::new()
}

164
core/src/util/handle.rs
View File

@@ -1,18 +1,21 @@
//! A helper type for Arc<Mutex<T>>
//! Currently there are mut versions (of Ref stuff) which don't do anything different under the hood,
//! leaving them in for now in case I decide RwLock is a desired feature
use std::{
any::{Any, TypeId},
marker::Unsize,
ops::CoerceUnsized,
sync::{Arc, Mutex, Weak},
ops::{CoerceUnsized, Deref, DerefMut},
sync::{Arc, MappedMutexGuard, Mutex, MutexGuard, Weak},
};
pub struct Handle<T: ?Sized>(Arc<Mutex<T>>);
pub struct WeakHandle<T: ?Sized>(Weak<Mutex<T>>);
pub type Ref<'a, T> = std::sync::MutexGuard<'a, T>;
pub type RefMut<'a, T> = std::sync::MutexGuard<'a, T>;
pub type Ref<'a, T> = MutexGuard<'a, T>;
pub type RefMut<'a, T> = MutexGuard<'a, T>;
pub type RefMap<'a, T> = std::sync::MappedMutexGuard<'a, T>;
pub type RefMapMut<'a, T> = std::sync::MappedMutexGuard<'a, T>;
pub type RefMap<'a, T> = MappedMutexGuard<'a, T>;
pub type RefMapMut<'a, T> = MappedMutexGuard<'a, T>;
impl<T: ?Sized> Handle<T> {
pub fn get(&self) -> Ref<'_, T> {
@@ -23,6 +26,30 @@ impl<T: ?Sized> Handle<T> {
self.0.lock().unwrap()
}
pub fn get_take<'a>(self) -> RefGuard<'a, T> {
let handle = self;
RefGuard {
guard: unsafe {
std::mem::transmute::<MutexGuard<'_, T>, MutexGuard<'_, T>>(
handle.0.lock().unwrap(),
)
},
handle,
}
}
pub fn get_take_mut<'a>(self) -> RefGuardMut<'a, T> {
let handle = self;
RefGuardMut {
guard: unsafe {
std::mem::transmute::<MutexGuard<'_, T>, MutexGuard<'_, T>>(
handle.0.lock().unwrap(),
)
},
handle,
}
}
pub fn refs(&self) -> usize {
Arc::strong_count(&self.0)
}
@@ -30,6 +57,20 @@ impl<T: ?Sized> Handle<T> {
pub fn weak(&self) -> WeakHandle<T> {
WeakHandle(Arc::downgrade(&self.0))
}
/// # Safety
/// you must guarantee the type outside
/// ideally you check the typeid, but this is often used
/// when the trait object is wrapped one or more times
/// and you'd have to implement each one individually
pub unsafe fn downcast<U: 'static>(self) -> Handle<U>
where
T: 'static,
{
let raw: *const Mutex<T> = Arc::into_raw(self.0);
let raw: *const Mutex<U> = raw.cast();
Handle(unsafe { Arc::from_raw(raw) })
}
}
impl<T: ?Sized> WeakHandle<T> {
@@ -43,13 +84,13 @@ impl<T: ?Sized> WeakHandle<T> {
/// # Safety
/// you must guarantee the type outside
pub unsafe fn downcast<U: 'static>(self) -> Option<WeakHandle<U>>
pub unsafe fn downcast<U: 'static>(self) -> WeakHandle<U>
where
T: 'static,
{
let raw: *const Mutex<T> = self.0.into_raw();
let raw: *const Mutex<U> = raw.cast();
Some(WeakHandle(unsafe { Weak::from_raw(raw) }))
WeakHandle(unsafe { Weak::from_raw(raw) })
}
}
@@ -79,3 +120,108 @@ impl<T> From<T> for Handle<T> {
impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<Handle<U>> for Handle<T> {}
impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<WeakHandle<U>> for WeakHandle<T> {}
// yucky
// TODO: is drop order important here?
// something stupid could happen that I don't know about
// if handle is dropped before guard
pub struct RefGuard<'a, T: ?Sized> {
guard: MutexGuard<'a, T>,
handle: Handle<T>,
}
pub struct RefGuardMut<'a, T: ?Sized> {
guard: MutexGuard<'a, T>,
handle: Handle<T>,
}
pub struct MappedRefGuard<'a, T: ?Sized, U> {
guard: MappedMutexGuard<'a, U>,
handle: Handle<T>,
}
pub struct MappedRefGuardMut<'a, T: ?Sized, U> {
guard: MappedMutexGuard<'a, U>,
handle: Handle<T>,
}
impl<'a, T: ?Sized> RefGuard<'a, T> {
pub fn map<U>(s: Self, f: impl FnOnce(&mut T) -> &mut U) -> MappedRefGuard<'a, T, U> {
MappedRefGuard {
guard: MutexGuard::map(s.guard, f),
handle: s.handle,
}
}
}
impl<'a, T: ?Sized> RefGuardMut<'a, T> {
pub fn map<U>(s: Self, f: impl FnOnce(&mut T) -> &mut U) -> MappedRefGuardMut<'a, T, U> {
MappedRefGuardMut {
guard: MutexGuard::map(s.guard, f),
handle: s.handle,
}
}
}
impl<'a, T: ?Sized, U> MappedRefGuard<'a, T, U> {
pub fn map<U2>(s: Self, f: impl FnOnce(&mut U) -> &mut U2) -> MappedRefGuard<'a, T, U2> {
MappedRefGuard {
guard: MappedMutexGuard::map(s.guard, f),
handle: s.handle,
}
}
}
impl<'a, T: ?Sized, U> MappedRefGuardMut<'a, T, U> {
pub fn map<U2>(s: Self, f: impl FnOnce(&mut U) -> &mut U2) -> MappedRefGuardMut<'a, T, U2> {
MappedRefGuardMut {
guard: MappedMutexGuard::map(s.guard, f),
handle: s.handle,
}
}
}
impl<T: ?Sized> Deref for RefGuard<'_, T> {
type Target = T;
fn deref(&self) -> &Self::Target {
&self.guard
}
}
impl<T: ?Sized> Deref for RefGuardMut<'_, T> {
type Target = T;
fn deref(&self) -> &Self::Target {
&self.guard
}
}
impl<T: ?Sized> DerefMut for RefGuardMut<'_, T> {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.guard
}
}
impl<T: ?Sized, U> Deref for MappedRefGuard<'_, T, U> {
type Target = U;
fn deref(&self) -> &Self::Target {
&self.guard
}
}
impl<T: ?Sized, U> Deref for MappedRefGuardMut<'_, T, U> {
type Target = U;
fn deref(&self) -> &Self::Target {
&self.guard
}
}
impl<T: ?Sized, U> DerefMut for MappedRefGuardMut<'_, T, U> {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.guard
}
}

54
core/src/util/id.rs
View File

@@ -1,3 +1,5 @@
use std::sync::Mutex;
#[repr(C)]
#[derive(Eq, Hash, PartialEq, Debug, Clone, Copy, bytemuck::Zeroable)]
pub struct Id<I = u64>(I);
@@ -9,7 +11,14 @@ pub struct IdTracker<I = u64> {
cur: Id<I>,
}
impl<I: IdNum> IdTracker<I> {
impl<I: const IdNum> IdTracker<I> {
pub const fn new() -> Self {
Self {
free: Vec::new(),
cur: Id(I::first()),
}
}
#[allow(clippy::should_implement_trait)]
pub fn next(&mut self) -> Id<I> {
if let Some(id) = self.free.pop() {
@@ -43,22 +52,19 @@ impl<I: IdNum> Id<I> {
}
}
impl<I: IdNum> Default for IdTracker<I> {
impl<I: const IdNum> Default for IdTracker<I> {
fn default() -> Self {
Self {
free: Vec::new(),
cur: Id(I::first()),
}
Self::new()
}
}
pub trait IdNum {
pub const trait IdNum {
fn first() -> Self;
fn next(&self) -> Self;
fn idx(&self) -> usize;
}
impl IdNum for u64 {
impl const IdNum for u64 {
fn first() -> Self {
0
}
@@ -72,7 +78,7 @@ impl IdNum for u64 {
}
}
impl IdNum for u32 {
impl const IdNum for u32 {
fn first() -> Self {
0
}
@@ -85,3 +91,33 @@ impl IdNum for u32 {
*self as usize
}
}
pub struct StaticIdTracker<I = u64>(Mutex<IdTracker<I>>);
impl<I: const IdNum> StaticIdTracker<I> {
pub const fn new() -> Self {
Self(Mutex::new(IdTracker::new()))
}
#[allow(clippy::should_implement_trait)]
pub fn next(&self) -> Id<I> {
let mut s = self.0.lock().unwrap();
if let Some(id) = s.free.pop() {
return id;
}
let next = s.cur.next();
std::mem::replace(&mut s.cur, next)
}
#[allow(dead_code)]
pub fn free(&self, id: Id<I>) {
let mut s = self.0.lock().unwrap();
s.free.push(id);
}
}
impl<I: const IdNum> Default for StaticIdTracker<I> {
fn default() -> Self {
Self::new()
}
}

6
core/src/util/refcount.rs
View File

@@ -24,6 +24,12 @@ impl RefCounter {
}
}
impl Default for RefCounter {
fn default() -> Self {
Self::new()
}
}
impl Clone for RefCounter {
fn clone(&self) -> Self {
self.0.fetch_add(1, Ordering::Release);

42
macro/src/lib.rs
View File

@@ -2,12 +2,13 @@ extern crate proc_macro;
use proc_macro::TokenStream;
use quote::quote;
use syn::{
Block, Ident, Signature, Token, Visibility,
Attribute, Block, Ident, ItemTrait, Signature, Token, Visibility,
parse::{Parse, ParseStream, Result},
parse_macro_input,
parse_macro_input, parse_quote,
};
struct Input {
attrs: Vec<Attribute>,
vis: Visibility,
name: Ident,
fns: Vec<InputFn>,
@@ -20,6 +21,7 @@ struct InputFn {
impl Parse for Input {
fn parse(input: ParseStream) -> Result<Self> {
let attrs = input.call(Attribute::parse_outer)?;
let vis = input.parse()?;
input.parse::<Token![trait]>()?;
let name = input.parse()?;
@@ -33,27 +35,23 @@ impl Parse for Input {
if !input.is_empty() {
input.error("function expected");
}
Ok(Input { vis, name, fns })
Ok(Input {
attrs,
vis,
name,
fns,
})
}
}
// pub trait $name<W: WidgetLike<Tag>, Tag> {
// $(
// fn $fn $(<$($T $(: $TT $(+ $TL)?)?,)*>)?($self $(, $arg: $ty)*) -> $ret;
// )*
// }
//
// impl<W: WidgetLike<Tag>, Tag> $name<W, Tag> for W {
// $(
// fn $fn $(<$($T $(: $TT $(+ $TL)?)?,)*>)?($self $(, $arg: $ty)*) -> $ret {
// $code
// }
// )*
// }
#[proc_macro]
pub fn widget_trait(input: TokenStream) -> TokenStream {
let Input { vis, name, fns } = parse_macro_input!(input as Input);
let Input {
attrs,
vis,
name,
fns,
} = parse_macro_input!(input as Input);
let sigs: Vec<_> = fns.iter().map(|f| f.sig.clone()).collect();
let impls: Vec<_> = fns
@@ -61,10 +59,16 @@ pub fn widget_trait(input: TokenStream) -> TokenStream {
.map(|InputFn { sig, body }| quote! { #sig #body })
.collect();
TokenStream::from(quote! {
let mut trai: ItemTrait = parse_quote!(
#vis trait #name<WL: WidgetLike<Tag>, Tag> {
#(#sigs;)*
}
);
trai.attrs = attrs;
TokenStream::from(quote! {
#trai
impl<WL: WidgetLike<Tag>, Tag> #name<WL, Tag> for WL {
#(#impls)*

8
src/bin/test/main.rs
View File

@@ -58,7 +58,7 @@ impl DefaultAppState for Client {
.on(CursorSense::click(), move |ctx| {
let child = image(include_bytes!("assets/sungals.png"))
.center()
.add(ctx.ui);
.add(ctx.data.ui);
span_add_.get_mut().children.push(child);
})
.sized((150, 150))
@@ -113,7 +113,9 @@ impl DefaultAppState for Client {
.text_align(Align::LEFT)
.wrap(true)
.attr::<Selectable>(());
let msg_box = text.background(rect(Color::WHITE.darker(0.5))).add(ctx.ui);
let msg_box = text
.background(rect(Color::WHITE.darker(0.5)))
.add(&mut Ui::new());
texts_.get_mut().children.push(msg_box);
})
.add(ui);
@@ -126,7 +128,7 @@ impl DefaultAppState for Client {
add_text.width(rest(1)),
Rect::new(Color::GREEN)
.on(CursorSense::click(), move |ctx| {
ctx.ui.run_event(ctx.state, add_text_, Submit, ());
Events::<Submit, _>::run(add_text_.id(), &mut (), ctx.state);
})
.sized((40, 40)),
)

37
src/default/attr.rs
View File

@@ -2,20 +2,22 @@ use crate::{default::UiState, prelude::*};
use std::time::{Duration, Instant};
use winit::dpi::{LogicalPosition, LogicalSize};
event_ctx!(UiState);
pub struct Selector;
impl<W: 'static> WidgetAttr<W> for Selector {
impl<W: Widget + 'static> WidgetAttr<W> for Selector {
type Input = WidgetRef<TextEdit>;
fn run(ui: &mut Ui, container: WidgetRef<W>, id: Self::Input) {
ui.register_event(container, CursorSense::click_or_drag(), move |mut ctx| {
let ui = ctx.ui;
container.on(CursorSense::click_or_drag(), move |ctx| {
let ui = &mut ctx.data.ui;
let region = ui.window_region(&id).unwrap();
let id_pos = region.top_left;
let container_pos = ui.window_region(&container).unwrap().top_left;
ctx.data.cursor += container_pos - id_pos;
ctx.data.size = region.size();
select(ui, id, ctx.state, ctx.data);
let pos = ctx.data.pos + container_pos - id_pos;
let size = region.size();
select(ui, id, ctx.state, pos, size, ctx.data.sense.is_dragging());
});
}
}
@@ -26,18 +28,31 @@ impl WidgetAttr<TextEdit> for Selectable {
type Input = ();
fn run(ui: &mut Ui, id: WidgetRef<TextEdit>, _: Self::Input) {
ui.register_event(id, CursorSense::click_or_drag(), move |ctx| {
select(ctx.ui, id, ctx.state, ctx.data);
id.on(CursorSense::click_or_drag(), move |ctx| {
select(
ctx.data.ui,
id,
ctx.state,
ctx.data.pos,
ctx.data.size,
ctx.data.sense.is_dragging(),
);
});
}
}
fn select(ui: &mut Ui, id: WidgetRef<TextEdit>, state: &mut UiState, data: CursorData) {
fn select(
ui: &mut Ui,
id: WidgetRef<TextEdit>,
state: &mut UiState,
pos: Vec2,
size: Vec2,
dragging: bool,
) {
let now = Instant::now();
let recent = (now - state.last_click) < Duration::from_millis(300);
state.last_click = now;
id.get_mut()
.select(data.cursor, data.size, data.sense.is_dragging(), recent);
id.get_mut().select(pos, size, dragging, recent);
if let Some(region) = ui.window_region(&id) {
state.window.set_ime_allowed(true);
state.window.set_ime_cursor_area(

16
src/default/event.rs
View File

@@ -1,15 +1,9 @@
use crate::layout::DefaultEvent;
use iris_core::layout::Event;
#[derive(Eq, PartialEq, Hash, Clone)]
#[derive(Clone)]
pub struct Submit;
impl Event for Submit {}
#[derive(Eq, PartialEq, Hash, Clone)]
#[derive(Clone)]
pub struct Edited;
impl DefaultEvent for Submit {
type Data = ();
}
impl DefaultEvent for Edited {
type Data = ();
}
impl Event for Edited {}

6
src/default/mod.rs
View File

@@ -130,13 +130,13 @@ impl<State: DefaultAppState> AppState for DefaultState<State> {
ui_state.window.set_ime_allowed(false);
}
TextInputResult::Submit => {
ui.run_event(app_state, sel, Submit, ());
Events::<Submit, _>::run(sel.id(), &mut (), app_state);
}
TextInputResult::Paste => {
if let Ok(t) = ui_state.clipboard.get_text() {
sel.get_mut().insert(&t);
}
ui.run_event(app_state, sel, Edited, ());
Events::<Edited, _>::run(sel.id(), &mut (), app_state);
}
TextInputResult::Copy(text) => {
if let Err(err) = ui_state.clipboard.set_text(text) {
@@ -144,7 +144,7 @@ impl<State: DefaultAppState> AppState for DefaultState<State> {
}
}
TextInputResult::Used => {
ui.run_event(app_state, sel, Edited, ());
Events::<Edited, _>::run(sel.id(), &mut (), app_state);
}
TextInputResult::Unused => {}
}

52
src/event.rs
View File

@@ -6,14 +6,14 @@ pub mod eventable {
widget_trait! {
pub trait Eventable;
fn on<E: Event, Ctx: 'static>(
fn on<E: EventAlias, Ctx: 'static>(
self,
event: E,
f: impl WidgetEventFn<Ctx, E::Data, WL::Widget>,
f: impl for<'a> EventIdFn<Ctx, <E::Event as Event>::Data<'a>, WL::Widget>,
) -> impl WidgetIdFn<WL::Widget> {
move |ui| {
let id = self.add(ui);
ui.register_widget_event(id.weak(), event, f);
Events::<E::Event, Ctx>::register(id.weak(), event.into_event(), f);
id
}
}
@@ -26,53 +26,37 @@ macro_rules! event_ctx {
($ty: ty) => {
mod local_event_trait {
use super::*;
use std::marker::Sized;
#[allow(unused_imports)]
use $crate::prelude::*;
widget_trait! {
#[allow(unused)]
pub trait EventableCtx<W: ?Sized, Tag, Ctx: 'static> {
fn on<E: Event>(
pub trait EventableCtx;
fn on<E: EventAlias>(
self,
event: E,
f: impl WidgetEventFn<Ctx, E::Data, W>,
) -> impl WidgetIdFn<W> + EventableCtx<W, IdFnTag, Ctx>;
}
impl<WL: WidgetLike<Tag>, Tag> EventableCtx<WL::Widget, Tag, $ty> for WL {
fn on<E: Event>(
self,
event: E,
f: impl WidgetEventFn<$ty, E::Data, WL::Widget>,
) -> impl WidgetIdFn<WL::Widget> + EventableCtx<WL::Widget, IdFnTag, $ty> {
f: impl for<'a> EventIdFn<$ty, <E::Event as Event>::Data<'a>, WL::Widget>,
) -> impl WidgetIdFn<WL::Widget> {
eventable::Eventable::on(self, event, f)
}
}
use std::marker::Sized;
#[allow(unused)]
pub trait EventableCtxUi<W: ?Sized, Tag, Ctx: 'static>
where
WidgetRef<W>: EventableCtx<W, Tag, Ctx>,
{
fn on<E: Event>(
&mut self,
widget: WidgetRef<W>,
pub trait EventableCtxRef<W: Widget + ?Sized> {
fn on<E: EventAlias>(
self,
event: E,
f: impl WidgetEventFn<Ctx, E::Data, W>,
f: impl for<'a> EventIdFn<$ty, <E::Event as Event>::Data<'a>, W>,
);
}
impl<W: ?Sized + 'static, Tag> EventableCtxUi<W, Tag, $ty> for Ui
where
WidgetRef<W>: EventableCtx<W, Tag, $ty>,
{
fn on<E: Event>(
&mut self,
widget: WidgetRef<W>,
impl<W: Widget + ?Sized> EventableCtxRef<W> for WidgetRef<W> {
fn on<E: EventAlias>(
self,
event: E,
f: impl WidgetEventFn<$ty, E::Data, W>,
f: impl for<'a> EventIdFn<$ty, <E::Event as Event>::Data<'a>, W>,
) {
self.register_widget_event(widget, event, f);
Events::<E::Event, $ty>::register(self, event.into_event(), f);
}
}
}

0
src/widget/event.rs
View File

217
src/widget/sense.rs
View File

@@ -1,8 +1,5 @@
use crate::layout::{UiRegion, Vec2};
use crate::prelude::*;
use crate::{
layout::{UiModule, UiRegion, Vec2},
util::HashMap,
};
use std::{
ops::{BitOr, Deref, DerefMut},
rc::Rc,
@@ -26,8 +23,22 @@ pub enum CursorSense {
Scroll,
}
#[derive(Clone)]
pub struct CursorSenses(Vec<CursorSense>);
impl Event for CursorSenses {
type Data<'a> = CursorData<'a>;
type State = SensorState;
fn should_run(&self, data: &mut Self::Data<'_>) -> bool {
if let Some(sense) = should_run(self, data.cursor, data.hover) {
data.sense = sense;
true
} else {
false
}
}
}
impl CursorSense {
pub fn click() -> Self {
Self::PressStart(CursorButton::Left)
@@ -72,6 +83,16 @@ impl CursorButtons {
self.middle.end_frame();
self.right.end_frame();
}
pub fn iter(&self) -> impl Iterator<Item = (CursorButton, &ActivationState)> {
[
CursorButton::Left,
CursorButton::Middle,
CursorButton::Right,
]
.into_iter()
.map(|b| (b, self.select(&b)))
}
}
impl CursorState {
@@ -100,70 +121,25 @@ pub struct Sensor<Ctx, Data> {
pub f: Rc<dyn EventFn<Ctx, Data>>,
}
pub type SensorMap<Ctx, Data> = HashMap<WidgetId, SensorGroup<Ctx, Data>>;
pub type SenseShape = UiRegion;
pub struct SensorGroup<Ctx, Data> {
#[derive(Default, Debug)]
pub struct SensorState {
pub hover: ActivationState,
pub sensors: Vec<Sensor<Ctx, Data>>,
}
#[derive(Clone)]
pub struct CursorData {
pub cursor: Vec2,
pub struct CursorData<'a> {
/// where this widget was hit
pub pos: Vec2,
pub size: Vec2,
pub scroll_delta: Vec2,
/// the (first) sense that triggered this event
/// the senses are checked in order
pub hover: ActivationState,
pub cursor: &'a CursorState,
pub ui: &'a mut Ui,
/// the first sense that triggered this
pub sense: CursorSense,
}
pub struct CursorModule<Ctx> {
map: SensorMap<Ctx, CursorData>,
active: HashMap<usize, HashMap<WidgetId, SenseShape>>,
}
impl<Ctx: 'static> UiModule for CursorModule<Ctx> {
fn on_draw(&mut self, inst: &WidgetInstance) {
if self.map.contains_key(&inst.id) {
self.active
.entry(inst.layer)
.or_default()
.insert(inst.id, inst.region);
}
}
fn on_undraw(&mut self, inst: &WidgetInstance) {
if let Some(layer) = self.active.get_mut(&inst.layer) {
layer.remove(&inst.id);
}
}
fn on_remove(&mut self, id: &WidgetId) {
self.map.remove(id);
for layer in self.active.values_mut() {
layer.remove(id);
}
}
fn on_move(&mut self, inst: &WidgetInstance) {
if let Some(map) = self.active.get_mut(&inst.layer)
&& let Some(region) = map.get_mut(&inst.id)
{
*region = inst.region;
}
}
}
impl<Ctx> CursorModule<Ctx> {
pub fn merge(&mut self, other: Self) {
for (id, group) in other.map {
for sensor in group.sensors {
self.map.entry(id).or_default().sensors.push(sensor);
}
}
}
}
pub trait SensorUi {
fn run_sensors<Ctx: 'static>(&mut self, ctx: &mut Ctx, cursor: &CursorState, window_size: Vec2);
}
@@ -175,55 +151,41 @@ impl SensorUi for Ui {
cursor: &CursorState,
window_size: Vec2,
) {
CursorModule::<Ctx>::run(self, ctx, cursor, window_size);
}
}
impl<Ctx: 'static> CursorModule<Ctx> {
pub fn run(ui: &mut Ui, ctx: &mut Ctx, cursor: &CursorState, window_size: Vec2) {
let layers = std::mem::take(&mut ui.data_mut().layers);
let mut module = std::mem::take(ui.data_mut().modules.get_mut::<Self>());
let ui_id = self.id();
let layers = std::mem::take(&mut self.data_mut().layers);
let mut active = std::mem::take(&mut *Events::<CursorSenses, Ctx>::active(ui_id));
for i in layers.indices().rev() {
let Some(list) = module.active.get_mut(&i) else {
continue;
};
let mut sensed = false;
for (id, shape) in list.iter() {
let group = module.map.get_mut(id).unwrap();
for (id, state) in active.get_mut(&i).into_iter().flatten() {
let shape = self.active().get(id).unwrap().region;
let region = shape.to_px(window_size);
let in_shape = cursor.exists && region.contains(cursor.pos);
group.hover.update(in_shape);
if group.hover == ActivationState::Off {
state.hover.update(in_shape);
if state.hover == ActivationState::Off {
continue;
}
sensed = true;
for sensor in &mut group.sensors {
if let Some(sense) = should_run(&sensor.senses, cursor, group.hover) {
let data = CursorData {
cursor: cursor.pos - region.top_left,
let mut data = CursorData {
pos: cursor.pos - region.top_left,
size: region.bot_right - region.top_left,
scroll_delta: cursor.scroll_delta,
sense,
hover: state.hover,
cursor,
ui: self,
// this does not have any meaning;
// might wanna set up Event to have a prepare stage
sense: CursorSense::Hovering,
};
(sensor.f)(EventCtx {
ui,
state: ctx,
data,
});
}
}
Events::<CursorSenses, Ctx>::run(*id, &mut data, ctx);
}
if sensed {
break;
}
}
let ui_mod = ui.data_mut().modules.get_mut::<Self>();
std::mem::swap(ui_mod, &mut module);
ui_mod.merge(module);
ui.data_mut().layers = layers;
*Events::<CursorSenses, Ctx>::active(ui_id) = active;
self.data_mut().layers = layers;
}
}
@@ -291,66 +253,10 @@ impl ActivationState {
}
}
impl Event for CursorSenses {
type Module<Ctx: 'static> = CursorModule<Ctx>;
type Data = CursorData;
}
impl Event for CursorSense {
type Module<Ctx: 'static> = CursorModule<Ctx>;
type Data = CursorData;
}
impl<E: Event<Data = <CursorSenses as Event>::Data> + Into<CursorSenses>, Ctx: 'static>
EventModule<E, Ctx> for CursorModule<Ctx>
{
fn register(&mut self, id: WidgetId, senses: E, f: impl EventFn<Ctx, <E as Event>::Data>) {
// TODO: does not add to active if currently active
self.map.entry(id).or_default().sensors.push(Sensor {
senses: senses.into(),
f: Rc::new(f),
});
}
fn run<'a>(
&mut self,
id: WidgetId,
event: E,
) -> Option<impl FnOnce(EventCtx<Ctx, <E as Event>::Data>) + use<'a, Ctx, E>> {
let senses = event.into();
if let Some(group) = self.map.get_mut(&id) {
let fs: Vec<_> = group
.sensors
.iter_mut()
.filter_map(|sensor| {
if sensor.senses.iter().any(|s| senses.contains(s)) {
Some(sensor.f.clone())
} else {
None
}
})
.collect();
Some(move |ctx: EventCtx<Ctx, CursorData>| {
for f in fs {
f(EventCtx {
state: ctx.state,
ui: ctx.ui,
data: ctx.data.clone(),
});
}
})
} else {
None
}
}
}
impl<Ctx, Data> Default for SensorGroup<Ctx, Data> {
fn default() -> Self {
Self {
hover: Default::default(),
sensors: Default::default(),
}
impl EventAlias for CursorSense {
type Event = CursorSenses;
fn into_event(self) -> Self::Event {
CursorSenses::from(self)
}
}
@@ -390,12 +296,3 @@ impl BitOr<CursorSense> for CursorSenses {
self
}
}
impl<Ctx> Default for CursorModule<Ctx> {
fn default() -> Self {
Self {
map: Default::default(),
active: Default::default(),
}
}
}