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

IDC FINALLY OH MY GOD (I think like ctx + resize propagation + some other stuff)

Browse Source
This commit is contained in:
Shadow Cat
2025-09-11 00:59:26 -04:00
parent 709a2d0e17
commit 242c3b992e
15 changed files with 476 additions and 281 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/core/image.rs
View File

@@ -15,7 +15,7 @@ impl Widget for Image {
} }
} }
pub fn image(image: impl LoadableImage) -> impl WidgetFn<Image> { pub fn image<Ctx>(image: impl LoadableImage) -> impl WidgetFn<Image, Ctx> {
let image = image.get_image().expect("Failed to load image"); let image = image.get_image().expect("Failed to load image");
move |ui| Image { move |ui| Image {
handle: ui.add_texture(image), handle: ui.add_texture(image),

28
src/core/sense.rs
View File

@@ -1,25 +1,26 @@
use crate::prelude::*; use crate::prelude::*;
pub trait Sensable<W, Tag> { pub trait Sensable<W, Ctx, Tag> {
fn on(self, sense: Senses, f: impl SenseFn) -> impl WidgetIdFn<W>; fn on(self, sense: Senses, f: impl SenseFn<Ctx>) -> impl WidgetIdFn<W, Ctx>;
fn id_on( fn id_on(
self, self,
senses: Senses, senses: Senses,
f: impl FnMut(&WidgetId<W>, &mut Ui, SenseCtx) + 'static, f: impl FnMut(&WidgetId<W>, &mut Ctx, SenseCtx) + 'static,
) -> impl WidgetIdFn<W> ) -> impl WidgetIdFn<W, Ctx>
where where
W: Widget; W: Widget;
fn edit_on( fn edit_on(
self, self,
senses: Senses, senses: Senses,
f: impl FnMut(&mut W, SenseCtx) + 'static, f: impl FnMut(&mut W, SenseCtx) + 'static,
) -> impl WidgetIdFn<W> ) -> impl WidgetIdFn<W, Ctx>
where where
W: Widget; W: Widget,
Ctx: UiCtx;
} }
impl<W: WidgetLike<Tag>, Tag> Sensable<W::Widget, Tag> for W { impl<W: WidgetLike<Ctx, Tag>, Ctx, Tag> Sensable<W::Widget, Ctx, Tag> for W {
fn on(self, senses: Senses, f: impl SenseFn) -> impl WidgetIdFn<W::Widget> { fn on(self, senses: Senses, f: impl SenseFn<Ctx>) -> impl WidgetIdFn<W::Widget, Ctx> {
move |ui| { move |ui| {
let id = self.add(ui); let id = self.add(ui);
ui.add_sensor( ui.add_sensor(
@@ -35,24 +36,25 @@ impl<W: WidgetLike<Tag>, Tag> Sensable<W::Widget, Tag> for W {
fn id_on( fn id_on(
self, self,
senses: Senses, senses: Senses,
mut f: impl FnMut(&WidgetId<W::Widget>, &mut Ui, SenseCtx) + 'static, mut f: impl FnMut(&WidgetId<W::Widget>, &mut Ctx, SenseCtx) + 'static,
) -> impl WidgetIdFn<W::Widget> ) -> impl WidgetIdFn<W::Widget, Ctx>
where where
W::Widget: Widget, W::Widget: Widget,
{ {
self.with_id(move |ui, id| { self.with_id(move |ui, id| {
let id2 = id.clone(); let id2 = id.clone();
ui.add(id.on(senses, move |ui, pos| f(&id2, ui, pos))) id.on(senses, move |ctx, pos| f(&id2, ctx, pos)).add(ui)
}) })
} }
fn edit_on( fn edit_on(
self, self,
senses: Senses, senses: Senses,
mut f: impl FnMut(&mut W::Widget, SenseCtx) + 'static, mut f: impl FnMut(&mut W::Widget, SenseCtx) + 'static,
) -> impl WidgetIdFn<W::Widget> ) -> impl WidgetIdFn<W::Widget, Ctx>
where where
W::Widget: Widget, W::Widget: Widget,
Ctx: UiCtx,
{ {
self.id_on(senses, move |id, ui, pos| f(&mut ui[id], pos)) self.id_on(senses, move |id, ctx, pos| f(&mut ctx.ui()[id], pos))
} }
} }

98
src/core/text.rs
View File

@@ -5,6 +5,7 @@ use crate::prelude::*;
pub struct Text { pub struct Text {
pub content: String, pub content: String,
pub attrs: TextAttrs, pub attrs: TextAttrs,
/// inner alignment of text region (within where its drawn)
pub align: Align, pub align: Align,
buf: TextBuffer, buf: TextBuffer,
cursor: Cursor, cursor: Cursor,
@@ -40,17 +41,109 @@ impl Text {
size: Vec2::ZERO, size: Vec2::ZERO,
} }
} }
pub fn select(&mut self, pos: Vec2, size: Vec2) { pub fn select(&mut self, pos: Vec2, size: Vec2) {
let pos = pos - self.region().top_left.to_size(size); let pos = pos - self.region().top_left.to_size(size);
let Some(cursor) = self.buf.hit(pos.x, pos.y) else { let Some(cursor) = self.buf.hit(pos.x, pos.y) else {
return; return;
}; };
self.cursor = Cursor::Select { self.cursor = Cursor::Select {
line: cursor.line, line: cursor.line as isize,
idx: cursor.index, col: cursor.index as isize,
}; };
} }
pub fn deselect(&mut self) {
self.cursor = Cursor::None;
}
pub fn insert(&mut self, text: &str) {
let i = self.update_cursor();
self.content.insert_str(i, text);
match &mut self.cursor {
Cursor::None => (),
Cursor::Select { line, col } => {
*col += 1;
}
}
}
pub fn backspace(&mut self) {
if let Some(i) = self.update_cursor().checked_sub(1) {
self.content.remove(i);
match &mut self.cursor {
Cursor::None => (),
Cursor::Select { line, col } => {
*col -= 1;
}
}
}
}
pub fn delete(&mut self) {
let i = self.update_cursor();
if i != self.content.len() {
self.content.remove(i);
}
}
pub fn move_cursor(&mut self, dir: Dir) {
if let Cursor::Select { line, col } = &mut self.cursor {
match dir {
Dir::LEFT => *col -= 1,
Dir::RIGHT => *col += 1,
Dir::UP => *line -= 1,
Dir::DOWN => *line += 1,
}
}
}
pub fn update_cursor(&mut self) -> usize {
match &mut self.cursor {
Cursor::None => 0,
Cursor::Select { line, col } => {
if *col < 0 {
*line -= 1;
}
if *line < 0 {
*line = 0;
*col = 0;
}
let mut idx = self.content.len();
let mut l = 0;
let mut c = 0;
let mut cur_len = 0;
for (i, ch) in self.content.chars().enumerate() {
if ch == '\n' {
l += 1;
c = 0;
} else {
if l == *line {
cur_len = i as isize + 1;
if c == *col {
idx = i;
}
}
c += 1;
}
}
if *col < 0 {
*col = cur_len;
}
if *col > cur_len {
*col = 0;
*line += 1;
}
if *line > l {
*line = l;
*col = cur_len;
}
idx
}
}
}
pub fn region(&self) -> UiRegion { pub fn region(&self) -> UiRegion {
UiRegion::from_size_align(self.size, self.align) UiRegion::from_size_align(self.size, self.align)
} }
@@ -58,6 +151,7 @@ impl Text {
impl Widget for Text { impl Widget for Text {
fn draw(&mut self, painter: &mut Painter) { fn draw(&mut self, painter: &mut Painter) {
self.update_cursor();
let (handle, offset) = let (handle, offset) =
painter.render_text(&mut self.buf, &self.content, &self.attrs, &self.cursor); painter.render_text(&mut self.buf, &self.content, &self.attrs, &self.cursor);
let dims = handle.size(); let dims = handle.size();

42
src/core/trait_fns.rs
View File

@@ -1,34 +1,34 @@
use super::*; use super::*;
use crate::prelude::*; use crate::prelude::*;
pub trait CoreWidget<W, Tag> { pub trait CoreWidget<W, Ctx, Tag> {
fn pad(self, padding: impl Into<Padding>) -> impl WidgetFn<Padded>; fn pad(self, padding: impl Into<Padding>) -> impl WidgetFn<Padded, Ctx>;
fn align(self, align: Align) -> impl WidgetFn<Aligned>; fn align(self, align: Align) -> impl WidgetFn<Aligned, Ctx>;
fn center(self) -> impl WidgetFn<Aligned>; fn center(self) -> impl WidgetFn<Aligned, Ctx>;
fn label(self, label: impl Into<String>) -> impl WidgetIdFn<W>; fn label(self, label: impl Into<String>) -> impl WidgetIdFn<W, Ctx>;
fn size(self, size: impl Into<Vec2>) -> impl WidgetFn<Sized>; fn size(self, size: impl Into<Vec2>) -> impl WidgetFn<Sized, Ctx>;
} }
impl<W: WidgetLike<Tag>, Tag> CoreWidget<W::Widget, Tag> for W { impl<W: WidgetLike<Ctx, Tag>, Ctx, Tag> CoreWidget<W::Widget, Ctx, Tag> for W {
fn pad(self, padding: impl Into<Padding>) -> impl WidgetFn<Padded> { fn pad(self, padding: impl Into<Padding>) -> impl WidgetFn<Padded, Ctx> {
|ui| Padded { |ui| Padded {
padding: padding.into(), padding: padding.into(),
inner: self.add(ui).erase_type(), inner: self.add(ui).any(),
} }
} }
fn align(self, align: Align) -> impl WidgetFn<Aligned> { fn align(self, align: Align) -> impl WidgetFn<Aligned, Ctx> {
move |ui| Aligned { move |ui| Aligned {
inner: self.add(ui).erase_type(), inner: self.add(ui).any(),
align, align,
} }
} }
fn center(self) -> impl WidgetFn<Aligned> { fn center(self) -> impl WidgetFn<Aligned, Ctx> {
self.align(Align::Center) self.align(Align::Center)
} }
fn label(self, label: impl Into<String>) -> impl WidgetIdFn<W::Widget> { fn label(self, label: impl Into<String>) -> impl WidgetIdFn<W::Widget, Ctx> {
|ui| { |ui| {
let id = self.add(ui); let id = self.add(ui);
ui.set_label(&id, label.into()); ui.set_label(&id, label.into());
@@ -36,28 +36,28 @@ impl<W: WidgetLike<Tag>, Tag> CoreWidget<W::Widget, Tag> for W {
} }
} }
fn size(self, size: impl Into<Vec2>) -> impl WidgetFn<Sized> { fn size(self, size: impl Into<Vec2>) -> impl WidgetFn<Sized, Ctx> {
move |ui| Sized { move |ui| Sized {
inner: self.add(ui).erase_type(), inner: self.add(ui).any(),
size: size.into(), size: size.into(),
} }
} }
} }
pub trait CoreWidgetArr<const LEN: usize, Tag> { pub trait CoreWidgetArr<const LEN: usize, Ctx, Tag> {
fn span(self, dir: Dir, lengths: impl IntoSpanLens<LEN>) -> impl WidgetFn<Span>; fn span(self, dir: Dir, lengths: impl IntoSpanLens<LEN>) -> impl WidgetFn<Span, Ctx>;
fn stack(self) -> impl WidgetFn<Stack>; fn stack(self) -> impl WidgetFn<Stack, Ctx>;
} }
impl<const LEN: usize, Wa: WidgetArrLike<LEN, Tag>, Tag> CoreWidgetArr<LEN, Tag> for Wa { impl<const LEN: usize, Wa: WidgetArrLike<LEN, Ctx, Tag>, Ctx, Tag> CoreWidgetArr<LEN, Ctx, Tag> for Wa {
fn span(self, dir: Dir, lengths: impl IntoSpanLens<LEN>) -> impl WidgetFn<Span> { fn span(self, dir: Dir, lengths: impl IntoSpanLens<LEN>) -> impl WidgetFn<Span, Ctx> {
let lengths = lengths.into_lens(); let lengths = lengths.into_lens();
move |ui| Span { move |ui| Span {
children: self.ui(ui).arr.into_iter().zip(lengths).collect(), children: self.ui(ui).arr.into_iter().zip(lengths).collect(),
dir, dir,
} }
} }
fn stack(self) -> impl WidgetFn<Stack> { fn stack(self) -> impl WidgetFn<Stack, Ctx> {
move |ui| Stack { move |ui| Stack {
children: self.ui(ui).arr.to_vec(), children: self.ui(ui).arr.to_vec(),
} }

37
src/layout/id.rs
View File

@@ -78,7 +78,7 @@ impl<W> WidgetId<W> {
} }
} }
pub fn erase_type(self) -> WidgetId<AnyWidget> { pub fn any(self) -> WidgetId<AnyWidget> {
self.cast_type() self.cast_type()
} }
@@ -127,14 +127,14 @@ impl<W> Drop for WidgetId<W> {
pub struct IdTag; pub struct IdTag;
pub struct IdFnTag; pub struct IdFnTag;
pub trait WidgetIdFn<W>: FnOnce(&mut Ui) -> WidgetId<W> {} pub trait WidgetIdFn<W, Ctx>: FnOnce(&mut Ui<Ctx>) -> WidgetId<W> {}
impl<W, F: FnOnce(&mut Ui) -> WidgetId<W>> WidgetIdFn<W> for F {} impl<W, F: FnOnce(&mut Ui<Ctx>) -> WidgetId<W>, Ctx> WidgetIdFn<W, Ctx> for F {}
/// TODO: does this ever make sense to use? it allows for invalid ids /// TODO: does this ever make sense to use? it allows for invalid ids
pub trait Idable<Tag> { pub trait Idable<Ctx, Tag> {
type Widget: Widget; type Widget: Widget;
fn set(self, ui: &mut Ui, id: &WidgetId<Self::Widget>); fn set(self, ui: &mut Ui<Ctx>, id: &WidgetId<Self::Widget>);
fn id(self, id: &WidgetId<Self::Widget>) -> impl WidgetIdFn<Self::Widget> fn id(self, id: &WidgetId<Self::Widget>) -> impl WidgetIdFn<Self::Widget, Ctx>
where where
Self: Sized, Self: Sized,
{ {
@@ -144,7 +144,7 @@ pub trait Idable<Tag> {
id id
} }
} }
fn id_static(self, id: StaticWidgetId<Self::Widget>) -> impl WidgetIdFn<Self::Widget> fn id_static(self, id: StaticWidgetId<Self::Widget>) -> impl WidgetIdFn<Self::Widget, Ctx>
where where
Self: Sized, Self: Sized,
{ {
@@ -156,33 +156,33 @@ pub trait Idable<Tag> {
} }
} }
impl<W: Widget> Idable<WidgetTag> for W { impl<W: Widget, Ctx> Idable<Ctx, WidgetTag> for W {
type Widget = W; type Widget = W;
fn set(self, ui: &mut Ui, id: &WidgetId<Self::Widget>) { fn set(self, ui: &mut Ui<Ctx>, id: &WidgetId<Self::Widget>) {
ui.set(id, self); ui.set(id, self);
} }
} }
impl<F: FnOnce(&mut Ui) -> W, W: Widget> Idable<FnTag> for F { impl<F: FnOnce(&mut Ui<Ctx>) -> W, W: Widget, Ctx> Idable<Ctx, FnTag> for F {
type Widget = W; type Widget = W;
fn set(self, ui: &mut Ui, id: &WidgetId<Self::Widget>) { fn set(self, ui: &mut Ui<Ctx>, id: &WidgetId<Self::Widget>) {
let w = self(ui); let w = self(ui);
ui.set(id, w); ui.set(id, w);
} }
} }
impl<W: 'static> WidgetLike<IdTag> for WidgetId<W> { impl<W: 'static, Ctx> WidgetLike<Ctx, IdTag> for WidgetId<W> {
type Widget = W; type Widget = W;
fn add(self, _: &mut Ui) -> WidgetId<W> { fn add(self, _: &mut Ui<Ctx>) -> WidgetId<W> {
self self
} }
} }
impl<W: 'static, F: FnOnce(&mut Ui) -> WidgetId<W>> WidgetLike<IdFnTag> for F { impl<W: 'static, F: FnOnce(&mut Ui<Ctx>) -> WidgetId<W>, Ctx> WidgetLike<Ctx, IdFnTag> for F {
type Widget = W; type Widget = W;
fn add(self, ui: &mut Ui) -> WidgetId<W> { fn add(self, ui: &mut Ui<Ctx>) -> WidgetId<W> {
self(ui) self(ui)
} }
} }
@@ -191,11 +191,14 @@ impl<W> StaticWidgetId<W> {
pub fn to_id(&self, send: &Sender<Id>) -> WidgetId<W> { pub fn to_id(&self, send: &Sender<Id>) -> WidgetId<W> {
WidgetId::new(self.id.id(), self.ty, send.clone(), true) WidgetId::new(self.id.id(), self.ty, send.clone(), true)
} }
pub fn any(self) -> StaticWidgetId<AnyWidget> {
unsafe { std::mem::transmute(self) }
}
} }
impl<W: 'static> WidgetLike<IdTag> for StaticWidgetId<W> { impl<W: 'static, Ctx> WidgetLike<Ctx, IdTag> for StaticWidgetId<W> {
type Widget = W; type Widget = W;
fn add(self, ui: &mut Ui) -> WidgetId<W> { fn add(self, ui: &mut Ui<Ctx>) -> WidgetId<W> {
self.id(&ui.send) self.id(&ui.send)
} }
} }

75
src/layout/painter.rs
View File

@@ -2,8 +2,8 @@ use std::ops::Range;
use crate::{ use crate::{
layout::{ layout::{
Active, Cursor, SensorMap, SizeCtx, TextAttrs, TextBuffer, TextData, TextOffset, Active, Cursor, TextAttrs, TextBuffer, TextData, TextOffset, TextureHandle, Textures,
TextureHandle, Textures, UiRegion, Vec2, WidgetId, Widgets, UiRegion, Vec2, WidgetId, Widgets,
}, },
render::{Primitive, PrimitiveHandle, Primitives}, render::{Primitive, PrimitiveHandle, Primitives},
util::{HashSet, Id}, util::{HashSet, Id},
@@ -15,12 +15,12 @@ pub struct Painter<'a, 'c> {
textures: Vec<TextureHandle>, textures: Vec<TextureHandle>,
primitives: Vec<PrimitiveHandle>, primitives: Vec<PrimitiveHandle>,
children: Vec<Id>, children: Vec<Id>,
sized_children: HashSet<Id>,
id: Id, id: Id,
} }
pub struct PainterCtx<'a> { pub struct PainterCtx<'a> {
pub widgets: &'a Widgets, pub widgets: &'a Widgets,
pub sensor_map: &'a SensorMap,
pub active: &'a mut Active, pub active: &'a mut Active,
pub primitives: &'a mut Primitives, pub primitives: &'a mut Primitives,
pub textures: &'a mut Textures, pub textures: &'a mut Textures,
@@ -36,6 +36,7 @@ pub struct WidgetInstance {
pub textures: Vec<TextureHandle>, pub textures: Vec<TextureHandle>,
pub primitives: Vec<PrimitiveHandle>, pub primitives: Vec<PrimitiveHandle>,
pub children: Vec<Id>, pub children: Vec<Id>,
pub resize: Option<Id>,
pub span: Range<usize>, pub span: Range<usize>,
} }
@@ -43,7 +44,6 @@ impl<'a> PainterCtx<'a> {
pub fn new( pub fn new(
widgets: &'a Widgets, widgets: &'a Widgets,
primitives: &'a mut Primitives, primitives: &'a mut Primitives,
sensor_map: &'a SensorMap,
active: &'a mut Active, active: &'a mut Active,
textures: &'a mut Textures, textures: &'a mut Textures,
text: &'a mut TextData, text: &'a mut TextData,
@@ -51,7 +51,6 @@ impl<'a> PainterCtx<'a> {
) -> Self { ) -> Self {
Self { Self {
widgets, widgets,
sensor_map,
active, active,
primitives, primitives,
textures, textures,
@@ -63,11 +62,24 @@ impl<'a> PainterCtx<'a> {
pub fn redraw(&mut self, id: &Id) { pub fn redraw(&mut self, id: &Id) {
self.drawing.clear(); self.drawing.clear();
let Some(active) = self.active.widgets.get(id) else {
return;
};
if let Some(rid) = &active.resize {
self.redraw(&rid.duplicate());
if self.drawing.contains(id) {
return;
}
}
let Some(active) = self.remove(id) else { let Some(active) = self.remove(id) else {
return; return;
}; };
self.primitives.set_pos(active.span.start); self.primitives.set_pos(active.span.start);
self.draw_inner(id, active.region, active.parent(), Some(active.children)); self.draw_inner(id, active.region, active.parent(), Some(active.children));
self.active.widgets.get_mut(id).unwrap().resize = active.resize;
let delta = self.primitives.apply(active.span.clone()); let delta = self.primitives.apply(active.span.clone());
if delta != 0 if delta != 0
&& let Some(parent) = active.parent && let Some(parent) = active.parent
@@ -90,13 +102,20 @@ impl<'a> PainterCtx<'a> {
parent: Option<Id>, parent: Option<Id>,
old_children: Option<Vec<Id>>, old_children: Option<Vec<Id>>,
) { ) {
// I have no idea if these checks work lol
// the idea is u can't redraw stuff u already drew,
// and if parent is different then there's another copy with a different parent
// but this has a very weird issue where you can't move widgets unless u remove first
// so swapping is impossible rn I think?
// there's definitely better solutions like a counter (>1 = panic) but don't care rn
if self.drawing.contains(id) { if self.drawing.contains(id) {
panic!("Cannot draw the same widget twice"); panic!("Cannot draw the same widget twice (1)");
} }
let mut old_children = old_children.unwrap_or_default(); let mut old_children = old_children.unwrap_or_default();
let mut resize = None;
if let Some(active) = self.active.widgets.get(id) { if let Some(active) = self.active.widgets.get(id) {
if active.parent != parent { if active.parent != parent {
panic!("Cannot draw the same widget twice"); panic!("Cannot draw the same widget twice (2)");
} }
if active.region == region { if active.region == region {
self.primitives.skip(&active.span); self.primitives.skip(&active.span);
@@ -106,6 +125,7 @@ impl<'a> PainterCtx<'a> {
// else if active.region.size() == region.size() { move } // else if active.region.size() == region.size() { move }
let active = self.remove(id).unwrap(); let active = self.remove(id).unwrap();
old_children = active.children; old_children = active.children;
resize = active.resize;
} }
let mut painter = Painter { let mut painter = Painter {
@@ -115,6 +135,7 @@ impl<'a> PainterCtx<'a> {
primitives: Vec::new(), primitives: Vec::new(),
ctx: self, ctx: self,
children: Vec::new(), children: Vec::new(),
sized_children: HashSet::new(),
}; };
// draw widgets // draw widgets
@@ -122,6 +143,8 @@ impl<'a> PainterCtx<'a> {
painter.ctx.widgets.get_dyn_dynamic(id).draw(&mut painter); painter.ctx.widgets.get_dyn_dynamic(id).draw(&mut painter);
let end_i = painter.ctx.primitives.cur_pos(); let end_i = painter.ctx.primitives.cur_pos();
let sized_children = painter.sized_children;
// add to active // add to active
let instance = WidgetInstance { let instance = WidgetInstance {
id: id.duplicate(), id: id.duplicate(),
@@ -131,14 +154,20 @@ impl<'a> PainterCtx<'a> {
span: start_i..end_i, span: start_i..end_i,
primitives: painter.primitives, primitives: painter.primitives,
children: painter.children, children: painter.children,
resize,
}; };
for cid in sized_children {
if let Some(w) = self.active.widgets.get_mut(&cid) {
w.resize = Some(id.duplicate())
}
}
for c in &old_children { for c in &old_children {
if !instance.children.contains(c) { if !instance.children.contains(c) {
self.remove_rec(c); self.remove_rec(c);
} }
} }
self.active.add(id, instance, self.sensor_map); self.active.add(id, instance, self.widgets);
} }
fn remove(&mut self, id: &Id) -> Option<WidgetInstance> { fn remove(&mut self, id: &Id) -> Option<WidgetInstance> {
@@ -168,8 +197,6 @@ impl<'a> PainterCtx<'a> {
let instance = self.active.widgets.get_mut(&parent).unwrap(); let instance = self.active.widgets.get_mut(&parent).unwrap();
let end = &mut instance.span.end; let end = &mut instance.span.end;
*end = end.strict_add_signed(delta); *end = end.strict_add_signed(delta);
// ids are supposed to be unique so theoretically no cloning is needed
// leaving for now for testing
let parent = instance.parent(); let parent = instance.parent();
for child in instance for child in instance
.children .children
@@ -186,6 +213,7 @@ impl<'a> PainterCtx<'a> {
fn shift_child(&mut self, child: &Id, start: usize, delta: isize) { fn shift_child(&mut self, child: &Id, start: usize, delta: isize) {
let instance = self.active.widgets.get_mut(child).unwrap(); let instance = self.active.widgets.get_mut(child).unwrap();
// = also prevents the original id from getting shifted
if instance.span.start <= start { if instance.span.start <= start {
return; return;
} }
@@ -263,6 +291,7 @@ impl<'a, 'c> Painter<'a, 'c> {
} }
pub fn size<W>(&mut self, id: &WidgetId<W>) -> Vec2 { pub fn size<W>(&mut self, id: &WidgetId<W>) -> Vec2 {
self.sized_children.insert(id.id.duplicate());
self.ctx self.ctx
.widgets .widgets
.get_dyn_dynamic(&id.id) .get_dyn_dynamic(&id.id)
@@ -275,10 +304,36 @@ impl<'a, 'c> Painter<'a, 'c> {
text: self.ctx.text, text: self.ctx.text,
textures: self.ctx.textures, textures: self.ctx.textures,
widgets: self.ctx.widgets, widgets: self.ctx.widgets,
checked: &mut self.sized_children,
} }
} }
} }
pub struct SizeCtx<'a> {
pub size: Vec2,
pub text: &'a mut TextData,
pub textures: &'a mut Textures,
widgets: &'a Widgets,
checked: &'a mut HashSet<Id>,
}
impl SizeCtx<'_> {
pub fn size<W>(&mut self, id: &WidgetId<W>) -> Vec2 {
self.checked.insert(id.id.duplicate());
self.widgets.get_dyn_dynamic(&id.id).get_size(self)
}
pub fn draw_text(
&mut self,
buffer: &mut TextBuffer,
content: &str,
attrs: &TextAttrs,
cursor: &Cursor,
) -> (TextureHandle, TextOffset) {
self.text
.draw(buffer, content, attrs, cursor, self.textures)
}
}
impl WidgetInstance { impl WidgetInstance {
pub fn parent(&self) -> Option<Id> { pub fn parent(&self) -> Option<Id> {
self.parent.as_ref().map(|p| p.duplicate()) self.parent.as_ref().map(|p| p.duplicate())

55
src/layout/sense.rs
View File

@@ -1,7 +1,5 @@
use std::any::Any;
use crate::{ use crate::{
layout::{Ui, UiRegion, Vec2, WidgetId}, layout::{Ui, UiRegion, Vec2},
util::{HashMap, Id, bitflags}, util::{HashMap, Id, bitflags},
}; };
@@ -30,19 +28,18 @@ pub enum ActivationState {
Off, Off,
} }
pub struct Sensor { pub struct Sensor<Ctx> {
pub senses: Senses, pub senses: Senses,
pub f: Box<dyn SenseFn>, pub f: Box<dyn SenseFn<Ctx>>,
} }
pub type SensorMap = HashMap<Id, SensorGroup>; pub type SensorMap<Ctx> = HashMap<Id, SensorGroup<Ctx>>;
pub type ActiveSensors = HashMap<Id, SenseShape>; pub type ActiveSensors = HashMap<Id, SenseShape>;
pub type SenseShape = UiRegion; pub type SenseShape = UiRegion;
#[derive(Default)] pub struct SensorGroup<Ctx> {
pub struct SensorGroup {
pub hover: ActivationState, pub hover: ActivationState,
pub cursor: ActivationState, pub cursor: ActivationState,
pub sensors: Vec<Sensor>, pub sensors: Vec<Sensor<Ctx>>,
} }
pub struct SenseCtx { pub struct SenseCtx {
@@ -50,21 +47,18 @@ pub struct SenseCtx {
pub size: Vec2, pub size: Vec2,
} }
pub trait SenseFn: FnMut(&mut Ui, SenseCtx) + 'static {} pub trait SenseFn<Ctx>: FnMut(&mut Ctx, SenseCtx) + 'static {}
impl<F: FnMut(&mut Ui, SenseCtx) + 'static> SenseFn for F {} impl<F: FnMut(&mut Ctx, SenseCtx) + 'static, Ctx> SenseFn<Ctx> for F {}
impl Ui { pub trait UiCtx {
pub fn add_sensor<W>(&mut self, id: &WidgetId<W>, f: Sensor) { fn ui(&mut self) -> &mut Ui<Self>
self.sensor_map where
.entry(id.id.duplicate()) Self: Sized;
.or_default()
.sensors
.push(f);
} }
pub fn run_sensors(&mut self, cursor: &CursorState, window_size: Vec2) { pub fn run_sensors<Ctx: UiCtx>(ctx: &mut Ctx, cursor: &CursorState, window_size: Vec2) {
let active = std::mem::take(&mut self.active.sensors); let active = std::mem::take(&mut ctx.ui().active.sensors);
let mut map = std::mem::take(&mut self.sensor_map); let mut map = std::mem::take(&mut ctx.ui().sensor_map);
for (id, shape) in active.iter() { for (id, shape) in active.iter() {
let group = &mut map.get_mut(id).unwrap(); let group = &mut map.get_mut(id).unwrap();
let region = shape.to_screen(window_size); let region = shape.to_screen(window_size);
@@ -74,17 +68,16 @@ impl Ui {
for sensor in &mut group.sensors { for sensor in &mut group.sensors {
if should_run(sensor.senses, group.cursor, group.hover) { if should_run(sensor.senses, group.cursor, group.hover) {
let ctx = SenseCtx { let sctx = SenseCtx {
cursor: cursor.pos - region.top_left, cursor: cursor.pos - region.top_left,
size: region.bot_right - region.top_left, size: region.bot_right - region.top_left,
}; };
(sensor.f)(self, ctx); (sensor.f)(ctx, sctx);
} }
} }
} }
self.sensor_map = map; ctx.ui().sensor_map = map;
self.active.sensors = active; ctx.ui().active.sensors = active;
}
} }
pub fn should_run(senses: Senses, cursor: ActivationState, hover: ActivationState) -> bool { pub fn should_run(senses: Senses, cursor: ActivationState, hover: ActivationState) -> bool {
@@ -138,3 +131,13 @@ impl ActivationState {
} }
} }
} }
impl<Ctx> Default for SensorGroup<Ctx> {
fn default() -> Self {
Self {
hover: Default::default(),
cursor: Default::default(),
sensors: Default::default(),
}
}
}

24
src/layout/text.rs
View File

@@ -33,8 +33,8 @@ pub enum Cursor {
#[default] #[default]
None, None,
Select { Select {
line: usize, line: isize,
idx: usize, col: isize,
}, },
} }
@@ -78,15 +78,14 @@ impl TextData {
let mut max_y = 0; let mut max_y = 0;
let c = attrs.color; let c = attrs.color;
let mut max_width = 0.0f32; let mut max_width = 0.0f32;
let mut i = 0;
let mut cursor_x = 0; let mut cursor_x = 0;
for (run_i, run) in buffer.layout_runs().enumerate() { for (run_i, run) in buffer.layout_runs().enumerate() {
if let Cursor::Select { line, .. } = cursor if let Cursor::Select { line, .. } = cursor
&& *line == run_i && *line == run_i as isize
{ {
cursor_x = run.line_w as i32; cursor_x = run.line_w as i32;
} }
for glyph in run.glyphs.iter() { for (i, glyph) in run.glyphs.iter().enumerate() {
let physical_glyph = glyph.physical((0., 0.), 1.0); let physical_glyph = glyph.physical((0., 0.), 1.0);
let glyph_color = match glyph.color_opt { let glyph_color = match glyph.color_opt {
@@ -94,13 +93,12 @@ impl TextData {
None => cosmic_text::Color::rgba(c.r, c.g, c.b, c.a), None => cosmic_text::Color::rgba(c.r, c.g, c.b, c.a),
}; };
if let Cursor::Select { idx, line } = cursor if let Cursor::Select { col: idx, line } = cursor
&& *line == run_i && *line == run_i as isize
&& *idx == i && *idx == i as isize
{ {
cursor_x = physical_glyph.x; cursor_x = physical_glyph.x;
} }
i += 1;
self.swash_cache.with_pixels( self.swash_cache.with_pixels(
&mut self.font_system, &mut self.font_system,
@@ -133,19 +131,23 @@ impl TextData {
image.put_pixel(x, y, color); image.put_pixel(x, y, color);
} }
if let &Cursor::Select { line, .. } = cursor { if let &Cursor::Select { line, .. } = cursor {
let x = (cursor_x - min_x) as u32;
for y in 0..attrs.line_height as u32 { for y in 0..attrs.line_height as u32 {
// no clue if this is good or bad for non integer values // no clue if this is good or bad for non integer values
// depends on how the layouting is actually done // depends on how the layouting is actually done
let x = (cursor_x - min_x) as u32;
let y = (y as f32 + attrs.line_height * line as f32 - min_y as f32) as u32; let y = (y as f32 + attrs.line_height * line as f32 - min_y as f32) as u32;
image.put_pixel(x, y, Rgba(c.as_arr())); image.put_pixel(x, y, Rgba(c.as_arr()));
} }
} }
let mut lines = buffer.lines.len();
if content.ends_with('\n') {
lines += 1;
}
let offset = TextOffset { let offset = TextOffset {
top_left: Vec2::new(min_x as f32, min_y as f32), top_left: Vec2::new(min_x as f32, min_y as f32),
bot_right: Vec2::new( bot_right: Vec2::new(
max_width - max_x as f32, max_width - max_x as f32,
attrs.line_height * buffer.lines.len() as f32 - max_y as f32, attrs.line_height * lines as f32 - max_y as f32,
), ),
}; };
(textures.add(image), offset) (textures.add(image), offset)

112
src/layout/ui.rs
View File

@@ -2,21 +2,21 @@ use image::DynamicImage;
use crate::{ use crate::{
layout::{ layout::{
ActiveSensors, PainterCtx, SensorMap, StaticWidgetId, TextData, TextureHandle, Textures, ActiveSensors, PainterCtx, Sensor, SensorMap, StaticWidgetId, TextData, TextureHandle,
Vec2, Widget, WidgetId, WidgetInstance, WidgetLike, Textures, Vec2, Widget, WidgetId, WidgetInstance, WidgetLike,
}, },
render::Primitives, render::Primitives,
util::{HashMap, Id, IdTracker}, util::{DynBorrower, HashMap, HashSet, Id, IdTracker},
}; };
use std::{ use std::{
any::{Any, TypeId}, any::{Any, TypeId},
ops::{Deref, DerefMut, Index, IndexMut}, ops::{Index, IndexMut},
sync::mpsc::{Receiver, Sender, channel}, sync::mpsc::{Receiver, Sender, channel},
}; };
pub struct Ui { pub struct Ui<Ctx> {
root: Option<WidgetId>, root: Option<WidgetId>,
widgets: Widgets, pub(super) widgets: Widgets,
updates: Vec<Id>, updates: Vec<Id>,
recv: Receiver<Id>, recv: Receiver<Id>,
pub(super) send: Sender<Id>, pub(super) send: Sender<Id>,
@@ -24,11 +24,11 @@ pub struct Ui {
// TODO: make these non pub(crate) // TODO: make these non pub(crate)
pub(crate) primitives: Primitives, pub(crate) primitives: Primitives,
pub(crate) textures: Textures, pub(crate) textures: Textures,
pub(crate) text: TextData, text: TextData,
full_redraw: bool, full_redraw: bool,
pub(super) active: Active, pub(super) active: Active,
pub(super) sensor_map: SensorMap, pub(super) sensor_map: SensorMap<Ctx>,
} }
#[derive(Default)] #[derive(Default)]
@@ -38,19 +38,23 @@ pub struct Widgets {
} }
pub struct WidgetData { pub struct WidgetData {
widget: Box<dyn Widget>, pub widget: Box<dyn Widget>,
borrowed: bool, pub label: String,
label: String, pub sized_children: HashSet<Id>,
/// dynamic borrow checking
pub borrowed: bool,
/// whether this widget has any sensors
pub sensor: bool,
} }
impl Ui { impl<Ctx> Ui<Ctx> {
pub fn add<W: Widget, Tag>(&mut self, w: impl WidgetLike<Tag, Widget = W>) -> WidgetId<W> { pub fn add<W: Widget, Tag>(&mut self, w: impl WidgetLike<Ctx, Tag, Widget = W>) -> WidgetId<W> {
w.add(self) w.add(self)
} }
pub fn add_static<W: Widget, Tag>( pub fn add_static<W: Widget, Tag>(
&mut self, &mut self,
w: impl WidgetLike<Tag, Widget = W>, w: impl WidgetLike<Ctx, Tag, Widget = W>,
) -> StaticWidgetId<W> { ) -> StaticWidgetId<W> {
let id = w.add(self); let id = w.add(self);
id.into_static() id.into_static()
@@ -58,7 +62,7 @@ impl Ui {
/// useful for debugging /// useful for debugging
pub fn set_label<W>(&mut self, id: &WidgetId<W>, label: String) { pub fn set_label<W>(&mut self, id: &WidgetId<W>, label: String) {
*self.widgets.label_mut(id).unwrap() = label; self.widgets.data_mut(&id.id).unwrap().label = label;
} }
pub fn add_widget<W: Widget>(&mut self, w: W) -> WidgetId<W> { pub fn add_widget<W: Widget>(&mut self, w: W) -> WidgetId<W> {
@@ -75,8 +79,8 @@ impl Ui {
self.widgets.insert(id.id.duplicate(), w); self.widgets.insert(id.id.duplicate(), w);
} }
pub fn set_root<Tag>(&mut self, w: impl WidgetLike<Tag>) { pub fn set_root<Tag>(&mut self, w: impl WidgetLike<Ctx, Tag>) {
self.root = Some(w.add(self).erase_type()); self.root = Some(w.add(self).any());
self.full_redraw = true; self.full_redraw = true;
} }
@@ -121,7 +125,6 @@ impl Ui {
let mut ctx = PainterCtx::new( let mut ctx = PainterCtx::new(
&self.widgets, &self.widgets,
&mut self.primitives, &mut self.primitives,
&self.sensor_map,
&mut self.active, &mut self.active,
&mut self.textures, &mut self.textures,
&mut self.text, &mut self.text,
@@ -145,7 +148,6 @@ impl Ui {
let mut ctx = PainterCtx::new( let mut ctx = PainterCtx::new(
&self.widgets, &self.widgets,
&mut self.primitives, &mut self.primitives,
&self.sensor_map,
&mut self.active, &mut self.active,
&mut self.textures, &mut self.textures,
&mut self.text, &mut self.text,
@@ -160,6 +162,7 @@ impl Ui {
/// free any resources that don't have references anymore /// free any resources that don't have references anymore
fn free(&mut self) { fn free(&mut self) {
for id in self.recv.try_iter() { for id in self.recv.try_iter() {
self.sensor_map.remove(&id);
self.widgets.delete(id); self.widgets.delete(id);
} }
self.textures.free(); self.textures.free();
@@ -176,9 +179,18 @@ impl Ui {
pub fn active_widgets(&self) -> usize { pub fn active_widgets(&self) -> usize {
self.active.widgets.len() self.active.widgets.len()
} }
pub fn add_sensor<W>(&mut self, id: &WidgetId<W>, f: Sensor<Ctx>) {
self.sensor_map
.entry(id.id.duplicate())
.or_default()
.sensors
.push(f);
self.widgets.data_mut(&id.id).unwrap().sensor = true;
}
} }
impl<W: Widget> Index<&WidgetId<W>> for Ui { impl<W: Widget, Ctx> Index<&WidgetId<W>> for Ui<Ctx> {
type Output = W; type Output = W;
fn index(&self, id: &WidgetId<W>) -> &Self::Output { fn index(&self, id: &WidgetId<W>) -> &Self::Output {
@@ -186,14 +198,14 @@ impl<W: Widget> Index<&WidgetId<W>> for Ui {
} }
} }
impl<W: Widget> IndexMut<&WidgetId<W>> for Ui { impl<W: Widget, Ctx> IndexMut<&WidgetId<W>> for Ui<Ctx> {
fn index_mut(&mut self, id: &WidgetId<W>) -> &mut Self::Output { fn index_mut(&mut self, id: &WidgetId<W>) -> &mut Self::Output {
self.updates.push(id.id.duplicate()); self.updates.push(id.id.duplicate());
self.get_mut(id).unwrap() self.get_mut(id).unwrap()
} }
} }
impl<W: Widget> Index<StaticWidgetId<W>> for Ui { impl<W: Widget, Ctx> Index<StaticWidgetId<W>> for Ui<Ctx> {
type Output = W; type Output = W;
fn index(&self, id: StaticWidgetId<W>) -> &Self::Output { fn index(&self, id: StaticWidgetId<W>) -> &Self::Output {
@@ -201,7 +213,7 @@ impl<W: Widget> Index<StaticWidgetId<W>> for Ui {
} }
} }
impl<W: Widget> IndexMut<StaticWidgetId<W>> for Ui { impl<W: Widget, Ctx> IndexMut<StaticWidgetId<W>> for Ui<Ctx> {
fn index_mut(&mut self, id: StaticWidgetId<W>) -> &mut Self::Output { fn index_mut(&mut self, id: StaticWidgetId<W>) -> &mut Self::Output {
self.updates.push(id.id.id()); self.updates.push(id.id.id());
self.widgets.get_static_mut(&id).unwrap() self.widgets.get_static_mut(&id).unwrap()
@@ -233,10 +245,7 @@ impl Widgets {
if data.borrowed { if data.borrowed {
panic!("tried to mutably borrow the same widget twice"); panic!("tried to mutably borrow the same widget twice");
} }
WidgetWrapper { WidgetWrapper::new(data.widget.as_mut(), &mut data.borrowed)
widget: data.widget.as_mut(),
borrowed: &mut data.borrowed,
}
} }
pub fn get_static<W: Widget>(&self, id: &StaticWidgetId<W>) -> Option<&W> { pub fn get_static<W: Widget>(&self, id: &StaticWidgetId<W>) -> Option<&W> {
@@ -259,12 +268,12 @@ impl Widgets {
self.insert_any(id, Box::new(widget), std::any::type_name::<W>().to_string()); self.insert_any(id, Box::new(widget), std::any::type_name::<W>().to_string());
} }
pub fn label<W>(&self, id: &WidgetId<W>) -> Option<&String> { pub fn data(&self, id: &Id) -> Option<&WidgetData> {
self.map.get(&id.id).map(|d| &d.label) self.map.get(id)
} }
pub fn label_mut<W>(&mut self, id: &WidgetId<W>) -> Option<&mut String> { pub fn data_mut(&mut self, id: &Id) -> Option<&mut WidgetData> {
self.map.get_mut(&id.id).map(|d| &mut d.label) self.map.get_mut(id)
} }
pub fn insert_any(&mut self, id: Id, widget: Box<dyn Widget>, label: String) { pub fn insert_any(&mut self, id: Id, widget: Box<dyn Widget>, label: String) {
@@ -272,8 +281,10 @@ impl Widgets {
id, id,
WidgetData { WidgetData {
widget, widget,
borrowed: false,
label, label,
sized_children: HashSet::new(),
borrowed: false,
sensor: false,
}, },
); );
} }
@@ -296,36 +307,7 @@ impl Widgets {
} }
} }
pub struct WidgetWrapper<'a> { pub type WidgetWrapper<'a> = DynBorrower<'a, dyn Widget>;
widget: &'a mut dyn Widget,
borrowed: &'a mut bool,
}
impl<'a> WidgetWrapper<'a> {
pub fn new(widget: &'a mut dyn Widget, borrowed: &'a mut bool) -> Self {
Self { widget, borrowed }
}
}
impl Drop for WidgetWrapper<'_> {
fn drop(&mut self) {
*self.borrowed = false;
}
}
impl Deref for WidgetWrapper<'_> {
type Target = dyn Widget;
fn deref(&self) -> &Self::Target {
self.widget
}
}
impl DerefMut for WidgetWrapper<'_> {
fn deref_mut(&mut self) -> &mut Self::Target {
self.widget
}
}
impl dyn Widget { impl dyn Widget {
pub fn as_any(&self) -> &dyn Any { pub fn as_any(&self) -> &dyn Any {
@@ -337,7 +319,7 @@ impl dyn Widget {
} }
} }
impl Default for Ui { impl<Ctx> Default for Ui<Ctx> {
fn default() -> Self { fn default() -> Self {
let (send, recv) = channel(); let (send, recv) = channel();
Self { Self {
@@ -377,8 +359,8 @@ impl Active {
instance instance
} }
pub fn add(&mut self, id: &Id, instance: WidgetInstance, sensors_map: &SensorMap) { pub fn add(&mut self, id: &Id, instance: WidgetInstance, widgets: &Widgets) {
if sensors_map.get(id).is_some() { if widgets.data(id).is_some_and(|w| w.sensor) {
self.sensors.insert(id.duplicate(), instance.region); self.sensors.insert(id.duplicate(), instance.region);
} }
self.widgets.insert(id.duplicate(), instance); self.widgets.insert(id.duplicate(), instance);

68
src/layout/widget.rs
View File

@@ -1,7 +1,4 @@
use crate::layout::{ use crate::layout::{Painter, SizeCtx, StaticWidgetId, Ui, Vec2, WidgetId, WidgetIdFn};
Cursor, Painter, StaticWidgetId, TextAttrs, TextBuffer, TextData, TextOffset, TextureHandle,
Textures, Ui, Vec2, WidgetId, WidgetIdFn, Widgets,
};
use std::{any::Any, marker::PhantomData}; use std::{any::Any, marker::PhantomData};
@@ -12,39 +9,16 @@ pub trait Widget: Any {
} }
} }
pub struct SizeCtx<'a> {
pub size: Vec2,
pub text: &'a mut TextData,
pub textures: &'a mut Textures,
pub(super) widgets: &'a Widgets,
}
impl SizeCtx<'_> {
pub fn size<W>(&mut self, id: &WidgetId<W>) -> Vec2 {
self.widgets.get_dyn_dynamic(&id.id).get_size(self)
}
pub fn draw_text(
&mut self,
buffer: &mut TextBuffer,
content: &str,
attrs: &TextAttrs,
cursor: &Cursor,
) -> (TextureHandle, TextOffset) {
self.text
.draw(buffer, content, attrs, cursor, self.textures)
}
}
pub struct WidgetTag; pub struct WidgetTag;
pub struct FnTag; pub struct FnTag;
pub trait WidgetLike<Tag> { pub trait WidgetLike<Ctx, Tag> {
type Widget: 'static; type Widget: 'static;
fn add(self, ui: &mut Ui) -> WidgetId<Self::Widget>; fn add(self, ui: &mut Ui<Ctx>) -> WidgetId<Self::Widget>;
fn with_id<W2>( fn with_id<W2>(
self, self,
f: impl FnOnce(&mut Ui, WidgetId<Self::Widget>) -> WidgetId<W2>, f: impl FnOnce(&mut Ui<Ctx>, WidgetId<Self::Widget>) -> WidgetId<W2>,
) -> impl WidgetIdFn<W2> ) -> impl WidgetIdFn<W2, Ctx>
where where
Self: Sized, Self: Sized,
{ {
@@ -53,7 +27,7 @@ pub trait WidgetLike<Tag> {
f(ui, id) f(ui, id)
} }
} }
fn add_static(self, ui: &mut Ui) -> StaticWidgetId<Self::Widget> fn add_static(self, ui: &mut Ui<Ctx>) -> StaticWidgetId<Self::Widget>
where where
Self: Sized, Self: Sized,
{ {
@@ -64,19 +38,19 @@ pub trait WidgetLike<Tag> {
/// A function that returns a widget given a UI. /// A function that returns a widget given a UI.
/// Useful for defining trait functions on widgets that create a parent widget so that the children /// Useful for defining trait functions on widgets that create a parent widget so that the children
/// don't need to be IDs yet /// don't need to be IDs yet
pub trait WidgetFn<W: Widget>: FnOnce(&mut Ui) -> W {} pub trait WidgetFn<W: Widget, Ctx>: FnOnce(&mut Ui<Ctx>) -> W {}
impl<W: Widget, F: FnOnce(&mut Ui) -> W> WidgetFn<W> for F {} impl<W: Widget, F: FnOnce(&mut Ui<Ctx>) -> W, Ctx> WidgetFn<W, Ctx> for F {}
impl<W: Widget, F: FnOnce(&mut Ui) -> W> WidgetLike<FnTag> for F { impl<W: Widget, F: FnOnce(&mut Ui<Ctx>) -> W, Ctx> WidgetLike<Ctx, FnTag> for F {
type Widget = W; type Widget = W;
fn add(self, ui: &mut Ui) -> WidgetId<W> { fn add(self, ui: &mut Ui<Ctx>) -> WidgetId<W> {
self(ui).add(ui) self(ui).add(ui)
} }
} }
impl<W: Widget> WidgetLike<WidgetTag> for W { impl<W: Widget, Ctx> WidgetLike<Ctx, WidgetTag> for W {
type Widget = W; type Widget = W;
fn add(self, ui: &mut Ui) -> WidgetId<W> { fn add(self, ui: &mut Ui<Ctx>) -> WidgetId<W> {
ui.add_widget(self) ui.add_widget(self)
} }
} }
@@ -96,22 +70,22 @@ impl<const LEN: usize, Ws> WidgetArr<LEN, Ws> {
} }
pub struct ArrTag; pub struct ArrTag;
pub trait WidgetArrLike<const LEN: usize, Tags> { pub trait WidgetArrLike<const LEN: usize, Ctx, Tags> {
type Ws; type Ws;
fn ui(self, ui: &mut Ui) -> WidgetArr<LEN, Self::Ws>; fn ui(self, ui: &mut Ui<Ctx>) -> WidgetArr<LEN, Self::Ws>;
} }
impl<const LEN: usize, Ws> WidgetArrLike<LEN, ArrTag> for WidgetArr<LEN, Ws> { impl<const LEN: usize, Ws, Ctx> WidgetArrLike<LEN, Ctx, ArrTag> for WidgetArr<LEN, Ws> {
type Ws = Ws; type Ws = Ws;
fn ui(self, _: &mut Ui) -> WidgetArr<LEN, Ws> { fn ui(self, _: &mut Ui<Ctx>) -> WidgetArr<LEN, Ws> {
self self
} }
} }
impl<W: WidgetLike<WidgetTag>> WidgetArrLike<1, WidgetTag> for W { impl<W: WidgetLike<Ctx, WidgetTag>, Ctx> WidgetArrLike<1, Ctx, WidgetTag> for W {
type Ws = (W::Widget,); type Ws = (W::Widget,);
fn ui(self, ui: &mut Ui) -> WidgetArr<1, (W::Widget,)> { fn ui(self, ui: &mut Ui<Ctx>) -> WidgetArr<1, (W::Widget,)> {
WidgetArr::new([self.add(ui).erase_type()]) WidgetArr::new([self.add(ui).any()])
} }
} }
@@ -121,9 +95,9 @@ macro_rules! impl_widget_arr {
impl_widget_arr!($n;$($W)*;$(${concat($W,Tag)})*); impl_widget_arr!($n;$($W)*;$(${concat($W,Tag)})*);
}; };
($n:expr;$($W:ident)*;$($Tag:ident)*) => { ($n:expr;$($W:ident)*;$($Tag:ident)*) => {
impl<$($W: WidgetLike<$Tag>,$Tag,)*> WidgetArrLike<$n, ($($Tag,)*)> for ($($W,)*) { impl<Ctx, $($W: WidgetLike<Ctx, $Tag>,$Tag,)*> WidgetArrLike<$n, Ctx, ($($Tag,)*)> for ($($W,)*) {
type Ws = ($($W::Widget,)*); type Ws = ($($W::Widget,)*);
fn ui(self, ui: &mut Ui) -> WidgetArr<$n, ($($W::Widget,)*)> { fn ui(self, ui: &mut Ui<Ctx>) -> WidgetArr<$n, ($($W::Widget,)*)> {
#[allow(non_snake_case)] #[allow(non_snake_case)]
let ($($W,)*) = self; let ($($W,)*) = self;
WidgetArr::new( WidgetArr::new(

2
src/render/mod.rs
View File

@@ -48,7 +48,7 @@ impl UiRenderer {
pass.draw(0..4, 0..self.instance.len() as u32); pass.draw(0..4, 0..self.instance.len() as u32);
} }
pub fn update(&mut self, device: &Device, queue: &Queue, ui: &mut Ui) { pub fn update<Ctx>(&mut self, device: &Device, queue: &Queue, ui: &mut Ui<Ctx>) {
if ui.primitives.updated { if ui.primitives.updated {
self.instance self.instance
.update(device, queue, ui.primitives.instances()); .update(device, queue, ui.primitives.instances());

145
src/testing/mod.rs
View File

@@ -5,7 +5,12 @@ use cosmic_text::Family;
use render::Renderer; use render::Renderer;
use senses::*; use senses::*;
use ui::prelude::*; use ui::prelude::*;
use winit::{event::WindowEvent, event_loop::ActiveEventLoop, window::Window}; use winit::{
event::WindowEvent,
event_loop::ActiveEventLoop,
keyboard::{Key, NamedKey},
window::Window,
};
use crate::testing::input::Input; use crate::testing::input::Input;
@@ -20,7 +25,7 @@ pub fn main() {
pub struct Client { pub struct Client {
renderer: Renderer, renderer: Renderer,
input: Input, input: Input,
ui: Ui, ui: Ui<Client>,
info: WidgetId<Text>, info: WidgetId<Text>,
selected: Option<WidgetId<Text>>, selected: Option<WidgetId<Text>>,
} }
@@ -71,22 +76,31 @@ impl Client {
let span_add = Span::empty(Dir::RIGHT).add_static(&mut ui); let span_add = Span::empty(Dir::RIGHT).add_static(&mut ui);
let main = pad_test.pad(10).add_static(&mut ui); let add_button = rect(Color::LIME)
.radius(30)
.on(PRESS_START, move |ctx: &mut Client, _| {
let child = ctx
.ui
.add(image(include_bytes!("assets/sungals.png")).center())
.any();
ctx.ui[span_add].children.push((child, sized()));
})
.size(150)
.align(Align::BotRight);
let switch_button = |color, to, label| { let del_button = rect(Color::RED)
let rect = rect(color) .radius(30)
.id_on(PRESS_START, move |id, ui, _| { .on(PRESS_START, move |ctx: &mut Client, _| {
ui[main].inner.set_static(to); ctx.ui[span_add].children.pop();
ui[id].color = color.add_rgb(-0.2);
}) })
.edit_on(HOVER_START | PRESS_END, move |r, _| { .size(150)
r.color = color.add_rgb(0.4); .align(Align::BotLeft);
})
.edit_on(HOVER_END, move |r, _| { let span_add_test = (span_add, add_button, del_button)
r.color = color; .stack()
}); .add_static(&mut ui);
(rect, text(label).font_size(30)).stack()
}; let main = pad_test.pad(10).add_static(&mut ui);
let btext = |content| text(content).font_size(30); let btext = |content| text(content).font_size(30);
@@ -113,56 +127,51 @@ impl Client {
let texts = Span::empty(Dir::DOWN).add(&mut ui); let texts = Span::empty(Dir::DOWN).add(&mut ui);
let text_edit_scroll = ( let text_edit_scroll = (
texts, texts,
text("add").font_size(30).edit_on(PRESS_START, |text, ctx| { text("add")
text.select(ctx.cursor, ctx.size); .font_size(30)
}), .id_on(PRESS_START, |id, client: &mut Client, ctx| {
client.ui[id].select(ctx.cursor, ctx.size);
client.selected = Some(id.clone());
})
.pad(30),
) )
.span(Dir::DOWN, [ratio(1), fixed(40)]) .span(Dir::DOWN, [ratio(1), sized()])
.add_static(&mut ui); .add_static(&mut ui);
let switch_button = |color, to, label| {
let rect = rect(color)
.id_on(PRESS_START, move |id, ctx: &mut Client, _| {
ctx.ui[main].inner.set_static(to);
ctx.ui[id].color = color.add_rgb(-0.2);
})
.edit_on(HOVER_START | PRESS_END, move |r, _| {
r.color = color.add_rgb(0.4);
})
.edit_on(HOVER_END, move |r, _| {
r.color = color;
});
(rect, text(label).font_size(30)).stack()
};
let tabs = ( let tabs = (
switch_button(Color::RED, pad_test, "pad"), switch_button(Color::RED, pad_test.any(), "pad"),
switch_button(Color::GREEN, span_test, "span"), switch_button(Color::GREEN, span_test.any(), "span"),
switch_button(Color::BLUE, span_add, "image span"), switch_button(Color::BLUE, span_add_test.any(), "image span"),
switch_button(Color::MAGENTA, text_test, "text layout"), switch_button(Color::MAGENTA, text_test.any(), "text layout"),
switch_button( switch_button(
Color::YELLOW.mul_rgb(0.5), Color::YELLOW.mul_rgb(0.5),
text_edit_scroll, text_edit_scroll.any(),
"text edit scroll", "text edit scroll",
), ),
) )
.span(Dir::RIGHT, ratio(1)); .span(Dir::RIGHT, ratio(1));
let add_button = rect(Color::LIME)
.radius(30)
.on(PRESS_START, move |ui, _| {
let child = ui
.add(image(include_bytes!("assets/sungals.png")).center())
.erase_type();
ui[span_add].children.push((child, sized()));
})
.size(150)
.align(Align::BotRight);
let del_button = rect(Color::RED)
.radius(30)
.on(PRESS_START, move |ui, _| {
ui[span_add].children.pop();
})
.size(150)
.align(Align::BotLeft);
let info = text("").add(&mut ui); let info = text("").add(&mut ui);
let info_sect = info.clone().pad(10).align(Align::BotLeft); let info_sect = info.clone().pad(10).align(Align::BotLeft);
ui.set_root( ui.set_root(
( (
tabs.label("tabs"), tabs.label("tabs"),
( (main, info_sect.label("info sect"))
main,
add_button.label("add button"),
del_button.label("del button"),
info_sect.label("info sect"),
)
.stack() .stack()
.label("main stack"), .label("main stack"),
) )
@@ -183,7 +192,7 @@ impl Client {
self.input.event(&event); self.input.event(&event);
let cursor_state = self.cursor_state(); let cursor_state = self.cursor_state();
let window_size = self.window_size(); let window_size = self.window_size();
self.ui.run_sensors(&cursor_state, window_size); run_sensors(self, &cursor_state, window_size);
match event { match event {
WindowEvent::CloseRequested => event_loop.exit(), WindowEvent::CloseRequested => event_loop.exit(),
WindowEvent::RedrawRequested => { WindowEvent::RedrawRequested => {
@@ -195,6 +204,34 @@ impl Client {
self.ui.resize((size.width, size.height)); self.ui.resize((size.width, size.height));
self.renderer.resize(&size) self.renderer.resize(&size)
} }
WindowEvent::KeyboardInput { event, .. } => {
if let Some(sel) = &self.selected
&& event.state.is_pressed()
{
let w = &mut self.ui[sel];
match &event.logical_key {
Key::Named(named) => match named {
NamedKey::Backspace => w.backspace(),
NamedKey::Delete => w.delete(),
NamedKey::Space => w.insert(" "),
NamedKey::Enter => w.insert("\n"),
NamedKey::ArrowRight => w.move_cursor(Dir::RIGHT),
NamedKey::ArrowLeft => w.move_cursor(Dir::LEFT),
NamedKey::ArrowUp => w.move_cursor(Dir::UP),
NamedKey::ArrowDown => w.move_cursor(Dir::DOWN),
NamedKey::Escape => {
w.deselect();
self.selected = None;
}
_ => (),
},
Key::Character(text) => {
w.insert(text);
}
_ => (),
}
}
}
_ => (), _ => (),
} }
let new = format!( let new = format!(
@@ -211,3 +248,9 @@ impl Client {
} }
} }
} }
impl UiCtx for Client {
fn ui(&mut self) -> &mut Ui<Self> {
&mut self.ui
}
}

2
src/testing/render/mod.rs
View File

@@ -21,7 +21,7 @@ pub struct Renderer {
} }
impl Renderer { impl Renderer {
pub fn update(&mut self, updates: &mut Ui) { pub fn update<Ctx>(&mut self, updates: &mut Ui<Ctx>) {
self.ui.update(&self.device, &self.queue, updates); self.ui.update(&self.device, &self.queue, updates);
} }

35
src/util/borrow.rs Normal file
View File

@@ -0,0 +1,35 @@
use std::ops::{Deref, DerefMut};
pub struct DynBorrower<'a, T: ?Sized> {
data: &'a mut T,
borrowed: &'a mut bool,
}
impl<'a, T: ?Sized> DynBorrower<'a, T> {
pub fn new(data: &'a mut T, borrowed: &'a mut bool) -> Self {
if *borrowed {
panic!("tried to mutably borrow the same thing twice");
}
Self { data, borrowed }
}
}
impl<T: ?Sized> Drop for DynBorrower<'_, T> {
fn drop(&mut self) {
*self.borrowed = false;
}
}
impl<T: ?Sized> Deref for DynBorrower<'_, T> {
type Target = T;
fn deref(&self) -> &Self::Target {
self.data
}
}
impl<T: ?Sized> DerefMut for DynBorrower<'_, T> {
fn deref_mut(&mut self) -> &mut Self::Target {
self.data
}
}

6
src/util/mod.rs
View File

@@ -1,12 +1,14 @@
mod bitflags;
mod borrow;
mod id; mod id;
mod math; mod math;
mod refcount; mod refcount;
mod bitflags;
pub(crate) use bitflags::*;
pub(crate) use borrow::*;
pub(crate) use id::*; pub(crate) use id::*;
pub(crate) use math::*; pub(crate) use math::*;
pub(crate) use refcount::*; pub(crate) use refcount::*;
pub(crate) use bitflags::*;
pub type HashMap<K, V> = std::collections::HashMap<K, V>; pub type HashMap<K, V> = std::collections::HashMap<K, V>;
pub type HashSet<K> = std::collections::HashSet<K>; pub type HashSet<K> = std::collections::HashSet<K>;