remove Adhoc trait, they can all be implemented via View

src/view/mod.rs

@@ -30,9 +30,6 @@ pub use style::{Elements, Palette, StyleKind};
 
 mod internal_views;
 
-mod adhoc;
-pub use adhoc::Adhoc;
-
 mod builder;
 pub use builder::{Builder, View, ViewExt};
 

src/view/ui.rs

@@ -11,7 +11,7 @@ use crate::{
 use super::{
     filter::{Filter, Filterable},
     input::InputState,
-    internal_views, Adhoc, Builder, LayoutNodes, Palette, Response, State, View, ViewId, ViewNodes,
+    internal_views, Builder, LayoutNodes, Palette, Response, State, View, ViewId, ViewNodes,
 };
 
 impl<'a> Filterable for Ui<'a> {
@@ -48,13 +48,6 @@ impl<'a> Ui<'a> {
 }
 
 impl<'a> Ui<'a> {
-    pub fn adhoc<'v, A>(&self, view: A) -> A::Output
-    where
-        A: Adhoc<'v>,
-    {
-        view.show(self)
-    }
-
     pub fn show<'v, B>(&self, args: B) -> Response<<B::View as View>::Response>
     where
         B: Builder<'v>,
@@ -363,22 +356,22 @@ impl<'a> Ui<'a> {
     }
 
     pub fn checkbox(&self, value: &mut bool, label: impl Into<Str>) -> Response<bool> {
-        self.adhoc(views::checkbox(value, label))
+        self.show(views::checkbox(value, label))
     }
 
     pub fn todo_value(&self, value: &mut bool, label: impl Into<Str>) -> Response<bool> {
-        self.adhoc(views::todo_value(value, label))
+        self.show(views::todo_value(value, label))
     }
 
     pub fn selected(&self, value: &mut bool, label: impl Into<Str>) -> Response<bool> {
-        self.adhoc(views::selected(value, label))
+        self.show(views::selected(value, label))
     }
 
     pub fn radio<V>(&self, value: V, existing: &mut V, label: impl Into<Str>) -> Response<bool>
     where
-        V: PartialEq,
+        V: PartialEq + 'static,
     {
-        self.adhoc(views::radio(value, existing, label))
+        self.show(views::radio(value, existing, label))
     }
 
     pub fn label(&self, data: impl Into<Str>) -> Response {

src/views/checkbox.rs

@@ -1,14 +1,14 @@
 use crate::{
     renderer::Rgba,
-    view::{Adhoc, Palette, Response, StyleKind, Ui},
+    view::{Builder, Palette, StyleKind, Ui, View},
     Str,
 };
 
 use super::label::LabelStyle;
 
 pub type CheckboxClass = fn(&Palette, bool) -> CheckboxStyle;
 
-#[derive(Debug)]
+#[derive(Debug, Copy, Clone)]
 pub struct CheckboxStyle {
     pub checked: &'static str,
     pub unchecked: &'static str,
@@ -55,15 +55,32 @@ impl<'a> Checkbox<'a> {
     }
 }
 
-impl<'a> Adhoc<'a> for Checkbox<'a> {
-    // TODO make this an opaque response
-    type Output = Response<bool>;
+impl<'v> Builder<'v> for Checkbox<'v> {
+    type View = CheckboxView;
+}
+
+#[derive(Debug)]
+pub struct CheckboxView {
+    label: Str,
+    class: StyleKind<CheckboxClass, CheckboxStyle>,
+}
+
+impl View for CheckboxView {
+    type Args<'v> = Checkbox<'v>;
+    type Response = bool;
+
+    fn create(args: Self::Args<'_>) -> Self {
+        Self {
+            label: args.label,
+            class: args.class,
+        }
+    }
 
-    fn show(self, ui: &Ui) -> Self::Output {
+    fn update(&mut self, args: Self::Args<'_>, ui: &Ui) -> Self::Response {
         let resp = ui
             .mouse_area(|ui| {
                 let style = match self.class {
-                    StyleKind::Deferred(style) => (style)(&ui.palette(), *self.value),
+                    StyleKind::Deferred(style) => (style)(&ui.palette(), *args.value),
                     StyleKind::Direct(style) => style,
                 };
 
@@ -74,19 +91,19 @@ impl<'a> Adhoc<'a> for Checkbox<'a> {
                 };
 
                 ui.horizontal(|ui| {
-                    let marker = if *self.value {
+                    let marker = if *args.value {
                         style.checked
                     } else {
                         style.unchecked
                     };
                     ui.label(marker);
-                    ui.show(super::label(self.label).style(LabelStyle { foreground }));
+                    ui.show(super::label(&self.label).style(LabelStyle { foreground }));
                 });
             })
             .flatten_left();
 
-        *self.value ^= resp.clicked();
-        resp.map(|c| c.clicked())
+        *args.value ^= resp.clicked();
+        resp.clicked()
     }
 }
 

src/views/mod.rs

@@ -17,8 +17,8 @@ pub use button::{button, Button, ButtonClass, ButtonResponse, ButtonStyle};
 mod checkbox;
 pub use checkbox::{checkbox, Checkbox, CheckboxClass, CheckboxStyle};
 
-mod collapsible;
-pub use collapsible::{collapsible, Collapsible, CollapsibleClass, CollapsibleStyle};
+// mod collapsible;
+// pub use collapsible::{collapsible, Collapsible, CollapsibleClass, CollapsibleStyle};
 
 mod constrain;
 pub use constrain::{Constrain, Unconstrained};

src/views/radio.rs

@@ -1,14 +1,16 @@
+use std::marker::PhantomData;
+
 use crate::{
     renderer::Rgba,
-    view::{Adhoc, Palette, Response, StyleKind},
+    view::{Builder, Palette, StyleKind, Ui, View},
     Str,
 };
 
 use super::label::{label, LabelStyle};
 
 pub type RadioClass = fn(&Palette, bool) -> RadioStyle;
 
-#[derive(Debug)]
+#[derive(Debug, Copy, Clone)]
 pub struct RadioStyle {
     pub selected: Option<&'static str>,
     pub unselected: Option<&'static str>,
@@ -51,24 +53,55 @@ pub struct Radio<'a, V> {
     class: StyleKind<RadioClass, RadioStyle>,
 }
 
-impl<'v, V> Adhoc<'v> for Radio<'v, V>
+impl<'v, V: PartialEq + 'static> Builder<'v> for Radio<'v, V> {
+    type View = RadioView<V>;
+}
+
+pub struct RadioView<V>
 where
-    V: PartialEq,
+    V: PartialEq + 'static,
 {
-    type Output = Response<bool>;
+    label: Str,
+    class: StyleKind<RadioClass, RadioStyle>,
+    _marker: std::marker::PhantomData<V>,
+}
+
+impl<V: PartialEq> std::fmt::Debug for RadioView<V> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("RadioView")
+            .field("label", &self.label)
+            .field("class", &self.class)
+            .finish()
+    }
+}
+
+impl<V> View for RadioView<V>
+where
+    V: PartialEq + 'static,
+{
+    type Args<'v> = Radio<'v, V>;
+    type Response = bool;
+
+    fn create(args: Self::Args<'_>) -> Self {
+        Self {
+            label: args.label,
+            class: args.class,
+            _marker: PhantomData,
+        }
+    }
 
-    fn show(self, ui: &crate::view::Ui) -> Self::Output {
+    fn update(&mut self, args: Self::Args<'_>, ui: &Ui) -> Self::Response {
         let resp = ui
             .mouse_area(|ui| {
                 let style = match self.class {
                     StyleKind::Deferred(style) => {
-                        (style)(&ui.palette(), self.value == *self.existing)
+                        (style)(&ui.palette(), args.value == *args.existing)
                     }
                     StyleKind::Direct(style) => style,
                 };
 
                 let hovered = ui.is_hovered();
-                let fill = match (hovered, self.value == *self.existing) {
+                let fill = match (hovered, args.value == *args.existing) {
                     (false, true) => style.selected_background,
                     (false, false) => style.background,
                     (true, true) => style
@@ -84,15 +117,16 @@ where
                 };
 
                 ui.background(fill, |ui| {
-                    ui.show(label(self.label).style(LabelStyle { foreground }))
+                    ui.show(label(&self.label).style(LabelStyle { foreground }))
                 });
             })
             .flatten_left();
 
-        if resp.clicked() {
-            *self.existing = self.value;
+        let clicked = resp.clicked();
+        if clicked {
+            *args.existing = args.value;
         }
-        resp.map(|c| c.clicked())
+        clicked
     }
 }