use std::ops::{Index, IndexMut};
use kas::layout::{RulesSetter, RulesSolver};
use kas::prelude::*;
pub type Row<W> = List<kas::Right, W>;
pub type Column<W> = List<kas::Down, W>;
pub type BoxRow<M> = BoxList<kas::Right, M>;
pub type BoxColumn<M> = BoxList<kas::Down, M>;
pub type BoxList<D, M> = List<D, Box<dyn Widget<Msg = M>>>;
pub type RefRow<'a, M> = RefList<'a, kas::Right, M>;
pub type RefColumn<'a, M> = RefList<'a, kas::Down, M>;
pub type RefList<'a, D, M> = List<D, &'a mut dyn Widget<Msg = M>>;
#[handler(send=noauto, msg=<W as event::Handler>::Msg)]
#[widget(children=noauto)]
#[derive(Clone, Default, Debug, Widget)]
pub struct List<D: Directional, W: Widget> {
#[widget_core]
core: CoreData,
widgets: Vec<W>,
data: layout::DynRowStorage,
direction: D,
}
impl<D: Directional, W: Widget> WidgetChildren for List<D, W> {
#[inline]
fn len(&self) -> usize {
self.widgets.len()
}
#[inline]
fn get(&self, index: usize) -> Option<&dyn WidgetConfig> {
self.widgets.get(index).map(|w| w.as_widget())
}
#[inline]
fn get_mut(&mut self, index: usize) -> Option<&mut dyn WidgetConfig> {
self.widgets.get_mut(index).map(|w| w.as_widget_mut())
}
}
impl<D: Directional, W: Widget> Layout for List<D, W> {
fn size_rules(&mut self, size_handle: &mut dyn SizeHandle, axis: AxisInfo) -> SizeRules {
let dim = (self.direction, self.widgets.len());
let mut solver = layout::RowSolver::new(axis, dim, &mut self.data);
for (n, child) in self.widgets.iter_mut().enumerate() {
solver.for_child(&mut self.data, n, |axis| {
child.size_rules(size_handle, axis)
});
}
solver.finish(&mut self.data)
}
fn set_rect(&mut self, rect: Rect, align: AlignHints) {
self.core.rect = rect;
let dim = (self.direction, self.widgets.len());
let mut setter = layout::RowSetter::<D, Vec<u32>, _>::new(rect, dim, align, &mut self.data);
for (n, child) in self.widgets.iter_mut().enumerate() {
let align = AlignHints::default();
child.set_rect(setter.child_rect(&mut self.data, n), align);
}
}
fn spatial_range(&self) -> (usize, usize) {
let last = WidgetChildren::len(self).wrapping_sub(1);
match self.direction.is_reversed() {
false => (0, last),
true => (last, 0),
}
}
fn find_id(&self, coord: Coord) -> Option<WidgetId> {
if !self.rect().contains(coord) {
return None;
}
let solver = layout::RowPositionSolver::new(self.direction);
if let Some(child) = solver.find_child(&self.widgets, coord) {
return child.find_id(coord);
}
Some(self.id())
}
fn draw(&self, draw_handle: &mut dyn DrawHandle, mgr: &event::ManagerState, disabled: bool) {
let disabled = disabled || self.is_disabled();
let solver = layout::RowPositionSolver::new(self.direction);
solver.for_children(&self.widgets, draw_handle.target_rect(), |w| {
w.draw(draw_handle, mgr, disabled)
});
}
}
impl<D: Directional, W: Widget> event::SendEvent for List<D, W> {
fn send(&mut self, mgr: &mut Manager, id: WidgetId, event: Event) -> Response<Self::Msg> {
if !self.is_disabled() {
for child in &mut self.widgets {
if id <= child.id() {
return child.send(mgr, id, event);
}
}
}
Response::Unhandled(event)
}
}
impl<D: Directional + Default, W: Widget> List<D, W> {
pub fn new(widgets: Vec<W>) -> Self {
List {
core: Default::default(),
widgets,
data: Default::default(),
direction: Default::default(),
}
}
}
impl<D: Directional, W: Widget> List<D, W> {
pub fn new_with_direction(direction: D, widgets: Vec<W>) -> Self {
List {
core: Default::default(),
widgets,
data: Default::default(),
direction,
}
}
pub fn direction(&self) -> Direction {
self.direction.as_direction()
}
pub fn is_empty(&self) -> bool {
self.widgets.is_empty()
}
pub fn len(&self) -> usize {
self.widgets.len()
}
pub fn capacity(&self) -> usize {
self.widgets.capacity()
}
pub fn reserve(&mut self, additional: usize) {
self.widgets.reserve(additional);
}
pub fn clear(&mut self) -> TkAction {
let action = match self.widgets.is_empty() {
true => TkAction::None,
false => TkAction::Reconfigure,
};
self.widgets.clear();
action
}
pub fn push(&mut self, widget: W) -> TkAction {
self.widgets.push(widget);
TkAction::Reconfigure
}
pub fn pop(&mut self) -> (Option<W>, TkAction) {
let action = match self.widgets.is_empty() {
true => TkAction::None,
false => TkAction::Reconfigure,
};
(self.widgets.pop(), action)
}
pub fn insert(&mut self, index: usize, widget: W) -> TkAction {
self.widgets.insert(index, widget);
TkAction::Reconfigure
}
pub fn remove(&mut self, index: usize) -> (W, TkAction) {
let r = self.widgets.remove(index);
(r, TkAction::Reconfigure)
}
pub fn replace(&mut self, index: usize, mut widget: W) -> (W, TkAction) {
std::mem::swap(&mut widget, &mut self.widgets[index]);
(widget, TkAction::Reconfigure)
}
pub fn extend<T: IntoIterator<Item = W>>(&mut self, iter: T) -> TkAction {
let len = self.widgets.len();
self.widgets.extend(iter);
match len == self.widgets.len() {
true => TkAction::None,
false => TkAction::Reconfigure,
}
}
pub fn resize_with<F: Fn(usize) -> W>(&mut self, len: usize, f: F) -> TkAction {
let l0 = self.widgets.len();
if l0 == len {
return TkAction::None;
} else if l0 > len {
self.widgets.truncate(len);
} else {
self.widgets.reserve(len);
for i in l0..len {
self.widgets.push(f(i));
}
}
TkAction::Reconfigure
}
pub fn retain<F: FnMut(&W) -> bool>(&mut self, f: F) -> TkAction {
let len = self.widgets.len();
self.widgets.retain(f);
match len == self.widgets.len() {
true => TkAction::None,
false => TkAction::Reconfigure,
}
}
pub fn iter<'a>(&'a self) -> impl Iterator<Item = &'a W> {
ListIter {
list: self,
index: 0,
}
}
}
impl<D: Directional, W: Widget> Index<usize> for List<D, W> {
type Output = W;
fn index(&self, index: usize) -> &Self::Output {
&self.widgets[index]
}
}
impl<D: Directional, W: Widget> IndexMut<usize> for List<D, W> {
fn index_mut(&mut self, index: usize) -> &mut Self::Output {
&mut self.widgets[index]
}
}
struct ListIter<'a, D: Directional, W: Widget> {
list: &'a List<D, W>,
index: usize,
}
impl<'a, D: Directional, W: Widget> Iterator for ListIter<'a, D, W> {
type Item = &'a W;
fn next(&mut self) -> Option<Self::Item> {
let index = self.index;
if index < self.list.widgets.len() {
self.index = index + 1;
Some(&self.list.widgets[index])
} else {
None
}
}
fn size_hint(&self) -> (usize, Option<usize>) {
let len = self.len();
(len, Some(len))
}
}
impl<'a, D: Directional, W: Widget> ExactSizeIterator for ListIter<'a, D, W> {
fn len(&self) -> usize {
self.list.widgets.len() - self.index
}
}