use std::cmp;
use prototty::*;
use prototty::inputs::*;
use text_info::*;
use defaults::*;
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MenuEntry<T: Copy> {
pub name: String,
pub value: T,
}
impl<T: Copy, S: Into<String>> From<(S, T)> for MenuEntry<T> {
fn from((s, t): (S, T)) -> Self {
Self {
name: s.into(),
value: t,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Menu<T: Copy> {
pub entries: Vec<MenuEntry<T>>,
pub size: Size,
pub selected_info: TextInfo,
pub normal_info: TextInfo,
}
fn selected_info() -> TextInfo {
TextInfo::default()
.bold()
.foreground_colour(DEFAULT_BG)
.background_colour(DEFAULT_FG)
}
impl<T: Copy> Menu<T> {
pub fn new<S, V>(mut e: Vec<(S, T)>, size: V) -> Self
where
S: Into<String>,
V: Into<Size>,
{
Self {
entries: e.drain(..).map(Into::into).collect(),
size: size.into(),
normal_info: Default::default(),
selected_info: selected_info(),
}
}
pub fn smallest<S>(mut e: Vec<(S, T)>) -> Self
where
S: Into<String>,
{
let entries: Vec<MenuEntry<T>> = e.drain(..).map(Into::into).collect();
let width = entries.iter().fold(0, |acc, e| cmp::max(acc, e.name.len()));
let height = entries.len();
Self {
entries,
size: Size::new(width as u32, height as u32),
normal_info: Default::default(),
selected_info: selected_info(),
}
}
}
pub enum MenuOutput<T> {
Quit,
Cancel,
Finalise(T),
}
#[derive(Debug, Clone)]
pub struct MenuInstance<T: Copy> {
menu: Menu<T>,
index: usize,
}
impl<T: Copy> MenuInstance<T> {
pub fn new(menu: Menu<T>) -> Option<Self> {
Self::with_index(menu, 0)
}
pub fn with_index(menu: Menu<T>, index: usize) -> Option<Self> {
if index < menu.entries.len() {
Some(Self { menu, index })
} else {
None
}
}
pub fn index(&self) -> usize {
self.index
}
pub fn set_index(&mut self, index: usize) {
if index < self.menu.entries.len() {
self.index = index;
}
}
pub fn up(&mut self) {
self.index = self.index.saturating_sub(1);
}
pub fn down(&mut self) {
if self.index < self.menu.entries.len() - 1 {
self.index += 1;
}
}
pub fn selected(&self) -> T {
self.menu.entries[self.index].value
}
pub fn tick<I>(&mut self, inputs: I) -> Option<MenuOutput<T>>
where
I: IntoIterator<Item = Input>,
{
for input in inputs {
match input {
ETX => return Some(MenuOutput::Quit),
ESCAPE => return Some(MenuOutput::Cancel),
RETURN => {
return Some(MenuOutput::Finalise(self.selected()));
}
Input::Up => self.up(),
Input::Down => self.down(),
_ => (),
}
}
None
}
}
pub struct DefaultMenuInstanceView;
impl<T: Copy> View<MenuInstance<T>> for DefaultMenuInstanceView {
fn view<G: ViewGrid>(
&mut self,
value: &MenuInstance<T>,
offset: Coord,
depth: i32,
grid: &mut G,
) {
for (i, entry) in value.menu.entries.iter().enumerate() {
if i == value.menu.size.y() as usize {
break;
}
let info = if i == value.index {
&value.menu.selected_info
} else {
&value.menu.normal_info
};
for (j, ch) in entry.name.chars().enumerate() {
if j == value.menu.size.x() as usize {
break;
}
let coord = offset + Coord::new(j as i32, i as i32);
if let Some(cell) = grid.get_mut(coord, depth) {
cell.set_character(ch);
info.write_cell(cell);
}
}
}
}
}
impl<T: Copy> ViewSize<MenuInstance<T>> for DefaultMenuInstanceView {
fn size(&mut self, data: &MenuInstance<T>) -> Size {
data.menu.size
}
}