Introduce base view — radicle-tui

Every view has a base that all views share: a message sender, an update and an event callback.

 };
 use tui::ui::widget::input::{TextField, TextFieldProps, TextFieldState};
 use tui::ui::widget::text::{Paragraph, ParagraphProps, ParagraphState};
 use tui::ui::widget::{self, TableUtils};
 use tui::ui::widget::{self, BaseView, TableUtils};
 use tui::ui::widget::{
     Column, EventCallback, Properties, Shortcuts, ShortcutsProps, Table, TableProps,
     UpdateCallback, View, Widget,
     Column, Properties, Shortcuts, ShortcutsProps, Table, TableProps, View, Widget,
 };
 use tui::Selection;

 impl<'a> Properties for BrowsePageProps<'a> {}
 pub struct BrowsePage<'a, B> {
     /// Internal properties
     /// Internal base
     base: BaseView<State, Action>,
     /// Internal props
     props: BrowsePageProps<'a>,
     /// Message sender
     action_tx: UnboundedSender<Action>,
     /// Custom update handler
     on_update: Option<UpdateCallback<State>>,
     /// Additional custom event handler
     on_event: Option<EventCallback<Action>>,
     /// Notifications widget
     notifications: BoxedWidget<B>,
     /// Search widget

         };
         Self {
             action_tx: action_tx.clone(),
             props: BrowsePageProps::from(state),
             base: BaseView {
                 action_tx: action_tx.clone(),
                 on_update: None,
                 on_event: None,
             },
             props: props.clone(),
             notifications: Container::new(state, action_tx.clone())
                 .header(
                     Header::new(state, action_tx.clone())

                 .to_boxed(),
             search: Search::new(state, action_tx.clone()).to_boxed(),
             shortcuts: Shortcuts::new(state, action_tx.clone()).to_boxed(),
             on_update: None,
             on_event: None,
         }
     }
     fn on_event(mut self, callback: EventCallback<Action>) -> Self {
         self.on_event = Some(callback);
         self
     }
     fn on_update(mut self, callback: UpdateCallback<State>) -> Self {
         self.on_update = Some(callback);
         self
     fn base_mut(&mut self) -> &mut BaseView<State, Action> {
         &mut self.base
     }
     fn update(&mut self, state: &State) {
         self.props = BrowsePageProps::from_callback(self.on_update, state)
         self.props = BrowsePageProps::from_callback(self.base.on_update, state)
             .unwrap_or(BrowsePageProps::from(state));
         self.notifications.update(state);

         self.shortcuts.update(state);
     }
     fn handle_key_event(&mut self, key: Key) {
     fn handle_event(&mut self, key: Key) {
         if self.props.show_search {
             self.search.handle_key_event(key);
             self.search.handle_event(key);
         } else {
             match key {
                 Key::Esc | Key::Ctrl('c') => {
                     let _ = self.action_tx.send(Action::Exit { selection: None });
                     let _ = self.base.action_tx.send(Action::Exit { selection: None });
                 }
                 Key::Char('?') => {
                     let _ = self.action_tx.send(Action::OpenHelp);
                     let _ = self.base.action_tx.send(Action::OpenHelp);
                 }
                 Key::Char('/') => {
                     let _ = self.action_tx.send(Action::OpenSearch);
                     let _ = self.base.action_tx.send(Action::OpenSearch);
                 }
                 Key::Char('\n') => {
                     self.props

                         .selected
                         .and_then(|selected| self.props.notifications.get(selected))
                         .and_then(|notif| {
                             self.action_tx
                             self.base
                                 .action_tx
                                 .send(Action::Exit {
                                     selection: Some(
                                         Selection::default()

                         });
                 }
                 _ => {
                     self.notifications.handle_key_event(key);
                     self.notifications.handle_event(key);
                 }
             }
         }

         );
         if page_size != props.page_size {
             let _ = self.action_tx.send(Action::HelpPageSize(page_size));
             let _ = self.base.action_tx.send(Action::HelpPageSize(page_size));
         }
     }
 }

 use tui::ui::items::{IssueItem, IssueItemFilter};
 use tui::ui::span;
 use tui::ui::widget;
 use tui::ui::widget::container::{
     Container, ContainerProps, Footer, FooterProps, Header, HeaderProps,
 };
 use tui::ui::widget::input::{TextField, TextFieldProps, TextFieldState};
 use tui::ui::widget::text::{Paragraph, ParagraphProps, ParagraphState};
 use tui::ui::widget::{self, BaseView};
 use tui::ui::widget::{
     Column, EventCallback, Properties, Shortcuts, ShortcutsProps, Table, TableProps, TableUtils,
     UpdateCallback, View, Widget,
     Column, Properties, Shortcuts, ShortcutsProps, Table, TableProps, TableUtils, View, Widget,
 };
 use tui::Selection;

                         });
                 }
                 _ => {
                     self.issues.handle_key_event(key);
                     self.issues.handle_event(key);
                 }
             }
         }

     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(" ".into()),
             span::default(" "),
             span::default(&props.search).gray().dim(),
         ]);

                         });
                 }
                 _ => {
                     self.patches.handle_key_event(key);
                     self.patches.handle_event(key);
                 }
             }
         }

                 // Tick to terminate the select every N milliseconds
                 _ = ticker.tick() => (),
                 Some(event) = events_rx.recv() => match event {
                     Event::Key(key) => root.handle_key_event(key),
                     Event::Key(key) => root.handle_event(key),
                     Event::Resize => (),
                 },
                 // Handle state updates

 pub type UpdateCallback<S> = fn(&S) -> Box<dyn Any>;
 pub type EventCallback<A> = fn(&dyn Any, UnboundedSender<A>);
 /// A `View`s common fields.
 pub struct BaseView<S, A> {
     /// Message sender
     pub action_tx: UnboundedSender<A>,
     /// Custom update handler
     pub on_update: Option<UpdateCallback<S>>,
     /// Additional custom event handler
     pub on_event: Option<EventCallback<A>>,
 }
 /// Main trait defining a `View` behaviour.
 ///
 /// This is the first trait that you should implement to define a custom `Widget`.

         Self: Sized;
     /// Should set the optional custom event handler.
     fn on_event(self, callback: EventCallback<A>) -> Self
     fn on_event(mut self, callback: EventCallback<A>) -> Self
     where
         Self: Sized;
         Self: Sized,
     {
         self.base_mut().on_event = Some(callback);
         self
     }
     /// Should set the optional update handler.
     fn on_update(self, callback: UpdateCallback<S>) -> Self
     fn on_update(mut self, callback: UpdateCallback<S>) -> Self
     where
         Self: Sized;
         Self: Sized,
     {
         self.base_mut().on_update = Some(callback);
         self
     }
     /// Returns a boxed `View`
     fn to_boxed(self) -> Box<Self>

         Box::new(self)
     }
     /// Should handle key events and call `handle_key_event` on all children.
     /// Return a mutable reference to this widgets' base view.
     fn base_mut(&mut self) -> &mut BaseView<S, A>;
     /// 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_key_event(&mut self, key: Key);
     fn handle_event(&mut self, key: Key);
     /// Should update the internal props of this and all children.
     ///

     fn render(&self, frame: &mut Frame, area: Rect, props: Option<Box<dyn Any>>);
 }
 /// Needs to be implemented for items that are supposed to be rendering in tables.
 /// Needs to be implemented for items that are supposed to be rendered in tables.
 pub trait ToRow {
     fn to_row(&self) -> Vec<Cell>;
 }

         }
     }
     fn handle_key_event(&mut self, key: termion::event::Key) {
     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_key_event(key);
             page.handle_event(key);
         }
     }
 }

 impl<S, A> View<S, A> for Shortcuts<S, A> {
     fn new(_state: &S, action_tx: UnboundedSender<A>) -> Self {
         Self {
             _action_tx: action_tx.clone(),
             base: BaseView {
                 action_tx: action_tx.clone(),
                 on_update: None,
                 on_event: None,
             },
             props: ShortcutsProps::default(),
             on_update: None,
             on_event: None,
         }
     }
     fn on_event(mut self, callback: EventCallback<A>) -> Self {
         self.on_event = Some(callback);
         self
     fn base_mut(&mut self) -> &mut BaseView<S, A> {
         &mut self.base
     }
     fn on_update(mut self, callback: UpdateCallback<S>) -> Self {
         self.on_update = Some(callback);
         self
     }
     fn handle_key_event(&mut self, _key: Key) {}
     fn handle_event(&mut self, _key: Key) {}
     fn update(&mut self, state: &S) {
         self.props =
             ShortcutsProps::from_callback(self.on_update, state).unwrap_or(self.props.clone());
             ShortcutsProps::from_callback(self.base.on_update, state).unwrap_or(self.props.clone());
     }
 }

         self.props.selected = self.state.selected();
         if let Some(on_event) = self.on_event {
             (on_event)(&self.state, self.action_tx.clone());
         if let Some(on_event) = self.base.on_event {
             (on_event)(&self.state, self.base.action_tx.clone());
         }
     }
 }

 {
     fn render(&self, frame: &mut ratatui::Frame, area: Rect, props: Option<Box<dyn Any>>) {
         let props = props
             .and_then(TableProps::<'_, R>::from_boxed_any)
             .and_then(TableProps::from_boxed_any)
             .unwrap_or(self.props.clone());
         let widths: Vec<Constraint> = self

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

         }
     }
     fn handle_key_event(&mut self, key: termion::event::Key) {
     fn handle_event(&mut self, key: termion::event::Key) {
         if let Some(content) = &mut self.content {
             content.handle_key_event(key);
             content.handle_event(key);
         }
     }
 }

 use ratatui::style::Stylize;
 use ratatui::text::{Line, Span};
 use super::{EventCallback, Properties, UpdateCallback, View, Widget};
 use super::{BaseView, Properties, View, Widget};
 #[derive(Clone)]
 pub struct TextFieldProps {