Merge pull request #23 from kas-gui/push-lykwkxlnpnkm

dhardy · web-flow · commit 831887939a4f · 2026-02-03T09:33:12.000Z
Update kas to 0.17
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
@@ -23,7 +23,9 @@ jobs:
           override: true
           components: rustfmt
       - name: Install dependencies
-        run: sudo apt-get install -y libxkbcommon-dev libxcb-shape0-dev libxcb-xfixes0-dev
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libfontconfig1-dev
       - name: Test
         run: |
           cargo fmt -- --check
diff --git a/Cargo.toml b/Cargo.toml
@@ -7,7 +7,7 @@ resolver = "2"
 publish = false
 
 [dependencies]
-kas = "0.16.0"
+kas = { version = "0.17.0", features = ["view"] }
 chrono = "0.4"
 env_logger = "0.11.8"
 pest = "2.1"
diff --git a/src/cells.rs b/src/cells.rs
@@ -5,10 +5,9 @@
 
 //! Cells: a mini spreadsheet
 
-use kas::view::{
-    DataChanges, DataClerk, DataKey, DataLen, Driver, GridIndex, GridView, TokenChanges,
-};
-use kas::widgets::{EditBox, EditField, EditGuard, ScrollBars};
+use kas::view::clerk::{self, AsyncClerk, TokenChanges, TokenClerk};
+use kas::view::{Driver, GridIndex, GridView};
+use kas::widgets::{edit, EditBox, ScrollRegion};
 use kas::{prelude::*, TextOrSource};
 use std::collections::HashMap;
 use std::fmt;
@@ -41,7 +40,7 @@ const ROW_LEN: u32 = 100;
 
 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
 pub struct Key(ColKey, u8);
