grid flatten

This commit is contained in:
Michael Sippel 2021-06-13 17:20:39 +02:00
parent 44cba54320
commit 30a3df180b
Signed by: senvas
GPG key ID: F96CF119C34B64A6
2 changed files with 209 additions and 239 deletions

View file

@ -1,239 +0,0 @@
use {
async_std::stream::StreamExt,
std::{
sync::Arc,
collections::HashMap,
cmp::{min, max}
},
cgmath::{Point2, Vector2},
std::sync::RwLock,
crate::{
core::{InnerViewPort, OuterViewPort, Observer, ObserverExt, ObserverBroadcast, ChannelReceiver, ChannelSender},
terminal::{TerminalView, TerminalAtom},
index::{ImplIndexView},
grid::GridWindowIterator,
projection::ProjectionArg
}
};
pub struct Cell {
view: Arc<dyn TerminalView>,
_arg: Arc<RwLock<ProjectionArg<dyn TerminalView, CellLayout>>>
}
pub struct CellLayout {
cells: HashMap<Point2<i16>, Cell>,
col_widths: Vec<usize>,
row_heights: Vec<usize>,
cast: Arc<RwLock<ObserverBroadcast<dyn TerminalView>>>,
send: ChannelSender<Vec<(Point2<i16>, Point2<i16>)>>
}
impl ImplIndexView for CellLayout {
type Key = Point2<i16>;
type Value = TerminalAtom;
fn get(&self, pos: &Point2<i16>) -> Option<TerminalAtom> {
let cell_pos = self.get_cell_containing(pos);
let cell_off = self.get_cell_offset(&cell_pos);
self.cells.get(&cell_pos)?.view.get(&(pos - cell_off))
}
fn area(&self) -> Option<Vec<Point2<i16>>> {
Some(
self.cells.iter()
.flat_map(
|(cell_pos, cell)| {
let off = self.get_cell_offset(cell_pos);
cell.view.area()
.unwrap_or(Vec::new())
.into_iter()
.map(move |p| p + off)
}
).collect()
)
}
}
impl CellLayout {
pub fn with_port(port: InnerViewPort<dyn TerminalView>) -> Arc<RwLock<Self>> {
let (send, mut recv) = crate::core::channel::channel();
let v = Arc::new(RwLock::new(CellLayout {
cells: HashMap::new(),
col_widths: Vec::new(),
row_heights: Vec::new(),
cast: port.get_broadcast(),
send
}));
/*
* its is a bit ugly to spawn a task here, but we need the stream to decouple
* in order to avoid deadlocks
*/
async_std::task::spawn({
let l = v.clone();
async move {
while let Some((cell_idx, pos)) = recv.next().await {
l.write().unwrap().update_cell(&cell_idx, &pos);
}
}
});
port.set_view(Some(v.clone()));
v
}
pub fn set_cell(layout: &Arc<RwLock<Self>>, cell_pos: Point2<i16>, port: OuterViewPort<dyn TerminalView>) {
let sender = layout.read().unwrap().send.clone();
let arg = ProjectionArg::new(
move |s: Arc<RwLock<Self>>, pos: &Point2<i16>| {
sender.send((cell_pos, *pos));
}
);
layout.write().unwrap().cells.insert(
cell_pos,
Cell {
view: arg.read().unwrap().src.clone(),
_arg: arg.clone()
});
arg.write().unwrap().proj = Arc::downgrade(&layout);
port.add_observer(arg);
}
fn update_col_width(&mut self, col_idx: i16) -> bool {
let mut max_width = 0;
for row_idx in 0 .. self.row_heights.len() as i16 {
if let Some(cell) = self.cells.get(&Point2::new(col_idx, row_idx)) {
if let Some(area) = cell.view.area() {
max_width = max(
max_width,
area.iter()
.map(|pt| pt.x as usize + 1)
.max()
.unwrap_or(0)
);
}
}
}
let changed = (self.col_widths[col_idx as usize] != max_width);
self.col_widths[col_idx as usize] = max_width;
changed
}
fn update_row_height(&mut self, row_idx: i16) -> bool {
let mut max_height = 0;
for col_idx in 0 .. self.col_widths.len() as i16 {
if let Some(cell) = self.cells.get(&Point2::new(col_idx, row_idx)) {
if let Some(area) = cell.view.area() {
max_height = max(
max_height,
area.iter()
.map(|pt| pt.y as usize + 1)
.max()
.unwrap_or(0)
);
}
}
}
let changed = (self.row_heights[row_idx as usize] != max_height);
self.row_heights[row_idx as usize] = max_height;
changed
}
fn update_cell(&mut self, cell_pos: &Point2<i16>, pos: &Point2<i16>) {
for _ in self.col_widths.len() as i16 ..= cell_pos.x { self.col_widths.push(0); }
for _ in self.row_heights.len() as i16 ..= cell_pos.y { self.row_heights.push(0); }
let cell_off = self.get_cell_offset(cell_pos);
self.cast.notify(&(pos + cell_off));
let old_n = self.get_cell_offset(&(cell_pos + Vector2::new(1, 1)));
let old_width = self.get_width();
let old_height = self.get_height();
// does this really have to be recalculated every time ??
let width_changed = self.update_col_width(cell_pos.x);
let height_changed = self.update_row_height(cell_pos.y);
let extent = Point2::new(
max(self.get_width(), old_width) as i16,
max(self.get_height(), old_height) as i16
);
let new_n = self.get_cell_offset(&(cell_pos + Vector2::new(1, 1)));
/* if a cell updates its size, the complete rectangle to the right is refreshed
* todo: optimize to use area() of cell views
*/
if width_changed {
self.cast.notify_each(GridWindowIterator::from(
Point2::new(
min(old_n.x, new_n.x),
0
)
..
extent
));
}
if height_changed {
self.cast.notify_each(GridWindowIterator::from(
Point2::new(
0,
min(old_n.y, new_n.y)
)
..
extent
));
}
}
fn get_width(&self) -> usize {
self.col_widths.iter().sum()
}
fn get_height(&self) -> usize {
self.row_heights.iter().sum()
}
fn get_cell_offset(&self, cell_pos: &Point2<i16>) -> Vector2<i16> {
Vector2::new(
self.col_widths.iter().take(cell_pos.x as usize).sum::<usize>() as i16,
self.row_heights.iter().take(cell_pos.y as usize).sum::<usize>() as i16
)
}
fn get_cell_containing(&self, glob_pos: &Point2<i16>) -> Point2<i16> {
Point2::new(
self.col_widths.iter()
.fold(
(0, 0),
|(cell_idx, x), width|
(
cell_idx + if (x + *width as i16) <= glob_pos.x { 1 } else { 0 },
x + *width as i16
)).0,
self.row_heights.iter()
.fold(
(0, 0),
|(cell_idx, y), height|
(
cell_idx + if (y + *height as i16) <= glob_pos.y { 1 } else { 0 },
y + *height as i16
)).0
)
}
}

