Make store room-specific
This commit is contained in:
parent
15213f8003
commit
23c551a5b7
7 changed files with 85 additions and 173 deletions
|
|
@ -12,7 +12,6 @@ impl<M: Msg> TreeView<M> {
|
|||
#[allow(clippy::too_many_arguments)]
|
||||
async fn correct_cursor_offset<S: MsgStore<M>>(
|
||||
&mut self,
|
||||
room: &str,
|
||||
store: &S,
|
||||
frame: &mut Frame,
|
||||
size: Size,
|
||||
|
|
@ -28,8 +27,8 @@ impl<M: Msg> TreeView<M> {
|
|||
// The cursor is not visible any more. However, we can estimate
|
||||
// whether it is above or below the previous cursor position by
|
||||
// lexicographically comparing both positions' paths.
|
||||
let old_path = store.path(room, old_cursor_id).await;
|
||||
let new_path = store.path(room, &cursor.id).await;
|
||||
let old_path = store.path(old_cursor_id).await;
|
||||
let new_path = store.path(&cursor.id).await;
|
||||
if new_path < old_path {
|
||||
// Because we moved upwards, the cursor should appear at the top
|
||||
// of the screen.
|
||||
|
|
@ -49,9 +48,7 @@ impl<M: Msg> TreeView<M> {
|
|||
// isn't, we need to scroll the screen such that the cursor becomes fully
|
||||
// visible again. To do this, we'll need to re-layout because the cursor
|
||||
// could've moved anywhere.
|
||||
let blocks = self
|
||||
.layout_blocks(room, store, Some(cursor), frame, size)
|
||||
.await;
|
||||
let blocks = self.layout_blocks(store, Some(cursor), frame, size).await;
|
||||
let cursor_block = blocks.find(&cursor.id).expect("cursor must be in blocks");
|
||||
// First, ensure the cursor's last line is not below the bottom of the
|
||||
// screen. Then, ensure its top line is not above the top of the screen.
|
||||
|
|
@ -102,7 +99,6 @@ impl<M: Msg> TreeView<M> {
|
|||
/// Always stays at the same level of indentation.
|
||||
async fn find_prev_sibling<S: MsgStore<M>>(
|
||||
&self,
|
||||
room: &str,
|
||||
store: &S,
|
||||
tree: &mut Tree<M>,
|
||||
id: &mut M::Id,
|
||||
|
|
@ -122,8 +118,8 @@ impl<M: Msg> TreeView<M> {
|
|||
} else {
|
||||
// We're at the root of our tree, so we need to move to the root of
|
||||
// the previous tree.
|
||||
if let Some(prev_tree_id) = store.prev_tree(room, tree.root()).await {
|
||||
*tree = store.tree(room, &prev_tree_id).await;
|
||||
if let Some(prev_tree_id) = store.prev_tree(tree.root()).await {
|
||||
*tree = store.tree(&prev_tree_id).await;
|
||||
*id = prev_tree_id;
|
||||
true
|
||||
} else {
|
||||
|
|
@ -137,7 +133,6 @@ impl<M: Msg> TreeView<M> {
|
|||
/// Always stays at the same level of indentation.
|
||||
async fn find_next_sibling<S: MsgStore<M>>(
|
||||
&self,
|
||||
room: &str,
|
||||
store: &S,
|
||||
tree: &mut Tree<M>,
|
||||
id: &mut M::Id,
|
||||
|
|
@ -157,8 +152,8 @@ impl<M: Msg> TreeView<M> {
|
|||
} else {
|
||||
// We're at the root of our tree, so we need to move to the root of
|
||||
// the next tree.
|
||||
if let Some(next_tree_id) = store.next_tree(room, tree.root()).await {
|
||||
*tree = store.tree(room, &next_tree_id).await;
|
||||
if let Some(next_tree_id) = store.next_tree(tree.root()).await {
|
||||
*tree = store.tree(&next_tree_id).await;
|
||||
*id = next_tree_id;
|
||||
true
|
||||
} else {
|
||||
|
|
@ -170,14 +165,13 @@ impl<M: Msg> TreeView<M> {
|
|||
/// Move to the previous message, or don't move if this is not possible.
|
||||
async fn find_prev_msg<S: MsgStore<M>>(
|
||||
&self,
|
||||
room: &str,
|
||||
store: &S,
|
||||
tree: &mut Tree<M>,
|
||||
id: &mut M::Id,
|
||||
) -> bool {
|
||||
// Move to previous sibling, then to its last child
|
||||
// If not possible, move to parent
|
||||
if self.find_prev_sibling(room, store, tree, id).await {
|
||||
if self.find_prev_sibling(store, tree, id).await {
|
||||
while Self::find_last_child(tree, id) {}
|
||||
true
|
||||
} else {
|
||||
|
|
@ -188,7 +182,6 @@ impl<M: Msg> TreeView<M> {
|
|||
/// Move to the next message, or don't move if this is not possible.
|
||||
async fn find_next_msg<S: MsgStore<M>>(
|
||||
&self,
|
||||
room: &str,
|
||||
store: &S,
|
||||
tree: &mut Tree<M>,
|
||||
id: &mut M::Id,
|
||||
|
|
@ -197,7 +190,7 @@ impl<M: Msg> TreeView<M> {
|
|||
return true;
|
||||
}
|
||||
|
||||
if self.find_next_sibling(room, store, tree, id).await {
|
||||
if self.find_next_sibling(store, tree, id).await {
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
@ -205,7 +198,7 @@ impl<M: Msg> TreeView<M> {
|
|||
// can be found.
|
||||
let mut tmp_id = id.clone();
|
||||
while Self::find_parent(tree, &mut tmp_id) {
|
||||
if self.find_next_sibling(room, store, tree, &mut tmp_id).await {
|
||||
if self.find_next_sibling(store, tree, &mut tmp_id).await {
|
||||
*id = tmp_id;
|
||||
return true;
|
||||
}
|
||||
|
|
@ -216,26 +209,24 @@ impl<M: Msg> TreeView<M> {
|
|||
|
||||
pub async fn move_up<S: MsgStore<M>>(
|
||||
&mut self,
|
||||
room: &str,
|
||||
store: &S,
|
||||
cursor: &mut Option<Cursor<M::Id>>,
|
||||
frame: &mut Frame,
|
||||
size: Size,
|
||||
) {
|
||||
let old_blocks = self
|
||||
.layout_blocks(room, store, cursor.as_ref(), frame, size)
|
||||
.layout_blocks(store, cursor.as_ref(), frame, size)
|
||||
.await;
|
||||
let old_cursor_id = cursor.as_ref().map(|c| c.id.clone());
|
||||
|
||||
if let Some(cursor) = cursor {
|
||||
// We have a cursor to move around
|
||||
let path = store.path(room, &cursor.id).await;
|
||||
let mut tree = store.tree(room, path.first()).await;
|
||||
self.find_prev_msg(room, store, &mut tree, &mut cursor.id)
|
||||
.await;
|
||||
} else if let Some(last_tree) = store.last_tree(room).await {
|
||||
let path = store.path(&cursor.id).await;
|
||||
let mut tree = store.tree(path.first()).await;
|
||||
self.find_prev_msg(store, &mut tree, &mut cursor.id).await;
|
||||
} else if let Some(last_tree) = store.last_tree().await {
|
||||
// We need to select the last message of the last tree
|
||||
let tree = store.tree(room, &last_tree).await;
|
||||
let tree = store.tree(&last_tree).await;
|
||||
let mut id = last_tree;
|
||||
while Self::find_last_child(&tree, &mut id) {}
|
||||
*cursor = Some(Cursor::new(id));
|
||||
|
|
@ -244,74 +235,55 @@ impl<M: Msg> TreeView<M> {
|
|||
// message to move to.
|
||||
|
||||
if let Some(cursor) = cursor {
|
||||
self.correct_cursor_offset(
|
||||
room,
|
||||
store,
|
||||
frame,
|
||||
size,
|
||||
&old_blocks,
|
||||
&old_cursor_id,
|
||||
cursor,
|
||||
)
|
||||
.await;
|
||||
self.correct_cursor_offset(store, frame, size, &old_blocks, &old_cursor_id, cursor)
|
||||
.await;
|
||||
}
|
||||
}
|
||||
|
||||
pub async fn move_down<S: MsgStore<M>>(
|
||||
&mut self,
|
||||
room: &str,
|
||||
store: &S,
|
||||
cursor: &mut Option<Cursor<M::Id>>,
|
||||
frame: &mut Frame,
|
||||
size: Size,
|
||||
) {
|
||||
let old_blocks = self
|
||||
.layout_blocks(room, store, cursor.as_ref(), frame, size)
|
||||
.layout_blocks(store, cursor.as_ref(), frame, size)
|
||||
.await;
|
||||
let old_cursor_id = cursor.as_ref().map(|c| c.id.clone());
|
||||
|
||||
if let Some(cursor) = cursor {
|
||||
let path = store.path(room, &cursor.id).await;
|
||||
let mut tree = store.tree(room, path.first()).await;
|
||||
self.find_next_msg(room, store, &mut tree, &mut cursor.id)
|
||||
.await;
|
||||
let path = store.path(&cursor.id).await;
|
||||
let mut tree = store.tree(path.first()).await;
|
||||
self.find_next_msg(store, &mut tree, &mut cursor.id).await;
|
||||
}
|
||||
// If that condition doesn't hold, we're already at the bottom in
|
||||
// cursor-less mode and can't move further down anyways.
|
||||
|
||||
if let Some(cursor) = cursor {
|
||||
self.correct_cursor_offset(
|
||||
room,
|
||||
store,
|
||||
frame,
|
||||
size,
|
||||
&old_blocks,
|
||||
&old_cursor_id,
|
||||
cursor,
|
||||
)
|
||||
.await;
|
||||
self.correct_cursor_offset(store, frame, size, &old_blocks, &old_cursor_id, cursor)
|
||||
.await;
|
||||
}
|
||||
}
|
||||
|
||||
pub async fn move_up_sibling<S: MsgStore<M>>(
|
||||
&mut self,
|
||||
room: &str,
|
||||
store: &S,
|
||||
cursor: &mut Option<Cursor<M::Id>>,
|
||||
frame: &mut Frame,
|
||||
size: Size,
|
||||
) {
|
||||
let old_blocks = self
|
||||
.layout_blocks(room, store, cursor.as_ref(), frame, size)
|
||||
.layout_blocks(store, cursor.as_ref(), frame, size)
|
||||
.await;
|
||||
let old_cursor_id = cursor.as_ref().map(|c| c.id.clone());
|
||||
|
||||
if let Some(cursor) = cursor {
|
||||
let path = store.path(room, &cursor.id).await;
|
||||
let mut tree = store.tree(room, path.first()).await;
|
||||
self.find_prev_sibling(room, store, &mut tree, &mut cursor.id)
|
||||
let path = store.path(&cursor.id).await;
|
||||
let mut tree = store.tree(path.first()).await;
|
||||
self.find_prev_sibling(store, &mut tree, &mut cursor.id)
|
||||
.await;
|
||||
} else if let Some(last_tree) = store.last_tree(room).await {
|
||||
} else if let Some(last_tree) = store.last_tree().await {
|
||||
// I think moving to the root of the last tree makes the most sense
|
||||
// here. Alternatively, we could just not move the cursor, but that
|
||||
// wouldn't be very useful.
|
||||
|
|
@ -321,117 +293,82 @@ impl<M: Msg> TreeView<M> {
|
|||
// message to move to.
|
||||
|
||||
if let Some(cursor) = cursor {
|
||||
self.correct_cursor_offset(
|
||||
room,
|
||||
store,
|
||||
frame,
|
||||
size,
|
||||
&old_blocks,
|
||||
&old_cursor_id,
|
||||
cursor,
|
||||
)
|
||||
.await;
|
||||
self.correct_cursor_offset(store, frame, size, &old_blocks, &old_cursor_id, cursor)
|
||||
.await;
|
||||
}
|
||||
}
|
||||
|
||||
pub async fn move_down_sibling<S: MsgStore<M>>(
|
||||
&mut self,
|
||||
room: &str,
|
||||
store: &S,
|
||||
cursor: &mut Option<Cursor<M::Id>>,
|
||||
frame: &mut Frame,
|
||||
size: Size,
|
||||
) {
|
||||
let old_blocks = self
|
||||
.layout_blocks(room, store, cursor.as_ref(), frame, size)
|
||||
.layout_blocks(store, cursor.as_ref(), frame, size)
|
||||
.await;
|
||||
let old_cursor_id = cursor.as_ref().map(|c| c.id.clone());
|
||||
|
||||
if let Some(cursor) = cursor {
|
||||
let path = store.path(room, &cursor.id).await;
|
||||
let mut tree = store.tree(room, path.first()).await;
|
||||
self.find_next_sibling(room, store, &mut tree, &mut cursor.id)
|
||||
let path = store.path(&cursor.id).await;
|
||||
let mut tree = store.tree(path.first()).await;
|
||||
self.find_next_sibling(store, &mut tree, &mut cursor.id)
|
||||
.await;
|
||||
}
|
||||
// If that condition doesn't hold, we're already at the bottom in
|
||||
// cursor-less mode and can't move further down anyways.
|
||||
|
||||
if let Some(cursor) = cursor {
|
||||
self.correct_cursor_offset(
|
||||
room,
|
||||
store,
|
||||
frame,
|
||||
size,
|
||||
&old_blocks,
|
||||
&old_cursor_id,
|
||||
cursor,
|
||||
)
|
||||
.await;
|
||||
self.correct_cursor_offset(store, frame, size, &old_blocks, &old_cursor_id, cursor)
|
||||
.await;
|
||||
}
|
||||
}
|
||||
|
||||
pub async fn move_to_first<S: MsgStore<M>>(
|
||||
&mut self,
|
||||
room: &str,
|
||||
store: &S,
|
||||
cursor: &mut Option<Cursor<M::Id>>,
|
||||
frame: &mut Frame,
|
||||
size: Size,
|
||||
) {
|
||||
let old_blocks = self
|
||||
.layout_blocks(room, store, cursor.as_ref(), frame, size)
|
||||
.layout_blocks(store, cursor.as_ref(), frame, size)
|
||||
.await;
|
||||
let old_cursor_id = cursor.as_ref().map(|c| c.id.clone());
|
||||
|
||||
if let Some(tree_id) = store.first_tree(room).await {
|
||||
if let Some(tree_id) = store.first_tree().await {
|
||||
*cursor = Some(Cursor::new(tree_id));
|
||||
}
|
||||
|
||||
if let Some(cursor) = cursor {
|
||||
self.correct_cursor_offset(
|
||||
room,
|
||||
store,
|
||||
frame,
|
||||
size,
|
||||
&old_blocks,
|
||||
&old_cursor_id,
|
||||
cursor,
|
||||
)
|
||||
.await;
|
||||
self.correct_cursor_offset(store, frame, size, &old_blocks, &old_cursor_id, cursor)
|
||||
.await;
|
||||
}
|
||||
}
|
||||
|
||||
pub async fn move_to_last<S: MsgStore<M>>(
|
||||
&mut self,
|
||||
room: &str,
|
||||
store: &S,
|
||||
cursor: &mut Option<Cursor<M::Id>>,
|
||||
frame: &mut Frame,
|
||||
size: Size,
|
||||
) {
|
||||
let old_blocks = self
|
||||
.layout_blocks(room, store, cursor.as_ref(), frame, size)
|
||||
.layout_blocks(store, cursor.as_ref(), frame, size)
|
||||
.await;
|
||||
let old_cursor_id = cursor.as_ref().map(|c| c.id.clone());
|
||||
|
||||
if let Some(tree_id) = store.last_tree(room).await {
|
||||
let tree = store.tree(room, &tree_id).await;
|
||||
if let Some(tree_id) = store.last_tree().await {
|
||||
let tree = store.tree(&tree_id).await;
|
||||
let mut id = tree_id;
|
||||
while Self::find_last_child(&tree, &mut id) {}
|
||||
*cursor = Some(Cursor::new(id));
|
||||
}
|
||||
|
||||
if let Some(cursor) = cursor {
|
||||
self.correct_cursor_offset(
|
||||
room,
|
||||
store,
|
||||
frame,
|
||||
size,
|
||||
&old_blocks,
|
||||
&old_cursor_id,
|
||||
cursor,
|
||||
)
|
||||
.await;
|
||||
self.correct_cursor_offset(store, frame, size, &old_blocks, &old_cursor_id, cursor)
|
||||
.await;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -440,7 +377,6 @@ impl<M: Msg> TreeView<M> {
|
|||
|
||||
pub async fn center_cursor<S: MsgStore<M>>(
|
||||
&mut self,
|
||||
room: &str,
|
||||
store: &S,
|
||||
cursor: &mut Option<Cursor<M::Id>>,
|
||||
frame: &mut Frame,
|
||||
|
|
@ -451,20 +387,10 @@ impl<M: Msg> TreeView<M> {
|
|||
|
||||
// Correcting the offset just to make sure that this function
|
||||
// behaves nicely if the cursor has too many lines.
|
||||
let old_blocks = self
|
||||
.layout_blocks(room, store, Some(cursor), frame, size)
|
||||
.await;
|
||||
let old_blocks = self.layout_blocks(store, Some(cursor), frame, size).await;
|
||||
let old_cursor_id = Some(cursor.id.clone());
|
||||
self.correct_cursor_offset(
|
||||
room,
|
||||
store,
|
||||
frame,
|
||||
size,
|
||||
&old_blocks,
|
||||
&old_cursor_id,
|
||||
cursor,
|
||||
)
|
||||
.await;
|
||||
self.correct_cursor_offset(store, frame, size, &old_blocks, &old_cursor_id, cursor)
|
||||
.await;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue