123 lines
3.4 KiB
Rust
123 lines
3.4 KiB
Rust
use crate::layout::{Painter, SizeCtx, StaticWidgetId, Ui, Vec2, WidgetId, WidgetIdFn};
|
|
|
|
use std::{any::Any, marker::PhantomData};
|
|
|
|
pub trait Widget: Any {
|
|
fn draw(&mut self, painter: &mut Painter);
|
|
fn get_size(&mut self, ctx: &mut SizeCtx) -> Vec2 {
|
|
ctx.size
|
|
}
|
|
}
|
|
|
|
pub struct WidgetTag;
|
|
pub struct FnTag;
|
|
|
|
pub trait WidgetLike<Ctx, Tag> {
|
|
type Widget: 'static;
|
|
fn add(self, ui: &mut Ui<Ctx>) -> WidgetId<Self::Widget>;
|
|
fn with_id<W2>(
|
|
self,
|
|
f: impl FnOnce(&mut Ui<Ctx>, WidgetId<Self::Widget>) -> WidgetId<W2>,
|
|
) -> impl WidgetIdFn<W2, Ctx>
|
|
where
|
|
Self: Sized,
|
|
{
|
|
move |ui| {
|
|
let id = self.add(ui);
|
|
f(ui, id)
|
|
}
|
|
}
|
|
fn add_static(self, ui: &mut Ui<Ctx>) -> StaticWidgetId<Self::Widget>
|
|
where
|
|
Self: Sized,
|
|
{
|
|
self.add(ui).into_static()
|
|
}
|
|
}
|
|
|
|
/// 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
|
|
/// don't need to be IDs yet
|
|
pub trait WidgetFn<W: Widget, Ctx>: FnOnce(&mut Ui<Ctx>) -> W {}
|
|
impl<W: Widget, F: FnOnce(&mut Ui<Ctx>) -> W, Ctx> WidgetFn<W, Ctx> for F {}
|
|
|
|
impl<W: Widget, F: FnOnce(&mut Ui<Ctx>) -> W, Ctx> WidgetLike<Ctx, FnTag> for F {
|
|
type Widget = W;
|
|
fn add(self, ui: &mut Ui<Ctx>) -> WidgetId<W> {
|
|
self(ui).add(ui)
|
|
}
|
|
}
|
|
|
|
impl<W: Widget, Ctx> WidgetLike<Ctx, WidgetTag> for W {
|
|
type Widget = W;
|
|
fn add(self, ui: &mut Ui<Ctx>) -> WidgetId<W> {
|
|
ui.add_widget(self)
|
|
}
|
|
}
|
|
|
|
pub struct WidgetArr<const LEN: usize, Ws> {
|
|
pub arr: [WidgetId; LEN],
|
|
_pd: PhantomData<Ws>,
|
|
}
|
|
|
|
impl<const LEN: usize, Ws> WidgetArr<LEN, Ws> {
|
|
pub fn new(arr: [WidgetId; LEN]) -> Self {
|
|
Self {
|
|
arr,
|
|
_pd: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
|
|
pub struct ArrTag;
|
|
pub trait WidgetArrLike<const LEN: usize, Ctx, Tags> {
|
|
type Ws;
|
|
fn ui(self, ui: &mut Ui<Ctx>) -> WidgetArr<LEN, Self::Ws>;
|
|
}
|
|
|
|
impl<const LEN: usize, Ws, Ctx> WidgetArrLike<LEN, Ctx, ArrTag> for WidgetArr<LEN, Ws> {
|
|
type Ws = Ws;
|
|
fn ui(self, _: &mut Ui<Ctx>) -> WidgetArr<LEN, Ws> {
|
|
self
|
|
}
|
|
}
|
|
|
|
impl<W: WidgetLike<Ctx, WidgetTag>, Ctx> WidgetArrLike<1, Ctx, WidgetTag> for W {
|
|
type Ws = (W::Widget,);
|
|
fn ui(self, ui: &mut Ui<Ctx>) -> WidgetArr<1, (W::Widget,)> {
|
|
WidgetArr::new([self.add(ui).any()])
|
|
}
|
|
}
|
|
|
|
// I hate this language it's so bad why do I even use it
|
|
macro_rules! impl_widget_arr {
|
|
($n:expr;$($W:ident)*) => {
|
|
impl_widget_arr!($n;$($W)*;$(${concat($W,Tag)})*);
|
|
};
|
|
($n:expr;$($W:ident)*;$($Tag:ident)*) => {
|
|
impl<Ctx, $($W: WidgetLike<Ctx, $Tag>,$Tag,)*> WidgetArrLike<$n, Ctx, ($($Tag,)*)> for ($($W,)*) {
|
|
type Ws = ($($W::Widget,)*);
|
|
fn ui(self, ui: &mut Ui<Ctx>) -> WidgetArr<$n, ($($W::Widget,)*)> {
|
|
#[allow(non_snake_case)]
|
|
let ($($W,)*) = self;
|
|
WidgetArr::new(
|
|
[$($W.add(ui).cast_type(),)*],
|
|
)
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
impl_widget_arr!(1;A);
|
|
impl_widget_arr!(2;A B);
|
|
impl_widget_arr!(3;A B C);
|
|
impl_widget_arr!(4;A B C D);
|
|
impl_widget_arr!(5;A B C D E);
|
|
impl_widget_arr!(6;A B C D E F);
|
|
impl_widget_arr!(7;A B C D E F G);
|
|
impl_widget_arr!(8;A B C D E F G H);
|
|
impl_widget_arr!(9;A B C D E F G H I);
|
|
impl_widget_arr!(10;A B C D E F G H I J);
|
|
impl_widget_arr!(11;A B C D E F G H I J K);
|
|
impl_widget_arr!(12;A B C D E F G H I J K L);
|