sup 0.19.0

data/lib/sup/modes/search_results_mode.rb

@@ -0,0 +1,59 @@
+module Redwood
+
+class SearchResultsMode < ThreadIndexMode
+  def initialize query
+    @query = query
+    super [], query
+  end
+
+  register_keymap do |k|
+    k.add :refine_search, "Refine search", '|'
+    k.add :save_search, "Save search", '%'
+  end
+
+  def refine_search
+    text = BufferManager.ask :search, "refine query: ", (@query[:text] + " ")
+    return unless text && text !~ /^\s*$/
+    SearchResultsMode.spawn_from_query text
+  end
+
+  def save_search
+    name = BufferManager.ask :save_search, "Name this search: "
+    return unless name && name !~ /^\s*$/
+    name.strip!
+    unless SearchManager.valid_name? name
+      BufferManager.flash "Not saved: " + SearchManager.name_format_hint
+      return
+    end
+    if SearchManager.all_searches.include? name
+      BufferManager.flash "Not saved: \"#{name}\" already exists"
+      return
+    end
+    BufferManager.flash "Search saved as \"#{name}\"" if SearchManager.add name, @query[:text].strip
+  end
+
+  ## a proper is_relevant? method requires some way of asking the index
+  ## if an in-memory object satisfies a query. i'm not sure how to do
+  ## that yet. in the worst case i can make an in-memory index, add
+  ## the message, and search against it to see if i have > 0 results,
+  ## but that seems pretty insane.
+
+  def self.spawn_from_query text
+    begin
+      if SearchManager.predefined_queries.has_key? text
+        query = SearchManager.predefined_queries[text]
+      else
+        query = Index.parse_query(text)
+      end
+      return unless query
+      short_text = text.length < 20 ? text : text[0 ... 20] + "..."
+      mode = SearchResultsMode.new query
+      BufferManager.spawn "search: \"#{short_text}\"", mode
+      mode.load_threads :num => mode.buffer.content_height
+    rescue Index::ParseError => e
+      BufferManager.flash "Problem: #{e.message}!"
+    end
+  end
+end
+
+end

data/lib/sup/modes/text_mode.rb

@@ -0,0 +1,76 @@
+module Redwood
+
+class TextMode < ScrollMode
+  attr_reader :text
+  register_keymap do |k|
+    k.add :save_to_disk, "Save to disk", 's'
+    k.add :pipe, "Pipe to process", '|'
+  end
+
+  def initialize text="", filename=nil
+    @text = text
+    @filename = filename
+    update_lines
+    buffer.mark_dirty if buffer
+    super()
+  end
+
+  def save_to_disk
+    fn = BufferManager.ask_for_filename :filename, "Save to file: ", @filename
+    save_to_file(fn) { |f| f.puts text } if fn
+  end
+
+  def pipe
+    command = BufferManager.ask(:shell, "pipe command: ")
+    return if command.nil? || command.empty?
+
+    output = pipe_to_process(command) do |stream|
+      @text.each { |l| stream.puts l }
+    end
+
+    if output
+      BufferManager.spawn "Output of '#{command}'", TextMode.new(output.ascii)
+    else
+      BufferManager.flash "'#{command}' done!"
+    end
+  end
+
+  def text= t
+    @text = t
+    update_lines
+    if buffer
+      ensure_mode_validity
+      buffer.mark_dirty
+    end
+  end
+
+  def << line
+    @lines = [0] if @text.empty?
+    @text << line.fix_encoding!
+    @lines << @text.length
+    if buffer
+      ensure_mode_validity
+      buffer.mark_dirty
+    end
+  end
+
+  def lines
+    @lines.length - 1
+  end
+
+  def [] i
+    return nil unless i < @lines.length
+    @text[@lines[i] ... (i + 1 < @lines.length ? @lines[i + 1] - 1 : @text.length)].normalize_whitespace
+#    (@lines[i] ... (i + 1 < @lines.length ? @lines[i + 1] - 1 : @text.length)).inspect
+  end
+
+private
+
+  def update_lines
+    pos = @text.find_all_positions("\n")
+    pos.push @text.length unless pos.last == @text.length - 1
+    @lines = [0] + pos.map { |x| x + 1 }
+  end
+end
+
+end

data/lib/sup/modes/thread_index_mode.rb

