5 ## subclasses should implement:
8 class ThreadIndexMode < LineCursorMode
9 DATE_WIDTH = Time::TO_NICE_S_MAX_LEN
11 LOAD_MORE_THREAD_NUM = 20
13 HookManager.register "index-mode-size-widget", <<EOS
14 Generates the per-thread size widget for each thread.
16 thread: The message thread to be formatted.
19 HookManager.register "mark-as-spam", <<EOS
20 This hook is run when a thread is marked as spam
22 thread: The message thread being marked as spam.
25 register_keymap do |k|
26 k.add :load_threads, "Load #{LOAD_MORE_THREAD_NUM} more threads", 'M'
27 k.add_multi "Load all threads (! to confirm) :", '!' do |kk|
28 kk.add :load_all_threads, "Load all threads (may list a _lot_ of threads)", '!'
30 k.add :cancel_search, "Cancel current search", :ctrl_g
31 k.add :reload, "Refresh view", '@'
32 k.add :toggle_archived, "Toggle archived status", 'a'
33 k.add :toggle_starred, "Star or unstar all messages in thread", '*'
34 k.add :toggle_new, "Toggle new/read status of all messages in thread", 'N'
35 k.add :edit_labels, "Edit or add labels for a thread", 'l'
36 k.add :edit_message, "Edit message (drafts only)", 'e'
37 k.add :toggle_spam, "Mark/unmark thread as spam", 'S'
38 k.add :toggle_deleted, "Delete/undelete thread", 'd'
39 k.add :kill, "Kill thread (never to be seen in inbox again)", '&'
40 k.add :save, "Save changes now", '$'
41 k.add :jump_to_next_new, "Jump to next new thread", :tab
42 k.add :reply, "Reply to latest message in a thread", 'r'
43 k.add :reply_all, "Reply to all participants of the latest message in a thread", 'G'
44 k.add :forward, "Forward latest message in a thread", 'f'
45 k.add :toggle_tagged, "Tag/untag selected thread", 't'
46 k.add :toggle_tagged_all, "Tag/untag all threads", 'T'
47 k.add :tag_matching, "Tag matching threads", 'g'
48 k.add :apply_to_tagged, "Apply next command to all tagged threads", '+', '='
49 k.add :join_threads, "Force tagged threads to be joined into the same thread", '#'
50 k.add :toggle_sort, "Toggle newest first/last sort order", 'o'
51 k.add :undo, "Undo the previous action", 'u'
54 def initialize hidden_labels=[], load_thread_opts={}
56 @mutex = Mutex.new # covers the following variables:
59 @size_widget_width = nil
61 @tags = Tagger.new self
63 ## these guys, and @text and @lines, are not covered
65 @load_thread_opts = load_thread_opts
66 @hidden_labels = hidden_labels + LabelManager::HIDDEN_RESERVED_LABELS
67 @date_width = DATE_WIDTH
71 @interrupt_search = false
73 initialize_threads # defines @ts and @ts_mutex
74 update # defines @text and @lines
76 UpdateManager.register self
78 @save_thread_mutex = Mutex.new
80 @last_load_more_size = nil
81 to_load_more do |size|
82 next if @last_load_more_size == 0
83 load_threads :num => size,
84 :when_done => lambda { |num| @last_load_more_size = num }
88 def unsaved?; dirty? end
89 def lines; @text.length; end
90 def [] i; @text[i]; end
91 def contains_thread? t; @threads.include?(t) end
96 BufferManager.draw_screen
97 load_threads :num => buffer.content_height
100 ## open up a thread view window
101 def select t=nil, when_done=nil
102 t ||= cursor_thread or return
104 Redwood::reporting_thread("load messages for thread-view-mode") do
106 message = "Loading #{num.pluralize 'message body'}..."
107 BufferManager.say(message) do |sid|
108 t.each_with_index do |(m, *o), i|
110 BufferManager.say "#{message} (#{i}/#{num})", sid if t.size > 1
114 mode = ThreadViewMode.new t, @hidden_labels, self
115 BufferManager.spawn t.subj, mode
116 BufferManager.draw_screen
117 mode.jump_to_first_open
118 BufferManager.draw_screen # lame TODO: make this unnecessary
119 ## the first draw_screen is needed before topline and botline
120 ## are set, and the second to show the cursor having moved
122 update_text_for_line curpos
123 UpdateManager.relay self, :read, t.first
124 when_done.call if when_done
128 def multi_select threads
129 threads.each { |t| select t }
132 ## these two methods are called by thread-view-modes when the user
133 ## wants to view the previous/next thread without going back to
134 ## index-mode. we update the cursor as a convenience.
135 def launch_next_thread_after thread, &b
136 launch_another_thread thread, 1, &b
139 def launch_prev_thread_before thread, &b
140 launch_another_thread thread, -1, &b
143 def launch_another_thread thread, direction, &b
144 l = @lines[thread] or return
145 target_l = l + direction
146 t = @mutex.synchronize do
147 if target_l >= 0 && target_l < @threads.length
152 if t # there's a next thread
153 set_cursor_pos target_l # move out of mutex?
155 elsif b # no next thread. call the block anyways
160 def handle_single_message_labeled_update sender, m
161 ## no need to do anything different here; we don't differentiate
162 ## messages from their containing threads
163 handle_labeled_update sender, m
166 def handle_labeled_update sender, m
167 if(t = thread_containing(m))
168 l = @lines[t] or return
169 update_text_for_line l
170 elsif is_relevant?(m)
175 def handle_simple_update sender, m
176 t = thread_containing(m) or return
177 l = @lines[t] or return
178 update_text_for_line l
181 %w(read unread archived starred unstarred).each do |state|
182 define_method "handle_#{state}_update" do |*a|
183 handle_simple_update(*a)
188 def is_relevant? m; false; end
190 def handle_added_update sender, m
192 BufferManager.draw_screen
195 def handle_single_message_deleted_update sender, m
196 @ts_mutex.synchronize do
197 return unless @ts.contains? m
203 def handle_deleted_update sender, m
204 t = @ts_mutex.synchronize { @ts.thread_for m }
210 def handle_spammed_update sender, m
211 t = @ts_mutex.synchronize { @ts.thread_for m }
217 def handle_undeleted_update sender, m
226 @newest_first = !@newest_first
231 @mutex.synchronize do
232 ## let's see you do THIS in python
233 @threads = @ts.threads.select { |t| !@hidden_threads[t] }.sort_by { |t| [t.date, t.first.id] }
235 @threads = @threads.reverse
237 @size_widgets = @threads.map { |t| size_widget_for_thread t }
238 @size_widget_width = @size_widgets.max_of { |w| w.display_length }
245 return unless(t = cursor_thread)
246 message, *crap = t.find { |m, *o| m.has_label? :draft }
248 mode = ResumeMode.new message
249 BufferManager.spawn "Edit message", mode
251 BufferManager.flash "Not a draft message!"
255 ## returns an undo lambda
256 def actually_toggle_starred t
258 if t.has_label? :starred # if ANY message has a star
259 t.remove_label :starred # remove from all
260 UpdateManager.relay self, :unstarred, t.first
262 t.first.add_label :starred
263 UpdateManager.relay self, :starred, t.first
267 t.first.add_label :starred # add only to first
268 UpdateManager.relay self, :starred, t.first
270 t.remove_label :starred
271 UpdateManager.relay self, :unstarred, t.first
278 t = cursor_thread or return
279 undo = actually_toggle_starred t
280 UndoManager.register "toggling thread starred status", undo
281 update_text_for_line curpos
285 def multi_toggle_starred threads
286 UndoManager.register "toggling #{threads.size.pluralize 'thread'} starred status",
287 threads.map { |t| actually_toggle_starred t }
291 ## returns an undo lambda
292 def actually_toggle_archived t
295 if t.has_label? :inbox
296 t.remove_label :inbox
297 UpdateManager.relay self, :archived, t.first
299 thread.apply_label :inbox
300 update_text_for_line pos
301 UpdateManager.relay self,:unarchived, thread.first
305 UpdateManager.relay self, :unarchived, t.first
307 thread.remove_label :inbox
308 update_text_for_line pos
309 UpdateManager.relay self, :unarchived, thread.first
314 ## returns an undo lambda
315 def actually_toggle_spammed t
317 if t.has_label? :spam
319 add_or_unhide t.first
320 UpdateManager.relay self, :unspammed, t.first
322 thread.apply_label :spam
323 self.hide_thread thread
324 UpdateManager.relay self,:spammed, thread.first
329 UpdateManager.relay self, :spammed, t.first
331 thread.remove_label :spam
332 add_or_unhide thread.first
333 UpdateManager.relay self,:unspammed, thread.first
338 ## returns an undo lambda
339 def actually_toggle_deleted t
340 if t.has_label? :deleted
341 t.remove_label :deleted
342 add_or_unhide t.first
343 UpdateManager.relay self, :undeleted, t.first
345 t.apply_label :deleted
347 UpdateManager.relay self, :deleted, t.first
350 t.apply_label :deleted
352 UpdateManager.relay self, :deleted, t.first
354 t.remove_label :deleted
355 add_or_unhide t.first
356 UpdateManager.relay self, :undeleted, t.first
362 t = cursor_thread or return
363 undo = actually_toggle_archived t
364 UndoManager.register "deleting/undeleting thread #{t.first.id}", undo, lambda { update_text_for_line curpos }
365 update_text_for_line curpos
368 def multi_toggle_archived threads
369 undos = threads.map { |t| actually_toggle_archived t }
370 UndoManager.register "deleting/undeleting #{threads.size.pluralize 'thread'}", undos, lambda { regen_text }
375 t = cursor_thread or return
376 t.toggle_label :unread
377 update_text_for_line curpos
381 def multi_toggle_new threads
382 threads.each { |t| t.toggle_label :unread }
386 def multi_toggle_tagged threads
387 @mutex.synchronize { @tags.drop_all_tags }
392 ## this command has no non-tagged form. as a convenience, allow this
393 ## command to be applied to tagged threads without hitting ';'.
394 @tags.apply_to_tagged :join_threads
397 def multi_join_threads threads
398 @ts.join_threads threads or return
399 @tags.drop_all_tags # otherwise we have tag pointers to invalid threads!
404 n = @mutex.synchronize do
405 ((curpos + 1) ... lines).find { |i| @threads[i].has_label? :unread } ||
406 (0 ... curpos).find { |i| @threads[i].has_label? :unread }
409 ## jump there if necessary
410 jump_to_line n unless n >= topline && n < botline
413 BufferManager.flash "No new messages"
418 t = cursor_thread or return
419 multi_toggle_spam [t]
420 HookManager.run("mark-as-spam", :thread => t)
423 ## both spam and deleted have the curious characteristic that you
424 ## always want to hide the thread after either applying or removing
425 ## that label. in all thread-index-views except for
426 ## label-search-results-mode, when you mark a message as spam or
427 ## deleted, you want it to disappear immediately; in LSRM, you only
428 ## see deleted or spam emails, and when you undelete or unspam them
429 ## you also want them to disappear immediately.
430 def multi_toggle_spam threads
431 undos = threads.map { |t| actually_toggle_spammed t }
432 UndoManager.register "marking/unmarking #{threads.size.pluralize 'thread'} as spam",
433 undos, lambda { regen_text }
438 t = cursor_thread or return
439 multi_toggle_deleted [t]
442 ## see comment for multi_toggle_spam
443 def multi_toggle_deleted threads
444 undos = threads.map { |t| actually_toggle_deleted t }
445 UndoManager.register "deleting/undeleting #{threads.size.pluralize 'thread'}",
446 undos, lambda { regen_text }
451 t = cursor_thread or return
455 ## m-m-m-m-MULTI-KILL
456 def multi_kill threads
457 UndoManager.register "killing #{threads.size.pluralize 'thread'}" do
459 t.remove_label :killed
460 add_or_unhide t.first
466 t.apply_label :killed
471 BufferManager.flash "#{threads.size.pluralize 'thread'} killed."
474 def save background=true
476 Redwood::reporting_thread("saving thread") { actually_save }
483 @save_thread_mutex.synchronize do
484 BufferManager.say("Saving contacts...") { ContactManager.instance.save }
485 dirty_threads = @mutex.synchronize { (@threads + @hidden_threads.keys).select { |t| t.dirty? } }
486 next if dirty_threads.empty?
488 BufferManager.say("Saving threads...") do |say_id|
489 dirty_threads.each_with_index do |t, i|
490 BufferManager.say "Saving modified thread #{i + 1} of #{dirty_threads.length}...", say_id
498 UpdateManager.unregister self
502 BufferManager.clear @mbid if @mbid
503 sleep 0.1 # TODO: necessary?
504 BufferManager.erase_flash
511 t = cursor_thread or return
512 @mutex.synchronize { @tags.toggle_tag_for t }
513 update_text_for_line curpos
517 def toggle_tagged_all
518 @mutex.synchronize { @threads.each { |t| @tags.toggle_tag_for t } }
523 query = BufferManager.ask :search, "tag threads matching (regex): "
524 return if query.nil? || query.empty?
527 rescue RegexpError => e
528 BufferManager.flash "error interpreting '#{query}': #{e.message}"
531 @mutex.synchronize { @threads.each { |t| @tags.tag t if thread_matches?(t, query) } }
535 def apply_to_tagged; @tags.apply_to_tagged; end
538 thread = cursor_thread or return
539 speciall = (@hidden_labels + LabelManager::RESERVED_LABELS).uniq
541 old_labels = thread.labels
544 keepl, modifyl = thread.labels.partition { |t| speciall.member? t }
546 user_labels = BufferManager.ask_for_labels :label, "Labels for thread: ", modifyl, @hidden_labels
547 return unless user_labels
549 thread.labels = Set.new(keepl) + user_labels
550 user_labels.each { |l| LabelManager << l }
551 update_text_for_line curpos
553 UndoManager.register "labeling thread" do
554 thread.labels = old_labels
555 update_text_for_line pos
556 UpdateManager.relay self, :labeled, thread.first
559 UpdateManager.relay self, :labeled, thread.first
562 def multi_edit_labels threads
563 user_labels = BufferManager.ask_for_labels :labels, "Add/remove labels (use -label to remove): ", [], @hidden_labels
564 return unless user_labels
566 user_labels.map! { |l| (l.to_s =~ /^-/)? [l.to_s.gsub(/^-?/, '').to_sym, true] : [l, false] }
567 hl = user_labels.select { |(l,_)| @hidden_labels.member? l }
569 BufferManager.flash "'#{hl}' is a reserved label!"
573 old_labels = threads.map { |t| t.labels.dup }
576 user_labels.each do |(l, to_remove)|
584 UpdateManager.relay self, :labeled, t.first
589 UndoManager.register "labeling #{threads.size.pluralize 'thread'}" do
590 threads.zip(old_labels).map do |t, old_labels|
591 t.labels = old_labels
592 UpdateManager.relay self, :labeled, t.first
598 def reply type_arg=nil
599 t = cursor_thread or return
601 return if m.nil? # probably won't happen
603 mode = ReplyMode.new m, type_arg
604 BufferManager.spawn "Reply to #{m.subj}", mode
607 def reply_all; reply :all; end
610 t = cursor_thread or return
612 return if m.nil? # probably won't happen
614 ForwardMode.spawn_nicely :message => m
617 def load_n_threads_background n=LOAD_MORE_THREAD_NUM, opts={}
618 return if @load_thread # todo: wrap in mutex
619 @load_thread = Redwood::reporting_thread("load threads for thread-index-mode") do
620 num = load_n_threads n, opts
621 opts[:when_done].call(num) if opts[:when_done]
626 ## TODO: figure out @ts_mutex in this method
627 def load_n_threads n=LOAD_MORE_THREAD_NUM, opts={}
628 @interrupt_search = false
629 @mbid = BufferManager.say "Searching for threads..."
632 ts_to_load = ts_to_load + @ts.size unless n == -1 # -1 means all threads
635 last_update = Time.now
636 @ts.load_n_threads(ts_to_load, opts) do |i|
637 if (Time.now - last_update) >= 0.25
638 BufferManager.say "Loaded #{i.pluralize 'thread'}...", @mbid
640 BufferManager.draw_screen
641 last_update = Time.now
644 break if @interrupt_search
646 @ts.threads.each { |th| th.labels.each { |l| LabelManager << l } }
649 BufferManager.clear @mbid
651 BufferManager.draw_screen
654 ignore_concurrent_calls :load_n_threads
660 "line #{curpos + 1} of #{l} #{dirty? ? '*modified*' : ''}"
665 @interrupt_search = true
669 load_threads :num => -1
672 def load_threads opts={}
674 n = ThreadIndexMode::LOAD_MORE_THREAD_NUM
682 myopts = @load_thread_opts.merge({ :when_done => (lambda do |num|
683 opts[:when_done].call(num) if opts[:when_done]
686 BufferManager.flash "Found #{num.pluralize 'thread'}."
688 BufferManager.flash "No matches."
692 if opts[:background] || opts[:background].nil?
693 load_n_threads_background n, myopts
695 load_n_threads n, myopts
698 ignore_concurrent_calls :load_threads
700 def resize rows, cols
708 @ts_mutex.synchronize do
709 if (is_relevant?(m) || @ts.is_relevant?(m)) && !@ts.contains?(m)
710 @ts.load_thread_for_message m, @load_thread_opts
713 @hidden_threads.delete @ts.thread_for(m)
719 def thread_containing m; @ts_mutex.synchronize { @ts.thread_for m } end
721 ## used to tag threads by query. this can be made a lot more sophisticated,
722 ## but for right now we'll do the obvious this.
723 def thread_matches? t, query
724 t.subj =~ query || t.snippet =~ query || t.participants.any? { |x| x.longname =~ query }
727 def size_widget_for_thread t
728 HookManager.run("index-mode-size-widget", :thread => t) || default_size_widget_for(t)
731 def cursor_thread; @mutex.synchronize { @threads[curpos] }; end
740 @mutex.synchronize do
741 i = @threads.index(t) or return
742 raise "already hidden" if @hidden_threads[t]
743 @hidden_threads[t] = true
745 @size_widgets.delete_at i
750 def update_text_for_line l
751 return unless l # not sure why this happens, but it does, occasionally
755 @mutex.synchronize do
756 @size_widgets[l] = size_widget_for_thread @threads[l]
758 ## if the widget size has increased, we need to redraw everyone
759 need_update = @size_widgets[l].size > @size_widget_width
765 @text[l] = text_for_thread_at l
766 buffer.mark_dirty if buffer
771 threads = @mutex.synchronize { @threads }
772 @text = threads.map_with_index { |t, i| text_for_thread_at i }
773 @lines = threads.map_with_index { |t, i| [t, i] }.to_h
774 buffer.mark_dirty if buffer
777 def authors; map { |m, *o| m.from if m }.compact.uniq; end
779 def author_names_and_newness_for_thread t, limit=nil
784 break if limit and authors.size >= limit
787 if AccountManager.is_account?(m.from)
789 elsif t.authors.size == 1
795 new[name] ||= m.has_label?(:unread)
799 authors.to_a.map { |a| [a, new[a]] }
803 def text_for_thread_at line
804 t, size_widget = @mutex.synchronize { [@threads[line], @size_widgets[line]] }
806 date = t.date.to_nice_s
808 starred = t.has_label? :starred
810 ## format the from column
812 ann = author_names_and_newness_for_thread t, AUTHOR_LIMIT
814 ann.each_with_index do |(name, newness), i|
815 break if cur_width >= from_width
816 last = i == ann.length - 1
819 if cur_width + name.display_length > from_width
820 name[0 ... (from_width - cur_width - 1)] + "."
821 elsif cur_width + name.display_length == from_width
822 name[0 ... (from_width - cur_width)]
825 name[0 ... (from_width - cur_width)]
827 name[0 ... (from_width - cur_width - 1)] + ","
831 cur_width += abbrev.display_length
833 if last && from_width > cur_width
834 abbrev += " " * (from_width - cur_width)
837 from << [(newness ? :index_new_color : (starred ? :index_starred_color : :index_old_color)), abbrev]
840 dp = t.direct_participants.any? { |p| AccountManager.is_account? p }
841 p = dp || t.participants.any? { |p| AccountManager.is_account? p }
844 if t.has_label?(:draft)
846 elsif t.has_label?(:unread)
854 snippet = t.snippet + (t.snippet.empty? ? "" : "...")
856 size_widget_text = sprintf "%#{ @size_widget_width}s", size_widget
859 [:tagged_color, @tags.tagged?(t) ? ">" : " "],
860 [:none, sprintf("%#{@date_width}s", date)],
861 (starred ? [:starred_color, "*"] : [:none, " "]),
865 [subj_color, size_widget_text],
866 [:to_me_color, t.labels.member?(:attachment) ? "@" : " "],
867 [:to_me_color, dp ? ">" : (p ? '+' : " ")],
869 (t.labels - @hidden_labels).map { |label| [:label_color, "#{label} "] } +
871 [subj_color, t.subj + (t.subj.empty? ? "" : " ")],
872 [:snippet_color, snippet],
876 def dirty?; @mutex.synchronize { (@hidden_threads.keys + @threads).any? { |t| t.dirty? } } end
880 def default_size_widget_for t
890 [(buffer.content_width.to_f * 0.2).to_i, MIN_FROM_WIDTH].max
893 def initialize_threads
894 @ts = ThreadSet.new Index.instance, $config[:thread_by_subject]
895 @ts_mutex = Mutex.new