randre03
/
meli
forked from meli/meli
1
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

melib/ui: print threads in correct order

embed
Manos Pitsidianakis 2018-09-08 21:47:52 +03:00
parent 630330f632
commit 8c5879032e
Signed by: Manos Pitsidianakis
GPG Key ID: 73627C2F690DF710
3 changed files with 30 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
melib/src/mailbox/thread.rs
View File

@ -96,26 +96,27 @@ impl ThreadTree {
}
pub struct ThreadIterator<'a> {
init_pos: usize,
pos: usize,
stack: Vec<usize>,
tree: Ref<'a, Vec<ThreadTree>>,
}
impl<'a> Iterator for ThreadIterator<'a> {
type Item = usize;
fn next(&mut self) -> Option<usize> {
type Item = (usize, usize);
fn next(&mut self) -> Option<(usize, usize)> {
{
let mut tree = &(*self.tree);
for i in &self.stack {
for i in self.stack.iter() {
tree = &tree[*i].children;
}
if self.pos == tree.len() {
if self.pos == tree.len() || (self.stack.is_empty() && self.pos > self.init_pos) {
if self.stack.is_empty() {
return None;
}
self.pos = self.stack.pop().unwrap() + 1;
} else {
debug_assert!(self.pos < tree.len());
let ret = tree[self.pos].id;
let ret = (self.stack.len(), tree[self.pos].id);
if !tree[self.pos].children.is_empty() {
self.stack.push(self.pos);
self.pos = 0;
@ -231,18 +232,18 @@ impl PartialEq for ThreadNode {
pub struct RootIterator<'a> {
pos: usize,
root_set: Ref<'a, Vec<usize>>,
root_tree: Ref<'a, Vec<ThreadTree>>,
}
impl<'a> Iterator for RootIterator<'a> {
type Item = usize;
fn next(&mut self) -> Option<usize> {
{
if self.pos == self.root_set.len() {
if self.pos == self.root_tree.len() {
return None;
}
self.pos += 1;
return Some(self.root_set[self.pos - 1]);
return Some(self.root_tree[self.pos - 1].id);
}
}
}
@ -301,6 +302,8 @@ impl Threads {
root_set: RefCell::new(root_set),
message_ids,
hash_set,
subsort: RefCell::new((SortField::Subject, SortOrder::Desc)),
..Default::default()
};
t.build_collection(&collection);
@ -309,6 +312,7 @@ impl Threads {
pub fn thread_iter(&self, index: usize) -> ThreadIterator {
ThreadIterator {
init_pos: index,
pos: index,
stack: Vec::new(),
tree: self.tree.borrow(),
@ -470,13 +474,13 @@ impl Threads {
}
pub fn root_set(&self, idx: usize) -> usize {
self.root_set.borrow()[idx]
self.tree.borrow()[idx].id
}
pub fn root_iter<'a>(&'a self) -> RootIterator<'a> {
RootIterator {
pos: 0,
root_set: self.root_set.borrow(),
root_tree: self.tree.borrow(),
}
}

2
ui/src/components/mail/listing/compact.rs
View File

@ -85,7 +85,7 @@ impl CompactListing {
new_cursor_pos: (0, 0, 0),
length: 0,
sort: (Default::default(), Default::default()),
subsort: (Default::default(), Default::default()),
subsort: (SortField::Subject, SortOrder::Desc),
content,
dirty: true,
unfocused: false,

50
ui/src/components/mail/view/thread.rs
View File

@ -58,20 +58,12 @@ impl ThreadView {
context: &Context,
) -> Self {
/* stack to push thread messages in order in order to pop and print them later */
let mut stack: Vec<(usize, usize)> = Vec::with_capacity(32);
let mailbox = &context.accounts[coordinates.0][coordinates.1]
.as_ref()
.unwrap();
let threads = &mailbox.collection.threads;
let thread_node = &threads.thread_nodes()[threads.root_set(coordinates.2)];
if thread_node.message().is_some() {
stack.push((0, threads.root_set(coordinates.2)));
} else {
for &c in thread_node.children().iter() {
stack.push((1, c));
}
}
let thread_iter = threads.thread_iter(coordinates.2);
let mut view = ThreadView {
dirty: true,
initiated: false,
@ -84,10 +76,12 @@ impl ThreadView {
..Default::default()
};
let mut line = 0;
let mut max_ind = 0;
while let Some((ind, idx)) = stack.pop() {
max_ind = cmp::max(max_ind, ind);
let entry = view.make_entry(context, (ind, idx, line));
for (ind, idx) in thread_iter {
let entry = if let Some(msg_idx) = threads.thread_nodes()[idx].message() {
view.make_entry((ind, idx, line), msg_idx)
} else {
continue;
};
view.entries.push(entry);
line += 1;
match expanded_idx {
@ -97,10 +91,6 @@ impl ThreadView {
}
_ => {}
}
let thread_node = &threads.thread_nodes()[idx];
for &c in thread_node.children().iter() {
stack.push((ind + 1, c));
}
}
if expanded_idx.is_none() {
view.new_expanded_pos = view.entries.len().saturating_sub(1);
@ -191,22 +181,10 @@ impl ThreadView {
view
}
fn make_entry(&mut self, context: &Context, i: (usize, usize, usize)) -> ThreadEntry {
let (ind, idx, order) = i;
let mailbox = &context.accounts[self.coordinates.0][self.coordinates.1]
.as_ref()
.unwrap();
let thread_node = &mailbox.collection.threads.thread_nodes()[idx];
let msg_idx = if let Some(i) = thread_node.message() {
i
} else {
mailbox.collection.threads.thread_nodes()[thread_node.children()[0]]
.message()
.unwrap()
};
fn make_entry(&mut self, i: (usize, usize, usize), msg_idx: EnvelopeHash) -> ThreadEntry {
let (ind, _, _) = i;
ThreadEntry {
index: (ind, idx, order),
index: i,
indentation: ind,
msg_idx,
}
@ -438,9 +416,11 @@ impl ThreadView {
let i = if let Some(i) = thread_node.message() {
i
} else {
threads.thread_nodes()[thread_node.children()[0]]
.message()
.unwrap()
let mut iter_ptr = thread_node.children()[0];
while threads.thread_nodes()[iter_ptr].message().is_none() {
iter_ptr = threads.thread_nodes()[iter_ptr].children()[0];
}
threads.thread_nodes()[iter_ptr].message().unwrap()
};
let envelope: &Envelope = &mailbox.collection[&i];