@@ -0,0 +1,1033 @@
+require 'set'
+
+module Redwood
+
+## subclasses should implement:
+## - is_relevant?
+
+class ThreadIndexMode < LineCursorMode
+  DATE_WIDTH = Time::TO_NICE_S_MAX_LEN
+  MIN_FROM_WIDTH = 15
+  LOAD_MORE_THREAD_NUM = 20
+
+  HookManager.register "index-mode-size-widget", <<EOS
+Generates the per-thread size widget for each thread.
+Variables:
+  thread: The message thread to be formatted.
+EOS
+
+  HookManager.register "index-mode-date-widget", <<EOS
+Generates the per-thread date widget for each thread.
+Variables:
+  thread: The message thread to be formatted.
+EOS
+
+  HookManager.register "mark-as-spam", <<EOS
+This hook is run when a thread is marked as spam
+Variables:
+  thread: The message thread being marked as spam.
+EOS
+
+  register_keymap do |k|
+    k.add :load_threads, "Load #{LOAD_MORE_THREAD_NUM} more threads", 'M'
+    k.add_multi "Load all threads (! to confirm) :", '!' do |kk|
+      kk.add :load_all_threads, "Load all threads (may list a _lot_ of threads)", '!'
+    end
+    k.add :read_and_archive, "Archive thread (remove from inbox) and mark read", 'A'
+    k.add :cancel_search, "Cancel current search", :ctrl_g
+    k.add :reload, "Refresh view", '@'
+    k.add :toggle_archived, "Toggle archived status", 'a'
+    k.add :toggle_starred, "Star or unstar all messages in thread", '*'
+    k.add :toggle_new, "Toggle new/read status of all messages in thread", 'N'
+    k.add :edit_labels, "Edit or add labels for a thread", 'l'
+    k.add :edit_message, "Edit message (drafts only)", 'e'
+    k.add :toggle_spam, "Mark/unmark thread as spam", 'S'
+    k.add :toggle_deleted, "Delete/undelete thread", 'd'
+    k.add :kill, "Kill thread (never to be seen in inbox again)", '&'
+    k.add :flush_index, "Flush all changes now", '$'
+    k.add :jump_to_next_new, "Jump to next new thread", :tab
+    k.add :reply, "Reply to latest message in a thread", 'r'
+    k.add :reply_all, "Reply to all participants of the latest message in a thread", 'G'
+    k.add :forward, "Forward latest message in a thread", 'f'
+    k.add :toggle_tagged, "Tag/untag selected thread", 't'
+    k.add :toggle_tagged_all, "Tag/untag all threads", 'T'
+    k.add :tag_matching, "Tag matching threads", 'g'
+    k.add :apply_to_tagged, "Apply next command to all tagged threads", '+', '='
+    k.add :join_threads, "Force tagged threads to be joined into the same thread", '#'
+    k.add :undo, "Undo the previous action", 'u'
+  end
+
+  def initialize hidden_labels=[], load_thread_opts={}
+    super()
+    @mutex = Mutex.new # covers the following variables:
+    @threads = []
+    @hidden_threads = {}
+    @size_widget_width = nil
+    @size_widgets = []
+    @date_widget_width = nil
+    @date_widgets = []
+    @tags = Tagger.new self
+
+    ## these guys, and @text and @lines, are not covered
+    @load_thread = nil
+    @load_thread_opts = load_thread_opts
+    @hidden_labels = hidden_labels + LabelManager::HIDDEN_RESERVED_LABELS
+    @date_width = DATE_WIDTH
+
+    @interrupt_search = false
+
+    initialize_threads # defines @ts and @ts_mutex
+    update # defines @text and @lines
+
+    UpdateManager.register self
+
+    @save_thread_mutex = Mutex.new
+
+    @last_load_more_size = nil
+    to_load_more do |size|
+      next if @last_load_more_size == 0
+      load_threads :num => size,
+                   :when_done => lambda { |num| @last_load_more_size = num }
+    end
+  end
+
+  def unsaved?; dirty? end
+  def lines; @text.length; end
+  def [] i; @text[i]; end
+  def contains_thread? t; @threads.include?(t) end
+
+  def reload
+    drop_all_threads
+    UndoManager.clear
+    BufferManager.draw_screen
+    load_threads :num => buffer.content_height
+  end
+
+  ## open up a thread view window
+  def select t=nil, when_done=nil
+    t ||= cursor_thread or return
+
+    Redwood::reporting_thread("load messages for thread-view-mode") do
+      num = t.size
+      message = "Loading #{num.pluralize 'message body'}..."
+      BufferManager.say(message) do |sid|
+        t.each_with_index do |(m, *_), i|
+          next unless m
+          BufferManager.say "#{message} (#{i}/#{num})", sid if t.size > 1
+          m.load_from_source!
+        end
+      end
+      mode = ThreadViewMode.new t, @hidden_labels, self
+      BufferManager.spawn t.subj, mode
+      BufferManager.draw_screen
+      mode.jump_to_first_open if $config[:jump_to_open_message]
+      BufferManager.draw_screen # lame TODO: make this unnecessary
+      ## the first draw_screen is needed before topline and botline
+      ## are set, and the second to show the cursor having moved
+
+      t.remove_label :unread
+      Index.save_thread t
+
+      update_text_for_line curpos
+      UpdateManager.relay self, :read, t.first
+      when_done.call if when_done
+    end
+  end
+
+  def multi_select threads
+    threads.each { |t| select t }
+  end
+
+  ## these two methods are called by thread-view-modes when the user
+  ## wants to view the previous/next thread without going back to
+  ## index-mode. we update the cursor as a convenience.
+  def launch_next_thread_after thread, &b
+    launch_another_thread thread, 1, &b
+  end
+
+  def launch_prev_thread_before thread, &b
+    launch_another_thread thread, -1, &b
+  end
+
+  def launch_another_thread thread, direction, &b
+    l = @lines[thread] or return
+    target_l = l + direction
+    t = @mutex.synchronize do
+      if target_l >= 0 && target_l < @threads.length
+        @threads[target_l]
+      end
+    end
+
+    if t # there's a next thread
+      set_cursor_pos target_l # move out of mutex?
+      select t, b
+    elsif b # no next thread. call the block anyways
+      b.call
+    end
+  end
+
+  def handle_single_message_labeled_update sender, m
+    ## no need to do anything different here; we don't differentiate
+    ## messages from their containing threads
+    handle_labeled_update sender, m
+  end
+
+  def handle_labeled_update sender, m
+    if(t = thread_containing(m))
+      l = @lines[t] or return
+      update_text_for_line l
+    elsif is_relevant?(m)
+      add_or_unhide m
+    end
+  end
+
+  def handle_simple_update sender, m
+    t = thread_containing(m) or return
+    l = @lines[t] or return
+    update_text_for_line l
+  end
+
+  %w(read unread archived starred unstarred).each do |state|
+    define_method "handle_#{state}_update" do |*a|
+      handle_simple_update(*a)
+    end
+  end
+
+  ## overwrite me!
+  def is_relevant? m; false; end
+
+  def handle_added_update sender, m
+    add_or_unhide m
+    BufferManager.draw_screen
+  end
+
+  def handle_updated_update sender, m
+    t = thread_containing(m) or return
+    l = @lines[t] or return
+    @ts_mutex.synchronize do
+      @ts.delete_message m
+      @ts.add_message m
+    end
+    Index.save_thread t, sync_back = false
+    update_text_for_line l
+  end
+
+  def handle_location_deleted_update sender, m
+    t = thread_containing(m)
+    delete_thread t if t and t.first.id == m.id
+    @ts_mutex.synchronize do
+      @ts.delete_message m if t
+    end
+    update
+  end
+
+  def handle_single_message_deleted_update sender, m
+    @ts_mutex.synchronize do
+      return unless @ts.contains? m
+      @ts.remove_id m.id
+    end
+    update
+  end
+
+  def handle_deleted_update sender, m
+    t = @ts_mutex.synchronize { @ts.thread_for m }
+    return unless t
+    hide_thread t
+    update
+  end
+
+  def handle_killed_update sender, m
+    t = @ts_mutex.synchronize { @ts.thread_for m }
+    return unless t
+    hide_thread t
+    update
+  end
+
+  def handle_spammed_update sender, m
+    t = @ts_mutex.synchronize { @ts.thread_for m }
+    return unless t
+    hide_thread t
+    update
+  end
+
+  def handle_undeleted_update sender, m
+    add_or_unhide m
+  end
+
+  def handle_unkilled_update sender, m
+    add_or_unhide m
+  end
+
+  def undo
+    UndoManager.undo
+  end
+
+  def update
+    old_cursor_thread = cursor_thread
+    @mutex.synchronize do
+      ## let's see you do THIS in python
+      @threads = @ts.threads.select { |t| !@hidden_threads.member?(t) }.select(&:has_message?).sort_by(&:sort_key)
+      @size_widgets = @threads.map { |t| size_widget_for_thread t }
+      @size_widget_width = @size_widgets.max_of { |w| w.display_length }
+      @date_widgets = @threads.map { |t| date_widget_for_thread t }
+      @date_widget_width = @date_widgets.max_of { |w| w.display_length }
+    end
+    set_cursor_pos @threads.index(old_cursor_thread)||curpos
+
+    regen_text
+  end
+
+  def edit_message
+    return unless(t = cursor_thread)
+    message, *_ = t.find { |m, *o| m.has_label? :draft }
+    if message
+      mode = ResumeMode.new message
+      BufferManager.spawn "Edit message", mode
+    else
+      BufferManager.flash "Not a draft message!"
+    end
+  end
+
+  ## returns an undo lambda
+  def actually_toggle_starred t
+    if t.has_label? :starred # if ANY message has a star
+      t.remove_label :starred # remove from all
+      UpdateManager.relay self, :unstarred, t.first
+      lambda do
+        t.first.add_label :starred
+        UpdateManager.relay self, :starred, t.first
+        regen_text
+      end
+    else
+      t.first.add_label :starred # add only to first
+      UpdateManager.relay self, :starred, t.first
+      lambda do
+        t.remove_label :starred
+        UpdateManager.relay self, :unstarred, t.first
+        regen_text
+      end
+    end
+  end
+
+  def toggle_starred
+    t = cursor_thread or return
+    undo = actually_toggle_starred t
+    UndoManager.register "toggling thread starred status", undo, lambda { Index.save_thread t }
+    update_text_for_line curpos
+    cursor_down
+    Index.save_thread t
+  end
+
+  def multi_toggle_starred threads
+    UndoManager.register "toggling #{threads.size.pluralize 'thread'} starred status",
+      threads.map { |t| actually_toggle_starred t },
+      lambda { threads.each { |t| Index.save_thread t } }
+    regen_text
+    threads.each { |t| Index.save_thread t }
+  end
+
+  ## returns an undo lambda
+  def actually_toggle_archived t
+    thread = t
+    pos = curpos
+    if t.has_label? :inbox
+      t.remove_label :inbox
+      UpdateManager.relay self, :archived, t.first
+      lambda do
+        thread.apply_label :inbox
+        update_text_for_line pos
+        UpdateManager.relay self,:unarchived, thread.first
+      end
+    else
+      t.apply_label :inbox
+      UpdateManager.relay self, :unarchived, t.first
+      lambda do
+        thread.remove_label :inbox
+        update_text_for_line pos
+        UpdateManager.relay self, :unarchived, thread.first
+      end
+    end
+  end
+
+  ## returns an undo lambda
+  def actually_toggle_spammed t
+    thread = t
+    if t.has_label? :spam
+      t.remove_label :spam
+      add_or_unhide t.first
+      UpdateManager.relay self, :unspammed, t.first
+      lambda do
+        thread.apply_label :spam
+        self.hide_thread thread
+        UpdateManager.relay self,:spammed, thread.first
+      end
+    else
+      t.apply_label :spam
+      hide_thread t
+      UpdateManager.relay self, :spammed, t.first
+      lambda do
+        thread.remove_label :spam
+        add_or_unhide thread.first
+        UpdateManager.relay self,:unspammed, thread.first
+      end
+    end
+  end
+
+  ## returns an undo lambda
+  def actually_toggle_deleted t
+    if t.has_label? :deleted
+      t.remove_label :deleted
+      add_or_unhide t.first
+      UpdateManager.relay self, :undeleted, t.first
+      lambda do
+        t.apply_label :deleted
+        hide_thread t
+        UpdateManager.relay self, :deleted, t.first
+      end
+    else
+      t.apply_label :deleted
+      hide_thread t
+      UpdateManager.relay self, :deleted, t.first
+      lambda do
+        t.remove_label :deleted
+        add_or_unhide t.first
+        UpdateManager.relay self, :undeleted, t.first
+      end
+    end
+  end
+
+  def toggle_archived
+    t = cursor_thread or return
+    undo = actually_toggle_archived t
+    UndoManager.register "deleting/undeleting thread #{t.first.id}", undo, lambda { update_text_for_line curpos },
+                         lambda { Index.save_thread t }
+    update_text_for_line curpos
+    Index.save_thread t
+  end
+
+  def multi_toggle_archived threads
+    undos = threads.map { |t| actually_toggle_archived t }
+    UndoManager.register "deleting/undeleting #{threads.size.pluralize 'thread'}", undos, lambda { regen_text },
+                         lambda { threads.each { |t| Index.save_thread t } }
+    regen_text
+    threads.each { |t| Index.save_thread t }
+  end
+
+  def toggle_new
+    t = cursor_thread or return
+    t.toggle_label :unread
+    update_text_for_line curpos
+    cursor_down
+    Index.save_thread t
+  end
+
+  def multi_toggle_new threads
+    threads.each { |t| t.toggle_label :unread }
+    regen_text
+    threads.each { |t| Index.save_thread t }
+  end
+
+  def multi_toggle_tagged threads
+    @mutex.synchronize { @tags.drop_all_tags }
+    regen_text
+  end
+
+  def join_threads
+    ## this command has no non-tagged form. as a convenience, allow this
+    ## command to be applied to tagged threads without hitting ';'.
+    @tags.apply_to_tagged :join_threads
+  end
+
+  def multi_join_threads threads
+    @ts.join_threads threads or return
+    threads.each { |t| Index.save_thread t }
+    @tags.drop_all_tags # otherwise we have tag pointers to invalid threads!
+    update
+  end
+
+  def jump_to_next_new
+    n = @mutex.synchronize do
+      ((curpos + 1) ... lines).find { |i| @threads[i].has_label? :unread } ||
+        (0 ... curpos).find { |i| @threads[i].has_label? :unread }
+    end
+    if n
+      ## jump there if necessary
+      jump_to_line n unless n >= topline && n < botline
+      set_cursor_pos n
+    else
+      BufferManager.flash "No new messages."
+    end
+  end
+
+  def toggle_spam
+    t = cursor_thread or return
+    multi_toggle_spam [t]
+  end
+
+  ## both spam and deleted have the curious characteristic that you
+  ## always want to hide the thread after either applying or removing
+  ## that label. in all thread-index-views except for
+  ## label-search-results-mode, when you mark a message as spam or
+  ## deleted, you want it to disappear immediately; in LSRM, you only
+  ## see deleted or spam emails, and when you undelete or unspam them
+  ## you also want them to disappear immediately.
+  def multi_toggle_spam threads
+    undos = threads.map { |t| actually_toggle_spammed t }
+    threads.each { |t| HookManager.run("mark-as-spam", :thread => t) }
+    UndoManager.register "marking/unmarking  #{threads.size.pluralize 'thread'} as spam",
+                         undos, lambda { regen_text }, lambda { threads.each { |t| Index.save_thread t } }
+    regen_text
+    threads.each { |t| Index.save_thread t }
+  end
+
+  def toggle_deleted
+    t = cursor_thread or return
+    multi_toggle_deleted [t]
+  end
+
+  ## see comment for multi_toggle_spam
+  def multi_toggle_deleted threads
+    undos = threads.map { |t| actually_toggle_deleted t }
+    UndoManager.register "deleting/undeleting #{threads.size.pluralize 'thread'}",
+                         undos, lambda { regen_text }, lambda { threads.each { |t| Index.save_thread t } }
+    regen_text
+    threads.each { |t| Index.save_thread t }
+  end
+
+  def kill
+    t = cursor_thread or return
+    multi_kill [t]
+  end
+
+  def flush_index
+    @flush_id = BufferManager.say "Flushing index..."
+    Index.save_index
+    BufferManager.clear @flush_id
+  end
+
+  ## m-m-m-m-MULTI-KILL
+  def multi_kill threads
+    UndoManager.register "killing/unkilling #{threads.size.pluralize 'threads'}" do
+      threads.each do |t|
+        if t.toggle_label :killed
+          add_or_unhide t.first
+        else
+          hide_thread t
+        end
+      end.each do |t|
+        UpdateManager.relay self, :labeled, t.first
+        Index.save_thread t
+      end
+      regen_text
+    end
+
+    threads.each do |t|
+      if t.toggle_label :killed
+        hide_thread t
+      else
+        add_or_unhide t.first
+      end
+    end.each do |t|
+      # send 'labeled'... this might be more specific
+      UpdateManager.relay self, :labeled, t.first
+      Index.save_thread t
+    end
+
+    killed, unkilled = threads.partition { |t| t.has_label? :killed }.map(&:size)
+    BufferManager.flash "#{killed.pluralize 'thread'} killed, #{unkilled} unkilled"
+    regen_text
+  end
+
+  def cleanup
+    UpdateManager.unregister self
+
+    if @load_thread
+      @load_thread.kill
+      BufferManager.clear @mbid if @mbid
+      sleep 0.1 # TODO: necessary?
+      BufferManager.erase_flash
+    end
+    dirty_threads = @mutex.synchronize { (@threads + @hidden_threads.keys).select { |t| t.dirty? } }
+    fail "dirty threads remain" unless dirty_threads.empty?
+    super
+  end
+
+  def toggle_tagged
+    t = cursor_thread or return
+    @mutex.synchronize { @tags.toggle_tag_for t }
+    update_text_for_line curpos
+    cursor_down
+  end
+
+  def toggle_tagged_all
+    @mutex.synchronize { @threads.each { |t| @tags.toggle_tag_for t } }
+    regen_text
+  end
+
+  def tag_matching
+    query = BufferManager.ask :search, "tag threads matching (regex): "
+    return if query.nil? || query.empty?
+    query = begin
+      /#{query}/i
+    rescue RegexpError => e
+      BufferManager.flash "error interpreting '#{query}': #{e.message}"
+      return
+    end
+    @mutex.synchronize { @threads.each { |t| @tags.tag t if thread_matches?(t, query) } }
+    regen_text
+  end
+
+  def apply_to_tagged; @tags.apply_to_tagged; end
+
+  def edit_labels
+    thread = cursor_thread or return
+    speciall = (@hidden_labels + LabelManager::RESERVED_LABELS).uniq
+
+    old_labels = thread.labels
+    pos = curpos
+
+    keepl, modifyl = thread.labels.partition { |t| speciall.member? t }
+
+    user_labels = BufferManager.ask_for_labels :label, "Labels for thread: ", modifyl.sort_by {|x| x.to_s}, @hidden_labels
+    return unless user_labels
+
+    thread.labels = Set.new(keepl) + user_labels
+    user_labels.each { |l| LabelManager << l }
+    update_text_for_line curpos
+
+    UndoManager.register "labeling thread" do
+      thread.labels = old_labels
+      update_text_for_line pos
+      UpdateManager.relay self, :labeled, thread.first
+      Index.save_thread thread
+    end
+
+    UpdateManager.relay self, :labeled, thread.first
+    Index.save_thread thread
+  end
+
+  def multi_edit_labels threads
+    user_labels = BufferManager.ask_for_labels :labels, "Add/remove labels (use -label to remove): ", [], @hidden_labels
+    return unless user_labels
+
+    user_labels.map! { |l| (l.to_s =~ /^-/)? [l.to_s.gsub(/^-?/, '').to_sym, true] : [l, false] }
+    hl = user_labels.select { |(l,_)| @hidden_labels.member? l }
+    unless hl.empty?
+      BufferManager.flash "'#{hl}' is a reserved label!"
+      return
+    end
+
+    old_labels = threads.map { |t| t.labels.dup }
+
+    threads.each do |t|
+      user_labels.each do |(l, to_remove)|
+        if to_remove
+          t.remove_label l
+        else
+          t.apply_label l
+          LabelManager << l
+        end
+      end
+      UpdateManager.relay self, :labeled, t.first
+    end
+
+    regen_text
+
+    UndoManager.register "labeling #{threads.size.pluralize 'thread'}" do
+      threads.zip(old_labels).map do |t, old_labels|
+        t.labels = old_labels
+        UpdateManager.relay self, :labeled, t.first
+        Index.save_thread t
+      end
+      regen_text
+    end
+
+    threads.each { |t| Index.save_thread t }
+  end
+
+  def reply type_arg=nil
+    t = cursor_thread or return
+    m = t.latest_message
+    return if m.nil? # probably won't happen
+    m.load_from_source!
+    mode = ReplyMode.new m, type_arg
+    BufferManager.spawn "Reply to #{m.subj}", mode
+  end
+
+  def reply_all; reply :all; end
+
+  def forward
+    t = cursor_thread or return
+    m = t.latest_message
+    return if m.nil? # probably won't happen
+    m.load_from_source!
+    ForwardMode.spawn_nicely :message => m
+  end
+
+  def load_n_threads_background n=LOAD_MORE_THREAD_NUM, opts={}
+    return if @load_thread # todo: wrap in mutex
+    @load_thread = Redwood::reporting_thread("load threads for thread-index-mode") do
+      num = load_n_threads n, opts
+      opts[:when_done].call(num) if opts[:when_done]
+      @load_thread = nil
+    end
+  end
+
+  ## TODO: figure out @ts_mutex in this method
+  def load_n_threads n=LOAD_MORE_THREAD_NUM, opts={}
+    @interrupt_search = false
+    @mbid = BufferManager.say "Searching for threads..."
+
+    ts_to_load = n
+    ts_to_load = ts_to_load + @ts.size unless n == -1 # -1 means all threads
+
+    orig_size = @ts.size
+    last_update = Time.now
+    @ts.load_n_threads(ts_to_load, opts) do |i|
+      if (Time.now - last_update) >= 0.25
+        BufferManager.say "Loaded #{i.pluralize 'thread'}...", @mbid
+        update
+        BufferManager.draw_screen
+        last_update = Time.now
+      end
+      ::Thread.pass
+      break if @interrupt_search
+    end
+    @ts.threads.each { |th| th.labels.each { |l| LabelManager << l } }
+
+    update
+    BufferManager.clear @mbid
+    @mbid = nil
+    BufferManager.draw_screen
+    @ts.size - orig_size
+  end
+  ignore_concurrent_calls :load_n_threads
+
+  def status
+    if (l = lines) == 0
+      "line 0 of 0"
+    else
+      "line #{curpos + 1} of #{l}"
+    end
+  end
+
+  def cancel_search
+    @interrupt_search = true
+  end
+
+  def load_all_threads
+    load_threads :num => -1
+  end
+
+  def load_threads opts={}
+    if opts[:num].nil?
+      n = ThreadIndexMode::LOAD_MORE_THREAD_NUM
+    else
+      n = opts[:num]
+    end
+
+    myopts = @load_thread_opts.merge({ :when_done => (lambda do |num|
+      opts[:when_done].call(num) if opts[:when_done]
+
+      if num > 0
+        BufferManager.flash "Found #{num.pluralize 'thread'}."
+      else
+        BufferManager.flash "No matches."
+      end
+    end)})
+
+    if opts[:background] || opts[:background].nil?
+      load_n_threads_background n, myopts
+    else
+      load_n_threads n, myopts
+    end
+  end
+  ignore_concurrent_calls :load_threads
+
+  def read_and_archive
+    return unless cursor_thread
+    thread = cursor_thread # to make sure lambda only knows about 'old' cursor_thread
+
+    was_unread = thread.labels.member? :unread
+    UndoManager.register "reading and archiving thread" do
+      thread.apply_label :inbox
+      thread.apply_label :unread if was_unread
+      add_or_unhide thread.first
+      Index.save_thread thread
+    end
+
+    cursor_thread.remove_label :unread
+    cursor_thread.remove_label :inbox
+    hide_thread cursor_thread
+    regen_text
+    Index.save_thread thread
+  end
+
+  def multi_read_and_archive threads
+    old_labels = threads.map { |t| t.labels.dup }
+
+    threads.each do |t|
+      t.remove_label :unread
+      t.remove_label :inbox
+      hide_thread t
+    end
+    regen_text
+
+    UndoManager.register "reading and archiving #{threads.size.pluralize 'thread'}" do
+      threads.zip(old_labels).each do |t, l|
+        t.labels = l
+        add_or_unhide t.first
+        Index.save_thread t
+      end
+      regen_text
+    end
+
+    threads.each { |t| Index.save_thread t }
+  end
+
+  def resize rows, cols
+    regen_text
+    super
+  end
+
+protected
+
+  def add_or_unhide m
+    @ts_mutex.synchronize do
+      if (is_relevant?(m) || @ts.is_relevant?(m)) && !@ts.contains?(m)
+        @ts.load_thread_for_message m, @load_thread_opts
+      end
+
+      @hidden_threads.delete @ts.thread_for(m)
+    end
+
+    update
+  end
+
+  def thread_containing m; @ts_mutex.synchronize { @ts.thread_for m } end
+
+  ## used to tag threads by query. this can be made a lot more sophisticated,
+  ## but for right now we'll do the obvious this.
+  def thread_matches? t, query
+    t.subj =~ query || t.snippet =~ query || t.participants.any? { |x| x.longname =~ query }
+  end
+
+  def size_widget_for_thread t
+    HookManager.run("index-mode-size-widget", :thread => t) || default_size_widget_for(t)
+  end
+
+  def date_widget_for_thread t
+    HookManager.run("index-mode-date-widget", :thread => t) || default_date_widget_for(t)
+  end
+
+  def cursor_thread; @mutex.synchronize { @threads[curpos] }; end
+
+  def drop_all_threads
+    @tags.drop_all_tags
+    initialize_threads
+    update
+  end
+
+  def delete_thread t
+    @mutex.synchronize do
+      i = @threads.index(t) or return
+      @threads.delete_at i
+      @size_widgets.delete_at i
+      @date_widgets.delete_at i
+      @tags.drop_tag_for t
+    end
+  end
+
+  def hide_thread t
+    @mutex.synchronize do
+      i = @threads.index(t) or return
+      raise "already hidden" if @hidden_threads[t]
+      @hidden_threads[t] = true
+      @threads.delete_at i
+      @size_widgets.delete_at i
+      @date_widgets.delete_at i
+      @tags.drop_tag_for t
+    end
+  end
+
+  def update_text_for_line l
+    return unless l # not sure why this happens, but it does, occasionally
+
+    need_update = false
+
+    @mutex.synchronize do
+      @size_widgets[l] = size_widget_for_thread @threads[l]
+      @date_widgets[l] = date_widget_for_thread @threads[l]
+
+      ## if a widget size has increased, we need to redraw everyone
+      need_update =
+        (@size_widgets[l].size > @size_widget_width) or
+        (@date_widgets[l].size > @date_widget_width)
+    end
+
+    if need_update
+      update
+    else
+      @text[l] = text_for_thread_at l
+      buffer.mark_dirty if buffer
+    end
+  end
+
+  def regen_text
+    threads = @mutex.synchronize { @threads }
+    @text = threads.map_with_index { |t, i| text_for_thread_at i }
+    @lines = threads.map_with_index { |t, i| [t, i] }.to_h
+    buffer.mark_dirty if buffer
+  end
+
+  def authors; map { |m, *o| m.from if m }.compact.uniq; end
+
+  ## preserve author order from the thread
+  def author_names_and_newness_for_thread t, limit=nil
+    new = {}
+    seen = {}
+    authors = t.map do |m, *o|
+      next unless m && m.from
+      new[m.from] ||= m.has_label?(:unread)
+      next if seen[m.from]
+      seen[m.from] = true
+      m.from
+    end.compact
+
+    result = []
+    authors.each do |a|
+      break if limit && result.size >= limit
+      name = if AccountManager.is_account?(a)
+        "me"
+      elsif t.authors.size == 1
+        a.mediumname
+      else
+        a.shortname
+      end
+
+      result << [name, new[a]]
+    end
+
+    if result.size == 1 && (author_and_newness = result.assoc("me"))
+      unless (recipients = t.participants - t.authors).empty?
+        result = recipients.collect do |r|
+          break if limit && result.size >= limit
+          name = (recipients.size == 1) ? r.mediumname : r.shortname
+          ["(#{name})", author_and_newness[1]]
+        end
+      end
+    end
+
+    result
+  end
+
+  AUTHOR_LIMIT = 5
+  def text_for_thread_at line
+    t, size_widget, date_widget = @mutex.synchronize do
+      [@threads[line], @size_widgets[line], @date_widgets[line]]
+    end
+
+    starred = t.has_label? :starred
+
+    ## format the from column
+    cur_width = 0
+    ann = author_names_and_newness_for_thread t, AUTHOR_LIMIT
+    from = []
+    ann.each_with_index do |(name, newness), i|
+      break if cur_width >= from_width
+      last = i == ann.length - 1
+
+      abbrev =
+        if cur_width + name.display_length > from_width
+          name.slice_by_display_length(from_width - cur_width - 1) + "."
+        elsif cur_width + name.display_length == from_width
+          name.slice_by_display_length(from_width - cur_width)
+        else
+          if last
+            name.slice_by_display_length(from_width - cur_width)
+          else
+            name.slice_by_display_length(from_width - cur_width - 1) + ","
+          end
+        end
+
+      cur_width += abbrev.display_length
+
+      if last && from_width > cur_width
+        abbrev += " " * (from_width - cur_width)
+      end
+
+      from << [(newness ? :index_new_color : (starred ? :index_starred_color : :index_old_color)), abbrev]
+    end
+
+    is_me = AccountManager.method(:is_account?)
+    directly_participated = t.direct_participants.any?(&is_me)
+    participated = directly_participated || t.participants.any?(&is_me)
+
+    subj_color =
+      if t.has_label?(:draft)
+        :index_draft_color
+      elsif t.has_label?(:unread)
+        :index_new_color
+      elsif starred
+        :index_starred_color
+      elsif Colormap.sym_is_defined(:index_subject_color)
+        :index_subject_color
+      else
+        :index_old_color
+      end
+
+    size_padding = @size_widget_width - size_widget.display_length
+    size_widget_text = sprintf "%#{size_padding}s%s", "", size_widget
+
+    date_padding = @date_widget_width - date_widget.display_length
+    date_widget_text = sprintf "%#{date_padding}s%s", "", date_widget
+
+    [
+      [:tagged_color, @tags.tagged?(t) ? ">" : " "],
+      [:date_color, date_widget_text],
+      [:starred_color, (starred ? "*" : " ")],
+    ] +
+      from +
+      [
+      [:size_widget_color, size_widget_text],
+      [:with_attachment_color , t.labels.member?(:attachment) ? "@" : " "],
+      [:to_me_color, directly_participated ? ">" : (participated ? '+' : " ")],
+    ] +
+      (t.labels - @hidden_labels).sort_by {|x| x.to_s}.map {
+            |label| [Colormap.sym_is_defined("label_#{label}_color".to_sym) || :label_color, "#{label} "]
+      } +
+      [
+      [subj_color, t.subj + (t.subj.empty? ? "" : " ")],
+      [:snippet_color, t.snippet],
+    ]
+  end
+
+  def dirty?; @mutex.synchronize { (@hidden_threads.keys + @threads).any? { |t| t.dirty? } } end
+
+private
+
+  def default_size_widget_for t
+    case t.size
+    when 1
+      ""
+    else
+      "(#{t.size})"
+    end
+  end
+
+  def default_date_widget_for t
+    t.date.getlocal.to_nice_s
+  end
+
+  def from_width
+    [(buffer.content_width.to_f * 0.2).to_i, MIN_FROM_WIDTH].max
+  end
+
+  def initialize_threads
+    @ts = ThreadSet.new Index.instance, $config[:thread_by_subject]
+    @ts_mutex = Mutex.new
+    @hidden_threads = {}
+  end
+end
+
+end