napali 0.1.1

TUI interface for Integrated Reasoning's accelerated solver API
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

use super::{Component, Frame, State};
use crate::action::overlay::Overlay;
use crate::{action::Action, config::Config};
use color_eyre::eyre::Result;
use crossterm::event::KeyEvent;
use ratatui::{
  prelude::*,
  widgets::{Block, BorderType, Borders, Clear, Row, Table},
};
use tokio::sync::mpsc::UnboundedSender;

/// Manages the display of usage information and keybindings in Napali.
///
/// This struct handles interactions and state for displaying a helpful guide of keybindings
/// and their respective actions within the application.
#[derive(Default, Debug, Clone)]
pub struct UsageInfo {
  command_tx: Option<UnboundedSender<Action>>,
  config: Config,
  state: State,
}

impl Component for UsageInfo {
  /// Registers an action handler for sending actions.
  ///
  /// # Arguments
  /// - `tx`: The sender for dispatching actions.
  fn register_action_handler(
    &mut self,
    tx: UnboundedSender<Action>,
  ) -> Result<()> {
    self.command_tx = Some(tx);
    Ok(())
  }

  /// Registers a configuration handler.
  ///
  /// # Arguments
  /// - `config`: The application configuration.
  fn register_config_handler(&mut self, config: Config) -> Result<()> {
    self.config = config;
    Ok(())
  }

  /// Handles key events.
  ///
  /// # Arguments
  /// - `_key`: The key event to handle.
  fn handle_key_events(&mut self, _key: KeyEvent) -> Result<Option<Action>> {
    self.state = State::Hidden;
    Ok(None)
  }

  /// Updates the state based on the received action.
  ///
  /// # Arguments
  /// - `action`: The action received by the component.
  fn update(&mut self, action: Action) -> Result<Option<Action>> {
    if let Action::ToggleOverlay(overlay) = action {
      match overlay {
        Overlay::UsageInfo => {
          self.state = match self.state {
            State::Visible => State::Hidden,
            State::Hidden => State::Visible,
          };
        }
      }
    }
    Ok(None)
  }

  /// Draws the usage information on the terminal frame.
  ///
  /// # Arguments
  /// - `f`: The frame to draw onto.
  /// - `area`: The area where the component should be rendered.
  fn draw(&mut self, f: &mut Frame<'_>, area: Rect) -> Result<()> {
    if self.state != State::Hidden {
      let rect = area.inner(&Margin {
        horizontal: 4,
        vertical: 4,
      });
      let vertical_rects = Layout::default()
        .direction(Direction::Vertical)
        .constraints(vec![
          Constraint::Ratio(2, 7),
          Constraint::Ratio(3, 7),
          Constraint::Ratio(2, 7),
        ])
        .split(rect);
      let horizontal_rects = Layout::default()
        .direction(Direction::Horizontal)
        .constraints(vec![
          Constraint::Ratio(2, 7),
          Constraint::Ratio(3, 7),
          Constraint::Ratio(2, 7),
        ])
        .split(vertical_rects[1]);
      let rows = vec![
        // TODO: Make this component-specific
        Row::new(vec!["H", "Home"]),
        Row::new(vec!["S", "Session"]),
        Row::new(vec!["I", "Configuration"]),
        Row::new(vec!["E", "Email prompt"]),
        Row::new(vec!["q", "Quit"]),
        Row::new(vec!["?", "Show usage help"]),
      ];
      let table = Table::new(rows)
        .header(
          Row::new(vec!["Key", "Action"])
            .bottom_margin(1)
            .style(Style::default().add_modifier(Modifier::BOLD)),
        )
        .widths(&[Constraint::Percentage(10), Constraint::Percentage(90)])
        .column_spacing(1)
        .block(
          Block::default()
            .title("Usage")
            .title_alignment(Alignment::Left)
            .borders(Borders::ALL)
            .border_style(Style::default())
            .border_type(BorderType::Rounded)
            .style(Style::default()),
        )
        .style(Style::default());
      f.render_widget(Clear, horizontal_rects[1]);
      f.render_widget(
        table,
        horizontal_rects[1].inner(&Margin {
          vertical: 1,
          horizontal: 1,
        }),
      );
    }
    Ok(())
  }
}