rm: builder for core::listbox

examples/bk/select.rs → examples/select.rs

@@ -3,7 +3,7 @@ use promkit::{error::Result, preset::Select};
 fn main() -> Result {
     let mut p = Select::new(0..100)
         .title("What number do you like?")
-        .lines(5)
+        .window_size(5)
         .prompt()?;
     println!("result: {:?}", p.run()?);
     Ok(())

src/core/listbox.rs

@@ -2,8 +2,6 @@ use std::{fmt, iter::FromIterator};
 
 mod render;
 pub use render::Renderer;
-mod build;
-pub use build::Builder;
 
 use crate::core::cursor::Cursor;
 

src/core/listbox/render.rs

@@ -5,20 +5,45 @@ use crate::{
         event::{Event, KeyCode, KeyEvent, KeyEventKind, KeyEventState, KeyModifiers},
         style::ContentStyle,
     },
+    error::Result,
     grapheme::{trim, Graphemes},
     listbox::Listbox,
     pane::Pane,
-    render::{AsAny, Renderable},
+    render::{AsAny, Renderable, State},
 };
 
 #[derive(Clone)]
 pub struct Renderer {
     pub listbox: Listbox,
 
-    pub style: ContentStyle,
+    /// Style for selected line.
+    pub active_item_style: ContentStyle,
+    /// Style for un-selected line.
+    pub inactive_item_style: ContentStyle,
+
+    /// Symbol for selected line.
     pub cursor: String,
-    pub cursor_style: ContentStyle,
-    pub lines: Option<usize>,
+
+    /// Window size.
+    pub window_size: Option<usize>,
+}
+
+impl State<Renderer> {
+    pub fn try_new(
+        listbox: Listbox,
+        active_item_style: ContentStyle,
+        inactive_item_style: ContentStyle,
+        cursor: String,
+        window_size: Option<usize>,
+    ) -> Result<Box<State<Renderer>>> {
+        Ok(Box::new(State::<Renderer>::new(Renderer {
+            listbox,
+            active_item_style,
+            inactive_item_style,
+            cursor,
+            window_size,
+        })))
+    }
 }
 
 impl Renderable for Renderer {
@@ -30,23 +55,26 @@ impl Renderable for Renderer {
             .enumerate()
             .map(|(i, item)| {
                 if i == self.listbox.position() {
-                    Graphemes::new_with_style(format!("{}{}", self.cursor, item), self.cursor_style)
+                    Graphemes::new_with_style(
+                        format!("{}{}", self.cursor, item),
+                        self.active_item_style,
+                    )
                 } else {
                     Graphemes::new_with_style(
                         format!(
                             "{}{}",
                             " ".repeat(Graphemes::new(self.cursor.clone()).widths()),
                             item
                         ),
-                        self.style,
+                        self.inactive_item_style,
                     )
                 }
             })
             .collect::<Vec<Graphemes>>();
 
         let trimed = matrix.iter().map(|row| trim(width as usize, row)).collect();
 
-        Pane::new(trimed, self.listbox.position(), self.lines)
+        Pane::new(trimed, self.listbox.position(), self.window_size)
     }
 
     /// Default key bindings for item picker.

src/preset.rs

@@ -6,8 +6,8 @@ pub use checkbox::Checkbox;
 // pub use readline::Readline;
 // mod password;
 // pub use password::Password;
-// mod select;
-// pub use select::Select;
+mod select;
+pub use select::Select;
 // mod queryselect;
 // pub use queryselect::QuerySelect;
 // mod tree;

src/preset/select.rs

@@ -1,52 +1,83 @@
 use std::fmt::Display;
 
 use crate::{
+    crossterm::style::{Attribute, Attributes, Color, ContentStyle},
     error::Result,
     listbox,
-    preset::theme::select::Theme,
     render::{Renderable, State},
+    style::Style,
     text, Prompt,
 };
 
+pub struct Theme {
+    /// Style for title (enabled if you set title).
+    pub title_style: ContentStyle,
+
+    /// Style for selected item.
+    pub active_item_style: ContentStyle,
+    /// Style for un-selected item.
+    pub inactive_item_style: ContentStyle,
+
+    /// Symbol for selected line.
+    pub cursor: String,
+}
+
+impl Default for Theme {
+    fn default() -> Self {
+        Self {
+            title_style: Style::new()
+                .attrs(Attributes::from(Attribute::Bold))
+                .build(),
+            active_item_style: Style::new().fgc(Color::DarkCyan).build(),
+            inactive_item_style: Style::new().build(),
+            cursor: String::from("❯ "),
+        }
+    }
+}
+
 pub struct Select {
-    title_builder: text::Builder,
-    listbox_builder: listbox::Builder,
+    title: String,
+    listbox: listbox::Listbox,
+    theme: Theme,
+    window_size: Option<usize>,
 }
 
 impl Select {
     pub fn new<T: Display, I: IntoIterator<Item = T>>(items: I) -> Self {
         Self {
-            title_builder: Default::default(),
-            listbox_builder: listbox::Builder::new(items),
+            title: Default::default(),
+            listbox: listbox::Listbox::from_iter(items),
+            theme: Default::default(),
+            window_size: Default::default(),
         }
-        .theme(Theme::default())
     }
 
-    pub fn theme(mut self, theme: Theme) -> Self {
-        self.title_builder = self.title_builder.style(theme.title_style);
-        self.listbox_builder = self
-            .listbox_builder
-            .cursor(theme.cursor)
-            .style(theme.item_style)
-            .cursor_style(theme.cursor_style);
+    pub fn title<T: AsRef<str>>(mut self, text: T) -> Self {
+        self.title = text.as_ref().to_string();
         self
     }
 
-    pub fn title<T: AsRef<str>>(mut self, text: T) -> Self {
-        self.title_builder = self.title_builder.text(text);
+    pub fn theme(mut self, theme: Theme) -> Self {
+        self.theme = theme;
         self
     }
 
-    pub fn lines(mut self, lines: usize) -> Self {
-        self.listbox_builder = self.listbox_builder.lines(lines);
+    pub fn window_size(mut self, window_size: usize) -> Self {
+        self.window_size = Some(window_size);
         self
     }
 
     pub fn prompt(self) -> Result<Prompt<String>> {
         Prompt::try_new(
             vec![
-                self.title_builder.build_state()?,
-                self.listbox_builder.build_state()?,
+                State::<text::Renderer>::try_new(self.title, self.theme.title_style)?,
+                State::<listbox::Renderer>::try_new(
+                    self.listbox,
+                    self.theme.active_item_style,
+                    self.theme.inactive_item_style,
+                    self.theme.cursor,
+                    self.window_size,
+                )?,
             ],
             |_, _| Ok(true),
             |renderables: &Vec<Box<dyn Renderable + 'static>>| -> Result<String> {