git.cworth.org Git - sup/blob - lib/sup/modes/scroll-mode.rb

   1 module Redwood
   2
   3 class ScrollMode < Mode
   4   ## we define topline and botline as the top and bottom lines of any
   5   ## content in the currentview.
   6
   7   ## we left leftcol and rightcol as the left and right columns of any
   8   ## content in the current view. but since we're operating in a
   9   ## line-centric fashion, rightcol is always leftcol + the buffer
  10   ## width. (whereas botline is topline + at most the buffer height,
  11   ## and can be == to topline in the case that there's no content.)
  12
  13   attr_reader :status, :topline, :botline, :leftcol
  14
  15   COL_JUMP = 2
  16
  17   register_keymap do |k|
  18     k.add :line_down, "Down one line", :down, 'j', 'J'
  19     k.add :line_up, "Up one line", :up, 'k', 'K'
  20     k.add :col_left, "Left one column", :left, 'h'
  21     k.add :col_right, "Right one column", :right, 'l'
  22     k.add :page_down, "Down one page", :page_down, ' '
  23     k.add :page_up, "Up one page", :page_up, 'p', :backspace
  24     k.add :jump_to_start, "Jump to top", :home, '^', '1'
  25     k.add :jump_to_end, "Jump to bottom", :end, '$', '0'
  26     k.add :jump_to_left, "Jump to the left", '['
  27     k.add :search_in_buffer, "Search in current buffer", '/'
  28     k.add :continue_search_in_buffer, "Jump to next search occurrence in buffer", BufferManager::CONTINUE_IN_BUFFER_SEARCH_KEY
  29   end
  30
  31   def initialize opts={}
  32     @topline, @botline, @leftcol = 0, 0, 0
  33     @slip_rows = opts[:slip_rows] || 0 # when we pgup/pgdown,
  34                                        # how many lines do we keep?
  35     @twiddles = opts.member?(:twiddles) ? opts[:twiddles] : true
  36     @search_query = nil
  37     @search_line = nil
  38     @status = ""
  39     super()
  40   end
  41
  42   def rightcol; @leftcol + buffer.content_width; end
  43
  44   def draw
  45     ensure_mode_validity
  46     (@topline ... @botline).each { |ln| draw_line ln }
  47     ((@botline - @topline) ... buffer.content_height).each do |ln|
  48       if @twiddles
  49         buffer.write ln, 0, "~", :color => :twiddle_color
  50       else
  51         buffer.write ln, 0, ""
  52       end
  53     end
  54     @status = "lines #{@topline + 1}:#{@botline}/#{lines}"
  55   end
  56
  57   def in_search?; @search_line end
  58   def cancel_search!; @search_line = nil end
  59
  60   def continue_search_in_buffer
  61     unless @search_query
  62       BufferManager.flash "No current search!"
  63       return
  64     end
  65
  66     start = @search_line || search_start_line
  67     line = find_text @search_query, start
  68     if line.nil? && (start > 0)
  69       line = find_text @search_query, 0
  70       BufferManager.flash "Search wrapped to top!" if line
  71     end
  72     if line
  73       @search_line = line + 1
  74       search_goto_line line
  75       buffer.mark_dirty
  76     else
  77       BufferManager.flash "Not found!"
  78     end
  79   end
  80
  81   def search_in_buffer
  82     query = BufferManager.ask :search, "search in buffer: "
  83     return if query.nil? || query.empty?
  84     @search_query = Regexp.escape query
  85     continue_search_in_buffer
  86   end
  87
  88   ## subclasses can override these two!
  89   def search_goto_line line; jump_to_line line end
  90   def search_start_line; @topline end
  91
  92   def col_left
  93     return unless @leftcol > 0
  94     @leftcol -= COL_JUMP
  95     buffer.mark_dirty
  96   end
  97
  98   def col_right
  99     @leftcol += COL_JUMP
 100     buffer.mark_dirty
 101   end
 102
 103   def jump_to_col col
 104     col = col - (col % COL_JUMP)
 105     buffer.mark_dirty unless @leftcol == col
 106     @leftcol = col
 107   end
 108
 109   def jump_to_left; jump_to_col 0; end
 110
 111   ## set top line to l
 112   def jump_to_line l
 113     l = l.clamp 0, lines - 1
 114     return if @topline == l
 115     @topline = l
 116     @botline = [l + buffer.content_height, lines].min
 117     buffer.mark_dirty
 118   end
 119
 120   def at_top?; @topline == 0 end
 121   def at_bottom?; @botline == lines end
 122
 123   def line_down; jump_to_line @topline + 1; end
 124   def line_up;  jump_to_line @topline - 1; end
 125   def page_down; jump_to_line @topline + buffer.content_height - @slip_rows; end
 126   def page_up; jump_to_line @topline - buffer.content_height + @slip_rows; end
 127   def jump_to_start; jump_to_line 0; end
 128   def jump_to_end; jump_to_line lines - buffer.content_height; end
 129
 130   def ensure_mode_validity
 131     @topline = @topline.clamp 0, [lines - 1, 0].max
 132     @botline = [@topline + buffer.content_height, lines].min
 133   end
 134
 135   def resize *a
 136     super(*a)
 137     ensure_mode_validity
 138   end
 139
 140 protected
 141
 142   def find_text query, start_line
 143     regex = /#{query}/i
 144     (start_line ... lines).each do |i|
 145       case(s = self[i])
 146       when String
 147         return i if s =~ regex
 148       when Array
 149         return i if s.any? { |color, string| string =~ regex }
 150       end
 151     end
 152     nil
 153   end
 154
 155   def draw_line ln, opts={}
 156     regex = /(#{@search_query})/i
 157     case(s = self[ln])
 158     when String
 159       if in_search?
 160         draw_line_from_array ln, matching_text_array(s, regex), opts
 161       else
 162         draw_line_from_string ln, s, opts
 163       end
 164     when Array
 165       if in_search?
 166         ## seems like there ought to be a better way of doing this
 167         array = []
 168         s.each do |color, text|
 169           if text =~ regex
 170             array += matching_text_array text, regex, color
 171           else
 172             array << [color, text]
 173           end
 174         end
 175         draw_line_from_array ln, array, opts
 176       else
 177         draw_line_from_array ln, s, opts
 178       end
 179     else
 180       raise "unknown drawable object: #{s.inspect} in #{self} for line #{ln}" # good for debugging
 181     end
 182
 183       ## speed test
 184       # str = s.map { |color, text| text }.join
 185       # buffer.write ln - @topline, 0, str, :color => :none, :highlight => opts[:highlight]
 186       # return
 187   end
 188
 189   def matching_text_array s, regex, oldcolor=:none
 190     s.split(regex).map do |text|
 191       next if text.empty?
 192       if text =~ regex
 193         [:search_highlight_color, text]
 194       else
 195         [oldcolor, text]
 196       end
 197     end.compact + [[oldcolor, ""]]
 198   end
 199
 200   def draw_line_from_array ln, a, opts
 201     xpos = 0
 202     a.each do |color, text|
 203       raise "nil text for color '#{color}'" if text.nil? # good for debugging
 204
 205       if xpos + text.length < @leftcol
 206         buffer.write ln - @topline, 0, "", :color => color,
 207                      :highlight => opts[:highlight]
 208         xpos += text.length
 209       elsif xpos < @leftcol
 210         ## partial
 211         buffer.write ln - @topline, 0, text[(@leftcol - xpos) .. -1],
 212                      :color => color,
 213                      :highlight => opts[:highlight]
 214         xpos += text.length
 215       else
 216         buffer.write ln - @topline, xpos - @leftcol, text,
 217                      :color => color, :highlight => opts[:highlight]
 218         xpos += text.length
 219       end
 220     end
 221   end
 222
 223   def draw_line_from_string ln, s, opts
 224     buffer.write ln - @topline, 0, s[@leftcol .. -1], :highlight => opts[:highlight]
 225   end
 226 end
 227
 228 end
 229