use crate::direction::Direction;
use crate::event::{AnyCb, Event, EventResult};
use crate::theme::ColorStyle;
use crate::vec::Vec2;
use crate::view::{
IntoBoxedView, Offset, Position, Selector, View, ViewWrapper,
};
use crate::views::{CircularFocus, Layer, ShadowView, ViewBox};
use crate::Printer;
use crate::With;
use std::cell;
use std::ops::Deref;
pub struct StackView {
layers: Vec<Child>,
last_size: Vec2,
bg_dirty: cell::Cell<bool>,
}
enum Placement {
Floating(Position),
Fullscreen,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum LayerPosition {
FromBack(usize),
FromFront(usize),
}
impl Placement {
pub fn compute_offset<S, A, P>(
&self,
size: S,
available: A,
parent: P,
) -> Vec2
where
S: Into<Vec2>,
A: Into<Vec2>,
P: Into<Vec2>,
{
match *self {
Placement::Floating(ref position) => {
position.compute_offset(size, available, parent)
}
Placement::Fullscreen => Vec2::zero(),
}
}
}
enum ChildWrapper<T: View> {
Shadow(ShadowView<Layer<CircularFocus<T>>>),
Backfilled(Layer<CircularFocus<T>>),
Plain(CircularFocus<T>),
}
impl<T: View> ChildWrapper<T> {
fn unwrap(self) -> T {
match self {
ChildWrapper::Shadow(shadow) => shadow
.into_inner()
.ok()
.unwrap()
.into_inner()
.ok()
.unwrap()
.into_inner()
.ok()
.unwrap(),
ChildWrapper::Backfilled(background) => background
.into_inner()
.ok()
.unwrap()
.into_inner()
.ok()
.unwrap(),
ChildWrapper::Plain(layer) => layer.into_inner().ok().unwrap(),
}
}
}
impl<T: View> ChildWrapper<T> {
pub fn get_inner(&self) -> &T {
match *self {
ChildWrapper::Shadow(ref shadow) => {
shadow.get_inner().get_inner().get_inner()
}
ChildWrapper::Backfilled(ref background) => {
background.get_inner().get_inner()
}
ChildWrapper::Plain(ref layer) => layer.get_inner(),
}
}
pub fn get_inner_mut(&mut self) -> &mut T {
match *self {
ChildWrapper::Shadow(ref mut shadow) => {
shadow.get_inner_mut().get_inner_mut().get_inner_mut()
}
ChildWrapper::Backfilled(ref mut background) => {
background.get_inner_mut().get_inner_mut()
}
ChildWrapper::Plain(ref mut layer) => layer.get_inner_mut(),
}
}
}
impl<T: View> View for ChildWrapper<T> {
fn draw(&self, printer: &Printer<'_, '_>) {
match *self {
ChildWrapper::Shadow(ref v) => v.draw(printer),
ChildWrapper::Backfilled(ref v) => v.draw(printer),
ChildWrapper::Plain(ref v) => v.draw(printer),
}
}
fn on_event(&mut self, event: Event) -> EventResult {
match *self {
ChildWrapper::Shadow(ref mut v) => v.on_event(event),
ChildWrapper::Backfilled(ref mut v) => v.on_event(event),
ChildWrapper::Plain(ref mut v) => v.on_event(event),
}
}
fn layout(&mut self, size: Vec2) {
match *self {
ChildWrapper::Shadow(ref mut v) => v.layout(size),
ChildWrapper::Backfilled(ref mut v) => v.layout(size),
ChildWrapper::Plain(ref mut v) => v.layout(size),
}
}
fn required_size(&mut self, size: Vec2) -> Vec2 {
match *self {
ChildWrapper::Shadow(ref mut v) => v.required_size(size),
ChildWrapper::Backfilled(ref mut v) => v.required_size(size),
ChildWrapper::Plain(ref mut v) => v.required_size(size),
}
}
fn take_focus(&mut self, source: Direction) -> bool {
match *self {
ChildWrapper::Shadow(ref mut v) => v.take_focus(source),
ChildWrapper::Backfilled(ref mut v) => v.take_focus(source),
ChildWrapper::Plain(ref mut v) => v.take_focus(source),
}
}
fn call_on_any<'a>(
&mut self,
selector: &Selector<'_>,
callback: AnyCb<'a>,
) {
match *self {
ChildWrapper::Shadow(ref mut v) => {
v.call_on_any(selector, callback)
}
ChildWrapper::Backfilled(ref mut v) => {
v.call_on_any(selector, callback)
}
ChildWrapper::Plain(ref mut v) => {
v.call_on_any(selector, callback)
}
}
}
fn focus_view(&mut self, selector: &Selector<'_>) -> Result<(), ()> {
match *self {
ChildWrapper::Shadow(ref mut v) => v.focus_view(selector),
ChildWrapper::Backfilled(ref mut v) => v.focus_view(selector),
ChildWrapper::Plain(ref mut v) => v.focus_view(selector),
}
}
}
struct Child {
view: ChildWrapper<ViewBox>,
size: Vec2,
placement: Placement,
virgin: bool,
}
new_default!(StackView);
impl StackView {
pub fn new() -> Self {
StackView {
layers: Vec::new(),
last_size: Vec2::zero(),
bg_dirty: cell::Cell::new(true),
}
}
pub fn len(&self) -> usize {
self.layers.len()
}
pub fn is_empty(&self) -> bool {
self.layers.is_empty()
}
pub fn fits(&self, position: LayerPosition) -> bool {
let i = match position {
LayerPosition::FromBack(i) | LayerPosition::FromFront(i) => i,
};
i < self.len()
}
pub fn add_fullscreen_layer<T>(&mut self, view: T)
where
T: IntoBoxedView,
{
let boxed = ViewBox::boxed(view);
self.layers.push(Child {
view: ChildWrapper::Backfilled(Layer::new(
CircularFocus::wrap_tab(boxed),
)),
size: Vec2::zero(),
placement: Placement::Fullscreen,
virgin: true,
});
}
pub fn add_layer<T>(&mut self, view: T)
where
T: IntoBoxedView,
{
self.add_layer_at(Position::center(), view);
}
pub fn layer<T>(self, view: T) -> Self
where
T: IntoBoxedView,
{
self.with(|s| s.add_layer(view))
}
pub fn get(&self, pos: LayerPosition) -> Option<&dyn View> {
self.get_index(pos).and_then(|i| {
self.layers.get(i).map(|child| &**child.view.get_inner())
})
}
pub fn get_mut(&mut self, pos: LayerPosition) -> Option<&mut dyn View> {
self.get_index(pos).and_then(move |i| {
self.layers
.get_mut(i)
.map(|child| &mut **child.view.get_inner_mut())
})
}
pub fn find_layer_from_id(&mut self, id: &str) -> Option<LayerPosition> {
let selector = Selector::Id(id);
for (i, child) in self.layers.iter_mut().enumerate() {
let mut found = false;
child
.view
.call_on_any(&selector, Box::new(|_| found = true));
if found {
return Some(LayerPosition::FromBack(i));
}
}
None
}
pub fn fullscreen_layer<T>(self, view: T) -> Self
where
T: IntoBoxedView,
{
self.with(|s| s.add_fullscreen_layer(view))
}
pub fn transparent_layer<T>(self, view: T) -> Self
where
T: IntoBoxedView,
{
self.with(|s| s.add_transparent_layer(view))
}
pub fn add_layer_at<T>(&mut self, position: Position, view: T)
where
T: IntoBoxedView,
{
let boxed = ViewBox::boxed(view);
self.layers.push(Child {
view: ChildWrapper::Shadow(
ShadowView::new(Layer::new(CircularFocus::wrap_tab(boxed)))
.top_padding(position.y == Offset::Center)
.left_padding(position.x == Offset::Center),
),
size: Vec2::new(0, 0),
placement: Placement::Floating(position),
virgin: true,
});
}
pub fn add_transparent_layer<T>(&mut self, view: T)
where
T: IntoBoxedView,
{
self.add_transparent_layer_at(Position::center(), view);
}
pub fn add_transparent_layer_at<T>(&mut self, position: Position, view: T)
where
T: IntoBoxedView,
{
let boxed = ViewBox::boxed(view);
self.layers.push(Child {
view: ChildWrapper::Plain(CircularFocus::wrap_tab(boxed)),
size: Vec2::new(0, 0),
placement: Placement::Floating(position),
virgin: true,
});
}
pub fn layer_at<T>(self, position: Position, view: T) -> Self
where
T: IntoBoxedView,
{
self.with(|s| s.add_layer_at(position, view))
}
pub fn remove_layer(&mut self, position: LayerPosition) -> Box<dyn View> {
let i = self.get_index(position).unwrap();
self.layers.remove(i).view.unwrap().unwrap()
}
pub fn pop_layer(&mut self) -> Option<Box<dyn View>> {
self.bg_dirty.set(true);
self.layers
.pop()
.map(|child| child.view)
.map(ChildWrapper::unwrap)
.map(ViewBox::unwrap)
}
pub fn offset(&self) -> Vec2 {
let mut previous = Vec2::zero();
for layer in &self.layers {
let offset = layer.placement.compute_offset(
layer.size,
self.last_size,
previous,
);
previous = offset;
}
previous
}
pub fn layer_sizes(&self) -> Vec<Vec2> {
self.layers.iter().map(|layer| layer.size).collect()
}
fn get_index(&self, pos: LayerPosition) -> Option<usize> {
match pos {
LayerPosition::FromBack(i) => Some(i),
LayerPosition::FromFront(i) => {
self.layers.len().checked_sub(i + 1)
}
}
}
pub fn move_layer(&mut self, from: LayerPosition, to: LayerPosition) {
let from = self.get_index(from).unwrap();
let to = self.get_index(to).unwrap();
let removed = self.layers.remove(from);
self.layers.insert(to, removed);
}
pub fn move_to_front(&mut self, layer: LayerPosition) {
self.move_layer(layer, LayerPosition::FromFront(0));
}
pub fn move_to_back(&mut self, layer: LayerPosition) {
self.move_layer(layer, LayerPosition::FromBack(0));
}
pub fn reposition_layer(
&mut self,
layer: LayerPosition,
position: Position,
) {
let i = self.get_index(layer).unwrap();
let child = &mut self.layers[i];
match child.placement {
Placement::Floating(_) => {
child.placement = Placement::Floating(position);
self.bg_dirty.set(true);
}
Placement::Fullscreen => (),
}
}
pub fn draw_bg(&self, printer: &Printer<'_, '_>) {
if self.bg_dirty.get() {
for y in 0..printer.size.y {
printer.with_color(ColorStyle::background(), |printer| {
printer.print_hline((0, y), printer.size.x, " ");
});
}
self.bg_dirty.set(false);
}
}
pub fn draw_fg(&self, printer: &Printer<'_, '_>) {
let last = self.layers.len();
printer.with_color(ColorStyle::primary(), |printer| {
for (i, (v, offset)) in
StackPositionIterator::new(self.layers.iter(), printer.size)
.enumerate()
{
v.view.draw(
&printer
.offset(offset)
.cropped(v.size)
.focused(i + 1 == last),
);
}
});
}
}
struct StackPositionIterator<I> {
inner: I,
previous: Vec2,
total_size: Vec2,
}
impl<I> StackPositionIterator<I>
where
I: Iterator,
I::Item: Deref<Target = Child>,
{
pub fn new(inner: I, total_size: Vec2) -> Self {
let previous = Vec2::zero();
StackPositionIterator {
inner,
previous,
total_size,
}
}
}
impl<I> Iterator for StackPositionIterator<I>
where
I: Iterator,
I::Item: Deref<Target = Child>,
{
type Item = (I::Item, Vec2);
fn next(&mut self) -> Option<(I::Item, Vec2)> {
self.inner.next().map(|v| {
let offset = v.placement.compute_offset(
v.size,
self.total_size,
self.previous,
);
self.previous = offset;
(v, offset)
})
}
}
impl View for StackView {
fn draw(&self, printer: &Printer<'_, '_>) {
self.draw_bg(printer);
self.draw_fg(printer);
}
fn on_event(&mut self, event: Event) -> EventResult {
if event == Event::WindowResize {
self.bg_dirty.set(true);
}
match StackPositionIterator::new(
self.layers.iter_mut(),
self.last_size,
)
.last()
{
None => EventResult::Ignored,
Some((v, offset)) => v.view.on_event(event.relativized(offset)),
}
}
fn layout(&mut self, size: Vec2) {
self.last_size = size;
for layer in &mut self.layers {
let size = Vec2::min(size, layer.view.required_size(size));
layer.size = size;
layer.view.layout(layer.size);
if layer.virgin {
layer.view.take_focus(Direction::none());
layer.virgin = false;
}
}
}
fn required_size(&mut self, size: Vec2) -> Vec2 {
self.layers
.iter_mut()
.map(|layer| layer.view.required_size(size))
.fold(Vec2::new(1, 1), Vec2::max)
}
fn take_focus(&mut self, source: Direction) -> bool {
match self.layers.last_mut() {
None => false,
Some(v) => v.view.take_focus(source),
}
}
fn call_on_any<'a>(
&mut self,
selector: &Selector<'_>,
mut callback: AnyCb<'a>,
) {
for layer in &mut self.layers {
layer
.view
.call_on_any(selector, Box::new(|any| callback(any)));
}
}
fn focus_view(&mut self, selector: &Selector<'_>) -> Result<(), ()> {
for layer in &mut self.layers {
if layer.view.focus_view(selector).is_ok() {
return Ok(());
}
}
Err(())
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::views::TextView;
#[test]
fn pop_add() {
let mut stack = StackView::new().layer(TextView::new("1"));
for _ in 0..20 {
let layer = stack.pop_layer().unwrap();
stack.add_layer(layer);
}
let layer = stack.pop_layer().unwrap();
let text: Box<TextView> = layer.as_boxed_any().downcast().unwrap();
assert_eq!(text.get_content().source(), "1");
}
#[test]
fn move_layer_works() {
let mut stack = StackView::new()
.layer(TextView::new("1"))
.layer(TextView::new("2"))
.layer(TextView::new("3"))
.layer(TextView::new("4"));
stack.move_layer(
LayerPosition::FromFront(0),
LayerPosition::FromBack(0),
);
stack.move_layer(
LayerPosition::FromBack(0),
LayerPosition::FromFront(0),
);
stack.move_layer(
LayerPosition::FromFront(1),
LayerPosition::FromFront(0),
);
let layer = stack.pop_layer().unwrap();
let text: Box<TextView> = layer.as_boxed_any().downcast().unwrap();
assert_eq!(text.get_content().source(), "3");
let layer = stack.pop_layer().unwrap();
let text: Box<TextView> = layer.as_boxed_any().downcast().unwrap();
assert_eq!(text.get_content().source(), "4");
let layer = stack.pop_layer().unwrap();
let text: Box<TextView> = layer.as_boxed_any().downcast().unwrap();
assert_eq!(text.get_content().source(), "2");
let layer = stack.pop_layer().unwrap();
let text: Box<TextView> = layer.as_boxed_any().downcast().unwrap();
assert_eq!(text.get_content().source(), "1");
assert!(stack.pop_layer().is_none());
}
#[test]
fn get() {
let mut stack = StackView::new()
.layer(TextView::new("1"))
.layer(TextView::new("2"));
assert!(stack
.get(LayerPosition::FromFront(0))
.unwrap()
.as_any()
.is::<TextView>());
assert!(stack
.get(LayerPosition::FromBack(0))
.unwrap()
.as_any()
.is::<TextView>());
assert!(stack
.get_mut(LayerPosition::FromFront(0))
.unwrap()
.as_any_mut()
.is::<TextView>());
assert!(stack
.get_mut(LayerPosition::FromBack(0))
.unwrap()
.as_any_mut()
.is::<TextView>());
}
}