2022-06-19 23:13:21 +02:00
|
|
|
use {
|
2023-02-13 18:39:45 +01:00
|
|
|
r3vi::{
|
|
|
|
view::{
|
|
|
|
OuterViewPort,
|
|
|
|
singleton::*,
|
|
|
|
sequence::*
|
|
|
|
}
|
|
|
|
},
|
2022-06-19 23:13:21 +02:00
|
|
|
crate::{
|
2023-02-13 18:39:45 +01:00
|
|
|
editors::list::{
|
2022-06-19 23:13:21 +02:00
|
|
|
ListCursor, ListCursorMode,
|
2023-02-13 18:39:45 +01:00
|
|
|
editor::ListEditor
|
2022-06-19 23:13:21 +02:00
|
|
|
},
|
2023-02-13 18:39:45 +01:00
|
|
|
tree::{TreeCursor, TreeNav, TreeNavResult}
|
2022-06-19 23:13:21 +02:00
|
|
|
},
|
|
|
|
cgmath::Vector2
|
|
|
|
};
|
|
|
|
|
2022-12-19 11:26:07 +01:00
|
|
|
//<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
|
|
|
|
|
|
|
|
impl TreeNav for ListEditor {
|
2023-01-07 04:37:44 +01:00
|
|
|
fn get_addr_view(&self) -> OuterViewPort<dyn SequenceView<Item = isize>> {
|
|
|
|
self.addr_port.clone()
|
|
|
|
}
|
|
|
|
|
|
|
|
fn get_mode_view(&self) -> OuterViewPort<dyn SingletonView<Item = ListCursorMode>> {
|
|
|
|
self.mode_port.clone()
|
|
|
|
}
|
|
|
|
|
2022-06-19 23:13:21 +02:00
|
|
|
fn get_cursor_warp(&self) -> TreeCursor {
|
|
|
|
let cur = self.cursor.get();
|
|
|
|
match cur.mode {
|
|
|
|
ListCursorMode::Insert => TreeCursor {
|
|
|
|
leaf_mode: cur.mode,
|
|
|
|
tree_addr: if let Some(i) = cur.idx {
|
|
|
|
vec![
|
|
|
|
i - self.data.len() as isize - 1
|
|
|
|
]
|
|
|
|
} else {
|
|
|
|
vec![]
|
|
|
|
},
|
|
|
|
},
|
|
|
|
ListCursorMode::Select => {
|
|
|
|
if let Some(i) = cur.idx {
|
|
|
|
if i < self.data.len() as isize {
|
2023-07-03 12:32:03 +02:00
|
|
|
let mut sub_cur = self.data.get(i as usize).read().unwrap().get_cursor_warp();
|
2022-06-19 23:13:21 +02:00
|
|
|
sub_cur.tree_addr.insert(0, i as isize - self.data.len() as isize);
|
|
|
|
return sub_cur;
|
2022-10-14 23:42:35 +02:00
|
|
|
} else {
|
|
|
|
return TreeCursor {
|
|
|
|
leaf_mode: ListCursorMode::Select,
|
|
|
|
tree_addr: vec![ i as isize - self.data.len() as isize ],
|
|
|
|
};
|
2022-06-19 23:13:21 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
TreeCursor {
|
|
|
|
leaf_mode: cur.mode,
|
|
|
|
tree_addr: vec![],
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn get_cursor(&self) -> TreeCursor {
|
|
|
|
let cur = self.cursor.get();
|
|
|
|
match cur.mode {
|
|
|
|
ListCursorMode::Insert => TreeCursor {
|
|
|
|
leaf_mode: cur.mode,
|
|
|
|
tree_addr: if let Some(i) = cur.idx {
|
|
|
|
vec![i]
|
|
|
|
} else {
|
|
|
|
vec![]
|
|
|
|
},
|
|
|
|
},
|
|
|
|
ListCursorMode::Select => {
|
|
|
|
if let Some(i) = cur.idx {
|
|
|
|
if i < self.data.len() as isize {
|
2023-07-03 12:32:03 +02:00
|
|
|
let mut sub_cur = self.data.get(i as usize).read().unwrap().get_cursor();
|
2022-10-14 23:42:35 +02:00
|
|
|
if sub_cur.tree_addr.len() > 0 {
|
|
|
|
sub_cur.tree_addr.insert(0, i as isize);
|
|
|
|
return sub_cur;
|
|
|
|
} else {
|
|
|
|
return TreeCursor {
|
|
|
|
leaf_mode: ListCursorMode::Select,
|
|
|
|
tree_addr: vec![ i ],
|
|
|
|
};
|
|
|
|
}
|
2022-06-19 23:13:21 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
TreeCursor {
|
2022-10-14 23:42:35 +02:00
|
|
|
leaf_mode: ListCursorMode::Select,
|
2022-06-19 23:13:21 +02:00
|
|
|
tree_addr: vec![],
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn goto(&mut self, new_cur: TreeCursor) -> TreeNavResult {
|
|
|
|
let old_cur = self.cursor.get();
|
|
|
|
if let Some(i) = old_cur.idx {
|
|
|
|
if i < self.data.len() as isize {
|
2023-07-03 12:32:03 +02:00
|
|
|
self.data.get_mut(i as usize).write().unwrap().goto(TreeCursor::none());
|
2022-06-19 23:13:21 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
match new_cur.tree_addr.len() {
|
|
|
|
0 => {
|
|
|
|
self.cursor.set(ListCursor {
|
|
|
|
mode: new_cur.leaf_mode,
|
|
|
|
idx: None,
|
|
|
|
});
|
|
|
|
TreeNavResult::Continue
|
|
|
|
}
|
|
|
|
1 => {
|
2023-01-02 18:49:32 +01:00
|
|
|
let idx = crate::utils::modulo(new_cur.tree_addr[0], if new_cur.leaf_mode == ListCursorMode::Insert { 1 } else { 0 } + self.data.len() as isize);
|
2022-10-14 23:42:35 +02:00
|
|
|
|
2022-06-19 23:13:21 +02:00
|
|
|
self.cursor.set(ListCursor {
|
|
|
|
mode: new_cur.leaf_mode,
|
2022-10-14 23:42:35 +02:00
|
|
|
idx: Some(idx),
|
2022-06-19 23:13:21 +02:00
|
|
|
});
|
2022-10-14 23:42:35 +02:00
|
|
|
|
2022-10-15 04:44:58 +02:00
|
|
|
if new_cur.leaf_mode == ListCursorMode::Select && self.data.len() > 0 {
|
2022-12-19 11:26:07 +01:00
|
|
|
self.data
|
|
|
|
.get_mut(idx as usize)
|
2023-07-03 12:32:03 +02:00
|
|
|
.write().unwrap()
|
2022-12-19 11:26:07 +01:00
|
|
|
.goto(TreeCursor {
|
|
|
|
leaf_mode: ListCursorMode::Select,
|
|
|
|
tree_addr: vec![]
|
|
|
|
});
|
2022-10-14 23:42:35 +02:00
|
|
|
}
|
|
|
|
|
2022-06-19 23:13:21 +02:00
|
|
|
TreeNavResult::Continue
|
|
|
|
}
|
|
|
|
_ => {
|
2022-09-28 13:33:51 +02:00
|
|
|
if self.data.len() > 0 {
|
2023-01-02 18:49:32 +01:00
|
|
|
let idx = crate::utils::modulo(new_cur.tree_addr[0], self.data.len() as isize);
|
2022-06-19 23:13:21 +02:00
|
|
|
|
2022-09-28 13:33:51 +02:00
|
|
|
self.cursor.set(ListCursor {
|
|
|
|
mode: ListCursorMode::Select,
|
|
|
|
idx: Some(idx),
|
|
|
|
});
|
2022-06-19 23:13:21 +02:00
|
|
|
|
2022-12-19 11:26:07 +01:00
|
|
|
self.data
|
|
|
|
.get_mut(idx as usize)
|
2023-07-03 12:32:03 +02:00
|
|
|
.write().unwrap()
|
2022-12-19 11:26:07 +01:00
|
|
|
.goto(TreeCursor {
|
|
|
|
leaf_mode: new_cur.leaf_mode,
|
|
|
|
tree_addr: new_cur.tree_addr[1..].iter().cloned().collect(),
|
|
|
|
});
|
2022-09-28 13:33:51 +02:00
|
|
|
} else {
|
|
|
|
self.cursor.set(ListCursor::home());
|
|
|
|
}
|
2022-06-19 23:13:21 +02:00
|
|
|
|
|
|
|
TreeNavResult::Continue
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn goby(&mut self, direction: Vector2<isize>) -> TreeNavResult {
|
|
|
|
let mut cur = self.get_cursor();
|
|
|
|
match cur.tree_addr.len() {
|
|
|
|
0 => {
|
|
|
|
|
|
|
|
if direction.y < 0 {
|
|
|
|
// up
|
2022-10-15 03:52:38 +02:00
|
|
|
/*
|
2022-10-14 23:42:35 +02:00
|
|
|
self.cursor.set(ListCursor {
|
|
|
|
mode: cur.leaf_mode,
|
|
|
|
idx: None
|
2022-10-15 03:52:38 +02:00
|
|
|
});
|
|
|
|
*/
|
|
|
|
self.cursor.set(ListCursor::none());
|
2022-06-19 23:13:21 +02:00
|
|
|
TreeNavResult::Exit
|
|
|
|
} else if direction.y > 0 {
|
|
|
|
// dn
|
2022-10-14 23:42:35 +02:00
|
|
|
self.cursor.set(ListCursor {
|
|
|
|
mode: if self.data.len() > 0 { cur.leaf_mode } else { ListCursorMode::Insert },
|
|
|
|
idx: Some(0)
|
|
|
|
});
|
|
|
|
|
2022-06-19 23:13:21 +02:00
|
|
|
self.goby(Vector2::new(direction.x, direction.y-1));
|
|
|
|
TreeNavResult::Continue
|
|
|
|
} else {
|
|
|
|
TreeNavResult::Continue
|
|
|
|
}
|
|
|
|
},
|
|
|
|
|
|
|
|
1 => {
|
|
|
|
if direction.y > 0 {
|
|
|
|
// dn
|
|
|
|
if cur.tree_addr[0] < self.data.len() as isize {
|
2022-12-19 11:26:07 +01:00
|
|
|
if self.data
|
|
|
|
.get_mut(cur.tree_addr[0] as usize)
|
2023-07-03 12:32:03 +02:00
|
|
|
.write().unwrap()
|
2022-12-19 11:26:07 +01:00
|
|
|
.goby(Vector2::new(direction.x, direction.y))
|
|
|
|
== TreeNavResult::Continue {
|
|
|
|
self.cursor.set(ListCursor {
|
|
|
|
mode: ListCursorMode::Select,
|
|
|
|
idx: Some(cur.tree_addr[0])
|
|
|
|
})
|
|
|
|
}
|
2022-06-19 23:13:21 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
TreeNavResult::Continue
|
|
|
|
|
|
|
|
} else if direction.y < 0 {
|
|
|
|
// up
|
2022-10-14 23:42:35 +02:00
|
|
|
self.cursor.set(ListCursor {
|
|
|
|
mode: cur.leaf_mode,
|
|
|
|
idx: None
|
|
|
|
});
|
2022-06-24 15:54:05 +02:00
|
|
|
TreeNavResult::Exit
|
2022-06-19 23:13:21 +02:00
|
|
|
} else {
|
|
|
|
// horizontal
|
|
|
|
|
|
|
|
if (cur.tree_addr[0]+direction.x >= 0) &&
|
|
|
|
(cur.tree_addr[0]+direction.x <
|
|
|
|
self.data.len() as isize
|
|
|
|
+ if cur.leaf_mode == ListCursorMode::Insert { 1 } else { 0 })
|
|
|
|
{
|
2022-10-14 23:42:35 +02:00
|
|
|
let idx = cur.tree_addr[0] + direction.x;
|
2022-06-19 23:13:21 +02:00
|
|
|
self.cursor.set(ListCursor {
|
2022-09-28 13:33:51 +02:00
|
|
|
mode: if self.data.len() == 0 { ListCursorMode::Insert } else { cur.leaf_mode },
|
2022-10-14 23:42:35 +02:00
|
|
|
idx: Some(idx)
|
2022-06-19 23:13:21 +02:00
|
|
|
});
|
2022-10-14 23:42:35 +02:00
|
|
|
|
|
|
|
if idx < self.data.len() as isize {
|
2022-12-19 11:26:07 +01:00
|
|
|
self.data
|
|
|
|
.get_mut(idx as usize)
|
2023-07-03 12:32:03 +02:00
|
|
|
.write().unwrap()
|
2022-12-19 11:26:07 +01:00
|
|
|
.goto(TreeCursor {
|
|
|
|
leaf_mode: cur.leaf_mode,
|
|
|
|
tree_addr: vec![]
|
|
|
|
});
|
2022-10-14 23:42:35 +02:00
|
|
|
}
|
|
|
|
|
2022-06-19 23:13:21 +02:00
|
|
|
TreeNavResult::Continue
|
|
|
|
} else {
|
2022-10-14 23:42:35 +02:00
|
|
|
self.cursor.set(ListCursor {
|
|
|
|
mode: cur.leaf_mode,
|
|
|
|
idx: None
|
|
|
|
});
|
2022-10-15 03:52:38 +02:00
|
|
|
self.cursor.set(ListCursor::none());
|
2022-06-19 23:13:21 +02:00
|
|
|
TreeNavResult::Exit
|
|
|
|
}
|
|
|
|
}
|
|
|
|
},
|
|
|
|
depth => {
|
|
|
|
// nested
|
|
|
|
|
2022-09-28 13:33:51 +02:00
|
|
|
if cur.tree_addr[0] < self.data.len() as isize {
|
2023-08-07 21:46:50 +02:00
|
|
|
|
|
|
|
let cur_item = self.data
|
|
|
|
.get_mut(cur.tree_addr[0] as usize);
|
|
|
|
|
|
|
|
let result = cur_item.write().unwrap().goby(direction);
|
|
|
|
|
|
|
|
drop(cur_item);
|
|
|
|
|
|
|
|
match result
|
2022-12-19 11:26:07 +01:00
|
|
|
{
|
2022-09-28 13:33:51 +02:00
|
|
|
TreeNavResult::Exit => {
|
|
|
|
if direction.y < 0 {
|
|
|
|
// up
|
|
|
|
self.cursor.set(ListCursor {
|
|
|
|
mode: cur.leaf_mode,
|
|
|
|
idx: Some(cur.tree_addr[0])
|
|
|
|
});
|
|
|
|
|
|
|
|
TreeNavResult::Continue
|
|
|
|
} else if direction.y > 0 {
|
|
|
|
// dn
|
|
|
|
|
|
|
|
TreeNavResult::Continue
|
|
|
|
} else {
|
|
|
|
// horizontal
|
|
|
|
if (cur.tree_addr[0]+direction.x >= 0) &&
|
|
|
|
(cur.tree_addr[0]+direction.x < self.data.len() as isize)
|
|
|
|
{
|
|
|
|
if direction.x < 0 {
|
|
|
|
cur.tree_addr[0] -= 1;
|
|
|
|
for i in 1..depth {
|
|
|
|
cur.tree_addr[i] = -1;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
cur.tree_addr[0] += 1;
|
|
|
|
for i in 1..depth {
|
|
|
|
cur.tree_addr[i] = 0;
|
|
|
|
}
|
2022-06-19 23:13:21 +02:00
|
|
|
}
|
2022-09-28 13:33:51 +02:00
|
|
|
|
|
|
|
self.goto(cur)
|
2022-06-19 23:13:21 +02:00
|
|
|
} else {
|
2022-10-14 23:42:35 +02:00
|
|
|
self.cursor.set(ListCursor {
|
|
|
|
mode: cur.leaf_mode,
|
|
|
|
idx: None
|
|
|
|
});
|
2022-10-15 03:52:38 +02:00
|
|
|
self.cursor.set(ListCursor::none());
|
2022-09-28 13:33:51 +02:00
|
|
|
TreeNavResult::Exit
|
2022-06-19 23:13:21 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2022-09-28 13:33:51 +02:00
|
|
|
TreeNavResult::Continue => TreeNavResult::Continue
|
2022-06-19 23:13:21 +02:00
|
|
|
}
|
2022-09-28 13:33:51 +02:00
|
|
|
|
|
|
|
|
|
|
|
} else {
|
|
|
|
self.cursor.set(
|
|
|
|
ListCursor {
|
|
|
|
mode: ListCursorMode::Insert,
|
|
|
|
idx: Some(0)
|
|
|
|
}
|
|
|
|
);
|
|
|
|
TreeNavResult::Continue
|
|
|
|
}
|
2022-06-19 23:13:21 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|