Widget trait simplification — radicle-tui

This merges the view into the widget trait and removes unnecessary generic backend parameter.

 use tui::store;
 use tui::store::StateValue;
 use tui::task::{self, Interrupted};
 use tui::terminal::Backend;
 use tui::ui::items::{Filter, NotificationItem, NotificationItemFilter};
 use tui::ui::widget::{Properties, View, Window, WindowProps};
 use tui::ui::widget::{Properties, Widget, Window, WindowProps};
 use tui::ui::Frontend;
 use tui::Exit;

     ScrollHelp { progress: usize },
 }
 impl store::State<Action, Selection> for State {
 impl store::State<Selection> for State {
     type Action = Action;
     fn tick(&self) {}
     fn handle_action(&mut self, action: Action) -> Option<Exit<Selection>> {

         let (frontend, action_tx, action_rx) = Frontend::new();
         let state = State::try_from(&self.context)?;
         let window: Window<Backend, State, Action, Page> = Window::new(&state, action_tx.clone())
         let window: Window<State, Action, Page> = Window::new(&state, action_tx.clone())
             .page(
                 Page::Browse,
                 BrowsePage::new(&state, action_tx.clone()).to_boxed(),

 use termion::event::Key;
 use ratatui::backend::Backend;
 use ratatui::layout::{Constraint, Layout, Rect};
 use ratatui::style::Stylize;
 use ratatui::text::{Line, Span, Text};

 use tui::ui::widget::input::{TextField, TextFieldProps, TextFieldState};
 use tui::ui::widget::text::{Paragraph, ParagraphProps, ParagraphState};
 use tui::ui::widget::{self, BaseView, TableUtils};
 use tui::ui::widget::{
     Column, Properties, Shortcuts, ShortcutsProps, Table, TableProps, View, Widget,
 };
 use tui::ui::widget::{Column, Properties, Shortcuts, ShortcutsProps, Table, TableProps, Widget};
 use tui::Selection;
 use crate::tui_inbox::common::{InboxOperation, Mode, RepositoryMode, SelectionMode};
 use super::{Action, State};
 type BoxedWidget<B> = widget::BoxedWidget<B, State, Action>;
 type BoxedWidget = widget::BoxedWidget<State, Action>;
 #[derive(Clone)]
 struct BrowsePageProps<'a> {

 impl<'a> Properties for BrowsePageProps<'a> {}
 pub struct BrowsePage<'a, B> {
 pub struct BrowsePage<'a> {
     /// Internal base
     base: BaseView<State, Action>,
     /// Internal props
     props: BrowsePageProps<'a>,
     /// Notifications widget
     notifications: BoxedWidget<B>,
     notifications: BoxedWidget,
     /// Search widget
     search: BoxedWidget<B>,
     search: BoxedWidget,
     /// Shortcut widget
     shortcuts: BoxedWidget<B>,
     shortcuts: BoxedWidget,
 }
 impl<'a: 'static, B> View<State, Action> for BrowsePage<'a, B>
 where
     B: Backend + 'a,
 {
 impl<'a> BrowsePage<'a> {
     fn build_footer(props: &BrowsePageProps<'a>, selected: Option<usize>) -> Vec<Column<'a>> {
         let search = Line::from(vec![
             span::default(" Search ").cyan().dim().reversed(),
             span::default(" "),
             span::default(&props.search.to_string()).gray().dim(),
         ]);
         let seen = Line::from(vec![
             span::positive(&props.stats.get("Seen").unwrap_or(&0).to_string()).dim(),
             span::default(" Seen").dim(),
         ]);
         let unseen = Line::from(vec![
             span::positive(&props.stats.get("Unseen").unwrap_or(&0).to_string())
                 .magenta()
                 .dim(),
             span::default(" Unseen").dim(),
         ]);
         let progress = selected
             .map(|selected| {
                 TableUtils::progress(selected, props.notifications.len(), props.page_size)
             })
             .unwrap_or_default();
         let progress = span::default(&format!("{}%", progress)).dim();
         match NotificationItemFilter::from_str(&props.search)
             .unwrap_or_default()
             .state()
         {
             Some(state) => {
                 let block = match state {
                     NotificationState::Seen => seen,
                     NotificationState::Unseen => unseen,
                 };
                 [
                     Column::new(Text::from(search), Constraint::Fill(1)),
                     Column::new(
                         Text::from(block.clone()),
                         Constraint::Min(block.width() as u16),
                     ),
                     Column::new(Text::from(progress), Constraint::Min(4)),
                 ]
                 .to_vec()
             }
             None => [
                 Column::new(Text::from(search), Constraint::Fill(1)),
                 Column::new(
                     Text::from(seen.clone()),
                     Constraint::Min(seen.width() as u16),
                 ),
                 Column::new(
                     Text::from(unseen.clone()),
                     Constraint::Min(unseen.width() as u16),
                 ),
                 Column::new(Text::from(progress), Constraint::Min(4)),
             ]
             .to_vec(),
         }
     }
 }
 impl<'a: 'static> Widget for BrowsePage<'a> {
     type Action = Action;
     type State = State;
     fn new(state: &State, action_tx: UnboundedSender<Action>) -> Self {
         let props = BrowsePageProps::from(state);
         let name = match state.mode.repository() {

         }
     }
     fn base_mut(&mut self) -> &mut BaseView<State, Action> {
         &mut self.base
     }
     fn update(&mut self, state: &State) {
         self.props = BrowsePageProps::from_callback(self.base.on_update, state)
             .unwrap_or(BrowsePageProps::from(state));
         self.notifications.update(state);
         self.search.update(state);
         self.shortcuts.update(state);
     }
     fn handle_event(&mut self, key: Key) {
         if self.props.show_search {
             self.search.handle_event(key);

             let _ = self.base.action_tx.send(Action::BrowserPageSize(page_size));
         }
     }
     fn base_mut(&mut self) -> &mut BaseView<State, Action> {
         &mut self.base
     }
 }
 pub struct SearchProps {}
 impl Properties for SearchProps {}
 pub struct Search<B: Backend> {
 pub struct Search {
     /// Internal base
     base: BaseView<State, Action>,
     /// Internal props
     _props: SearchProps,
     /// Search input field
     input: BoxedWidget<B>,
     input: BoxedWidget,
 }
 impl<B: Backend> View<State, Action> for Search<B> {
 impl Widget for Search {
     type Action = Action;
     type State = State;
     fn new(state: &State, action_tx: UnboundedSender<Action>) -> Self
     where
         Self: Sized,

         }
     }
     fn base_mut(&mut self) -> &mut BaseView<State, Action> {
         &mut self.base
     }
     fn update(&mut self, state: &State) {
         self.input.update(state);
     }
     fn handle_event(&mut self, key: termion::event::Key) {
         match key {
             Key::Esc => {

             }
         }
     }
 }
 impl<B> Widget<B, State, Action> for Search<B>
 where
     B: Backend,
 {
     fn update(&mut self, state: &State) {
         self.input.update(state);
     }
     fn render(&self, frame: &mut ratatui::Frame, area: Rect, _props: Option<Box<dyn Any>>) {
         let layout = Layout::horizontal(Constraint::from_mins([0]))
             .horizontal_margin(1)

             }
         }
     }
 }
 impl<'a: 'static, B> Widget<B, State, Action> for HelpPage<'a, B>
 where
     B: Backend + 'a,
 {
     fn update(&mut self, state: &State) {
         self.props = HelpPageProps::from_callback(self.base.on_update, state)
             .unwrap_or(HelpPageProps::from(state));
         self.content.update(state);
     }
     fn render(&self, frame: &mut ratatui::Frame, area: Rect, props: Option<Box<dyn Any>>) {
         let props = props
             .and_then(HelpPageProps::from_boxed_any)

             }
         }
     }
 }
 impl<'a, B: Backend> BrowsePage<'a, B> {
     fn build_footer(props: &BrowsePageProps<'a>, selected: Option<usize>) -> Vec<Column<'a>> {
         let search = Line::from(vec![
             span::default(" Search ").cyan().dim().reversed(),
             span::default(" "),
             span::default(&props.search).gray().dim(),
         ]);
         let open = Line::from(vec![
             span::positive(&props.stats.get("Open").unwrap_or(&0).to_string()).dim(),
             span::default(" Open").dim(),
         ]);
         let solved = Line::from(vec![
             span::default(&props.stats.get("Solved").unwrap_or(&0).to_string())
                 .magenta()
                 .dim(),
             span::default(" Solved").dim(),
         ]);
         let closed = Line::from(vec![
             span::default(&props.stats.get("Closed").unwrap_or(&0).to_string())
                 .magenta()
                 .dim(),
             span::default(" Closed").dim(),
         ]);
         let sum = Line::from(vec![
             span::default("Σ ").dim(),
             span::default(&props.issues.len().to_string()).dim(),
         ]);
         let progress = selected
             .map(|selected| TableUtils::progress(selected, props.issues.len(), props.page_size))
             .unwrap_or_default();
         let progress = span::default(&format!("{}%", progress)).dim();
         match IssueItemFilter::from_str(&props.search)
             .unwrap_or_default()
             .state()
         {
             Some(state) => {
                 let block = match state {
                     issue::State::Open => open,
                     issue::State::Closed {
                         reason: issue::CloseReason::Other,
                     } => closed,
                     issue::State::Closed {
                         reason: issue::CloseReason::Solved,
                     } => solved,
                 };
     fn update(&mut self, state: &State) {
         self.props = BrowsePageProps::from_callback(self.base.on_update, state)
             .unwrap_or(BrowsePageProps::from(state));
                 [
                     Column::new(Text::from(search), Constraint::Fill(1)),
                     Column::new(
                         Text::from(block.clone()),
                         Constraint::Min(block.width() as u16),
                     ),
                     Column::new(Text::from(progress), Constraint::Min(4)),
                 ]
                 .to_vec()
             }
             None => [
                 Column::new(Text::from(search), Constraint::Fill(1)),
                 Column::new(
                     Text::from(open.clone()),
                     Constraint::Min(open.width() as u16),
                 ),
                 Column::new(
                     Text::from(closed.clone()),
                     Constraint::Min(closed.width() as u16),
                 ),
                 Column::new(Text::from(sum.clone()), Constraint::Min(sum.width() as u16)),
                 Column::new(Text::from(progress), Constraint::Min(4)),
             ]
             .to_vec(),
         }
         self.issues.update(state);
         self.search.update(state);
         self.shortcuts.update(state);
     }
 }
 impl<'a: 'static, B> Widget<B, State, Action> for BrowsePage<'a, B>
 where
     B: Backend + 'a,
 {
     fn render(&self, frame: &mut ratatui::Frame, area: Rect, props: Option<Box<dyn Any>>) {
         let props = props
             .and_then(BrowsePageProps::from_boxed_any)

 use tui::store;
 use tui::task;
 use tui::task::Interrupted;
 use tui::terminal::Backend;
 use tui::ui::items::{Filter, PatchItem, PatchItemFilter};
 use tui::ui::widget::Properties;
 use tui::ui::widget::View;
 use tui::ui::widget::Widget;
 use tui::ui::widget::Window;
 use tui::ui::widget::WindowProps;
 use tui::ui::Frontend;

 /// The `State` known to the application store. It handles user-defined
 /// application messages as well as ticks.
 pub trait State<A, P>
 pub trait State<P>
 where
     P: Clone + Debug + Send + Sync,
 {
     type Action;
     /// Handle a user-defined application message and return an `Exit` object
     /// in case the received message requested the application to also quit.
     fn handle_action(&mut self, action: A) -> Option<Exit<P>>;
     fn handle_action(&mut self, action: Self::Action) -> Option<Exit<P>>;
     /// Handle recurring tick.
     fn tick(&self);

 /// messages coming from the frontend and updates the state accordingly.
 pub struct Store<A, S, P>
 where
     S: State<A, P> + Clone + Send + Sync,
     S: State<P> + Clone + Send + Sync,
     P: Clone + Debug + Send + Sync,
 {
     state_tx: UnboundedSender<S>,

 impl<A, S, P> Store<A, S, P>
 where
     S: State<A, P> + Clone + Debug + Send + Sync + 'static,
     S: State<P, Action = A> + Clone + Debug + Send + Sync + 'static,
     P: Clone + Debug + Send + Sync + 'static,
 {
     /// By calling `main_loop`, the store will wait for new messages coming

 pub mod widget;
 use std::fmt::Debug;
 use std::io::{self};
 use std::time::Duration;
 use termion::raw::RawTerminal;
 use tokio::sync::broadcast;
 use tokio::sync::mpsc::{self, UnboundedReceiver, UnboundedSender};

 use super::store::State;
 use super::task::Interrupted;
 use super::terminal;
 use super::terminal::TermionBackendExt;
 use super::ui::widget::Widget;
 type Backend = TermionBackendExt<RawTerminal<io::Stdout>>;
 const RENDERING_TICK_RATE: Duration = Duration::from_millis(250);
 const INLINE_HEIGHT: usize = 20;

         mut interrupt_rx: broadcast::Receiver<Interrupted<P>>,
     ) -> anyhow::Result<Interrupted<P>>
     where
         S: State<A, P>,
         W: Widget<Backend, S, A>,
         S: State<P>,
         W: Widget<State = S, Action = A>,
         P: Clone + Send + Sync + Debug,
     {
         let mut ticker = tokio::time::interval(RENDERING_TICK_RATE);

 use super::theme::style;
 use super::{layout, span};
 pub type BoxedWidget<B, S, A> = Box<dyn Widget<B, S, A>>;
 pub type BoxedWidget<S, A> = Box<dyn Widget<State = S, Action = A>>;
 pub type UpdateCallback<S> = fn(&S) -> Box<dyn Any>;
 pub type EventCallback<A> = fn(&dyn Any, UnboundedSender<A>);

     pub on_event: Option<EventCallback<A>>,
 }
 /// Main trait defining a `View` behaviour.
 /// Main trait defining a `Widget` behaviour.
 ///
 /// This is the first trait that you should implement to define a custom `Widget`.
 pub trait View<S, A> {
 /// This is the trait that you should implement to define a custom `Widget`.
 pub trait Widget {
     type State;
     type Action;
     /// Should return a new view with props build from state (if type is known) and a
     /// message sender set.
     fn new(state: &S, action_tx: UnboundedSender<A>) -> Self
     fn new(state: &Self::State, action_tx: UnboundedSender<Self::Action>) -> Self
     where
         Self: Sized;
     /// Should handle key events and call `handle_event` on all children.
     ///
     /// After key events have been handled, the custom event handler `on_event` should
     /// be called
     fn handle_event(&mut self, key: Key);
     /// Should update the internal props of this and all children.
     ///
     /// Applications are usually defined by app-specific widgets that do know
     /// the type of `state`. These can use widgets from the library that do not know the
     /// type of `state`.
     ///
     /// If `on_update` is set, implementations of this function should call it to
     /// construct and update the internal props. If it is not set, app widgets can construct
     /// props directly via their state converters, whereas library widgets can just fallback
     /// to their current props.
     fn update(&mut self, state: &Self::State);
     /// Renders a widget to the given frame in the given area.
     ///
     /// Optional props take precedence over the internal ones.
     fn render(&self, frame: &mut Frame, area: Rect, props: Option<Box<dyn Any>>);
     /// Return a mutable reference to this widgets' base view.
     fn base_mut(&mut self) -> &mut BaseView<Self::State, Self::Action>;
     /// Should set the optional custom event handler.
     fn on_event(mut self, callback: EventCallback<A>) -> Self
     fn on_event(mut self, callback: EventCallback<Self::Action>) -> Self
     where
         Self: Sized,
     {

     }
     /// Should set the optional update handler.
     fn on_update(mut self, callback: UpdateCallback<S>) -> Self
     fn on_update(mut self, callback: UpdateCallback<Self::State>) -> Self
     where
         Self: Sized,
     {

 impl<Id> Properties for WindowProps<Id> {}
 pub struct Window<B, S, A, Id>
 where
     B: Backend,
 {
 pub struct Window<S, A, Id> {
     /// Internal base
     base: BaseView<S, A>,
     /// Internal properties
     props: WindowProps<Id>,
     /// All pages known
     pages: HashMap<Id, BoxedWidget<B, S, A>>,
     pages: HashMap<Id, BoxedWidget<S, A>>,
 }
 impl<B, S, A, Id> Window<B, S, A, Id>
 impl<S, A, Id> Window<S, A, Id>
 where
     B: Backend,
     Id: Clone + Hash + Eq + PartialEq,
 {
     pub fn page(mut self, id: Id, page: BoxedWidget<B, S, A>) -> Self {
         // self.pages.inse
     pub fn page(mut self, id: Id, page: BoxedWidget<S, A>) -> Self {
         self.pages.insert(id, page);
         self
     }
 }
 impl<'a: 'static, B, S, A, Id> View<S, A> for Window<B, S, A, Id>
 impl<'a: 'static, S, A, Id> Widget for Window<S, A, Id>
 where
     B: Backend + 'a,
     Id: Clone + Hash + Eq + PartialEq + 'a,
 {
     type Action = A;
     type State = S;
     fn new(_state: &S, action_tx: UnboundedSender<A>) -> Self
     where
         Self: Sized,

         }
     }
     fn base_mut(&mut self) -> &mut BaseView<S, A> {
         &mut self.base
     }
     fn update(&mut self, state: &S) {
         self.props =
             WindowProps::from_callback(self.base.on_update, state).unwrap_or(self.props.clone());
     fn handle_event(&mut self, key: termion::event::Key) {
         let page = self
             .props
             .current_page

             .and_then(|id| self.pages.get_mut(id));
         if let Some(page) = page {
             page.handle_event(key);
             page.update(state);
         }
     }
 }
 impl<'a: 'static, B, S, A, Id> Widget<B, S, A> for Window<B, S, A, Id>
 where
     B: Backend + 'a,
     Id: Clone + Hash + Eq + PartialEq + 'a,
 {
     fn render(&self, frame: &mut ratatui::Frame, _area: Rect, props: Option<Box<dyn Any>>) {
         let _props = props
             .and_then(WindowProps::from_boxed_any)

     }
 }
 impl<S, A> View<S, A> for Shortcuts<S, A> {
 impl<S, A> Widget for Shortcuts<S, A> {
     type Action = A;
     type State = S;
     fn new(_state: &S, action_tx: UnboundedSender<A>) -> Self {
         Self {
             base: BaseView {

         let table = Table::new([Row::new(row)], widths).column_spacing(0);
         frame.render_widget(table, area);
     }
     fn base_mut(&mut self) -> &mut BaseView<S, A> {
         &mut self.base
     }
 }
 #[derive(Clone, Debug)]

             (on_event)(&self.state, self.base.action_tx.clone());
         }
     }
 }
 impl<'a: 'static, B, S, A, R> Widget<B, S, A> for Table<'a, S, A, R>
 where
     B: Backend,
     R: ToRow + Clone + Debug + 'static,
 {
     fn update(&mut self, state: &S) {
         self.props =
             TableProps::from_callback(self.base.on_update, state).unwrap_or(self.props.clone());
         // TODO: Move to state reducer
         if let Some(selected) = self.state.selected() {
             if selected > self.props.items.len() {
                 self.begin();
             }
         }
     }
     fn render(&self, frame: &mut ratatui::Frame, area: Rect, props: Option<Box<dyn Any>>) {
         let props = props
             .and_then(TableProps::from_boxed_any)

 use crate::ui::ext::{FooterBlock, FooterBlockType, HeaderBlock};
 use crate::ui::theme::style;
 use super::{BaseView, BoxedWidget, Column, Properties, View, Widget};
 use super::{BaseView, BoxedWidget, Column, Properties, Widget};
 #[derive(Clone, Debug)]
 pub struct HeaderProps<'a> {

             .unwrap_or(self.props.clone());
     }
     fn handle_event(&mut self, _key: Key) {
         if let Some(on_event) = self.base.on_event {
             (on_event)(&self.props, self.base.action_tx.clone());
         }
     }
 }
 impl<'a: 'static, B, S, A> Widget<B, S, A> for Header<'a, S, A>
 where
     B: Backend,
 {
     fn render(&self, frame: &mut ratatui::Frame, area: Rect, props: Option<Box<dyn Any>>) {
         let props = props
             .and_then(HeaderProps::from_boxed_any)

 impl Properties for ContainerProps {}
 pub struct Container<B, S, A>
 where
     B: Backend,
 {
 pub struct Container<S, A> {
     /// Internal base
     base: BaseView<S, A>,
     /// Internal props
     props: ContainerProps,
     /// Container header
     header: Option<BoxedWidget<B, S, A>>,
     header: Option<BoxedWidget<S, A>>,
     /// Content widget
     content: Option<BoxedWidget<B, S, A>>,
     content: Option<BoxedWidget<S, A>>,
     /// Container footer
     footer: Option<BoxedWidget<B, S, A>>,
     footer: Option<BoxedWidget<S, A>>,
 }
 impl<B, S, A> Container<B, S, A>
 where
     B: Backend,
 {
     pub fn header(mut self, header: BoxedWidget<B, S, A>) -> Self {
 impl<S, A> Container<S, A> {
     pub fn header(mut self, header: BoxedWidget<S, A>) -> Self {
         self.header = Some(header);
         self
     }
     pub fn content(mut self, content: BoxedWidget<B, S, A>) -> Self {
     pub fn content(mut self, content: BoxedWidget<S, A>) -> Self {
         self.content = Some(content);
         self
     }
     pub fn footer(mut self, footer: BoxedWidget<B, S, A>) -> Self {
     pub fn footer(mut self, footer: BoxedWidget<S, A>) -> Self {
         self.footer = Some(footer);
         self
     }
 }
 impl<B, S, A> View<S, A> for Container<B, S, A>
 where
     B: Backend,
 {
 impl<S, A> Widget for Container<S, A> {
     type Action = A;
     type State = S;
     fn new(_state: &S, action_tx: UnboundedSender<A>) -> Self
     where
         Self: Sized,

 use tokio::sync::mpsc::UnboundedSender;
 use ratatui::layout::{Constraint, Layout};
 use ratatui::prelude::{Backend, Rect};
 use ratatui::prelude::Rect;
 use ratatui::style::Stylize;
 use ratatui::text::{Line, Span};
 use super::{BaseView, Properties, View, Widget};
 use super::{BaseView, Properties, Widget};
 #[derive(Clone)]
 pub struct TextFieldProps {

         }
     }
     fn base_mut(&mut self) -> &mut BaseView<S, A> {
         &mut self.base
     }
     fn update(&mut self, state: &S) {
         if let Some(on_update) = self.base.on_update {
             if let Some(props) = (on_update)(state).downcast_ref::<TextFieldProps>() {
                 self.props = props.clone();
                 if self.state.text.is_none() {
                     self.state.cursor_position = props.text.len().saturating_sub(1);
                 }
                 self.state.text = Some(props.text.clone());
             }
         }
     }
     fn handle_event(&mut self, key: Key) {
         match key {
             Key::Char(to_insert)