add default winit framework

src/bin/test/main.rs

@@ -1,86 +1,24 @@
-use app::App;
-use arboard::Clipboard;
 use cosmic_text::Family;
-use input::Input;
-use iris::prelude::*;
+use iris::{
+    prelude::*,
+    winit::{attr::Selectable, event::Submit, *},
+};
 use len_fns::*;
-use render::Renderer;
-use std::{
-    sync::Arc,
-    time::{Duration, Instant},
-};
-use winit::{
-    dpi::{LogicalPosition, LogicalSize},
-    event::{Ime, WindowEvent},
-    event_loop::ActiveEventLoop,
-    window::Window,
-};
-
-mod app;
-mod input;
-mod render;
+use winit::event::WindowEvent;
 
 fn main() {
-    App::run();
+    UiApp::<Client>::run();
 }
 
 pub struct Client {
-    renderer: Renderer,
-    window: Arc<Window>,
-    input: Input,
-    ui: Ui,
+    ui: DefaultUi,
     info: WidgetId<Text>,
-    focus: Option<WidgetId<TextEdit>>,
-    clipboard: Clipboard,
-    ime: usize,
-    last_click: Instant,
 }
 
-#[derive(Eq, PartialEq, Hash, Clone)]
-struct Submit;
+impl DefaultUiState for Client {
+    type Event = ();
 
-impl DefaultEvent for Submit {
-    type Data = ();
-}
-
-pub struct Selectable;
-
-impl WidgetAttr<TextEdit> for Selectable {
-    type Input = ();
-
-    fn run(ui: &mut Ui, id: &WidgetId<TextEdit>, _: Self::Input) {
-        let id = id.clone();
-        ui.register_event(
-            &id.clone(),
-            CursorSense::click_or_drag(),
-            move |client: &mut Client, data| {
-                let now = Instant::now();
-                let recent = (now - client.last_click) < Duration::from_millis(300);
-                client.last_click = now;
-                client.ui.text(&id).select(
-                    data.cursor,
-                    data.size,
-                    data.sense.is_dragging(),
-                    recent,
-                );
-                if let Some(region) = client.ui.window_region(&id) {
-                    client.window.set_ime_allowed(true);
-                    client.window.set_ime_cursor_area(
-                        LogicalPosition::<f32>::from(region.top_left.tuple()),
-                        LogicalSize::<f32>::from(region.size().tuple()),
-                    );
-                }
-                client.focus = Some(id.clone());
-            },
-        );
-    }
-}
-
-impl Client {
-    pub fn new(window: Arc<Window>) -> Self {
-        let renderer = Renderer::new(window.clone());
-
-        let mut ui = Ui::new();
+    fn new(mut ui: DefaultUi, _proxy: Proxy<Self::Event>) -> Self {
         let rrect = rect(Color::WHITE).radius(20);
         let pad_test = (
             rrect.color(Color::BLUE),
@@ -250,109 +188,26 @@ impl Client {
             .stack()
             .set_root(&mut ui);
 
-        Self {
-            renderer,
-            window,
-            input: Input::default(),
-            ui,
-            info,
-            focus: None,
-            clipboard: Clipboard::new().unwrap(),
-            ime: 0,
-            last_click: Instant::now(),
-        }
+        Self { ui, info }
     }
 
-    pub fn event(&mut self, event: WindowEvent, event_loop: &ActiveEventLoop) {
-        let input_changed = self.input.event(&event);
-        let cursor_state = self.cursor_state().clone();
-        let old = self.focus.clone();
-        if cursor_state.buttons.left.is_start() {
-            self.focus = None;
-        }
-        if input_changed {
-            let window_size = self.window_size();
-            self.run_sensors(&cursor_state, window_size);
-            self.ui.run_sensors(&cursor_state, window_size);
-        }
-        if old != self.focus
-            && let Some(old) = old
-        {
-            self.ui.text(&old).deselect();
-        }
-        match event {
-            WindowEvent::CloseRequested => event_loop.exit(),
-            WindowEvent::RedrawRequested => {
-                self.ui.update();
-                self.renderer.update(&mut self.ui);
-                self.renderer.draw()
-            }
-            WindowEvent::Resized(size) => {
-                self.ui.resize((size.width, size.height));
-                self.renderer.resize(&size)
-            }
-            WindowEvent::KeyboardInput { event, .. } => {
-                if let Some(sel) = &self.focus
-                    && event.state.is_pressed()
-                {
-                    let mut text = self.ui.text(sel);
-                    match text.apply_event(&event, &self.input.modifiers) {
-                        TextInputResult::Unfocus => {
-                            self.focus = None;
-                        }
-                        TextInputResult::Submit => {
-                            self.run_event(&sel.clone(), Submit, ());
-                        }
-                        TextInputResult::Paste => {
-                            if let Ok(t) = self.clipboard.get_text() {
-                                text.insert(&t);
-                            }
-                        }
-                        TextInputResult::Copy(text) => {
-                            if let Err(err) = self.clipboard.set_text(text) {
-                                eprintln!("failed to copy text to clipboard: {err}")
-                            }
-                        }
-                        TextInputResult::Unused | TextInputResult::Used => (),
-                    }
-                }
-            }
-            WindowEvent::Ime(ime) => {
-                if let Some(sel) = &self.focus {
-                    let mut text = self.ui.text(sel);
-                    match ime {
-                        Ime::Enabled | Ime::Disabled => (),
-                        Ime::Preedit(content, _pos) => {
-                            // TODO: highlight once that's real
-                            text.replace(self.ime, &content);
-                            self.ime = content.chars().count();
-                        }
-                        Ime::Commit(content) => {
-                            text.insert(&content);
-                        }
-                    }
-                }
-            }
-            _ => (),
-        }
+    fn ui(&mut self) -> &mut DefaultUi {
+        &mut self.ui
+    }
+
+    fn window_event(&mut self, _: WindowEvent) {
         let new = format!(
             "widgets: {}\nactive:{}\nviews: {}",
             self.ui.num_widgets(),
             self.ui.active_widgets(),
-            self.renderer.ui.view_count()
+            self.ui.renderer.ui.view_count()
         );
         if new != *self.ui[&self.info].content {
             *self.ui[&self.info].content = new;
         }
         if self.ui.needs_redraw() {
-            self.renderer.window().request_redraw();
+            self.ui.window.request_redraw();
         }
-        self.input.end_frame();
-    }
-}
-
-impl UiCtx for Client {
-    fn ui(&mut self) -> &mut Ui {
-        &mut self.ui
+        self.ui.input.end_frame();
     }
 }