964 lines
30 KiB
Rust
964 lines
30 KiB
Rust
/*
|
|
* meli - ui crate.
|
|
*
|
|
* Copyright 2017-2018 Manos Pitsidianakis
|
|
*
|
|
* This file is part of meli.
|
|
*
|
|
* meli is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* meli is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with meli. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
/*! Various useful components that can be used in a generic fashion.
|
|
*/
|
|
use super::*;
|
|
|
|
mod widgets;
|
|
|
|
pub use self::widgets::*;
|
|
|
|
/// A horizontally split in half container.
|
|
#[derive(Debug)]
|
|
pub struct HSplit {
|
|
top: Entity,
|
|
bottom: Entity,
|
|
show_divider: bool,
|
|
ratio: usize, // bottom/whole height * 100
|
|
}
|
|
|
|
impl fmt::Display for HSplit {
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
|
// TODO display subject/info
|
|
Display::fmt(&self.top, f)
|
|
}
|
|
}
|
|
|
|
impl HSplit {
|
|
pub fn new(top: Entity, bottom: Entity, ratio: usize, show_divider: bool) -> Self {
|
|
HSplit {
|
|
top,
|
|
bottom,
|
|
show_divider,
|
|
ratio,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Component for HSplit {
|
|
fn draw(&mut self, grid: &mut CellBuffer, area: Area, context: &mut Context) {
|
|
if !is_valid_area!(area) {
|
|
return;
|
|
}
|
|
let upper_left = upper_left!(area);
|
|
let bottom_right = bottom_right!(area);
|
|
let total_rows = get_y(bottom_right) - get_y(upper_left);
|
|
let bottom_entity_height = (self.ratio * total_rows) / 100;
|
|
let mid = get_y(upper_left) + total_rows - bottom_entity_height;
|
|
|
|
if self.show_divider {
|
|
for i in get_x(upper_left)..=get_x(bottom_right) {
|
|
grid[(i, mid)].set_ch('─');
|
|
}
|
|
context
|
|
.dirty_areas
|
|
.push_back(((get_x(upper_left), mid), (get_x(bottom_right), mid)));
|
|
}
|
|
|
|
self.top.component.draw(
|
|
grid,
|
|
(
|
|
upper_left,
|
|
(get_x(bottom_right), get_y(upper_left) + mid - 1),
|
|
),
|
|
context,
|
|
);
|
|
self.bottom.component.draw(
|
|
grid,
|
|
((get_x(upper_left), get_y(upper_left) + mid), bottom_right),
|
|
context,
|
|
);
|
|
}
|
|
fn process_event(&mut self, event: &mut UIEvent, context: &mut Context) -> bool {
|
|
self.top.rcv_event(event, context) || self.bottom.rcv_event(event, context)
|
|
}
|
|
fn is_dirty(&self) -> bool {
|
|
self.top.component.is_dirty() || self.bottom.component.is_dirty()
|
|
}
|
|
fn set_dirty(&mut self) {
|
|
self.top.component.set_dirty();
|
|
self.bottom.component.set_dirty();
|
|
}
|
|
}
|
|
|
|
/// A vertically split in half container.
|
|
#[derive(Debug)]
|
|
pub struct VSplit {
|
|
left: Entity,
|
|
right: Entity,
|
|
show_divider: bool,
|
|
/// This is the width of the right container to the entire width.
|
|
ratio: usize, // right/(container width) * 100
|
|
}
|
|
|
|
impl fmt::Display for VSplit {
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
|
// TODO display focused entity
|
|
Display::fmt(&self.right, f)
|
|
}
|
|
}
|
|
|
|
impl VSplit {
|
|
pub fn new(left: Entity, right: Entity, ratio: usize, show_divider: bool) -> Self {
|
|
VSplit {
|
|
left,
|
|
right,
|
|
show_divider,
|
|
ratio,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Component for VSplit {
|
|
fn draw(&mut self, grid: &mut CellBuffer, area: Area, context: &mut Context) {
|
|
if !is_valid_area!(area) {
|
|
return;
|
|
}
|
|
let upper_left = upper_left!(area);
|
|
let bottom_right = bottom_right!(area);
|
|
let total_cols = get_x(bottom_right) - get_x(upper_left);
|
|
let right_entity_width = (self.ratio * total_cols) / 100;
|
|
let mid = get_x(bottom_right) - right_entity_width;
|
|
|
|
if get_y(upper_left) > 1 {
|
|
let c = grid
|
|
.get(mid, get_y(upper_left) - 1)
|
|
.map(|a| a.ch())
|
|
.unwrap_or_else(|| ' ');
|
|
if let HORZ_BOUNDARY = c {
|
|
grid[(mid, get_y(upper_left) - 1)].set_ch(LIGHT_DOWN_AND_HORIZONTAL);
|
|
}
|
|
}
|
|
|
|
if self.show_divider {
|
|
for i in get_y(upper_left)..=get_y(bottom_right) {
|
|
grid[(mid, i)].set_ch(VERT_BOUNDARY);
|
|
grid[(mid, i)].set_fg(Color::Default);
|
|
grid[(mid, i)].set_bg(Color::Default);
|
|
}
|
|
if get_y(bottom_right) > 1 {
|
|
let c = grid
|
|
.get(mid, get_y(bottom_right) - 1)
|
|
.map(|a| a.ch())
|
|
.unwrap_or_else(|| ' ');
|
|
if let HORZ_BOUNDARY = c {
|
|
grid[(mid, get_y(bottom_right) + 1)].set_ch(LIGHT_UP_AND_HORIZONTAL);
|
|
}
|
|
}
|
|
context
|
|
.dirty_areas
|
|
.push_back(((mid, get_y(upper_left)), (mid, get_y(bottom_right))));
|
|
}
|
|
self.left
|
|
.component
|
|
.draw(grid, (upper_left, (mid - 1, get_y(bottom_right))), context);
|
|
self.right
|
|
.component
|
|
.draw(grid, ((mid + 1, get_y(upper_left)), bottom_right), context);
|
|
}
|
|
fn process_event(&mut self, event: &mut UIEvent, context: &mut Context) -> bool {
|
|
(self.left.rcv_event(event, context) || self.right.rcv_event(event, context))
|
|
}
|
|
fn is_dirty(&self) -> bool {
|
|
self.left.component.is_dirty() || self.right.component.is_dirty()
|
|
}
|
|
fn set_dirty(&mut self) {
|
|
self.left.component.set_dirty();
|
|
self.right.component.set_dirty();
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub enum PageMovement {
|
|
PageUp,
|
|
PageDown,
|
|
}
|
|
|
|
/// A pager for text.
|
|
/// `Pager` holds its own content in its own `CellBuffer` and when `draw` is called, it draws the
|
|
/// current view of the text. It is responsible for scrolling etc.
|
|
#[derive(Default, Debug)]
|
|
pub struct Pager {
|
|
cursor_pos: usize,
|
|
max_cursor_pos: Option<usize>,
|
|
height: usize,
|
|
|
|
width: usize,
|
|
dirty: bool,
|
|
content: CellBuffer,
|
|
movement: Option<PageMovement>,
|
|
}
|
|
|
|
impl fmt::Display for Pager {
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
|
// TODO display info
|
|
write!(f, "pager")
|
|
}
|
|
}
|
|
|
|
impl Pager {
|
|
pub fn update_from_str(&mut self, text: &str) {
|
|
let lines: Vec<&str> = text.trim().split('\n').collect();
|
|
let height = lines.len() + 1;
|
|
let width = lines.iter().map(|l| l.len()).max().unwrap_or(0);
|
|
let mut content = CellBuffer::new(width, height, Cell::with_char(' '));
|
|
//interpret_format_flowed(&text);
|
|
Pager::print_string(&mut content, text);
|
|
self.content = content;
|
|
self.height = height;
|
|
self.width = width;
|
|
self.dirty = true;
|
|
self.cursor_pos = 0;
|
|
self.max_cursor_pos = None;
|
|
}
|
|
pub fn from_string(mut text: String, context: &mut Context, cursor_pos: Option<usize>) -> Self {
|
|
let pager_filter: Option<&String> = context.settings.pager.filter.as_ref();
|
|
//let format_flowed: bool = context.settings.pager.format_flowed;
|
|
if let Some(bin) = pager_filter {
|
|
use std::io::Write;
|
|
use std::process::{Command, Stdio};
|
|
let mut filter_child = Command::new(bin)
|
|
.stdin(Stdio::piped())
|
|
.stdout(Stdio::piped())
|
|
.spawn()
|
|
.expect("Failed to start pager filter process");
|
|
{
|
|
let mut stdin = filter_child.stdin.as_mut().expect("failed to open stdin");
|
|
stdin
|
|
.write_all(text.as_bytes())
|
|
.expect("Failed to write to stdin");
|
|
}
|
|
|
|
text = String::from_utf8_lossy(
|
|
&filter_child
|
|
.wait_with_output()
|
|
.expect("Failed to wait on filter")
|
|
.stdout,
|
|
).to_string();
|
|
}
|
|
|
|
let lines: Vec<&str> = text.trim().split('\n').collect();
|
|
let height = lines.len() + 1;
|
|
let width = lines.iter().map(|l| l.len()).max().unwrap_or(0);
|
|
let mut content = CellBuffer::new(width, height, Cell::with_char(' '));
|
|
//interpret_format_flowed(&text);
|
|
Pager::print_string(&mut content, &text);
|
|
Pager {
|
|
cursor_pos: cursor_pos.unwrap_or(0),
|
|
height,
|
|
width,
|
|
dirty: true,
|
|
content,
|
|
..Default::default()
|
|
}
|
|
}
|
|
pub fn from_str(s: &str, cursor_pos: Option<usize>) -> Self {
|
|
let lines: Vec<&str> = s.trim().split('\n').collect();
|
|
let height = lines.len();
|
|
let width = lines.iter().map(|l| l.len()).max().unwrap_or(0);
|
|
let mut content = CellBuffer::new(width, height, Cell::with_char(' '));
|
|
Pager::print_string(&mut content, s);
|
|
Pager {
|
|
cursor_pos: cursor_pos.unwrap_or(0),
|
|
height,
|
|
width,
|
|
dirty: true,
|
|
content,
|
|
..Default::default()
|
|
}
|
|
}
|
|
pub fn from_buf(content: CellBuffer, cursor_pos: Option<usize>) -> Self {
|
|
let (width, height) = content.size();
|
|
Pager {
|
|
cursor_pos: cursor_pos.unwrap_or(0),
|
|
height,
|
|
width,
|
|
dirty: true,
|
|
content,
|
|
..Default::default()
|
|
}
|
|
}
|
|
pub fn print_string(content: &mut CellBuffer, s: &str) {
|
|
let lines: Vec<&str> = s.trim().split('\n').collect();
|
|
let width = lines.iter().map(|l| l.len()).max().unwrap_or(0);
|
|
if width > 0 {
|
|
for (i, l) in lines.iter().enumerate() {
|
|
write_string_to_grid(
|
|
l,
|
|
content,
|
|
Color::Default,
|
|
Color::Default,
|
|
((0, i), (width - 1, i)),
|
|
true,
|
|
);
|
|
}
|
|
}
|
|
}
|
|
pub fn cursor_pos(&self) -> usize {
|
|
self.cursor_pos
|
|
}
|
|
}
|
|
|
|
impl Component for Pager {
|
|
fn draw(&mut self, grid: &mut CellBuffer, area: Area, context: &mut Context) {
|
|
if !is_valid_area!(area) {
|
|
return;
|
|
}
|
|
if !self.is_dirty() {
|
|
return;
|
|
}
|
|
|
|
self.dirty = false;
|
|
|
|
let height = height!(area);
|
|
if let Some(mvm) = self.movement.take() {
|
|
match mvm {
|
|
PageMovement::PageUp => {
|
|
self.cursor_pos = self.cursor_pos.saturating_sub(height);
|
|
}
|
|
PageMovement::PageDown => {
|
|
/* This might "overflow" beyond the max_cursor_pos boundary if it's not yet
|
|
* set. TODO: Rework the page up/down stuff
|
|
*/
|
|
if self.cursor_pos + 2 * height + 1 < self.height {
|
|
self.cursor_pos += height;
|
|
} else {
|
|
self.cursor_pos = self.height.saturating_sub(height).saturating_sub(1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if self.height == 0 || self.width == 0 {
|
|
return;
|
|
}
|
|
|
|
match self.max_cursor_pos {
|
|
Some(max) if max <= self.cursor_pos => {
|
|
self.cursor_pos -= 1;
|
|
return;
|
|
}
|
|
Some(max) if max >= height => {
|
|
self.cursor_pos = 0;
|
|
return;
|
|
}
|
|
_ => {}
|
|
}
|
|
|
|
clear_area(grid, area);
|
|
//let pager_context: usize = context.settings.pager.pager_context;
|
|
//let pager_stop: bool = context.settings.pager.pager_stop;
|
|
//let rows = y(bottom_right) - y(upper_left);
|
|
//let page_length = rows / self.height;
|
|
let pos = copy_area_with_break(
|
|
grid,
|
|
&self.content,
|
|
area,
|
|
((0, self.cursor_pos), (self.width - 1, self.height - 1)),
|
|
);
|
|
if pos.1 < get_y(bottom_right!(area)) {
|
|
self.max_cursor_pos = Some(self.cursor_pos + 1);
|
|
}
|
|
context.dirty_areas.push_back(area);
|
|
}
|
|
fn process_event(&mut self, event: &mut UIEvent, context: &mut Context) -> bool {
|
|
match event.event_type {
|
|
UIEventType::Input(Key::Char('k')) => {
|
|
if self.cursor_pos > 0 {
|
|
self.cursor_pos -= 1;
|
|
self.dirty = true;
|
|
}
|
|
}
|
|
UIEventType::Input(Key::Char('j')) => {
|
|
if self.height > 0 && self.cursor_pos + 1 < self.height {
|
|
self.cursor_pos += 1;
|
|
self.dirty = true;
|
|
}
|
|
}
|
|
UIEventType::Input(Key::PageUp) => {
|
|
self.movement = Some(PageMovement::PageUp);
|
|
self.dirty = true;
|
|
}
|
|
UIEventType::Input(Key::PageDown) => {
|
|
self.movement = Some(PageMovement::PageDown);
|
|
self.dirty = true;
|
|
}
|
|
UIEventType::ChangeMode(UIMode::Normal) => {
|
|
self.dirty = true;
|
|
return false;
|
|
}
|
|
UIEventType::Resize => {
|
|
self.dirty = true;
|
|
self.max_cursor_pos = None;
|
|
return false;
|
|
}
|
|
_ => {
|
|
return false;
|
|
}
|
|
}
|
|
true
|
|
}
|
|
fn is_dirty(&self) -> bool {
|
|
self.dirty
|
|
}
|
|
fn set_dirty(&mut self) {
|
|
self.dirty = true;
|
|
}
|
|
}
|
|
|
|
/// Status bar.
|
|
#[derive(Debug)]
|
|
pub struct StatusBar {
|
|
container: Entity,
|
|
status: String,
|
|
notifications: VecDeque<String>,
|
|
ex_buffer: String,
|
|
display_buffer: String,
|
|
mode: UIMode,
|
|
height: usize,
|
|
dirty: bool,
|
|
}
|
|
|
|
impl fmt::Display for StatusBar {
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
|
// TODO display info
|
|
write!(f, "status bar")
|
|
}
|
|
}
|
|
|
|
impl StatusBar {
|
|
pub fn new(container: Entity) -> Self {
|
|
StatusBar {
|
|
container,
|
|
status: String::with_capacity(256),
|
|
notifications: VecDeque::new(),
|
|
ex_buffer: String::with_capacity(256),
|
|
display_buffer: String::with_capacity(8),
|
|
dirty: true,
|
|
mode: UIMode::Normal,
|
|
height: 1,
|
|
}
|
|
}
|
|
fn draw_status_bar(&mut self, grid: &mut CellBuffer, area: Area, context: &mut Context) {
|
|
clear_area(grid, area);
|
|
if let Some(n) = self.notifications.pop_front() {
|
|
self.dirty = true;
|
|
write_string_to_grid(&n, grid, Color::Byte(219), Color::Byte(88), area, false);
|
|
} else {
|
|
write_string_to_grid(
|
|
&self.status,
|
|
grid,
|
|
Color::Byte(123),
|
|
Color::Byte(26),
|
|
area,
|
|
false,
|
|
);
|
|
}
|
|
let (x, y) = bottom_right!(area);
|
|
for (idx, c) in self.display_buffer.chars().rev().enumerate() {
|
|
if let Some(cell) = grid.get_mut(x.saturating_sub(idx).saturating_sub(1), y) {
|
|
cell.set_ch(c);
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
change_colors(grid, area, Color::Byte(123), Color::Byte(26));
|
|
context.dirty_areas.push_back(area);
|
|
}
|
|
fn draw_execute_bar(&mut self, grid: &mut CellBuffer, area: Area, context: &mut Context) {
|
|
clear_area(grid, area);
|
|
write_string_to_grid(
|
|
&self.ex_buffer,
|
|
grid,
|
|
Color::Byte(219),
|
|
Color::Byte(88),
|
|
area,
|
|
false,
|
|
);
|
|
change_colors(grid, area, Color::Byte(219), Color::Byte(88));
|
|
context.dirty_areas.push_back(area);
|
|
}
|
|
}
|
|
|
|
impl Component for StatusBar {
|
|
fn draw(&mut self, grid: &mut CellBuffer, area: Area, context: &mut Context) {
|
|
if !is_valid_area!(area) {
|
|
return;
|
|
}
|
|
let upper_left = upper_left!(area);
|
|
let bottom_right = bottom_right!(area);
|
|
|
|
let total_rows = get_y(bottom_right) - get_y(upper_left);
|
|
if total_rows <= self.height {
|
|
return;
|
|
}
|
|
let height = self.height;
|
|
|
|
self.container.component.draw(
|
|
grid,
|
|
(
|
|
upper_left,
|
|
(get_x(bottom_right), get_y(bottom_right) - height),
|
|
),
|
|
context,
|
|
);
|
|
|
|
if !self.is_dirty() {
|
|
return;
|
|
}
|
|
self.dirty = false;
|
|
self.draw_status_bar(
|
|
grid,
|
|
(set_y(upper_left, get_y(bottom_right)), bottom_right),
|
|
context,
|
|
);
|
|
match self.mode {
|
|
UIMode::Normal => {}
|
|
UIMode::Execute => {
|
|
self.draw_execute_bar(
|
|
grid,
|
|
(
|
|
set_y(upper_left, get_y(bottom_right) - height + 1),
|
|
set_y(bottom_right, get_y(bottom_right) - height + 1),
|
|
),
|
|
context,
|
|
);
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
fn process_event(&mut self, event: &mut UIEvent, context: &mut Context) -> bool {
|
|
if self.container.rcv_event(event, context) {
|
|
return true;
|
|
}
|
|
|
|
match &event.event_type {
|
|
UIEventType::RefreshMailbox((ref idx_a, ref idx_f)) => {
|
|
match context.accounts[*idx_a].status(*idx_f) {
|
|
Ok(_) => {}
|
|
Err(_) => {
|
|
return false;
|
|
}
|
|
}
|
|
let m = &context.accounts[*idx_a][*idx_f].as_ref().unwrap();
|
|
self.status = format!(
|
|
"{} | Mailbox: {}, Messages: {}, New: {}",
|
|
self.mode,
|
|
m.folder.name(),
|
|
m.collection.len(),
|
|
m.collection.values().filter(|e| !e.is_seen()).count()
|
|
);
|
|
self.dirty = true;
|
|
}
|
|
UIEventType::ChangeMode(m) => {
|
|
let offset = self.status.find('|').unwrap_or_else(|| self.status.len());
|
|
self.status.replace_range(..offset, &format!("{} ", m));
|
|
self.dirty = true;
|
|
self.mode = *m;
|
|
match m {
|
|
UIMode::Normal => {
|
|
self.height = 1;
|
|
if !self.ex_buffer.is_empty() {
|
|
context.replies.push_back(UIEvent {
|
|
id: 0,
|
|
event_type: UIEventType::Command(self.ex_buffer.clone()),
|
|
});
|
|
}
|
|
self.ex_buffer.clear()
|
|
}
|
|
UIMode::Execute => {
|
|
self.height = 2;
|
|
}
|
|
_ => {}
|
|
};
|
|
}
|
|
UIEventType::ExInput(Key::Char(c)) => {
|
|
self.dirty = true;
|
|
self.ex_buffer.push(*c);
|
|
return true;
|
|
}
|
|
UIEventType::ExInput(Key::Ctrl('u')) => {
|
|
self.dirty = true;
|
|
self.ex_buffer.clear();
|
|
return true;
|
|
}
|
|
UIEventType::ExInput(Key::Backspace) | UIEventType::ExInput(Key::Ctrl('h')) => {
|
|
self.dirty = true;
|
|
self.ex_buffer.pop();
|
|
return true;
|
|
}
|
|
UIEventType::Resize => {
|
|
self.dirty = true;
|
|
}
|
|
UIEventType::StatusEvent(StatusEvent::DisplayMessage(s)) => {
|
|
self.notifications.push_back(s.clone());
|
|
self.dirty = true;
|
|
}
|
|
UIEventType::StatusEvent(StatusEvent::BufClear) => {
|
|
self.display_buffer.clear();
|
|
self.dirty = true;
|
|
}
|
|
UIEventType::StatusEvent(StatusEvent::BufSet(s)) => {
|
|
self.display_buffer = s.clone();
|
|
self.dirty = true;
|
|
}
|
|
_ => {}
|
|
}
|
|
false
|
|
}
|
|
fn is_dirty(&self) -> bool {
|
|
self.dirty || self.container.component.is_dirty()
|
|
}
|
|
fn set_dirty(&mut self) {
|
|
self.dirty = true;
|
|
}
|
|
}
|
|
|
|
// A box with a text content.
|
|
#[derive(Debug)]
|
|
pub struct TextBox {
|
|
_content: String,
|
|
}
|
|
|
|
impl TextBox {
|
|
pub fn new(s: String) -> Self {
|
|
TextBox { _content: s }
|
|
}
|
|
}
|
|
|
|
impl fmt::Display for TextBox {
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
|
// TODO display info
|
|
write!(f, "text box")
|
|
}
|
|
}
|
|
|
|
impl Component for TextBox {
|
|
fn draw(&mut self, _grid: &mut CellBuffer, _area: Area, _context: &mut Context) {}
|
|
fn process_event(&mut self, _event: &mut UIEvent, _context: &mut Context) -> bool {
|
|
false
|
|
}
|
|
fn set_dirty(&mut self) {}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct Progress {
|
|
description: String,
|
|
total_work: usize,
|
|
finished: usize,
|
|
}
|
|
|
|
impl Progress {
|
|
pub fn new(s: String, total_work: usize) -> Self {
|
|
Progress {
|
|
description: s,
|
|
total_work,
|
|
finished: 0,
|
|
}
|
|
}
|
|
|
|
pub fn add_work(&mut self, n: usize) {
|
|
if self.finished >= self.total_work {
|
|
return;
|
|
}
|
|
self.finished += n;
|
|
}
|
|
|
|
pub fn percentage(&self) -> usize {
|
|
if self.total_work > 0 {
|
|
100 * self.finished / self.total_work
|
|
} else {
|
|
0
|
|
}
|
|
}
|
|
|
|
pub fn description(&self) -> &str {
|
|
&self.description
|
|
}
|
|
}
|
|
|
|
impl fmt::Display for Progress {
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
|
// TODO display info
|
|
write!(f, "progress bar")
|
|
}
|
|
}
|
|
|
|
impl Component for Progress {
|
|
fn draw(&mut self, _grid: &mut CellBuffer, _area: Area, _context: &mut Context) {
|
|
unimplemented!()
|
|
}
|
|
fn process_event(&mut self, _event: &mut UIEvent, _context: &mut Context) -> bool {
|
|
false
|
|
}
|
|
fn set_dirty(&mut self) {}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct Tabbed {
|
|
children: Vec<Entity>,
|
|
cursor_pos: usize,
|
|
}
|
|
|
|
impl Tabbed {
|
|
pub fn new(children: Vec<Box<Component>>) -> Self {
|
|
Tabbed {
|
|
children: children.into_iter().map(Entity::from).collect(),
|
|
cursor_pos: 0,
|
|
}
|
|
}
|
|
fn draw_tabs(&mut self, grid: &mut CellBuffer, area: Area, context: &mut Context) {
|
|
let mut x = get_x(upper_left!(area));
|
|
let mut y: usize = get_y(upper_left!(area));
|
|
for (idx, c) in self.children.iter().enumerate() {
|
|
let (fg, bg) = if idx == self.cursor_pos {
|
|
(Color::Default, Color::Default)
|
|
} else {
|
|
(Color::Byte(15), Color::Byte(8))
|
|
};
|
|
let (x_, _y_) = write_string_to_grid(
|
|
&format!(" {} ", c),
|
|
grid,
|
|
fg,
|
|
bg,
|
|
(set_x(upper_left!(area), x), bottom_right!(area)),
|
|
false,
|
|
);
|
|
x = x_ + 1;
|
|
if y != _y_ {
|
|
break;
|
|
}
|
|
y = _y_;
|
|
}
|
|
let (cols, _) = grid.size();
|
|
let cslice: &mut [Cell] = grid;
|
|
for c in cslice[(y * cols) + x - 1..(y * cols) + cols].iter_mut() {
|
|
c.set_bg(Color::Byte(7));
|
|
c.set_ch(' ');
|
|
}
|
|
|
|
context.dirty_areas.push_back(area);
|
|
}
|
|
pub fn add_component(&mut self, new: Box<Component>) {
|
|
self.children.push(Entity::from(new));
|
|
}
|
|
}
|
|
|
|
impl fmt::Display for Tabbed {
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
|
// TODO display info
|
|
write!(f, "tabs")
|
|
}
|
|
}
|
|
|
|
impl Component for Tabbed {
|
|
fn draw(&mut self, grid: &mut CellBuffer, area: Area, context: &mut Context) {
|
|
if self.children.len() > 1 {
|
|
self.draw_tabs(
|
|
grid,
|
|
(
|
|
upper_left!(area),
|
|
set_x(upper_left!(area), get_x(bottom_right!(area))),
|
|
),
|
|
context,
|
|
);
|
|
let y = get_y(upper_left!(area));
|
|
self.children[self.cursor_pos].draw(
|
|
grid,
|
|
(set_y(upper_left!(area), y + 1), bottom_right!(area)),
|
|
context,
|
|
);
|
|
} else {
|
|
self.children[self.cursor_pos].draw(grid, area, context);
|
|
}
|
|
}
|
|
fn process_event(&mut self, event: &mut UIEvent, context: &mut Context) -> bool {
|
|
match event.event_type {
|
|
UIEventType::Input(Key::Char('T')) => {
|
|
self.cursor_pos = (self.cursor_pos + 1) % self.children.len();
|
|
self.set_dirty();
|
|
return true;
|
|
}
|
|
UIEventType::Action(Tab(NewDraft)) => {
|
|
self.add_component(Box::new(Composer::default()));
|
|
self.cursor_pos = self.children.len() - 1;
|
|
self.children[self.cursor_pos].set_dirty();
|
|
return true;
|
|
}
|
|
UIEventType::Action(Tab(Reply(coordinates, msg))) => {
|
|
self.add_component(Box::new(Composer::with_context(coordinates, msg, context)));
|
|
self.cursor_pos = self.children.len() - 1;
|
|
self.children[self.cursor_pos].set_dirty();
|
|
return true;
|
|
}
|
|
UIEventType::Action(Tab(TabOpen(ref mut e))) if e.is_some() => {
|
|
self.add_component(e.take().unwrap());
|
|
self.cursor_pos = self.children.len() - 1;
|
|
self.children[self.cursor_pos].set_dirty();
|
|
return true;
|
|
}
|
|
UIEventType::Action(Tab(Close)) => {
|
|
let id = *self.children[self.cursor_pos].id();
|
|
self.children[self.cursor_pos].kill(id);
|
|
return true;
|
|
}
|
|
UIEventType::Action(Tab(Kill(ref id))) => {
|
|
if let Some(c_idx) = self.children.iter().position(|x| x.id() == id) {
|
|
self.children.remove(c_idx);
|
|
self.cursor_pos = self.cursor_pos.saturating_sub(1);
|
|
self.set_dirty();
|
|
return true;
|
|
} else {
|
|
eprintln!(
|
|
"DEBUG: Child entity with id {:?} not found.\nList: {:?}",
|
|
id, self.children
|
|
);
|
|
}
|
|
}
|
|
_ => {}
|
|
}
|
|
self.children[self.cursor_pos].process_event(event, context)
|
|
}
|
|
fn is_dirty(&self) -> bool {
|
|
self.children[self.cursor_pos].is_dirty()
|
|
}
|
|
fn set_dirty(&mut self) {
|
|
self.children[self.cursor_pos].set_dirty();
|
|
}
|
|
}
|
|
|
|
|
|
type EntryIdentifier = Vec<u8>;
|
|
/// Shows selection to user
|
|
#[derive(Debug, PartialEq)]
|
|
pub struct Selector {
|
|
single_only: bool, /// allow only one selection
|
|
entries: Vec<(EntryIdentifier, bool)>,
|
|
selected_entry_count: u32,
|
|
content: CellBuffer,
|
|
|
|
cursor: usize,
|
|
|
|
dirty: bool,
|
|
}
|
|
|
|
impl fmt::Display for Selector {
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
|
Display::fmt("Selector", f)
|
|
}
|
|
}
|
|
|
|
impl Component for Selector {
|
|
fn draw(&mut self, grid: &mut CellBuffer, area: Area, context: &mut Context) {
|
|
eprintln!("drawing");
|
|
let (width, height) = self.content.size();
|
|
copy_area_with_break(
|
|
grid,
|
|
&self.content,
|
|
area,
|
|
((0, 0), (width, height)),
|
|
);
|
|
context.dirty_areas.push_back(area);
|
|
}
|
|
fn process_event(&mut self, event: &mut UIEvent, context: &mut Context) -> bool {
|
|
let (width, height) = self.content.size();
|
|
match event.event_type {
|
|
UIEventType::Input(Key::Char(' ')) => {
|
|
self.entries[self.cursor].1 = ! self.entries[self.cursor].1;
|
|
if self.entries[self.cursor].1 {
|
|
write_string_to_grid(
|
|
"x",
|
|
&mut self.content,
|
|
Color::Default,
|
|
Color::Default,
|
|
((1, self.cursor), (width, self.cursor)),
|
|
false,
|
|
);
|
|
} else {
|
|
write_string_to_grid(
|
|
" ",
|
|
&mut self.content,
|
|
Color::Default,
|
|
Color::Default,
|
|
((1, self.cursor), (width, self.cursor)),
|
|
false,
|
|
);
|
|
}
|
|
self.dirty = true;
|
|
return true;
|
|
},
|
|
UIEventType::Input(Key::Up) if self.cursor > 0 => {
|
|
self.cursor -= 1;
|
|
self.dirty = true;
|
|
return true;
|
|
},
|
|
UIEventType::Input(Key::Down) if self.cursor < height.saturating_sub(1) => {
|
|
self.cursor += 1;
|
|
self.dirty = true;
|
|
return true;
|
|
},
|
|
_ => {}
|
|
}
|
|
|
|
false
|
|
}
|
|
fn is_dirty(&self) -> bool {
|
|
self.dirty
|
|
}
|
|
fn set_dirty(&mut self) {
|
|
self.dirty = true;
|
|
}
|
|
}
|
|
|
|
impl Selector {
|
|
pub fn new(mut entries: Vec<(EntryIdentifier, String)>, single_only: bool) -> Selector {
|
|
let width = entries.iter().max_by_key(|e| e.1.len()).map(|v| v.1.len()).unwrap_or(0) + 4;
|
|
let height = entries.len();
|
|
let mut content = CellBuffer::new(width, height, Cell::with_char(' '));
|
|
let identifiers = entries.iter_mut().map(|(id, _)| (std::mem::replace(&mut *id, Vec::new()), false)).collect();
|
|
for (i, e) in entries.into_iter().enumerate() {
|
|
write_string_to_grid(
|
|
&format!("[ ] {}", e.1),
|
|
&mut content,
|
|
Color::Default,
|
|
Color::Default,
|
|
((0, i), (width - 1, i)),
|
|
false,
|
|
);
|
|
}
|
|
|
|
Selector {
|
|
single_only,
|
|
entries: identifiers,
|
|
selected_entry_count: 0,
|
|
content,
|
|
cursor: 0,
|
|
dirty: true,
|
|
}
|
|
}
|
|
|
|
pub fn collect(self) -> Vec<EntryIdentifier> {
|
|
self.entries.into_iter().filter(|v| v.1).map(|(id, _)| id).collect()
|
|
}
|
|
}
|