209
nested/src/grid/flatten.rs Normal file
View file

@ -0,0 +1,209 @@
use {
async_std::stream::StreamExt,
std::{
sync::{Arc},
collections::{HashMap, HashSet}
},
std::sync::RwLock,
cgmath::{Point2, Vector2},
crate::{
core::{
View, Observer, ObserverBroadcast, ObserverExt,
ViewPort, InnerViewPort, OuterViewPort,
channel::{ChannelSender, ChannelReceiver},
port::UpdateTask
},
grid::{GridView, GridWindowIterator},
index::IndexView,
projection::ProjectionHelper
}
};
impl<Item> OuterViewPort<dyn GridView<Item = OuterViewPort<dyn GridView<Item = Item>>>>
where Item: 'static{
pub fn flatten(&self) -> OuterViewPort<dyn GridView<Item = Item>> {
let port = ViewPort::new();
port.add_update_hook(Arc::new(self.0.clone()));
Flatten::new(self.clone(), port.inner());
port.into_outer()
}
}
pub struct Chunk<Item>
where Item: 'static
{
offset: Vector2<i16>,
limit: Point2<i16>,
view: Arc<dyn GridView<Item = Item>>
}
pub struct Flatten<Item>
where Item: 'static
{
limit: Point2<i16>,
top: Arc<dyn GridView<Item = OuterViewPort<dyn GridView<Item = Item>>>>,
chunks: HashMap<Point2<i16>, Chunk<Item>>,
cast: Arc<RwLock<ObserverBroadcast<dyn GridView<Item = Item>>>>,
proj_helper: ProjectionHelper<Self>
}
impl<Item> View for Flatten<Item>
where Item: 'static
{
type Msg = Point2<i16>;
}
impl<Item> IndexView<Point2<i16>> for Flatten<Item>
where Item: 'static
{
type Item = Item;
fn get(&self, idx: &Point2<i16>) -> Option<Self::Item> {
let chunk_idx = self.get_chunk_idx(*idx)?;
let chunk = self.chunks.get(&chunk_idx)?;
chunk.view.get(&(*idx - chunk.offset))
}
fn area(&self) -> Option<Vec<Point2<i16>>> {
Some(GridWindowIterator::from(Point2::new(0, 0) .. self.limit).collect())
}
}
/* TODO: remove unused projection args (bot-views) if they get replaced by a new viewport */
impl<Item> Flatten<Item>
where Item: 'static
{
pub fn new(
top_port: OuterViewPort<dyn GridView<Item = OuterViewPort<dyn GridView<Item = Item>>>>,
out_port: InnerViewPort<dyn GridView<Item = Item>>
) -> Arc<RwLock<Self>> {
let mut proj_helper = ProjectionHelper::new(out_port.0.update_hooks.clone());
let flat = Arc::new(RwLock::new(
Flatten {
limit: Point2::new(0, 0),
top: proj_helper.new_index_arg(
top_port,
|s: &mut Self, chunk_idx| {
s.update_chunk(*chunk_idx);
}
),
chunks: HashMap::new(),
cast: out_port.get_broadcast(),
proj_helper
}));
flat.write().unwrap().proj_helper.set_proj(&flat);
out_port.set_view(Some(flat.clone()));
flat
}
/// the top-sequence has changed the item at chunk_idx,
/// create a new observer for the contained sub sequence
fn update_chunk(&mut self, chunk_idx: Point2<i16>) {
if let Some(chunk_port) = self.top.get(&chunk_idx) {
self.chunks.insert(
chunk_idx,
Chunk {
offset: Vector2::new(0, 0),
limit: Point2::new(0, 0),
view: self.proj_helper.new_index_arg(
chunk_port.clone(),
move |s: &mut Self, idx| {
if let Some(chunk) = s.chunks.get(&chunk_idx) {
let chunk_offset = chunk.offset;
let chunk_limit = chunk.view.range().end;
let mut dirty_idx = Vec::new();
if chunk.limit != chunk_limit {
dirty_idx = s.update_all_offsets();
}
s.cast.notify(&(idx + chunk_offset));
s.cast.notify_each(dirty_idx);
}
}
)
}
);
chunk_port.0.update();
let dirty_idx = self.update_all_offsets();
self.cast.notify_each(dirty_idx);
} else {
// todo:
//self.proj_helper.remove_arg();
self.chunks.remove(&chunk_idx);
let dirty_idx = self.update_all_offsets();
self.cast.notify_each(dirty_idx);
}
}
/// recalculate all chunk offsets
/// and update size of flattened grid
fn update_all_offsets(&mut self) -> Vec<Point2<i16>> {
let mut dirty_idx = Vec::new();
let top_range = self.top.range();
let mut col_widths = vec![0 as i16; (top_range.end.x) as usize];
let mut row_heights = vec![0 as i16; (top_range.end.y) as usize];
for chunk_idx in GridWindowIterator::from(self.top.range()) {
if let Some(chunk) = self.chunks.get_mut(&chunk_idx) {
let old_offset = chunk.offset;
let old_limit = chunk.limit;
chunk.offset = Vector2::new(
(0 .. chunk_idx.x as usize).map(|x| col_widths[x]).sum(),
(0 .. chunk_idx.y as usize).map(|y| row_heights[y]).sum()
);
chunk.limit = chunk.view.range().end;
col_widths[chunk_idx.x as usize] = std::cmp::max(col_widths[chunk_idx.x as usize], chunk.limit.x);
row_heights[chunk_idx.y as usize] = std::cmp::max(row_heights[chunk_idx.y as usize], chunk.limit.y);
if old_offset != chunk.offset {
dirty_idx.extend(
GridWindowIterator::from(
Point2::new(std::cmp::min(old_offset.x, chunk.offset.x),
std::cmp::min(old_offset.y, chunk.offset.y))
.. Point2::new(std::cmp::max(old_offset.x, chunk.offset.x) + std::cmp::max(old_limit.x, chunk.limit.x),
std::cmp::max(old_offset.y, chunk.offset.y) + std::cmp::max(old_limit.y, chunk.limit.y)))
);
}
}
}
let old_limit = self.limit;
self.limit = Point2::new(
(0 .. top_range.end.x as usize).map(|x| col_widths[x]).sum(),
(0 .. top_range.end.y as usize).map(|y| row_heights[y]).sum()
);
dirty_idx
}
/// given an index in the flattened sequence,
/// which sub-sequence does it belong to?
fn get_chunk_idx(&self, glob_pos: Point2<i16>) -> Option<Point2<i16>> {
let mut offset = Point2::new(0, 0);
for chunk_idx in GridWindowIterator::from(self.top.range()) {
if let Some(chunk) = self.chunks.get(&chunk_idx) {
let chunk_range = chunk.view.range();
offset += Vector2::new(chunk_range.end.x, chunk_range.end.y);
if glob_pos.x < offset.x && glob_pos.y < offset.y {
return Some(chunk_idx);
}
}
}
None
}
}