cursive/src/views/radio.rs

224 lines
6.1 KiB
Rust
Raw Normal View History

use crate::direction::Direction;
use crate::event::{Event, EventResult, Key, MouseButton, MouseEvent};
2016-10-02 21:55:19 +00:00
use std::cell::RefCell;
use std::rc::Rc;
use crate::theme::ColorStyle;
use crate::vec::Vec2;
use crate::view::View;
use crate::Cursive;
use crate::{Printer, With};
2016-10-02 21:55:19 +00:00
struct SharedState<T> {
selection: usize,
values: Vec<Rc<T>>,
2018-11-30 22:34:17 +00:00
2019-02-28 23:55:02 +00:00
on_change: Option<Rc<dyn Fn(&mut Cursive, &T)>>,
2016-10-02 21:55:19 +00:00
}
impl<T> SharedState<T> {
pub fn selection(&self) -> Rc<T> {
2017-10-13 18:22:02 +00:00
Rc::clone(&self.values[self.selection])
2016-10-02 21:55:19 +00:00
}
}
/// Group to coordinate multiple radio buttons.
///
/// A `RadioGroup` is used to create and manage [`RadioButton`]s.
///
/// A `RadioGroup` can be cloned; it will keep pointing to the same group.
2016-10-02 21:55:19 +00:00
///
/// [`RadioButton`]: struct.RadioButton.html
#[derive(Clone)]
2016-10-02 21:55:19 +00:00
pub struct RadioGroup<T> {
// Given to every child button
state: Rc<RefCell<SharedState<T>>>,
}
2018-11-30 22:34:17 +00:00
impl<T: 'static> Default for RadioGroup<T> {
fn default() -> Self {
Self::new()
}
}
2018-11-30 22:34:17 +00:00
impl<T: 'static> RadioGroup<T> {
2016-10-02 21:55:19 +00:00
/// Creates an empty group for radio buttons.
pub fn new() -> Self {
RadioGroup {
state: Rc::new(RefCell::new(SharedState {
selection: 0,
values: Vec::new(),
2018-11-30 22:34:17 +00:00
on_change: None,
2016-10-02 21:55:19 +00:00
})),
}
}
/// Adds a new button to the group.
///
/// The button will display `label` next to it, and will embed `value`.
2017-10-12 23:38:55 +00:00
pub fn button<S: Into<String>>(
2018-06-11 06:29:10 +00:00
&mut self, value: T, label: S,
2017-10-12 23:38:55 +00:00
) -> RadioButton<T> {
let count = self.state.borrow().values.len();
2016-10-02 21:55:19 +00:00
self.state.borrow_mut().values.push(Rc::new(value));
2017-10-13 18:22:02 +00:00
RadioButton::new(Rc::clone(&self.state), count, label.into())
2016-10-02 21:55:19 +00:00
}
/// Returns the id of the selected button.
///
/// Buttons are indexed in the order they are created, starting from 0.
pub fn selected_id(&self) -> usize {
self.state.borrow().selection
}
/// Returns the value associated with the selected button.
pub fn selection(&self) -> Rc<T> {
self.state.borrow().selection()
}
2018-11-30 22:34:17 +00:00
/// Sets a callback to be used when the selection changes.
pub fn set_on_change<F: 'static + Fn(&mut Cursive, &T)>(
&mut self, on_change: F,
) {
self.state.borrow_mut().on_change = Some(Rc::new(on_change));
}
2018-11-30 23:44:56 +00:00
/// Sets a callback to be used when the selection changes.
///
/// Chainable variant.
pub fn on_change<F: 'static + Fn(&mut Cursive, &T)>(
self, on_change: F,
) -> Self {
self.with(|s| s.set_on_change(on_change))
}
2016-10-02 21:55:19 +00:00
}
impl RadioGroup<String> {
/// Adds a button, using the label itself as value.
2017-10-12 23:38:55 +00:00
pub fn button_str<S: Into<String>>(
2018-06-11 06:29:10 +00:00
&mut self, text: S,
2017-10-12 23:38:55 +00:00
) -> RadioButton<String> {
2016-10-02 21:55:19 +00:00
let text = text.into();
self.button(text.clone(), text)
}
}
/// Variant of `Checkbox` arranged in group.
///
2016-10-02 23:03:31 +00:00
/// `RadioButton`s are managed by a [`RadioGroup`]. A single group can contain
2016-10-02 21:55:19 +00:00
/// several radio buttons, but only one button per group can be active at a
/// time.
///
/// `RadioButton`s are not created directly, but through
/// [`RadioGroup::button()`].
///
/// [`RadioGroup`]: struct.RadioGroup.html
/// [`RadioGroup::button()`]: struct.RadioGroup.html#method.button
pub struct RadioButton<T> {
state: Rc<RefCell<SharedState<T>>>,
id: usize,
enabled: bool,
label: String,
}
2018-11-30 22:34:17 +00:00
impl<T: 'static> RadioButton<T> {
2016-10-02 21:55:19 +00:00
impl_enabled!(self.enabled);
2017-10-12 23:38:55 +00:00
fn new(
2018-06-11 06:29:10 +00:00
state: Rc<RefCell<SharedState<T>>>, id: usize, label: String,
2017-10-12 23:38:55 +00:00
) -> Self {
2016-10-02 21:55:19 +00:00
RadioButton {
2018-04-10 18:53:25 +00:00
state,
id,
2016-10-02 21:55:19 +00:00
enabled: true,
2018-04-10 18:53:25 +00:00
label,
2016-10-02 21:55:19 +00:00
}
}
/// Returns `true` if this button is selected.
pub fn is_selected(&self) -> bool {
self.state.borrow().selection == self.id
}
/// Selects this button, un-selecting any other in the same group.
2018-11-30 22:34:17 +00:00
pub fn select(&mut self) -> EventResult {
let mut state = self.state.borrow_mut();
state.selection = self.id;
if let Some(ref on_change) = state.on_change {
let on_change = Rc::clone(on_change);
let value = state.selection();
EventResult::with_cb(move |s| on_change(s, &value))
} else {
EventResult::Consumed(None)
}
2016-10-02 21:55:19 +00:00
}
/// Selects this button, un-selecting any other in the same group.
///
/// Chainable variant.
pub fn selected(self) -> Self {
2018-11-30 22:34:17 +00:00
self.with(|s| {
2018-11-30 23:44:56 +00:00
// Ignore the potential callback here
2018-11-30 22:34:17 +00:00
s.select();
})
2016-10-02 21:55:19 +00:00
}
2019-02-28 23:55:02 +00:00
fn draw_internal(&self, printer: &Printer<'_, '_>) {
2016-10-02 21:55:19 +00:00
printer.print((0, 0), "( )");
if self.is_selected() {
printer.print((1, 0), "X");
}
if !self.label.is_empty() {
// We want the space to be highlighted if focused
printer.print((3, 0), " ");
printer.print((4, 0), &self.label);
}
}
2017-10-13 00:29:12 +00:00
fn req_size(&self) -> Vec2 {
2016-10-02 21:55:19 +00:00
if self.label.is_empty() {
Vec2::new(3, 1)
} else {
Vec2::new(3 + 1 + self.label.len(), 1)
}
}
2017-10-13 00:29:12 +00:00
}
2017-12-12 02:54:40 +00:00
impl<T: 'static> View for RadioButton<T> {
2017-10-13 00:29:12 +00:00
fn required_size(&mut self, _: Vec2) -> Vec2 {
self.req_size()
}
2016-10-02 21:55:19 +00:00
fn take_focus(&mut self, _: Direction) -> bool {
self.enabled
}
2019-02-28 23:55:02 +00:00
fn draw(&self, printer: &Printer<'_, '_>) {
2018-11-09 22:08:43 +00:00
if self.enabled && printer.enabled {
2017-12-30 22:03:42 +00:00
printer.with_selection(printer.focused, |printer| {
self.draw_internal(printer)
});
2016-10-02 21:55:19 +00:00
} else {
printer.with_color(ColorStyle::secondary(), |printer| {
2017-12-30 22:03:42 +00:00
self.draw_internal(printer)
});
2016-10-02 21:55:19 +00:00
}
}
fn on_event(&mut self, event: Event) -> EventResult {
match event {
2017-10-12 23:38:55 +00:00
Event::Key(Key::Enter) | Event::Char(' ') => {
2018-11-30 22:34:17 +00:00
self.select()
2016-10-02 21:55:19 +00:00
}
2017-10-13 00:29:12 +00:00
Event::Mouse {
event: MouseEvent::Release(MouseButton::Left),
position,
offset,
2018-11-09 22:08:43 +00:00
} if position.fits_in_rect(offset, self.req_size()) => {
2018-11-30 22:34:17 +00:00
self.select()
2017-10-13 00:29:12 +00:00
}
2016-10-02 21:55:19 +00:00
_ => EventResult::Ignored,
}
}
}