-impl DataKey for Key {
+impl clerk::Key for Key {
     fn make_id(&self, parent: &Id) -> Id {
         assert_eq!(std::mem::size_of::<ColKey>(), 1);
         let key = (((self.0).0 as usize) << 8) | (self.1 as usize);
@@ -338,28 +337,34 @@ struct Clerk {
     empty_cell: Cell,
 }
 
-impl DataClerk<GridIndex> for Clerk {
+impl clerk::Clerk<GridIndex> for Clerk {
     type Data = CellData;
-    type Key = Key;
     type Item = Cell;
-    type Token = Key;
+
+    fn len(&self, _: &CellData, _: GridIndex) -> clerk::Len<GridIndex> {
+        clerk::Len::Known(GridIndex {
+            col: ColKey::LEN.cast(),
+            row: ROW_LEN,
+        })
+    }
+}
+
+impl AsyncClerk<GridIndex> for Clerk {
+    type Key = Key;
 
     fn update(
         &mut self,
         _: &mut ConfigCx<'_>,
         _: Id,
         _: Range<GridIndex>,
         _: &Self::Data,
-    ) -> DataChanges<GridIndex> {
-        DataChanges::Any
+    ) -> clerk::Changes<GridIndex> {
+        clerk::Changes::Any
     }
+}
 
-    fn len(&self, _: &CellData, _: GridIndex) -> DataLen<GridIndex> {
-        DataLen::Known(GridIndex {
-            col: ColKey::LEN.cast(),
-            row: ROW_LEN,
-        })
-    }
+impl TokenClerk<GridIndex> for Clerk {
+    type Token = Key;
 
     fn update_token(
         &self,
@@ -395,35 +400,36 @@ struct CellGuard {
     key: Key,
     is_input: bool,
 }
-impl EditGuard for CellGuard {
+impl edit::EditGuard for CellGuard {
     type Data = Cell;
 
-    fn update(edit: &mut EditField<Self>, cx: &mut ConfigCx, item: &Cell) {
-        edit.set_error_state(cx, item.parse_error);
-        if !edit.has_edit_focus() {
-            let text = if !item.display.is_empty() {
-                &item.display
-            } else {
-                &item.input
-            };
-            edit.set_str(cx, text);
-            edit.guard.is_input = false;
+    fn update(&mut self, edit: &mut edit::Editor, cx: &mut ConfigCx, item: &Cell) {
+        if item.parse_error {
+            edit.set_error(cx, None);
         }
+
+        let text = if !item.display.is_empty() {
+            &item.display
+        } else {
+            &item.input
+        };
+        edit.set_str(cx, text);
+        self.is_input = false;
     }
 
-    fn activate(edit: &mut EditField<Self>, cx: &mut EventCx, item: &Cell) -> IsUsed {
-        Self::focus_lost(edit, cx, item);
+    fn activate(&mut self, edit: &mut edit::Editor, cx: &mut EventCx, item: &Cell) -> IsUsed {
+        self.focus_lost(edit, cx, item);
         IsUsed::Used
     }
 
-    fn focus_gained(edit: &mut EditField<Self>, cx: &mut EventCx, item: &Cell) {
+    fn focus_gained(&mut self, edit: &mut edit::Editor, cx: &mut EventCx, item: &Cell) {
         edit.set_str(cx, &item.input);
-        edit.guard.is_input = true;
+        self.is_input = true;
     }
 
-    fn focus_lost(edit: &mut EditField<Self>, cx: &mut EventCx, item: &Cell) {
-        if edit.guard.is_input && edit.as_str() != item.input {
-            cx.push(UpdateInput(edit.guard.key, edit.clone_string()));
+    fn focus_lost(&mut self, edit: &mut edit::Editor, cx: &mut EventCx, item: &Cell) {
+        if self.is_input && edit.as_str() != item.input {
+            cx.push(UpdateInput(self.key, edit.clone_string()));
         }
     }
 }
@@ -436,6 +442,7 @@ impl Driver<Key, Cell> for CellDriver {
     // (a) there is currently no code to draw separators between cells
     // (b) EditField relies on a parent (EditBox) to draw background highlight on error state
     type Widget = EditBox<CellGuard>;
+    const TAB_NAVIGABLE: bool = false;
 
     fn make(&mut self, key: &Key) -> Self::Widget {
         EditBox::new(CellGuard {
@@ -479,8 +486,8 @@ pub fn window() -> Window<()> {
         struct {
             core: widget_core!(),
             data: CellData = data,
-            #[widget(&self.data)] cells: ScrollBars<GridView<Clerk, CellDriver>> =
-                ScrollBars::new(cells),
+            #[widget(&self.data)] cells: ScrollRegion<GridView<Clerk, CellDriver>> =
+                ScrollRegion::new_viewport(cells),
         }
         impl Events for Self {
             type Data = ();
diff --git a/src/crud.rs b/src/crud.rs
@@ -8,10 +8,10 @@
 use std::ops::Range;
 
 use kas::dir::Down;
+use kas::view::clerk::{AsyncClerk, Changes, Clerk, Len, TokenChanges, TokenClerk};
 use kas::view::filter::{ContainsCaseInsensitive, Filter, FilterValue, KeystrokeGuard, SetFilter};
-use kas::view::{DataChanges, DataClerk, DataLen, Driver, ListView, SelectionMsg, TokenChanges};
-use kas::widgets::edit::{EditBox, EditField, EditGuard};
-use kas::widgets::{AccessLabel, Button, ScrollBars, Text};
+use kas::view::{Driver, ListView, SelectionMsg};
+use kas::widgets::{edit, AccessLabel, Button, EditBox, ScrollRegion, Text};
 use kas::{prelude::*, TextOrSource};
 
 #[derive(Clone, Debug)]
@@ -48,18 +48,24 @@ enum Control {
 struct NameGuard {
     is_last: bool,
 }
-impl EditGuard for NameGuard {
+impl edit::EditGuard for NameGuard {
     type Data = Option<Entry>;
 
-    fn update(edit: &mut EditField<Self>, cx: &mut ConfigCx, data: &Self::Data) {
+    fn update(&mut self, edit: &mut edit::Editor, cx: &mut ConfigCx, data: &Self::Data) {
         if let Some(entry) = data.as_ref() {
-            let name = match edit.guard.is_last {
+            let name = match self.is_last {
                 false => &entry.first,
                 true => &entry.last,
             };
             edit.set_str(cx, name);
         }
-        edit.set_error_state(cx, edit.as_str().is_empty());
+        if edit.as_str().is_empty() {
+            edit.set_error(cx, None);
+        }
+    }
+
+    fn focus_lost(&mut self, _: &mut edit::Editor, _: &mut EventCx<'_>, _: &Self::Data) {
+        // Do nothing (the default impl calls Self::update)
     }
 }
 
@@ -124,20 +130,39 @@ struct EntriesClerk {
     filtered_entries: Vec<usize>,
 }
 
-impl DataClerk<usize> for EntriesClerk {
+impl EntriesClerk {
+    /// Delete the entry at `index`; return an index of a nearby item
+    fn delete(&mut self, index: usize) -> usize {
+        self.entries[index] = None;
+        for i in (index + 1..self.entries.len()).chain((0..index).rev()) {
+            if self.entries[i].is_some() {
+                return i;
+            }
+        }
+        0
+    }
+}
+
+impl Clerk<usize> for EntriesClerk {
     type Data = ContainsCaseInsensitive;
-    type Key = usize;
     type Item = Entry;
-    type Token = usize;
+
+    fn len(&self, _: &Self::Data, _: usize) -> Len<usize> {
+        Len::Known(self.filtered_entries.len())
+    }
+}
+
+impl AsyncClerk<usize> for EntriesClerk {
+    type Key = usize;
 
     fn update(
         &mut self,
         _: &mut ConfigCx,
         _: Id,
         _: Range<usize>,
         filter: &Self::Data,
-    ) -> DataChanges<usize> {
-        // TODO(opt) determine when updates are a no-op and return DataChanges::None
+    ) -> Changes<usize> {
+        // TODO(opt) determine when updates are a no-op and return Changes::None
 
         self.filtered_entries = self
             .entries
@@ -151,12 +176,12 @@ impl DataClerk<usize> for EntriesClerk {
             .map(|(i, _)| i)
             .collect();
 
-        DataChanges::Any
+        Changes::Any
     }
+}
 
-    fn len(&self, _: &Self::Data, _: usize) -> DataLen<usize> {
-        DataLen::Known(self.filtered_entries.len())
-    }
+impl TokenClerk<usize> for EntriesClerk {
+    type Token = usize;
 
     fn update_token(
         &self,
@@ -187,9 +212,10 @@ pub fn window() -> Window<()> {
     struct EntriesDriver;
     impl Driver<usize, Entry> for EntriesDriver {
         type Widget = Text<Entry, String>;
+        const TAB_NAVIGABLE: bool = false;
 
         fn make(&mut self, _: &usize) -> Self::Widget {
-            Text::new(Entry::format)
+            Text::new_gen(Entry::format)
         }
 
         fn navigable(_: &Self::Widget) -> bool {
@@ -216,15 +242,15 @@ pub fn window() -> Window<()> {
         #[layout(grid! {
             (0, 0) => "Filter:",
             (1, 0) => self.filter_field,
-            (0..2, 1..3) => frame!(self.list),
+            (0..=1, 1..=2) => frame!(self.list),
             (3, 1) => self.editor,
-            (0..4, 3) => self.controls,
+            (0..=3, 3) => self.controls,
         })]
         struct {
             core: widget_core!(),
             #[widget(&())] filter_field: EditBox<KeystrokeGuard> = EditBox::new(KeystrokeGuard),
-            #[widget(&self.filter)] list: ScrollBars<EntriesView> =
-                ScrollBars::new(EntriesView::new(clerk, EntriesDriver).with_selection_mode(kas::view::SelectionMode::Single)),
+            #[widget(&self.filter)] list: ScrollRegion<EntriesView> =
+                ScrollRegion::new_viewport(EntriesView::new(clerk, EntriesDriver).with_selection_mode(kas::view::SelectionMode::Single)),
             #[widget(&self.selected)] editor: Editor = Editor::default(),
             #[widget(&self.selected)] controls: Controls = Controls::default(),
             filter: ContainsCaseInsensitive,
@@ -251,7 +277,6 @@ pub fn window() -> Window<()> {
                             if let Some(item) = self.editor.make_item() {
                                 let index = self.list.inner().clerk().entries.len();
                                 self.list.inner_mut().clerk_mut().entries.push(Some(item));
-                                cx.update(self.list.as_node(&self.filter));
                                 self.list.inner_mut().select(cx, index);
                                 self.selected = self.list.inner().clerk().entries.get(index).cloned().flatten();
                                 cx.update(self.as_node(&()));
@@ -261,15 +286,13 @@ pub fn window() -> Window<()> {
                             if let Some(index) = self.selected() {
                                 if let Some(item) = self.editor.make_item() {
                                     self.list.inner_mut().clerk_mut().entries[index] = Some(item);
-                                    cx.update(self.list.as_node(&self.filter));
                                     cx.update(self.as_node(&()));
                                 }
                             }
                         }
                         Control::Delete => {
                             if let Some(index) = self.selected() {
-                                self.list.inner_mut().clerk_mut().entries[index] = None;
-                                cx.update(self.list.as_node(&self.filter));
+                                let index = self.list.inner_mut().clerk_mut().delete(index);
                                 self.list.inner_mut().select(cx, index);
                                 self.selected = self.list.inner().clerk().entries.get(index).cloned().flatten();
                                 cx.update(self.as_node(&()));
diff --git a/src/flight_booker.rs b/src/flight_booker.rs
@@ -8,7 +8,7 @@
 use chrono::{Duration, Local, NaiveDate, ParseError};
 use kas::prelude::*;
 use kas::widgets::dialog::MessageBox;
-use kas::widgets::{column, Adapt, Button, ComboBox, EditBox, EditField, EditGuard, Text};
+use kas::widgets::{column, edit, Adapt, Button, ComboBox, EditBox, Text};
 
 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
 enum Flight {
@@ -92,29 +92,31 @@ impl Guard {
         Guard { is_return_field }
     }
 }
-impl EditGuard for Guard {
+impl edit::EditGuard for Guard {
     type Data = Data;
 
-    fn edit(edit: &mut EditField<Self>, cx: &mut EventCx, _: &Self::Data) {
+    fn edit(&mut self, edit: &mut edit::Editor, cx: &mut EventCx, _: &Self::Data) {
         let result = NaiveDate::parse_from_str(edit.as_str().trim(), "%Y-%m-%d");
-        edit.set_error_state(cx, result.is_err());
+        if result.is_err() {
+            edit.set_error(cx, Some("not a valid date".into()));
+        }
 
         cx.push(ActionDate {
             result,
-            is_return_field: edit.guard.is_return_field,
+            is_return_field: self.is_return_field,
         });
     }
 
-    fn update(edit: &mut EditField<Self>, cx: &mut ConfigCx, data: &Self::Data) {
-        if !edit.has_edit_focus() && edit.as_str().is_empty() {
-            if let Ok(date) = match edit.guard.is_return_field {
+    fn update(&mut self, edit: &mut edit::Editor, cx: &mut ConfigCx, data: &Self::Data) {
+        if edit.as_str().is_empty() {
+            if let Ok(date) = match self.is_return_field {
                 false => data.out,
                 true => data.ret,
             } {
                 edit.set_string(cx, date.format("%Y-%m-%d").to_string());
             }
         }
-        if edit.guard.is_return_field {
+        if self.is_return_field {
             cx.set_disabled(edit.id(), data.flight == Flight::OneWay);
         }
     }
@@ -139,7 +141,7 @@ pub fn window() -> Window<()> {
         ),
         EditBox::new(Guard::new(false)),
         EditBox::new(Guard::new(true)),
-        Text::new(|_, data: &Data| format!("{}", data.error)),
+        Text::new_gen(|_, data: &Data| format!("{}", data.error)),
         Button::label_msg("&Book", ActionBook)
             .map_any()
             .on_update(|cx, _, data: &Data| cx.set_disabled(!data.error.is_none())),
@@ -176,7 +178,7 @@ pub fn window() -> Window<()> {
                     ),
                 }
             };
-            cx.add_window::<()>(MessageBox::new(msg).into_window("Booker result"));
+            cx.add_window::<()>(MessageBox::new(msg).into_window("Booker result"), false);
         });
 
     Window::new(ui, "Flight Booker").escapable()
diff --git a/src/main.rs b/src/main.rs
diff --git a/src/timer.rs b/src/timer.rs
