rubyterm 0.2.7 → 0.2.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3ddbf4d21fc1c56952d43421b3fdb23b68a7bf987769c3e01ee1e736ed597872
-  data.tar.gz: 5e385e0a98361a06069f5937655e037a438ae0064fdf845e4f384883a53e6117
+  metadata.gz: 1e558fb7c4f76d082d2b12a187b2896da650c41d78c68a7091e087b44da9f05a
+  data.tar.gz: 2218f739b992337ebef7a4aa23d4674beba0d98f8aec7b923308b8add330ef8c
 SHA512:
-  metadata.gz: 1d13beb2c8169a361ef35f49334e50cba685b7d7f9fab84b62d3a32f56b2d0a534ec3696d495639d9c1aaedb38cff5c9cd3b9850d0fafd9fdff5d21ccbc93634
-  data.tar.gz: 6337a2248a5c62f7d7a74bf4b69dbc0c5354b9dd9ec336b9300dfb7fdc0be158da68f275e01f6f14aff607bc509333e98fc858b3e74c6d155d04f605dee754ad
+  metadata.gz: bb871759cd9df280d3ea58f6567901e21e8bc6ece1c0338e9c5aa7c39e80dbfded97d2be82029f716b48b3de1b268afb732071497cd0fb7f51a4c8e6d7b59398
+  data.tar.gz: 1d2f2a46619c84ac22cfe8242cc635119a57550b57ea24d37f12dd612c9f7aebebeef157b5eda973950010898e6f55ea4b63678702f29a2feed4b791bcef9276

data/lib/rubyterm/app.rb

@@ -286,30 +286,10 @@ class RubyTerm
     when :"ctrl_+" then adjust_fontsize(1.0)
     when :"ctrl_-" then adjust_fontsize(-1.0)
     when :shift_page_up
-      @window.scrollback_page_up
-      # Full redraw to show scrollback buffer
-      redraw
+      scrollback_view_up
       return
     when :shift_page_down
-      # Don't do anything if not in scrollback mode
-      return if !@window.scrollback_mode
-      
-      # If we're exiting scrollback mode or still in it
-      changed = @window.scrollback_page_down
-      
-      # Redraw everything from scratch
-      redraw
-      
-      # Explicitly force cursor to be redrawn if exiting scrollback mode
-      if changed
-        # Clear cursor if it exists
-        @term.clear_cursor
-        # Force draw cursor again
-        @term.draw_cursor
-        # Ensure changes are flushed
-        @buffer.draw_flush
-        @window.flush
-      end
+      scrollback_view_down
       return
     when :XK_Insert  # Paste primary selection
       # FIXME: Giant hack
@@ -380,6 +360,82 @@ class RubyTerm
     redraw if @window.scrollback_reset
   end
 
+  # Lines the view moves per mouse wheel tick (Shift+PageUp/Down move a
+  # full page of 10).
+  WHEEL_SCROLL_LINES = 3
+
+  # Move the scrollback view up/down by +lines+ and repaint incrementally:
+  # blit the rows that stay on screen (the same CopyArea mechanism live
+  # scrolling uses) and repaint only the newly exposed ones. The previous
+  # full clear+redraw per step made wheel scrolling visibly jerky. Shared
+  # by Shift+PageUp/Down and the wheel.
+  #
+  # The blit carries the selection-highlight pixels along with their text
+  # (the selection is pinned to buffer content), so only the freshly
+  # repainted rows need the overlay re-stamped - reapply_selection does
+  # that at the end.
+  def scrollback_view_up(lines = 10)
+    # Nothing above the view: don't touch the cursor or repaint at all
+    # (wheel ticks arrive far more often than Shift+PageUp ever did).
+    return if @window.scrollback_count >= @window.scrollback_buffer_size
+    if !@window.scrollback_mode
+      # Leaving the live screen: repaint the cursor cell first - cursor
+      # redraws are suppressed once scrolled back, and the blit below would
+      # otherwise drag the cursor overlay along as if it were content.
+      @term.clear_cursor
+      @buffer.draw_flush
+    end
+    moved = @window.scrollback_scroll(lines)
+    rows = @term.height
+    # A jump of a screenful or more retains nothing worth blitting.
+    return redraw if moved >= rows
+    # Shift the surviving rows down by +moved+ (this also clears the
+    # vacated top band and re-draws the scrollback indicator over row 0).
+    @window.scroll_down(0, @window.width, (rows - moved) * char_h, moved * char_h)
+    # Repaint the newly exposed history rows. Row 0 stays the indicator
+    # line, so start at 1; include row +moved+, where the old top row's
+    # indicator-overlay pixels landed.
+    (1..moved).each { |sy| repaint_view_row(sy) }
+    @buffer.draw_flush
+    @window.flush
+    reapply_selection
+  end
+
+  def scrollback_view_down(lines = 10)
+    # Don't do anything if not in scrollback mode
+    return if !@window.scrollback_mode
+    moved = @window.scrollback_scroll(-lines)
+    return if moved == 0
+    exited = !@window.scrollback_mode  # landed back on the live screen
+    rows = @term.height
+    if moved >= rows
+      redraw
+    else
+      # Shift the surviving rows up (clears the vacated bottom band; the
+      # indicator is re-drawn only while still scrolled back).
+      @window.scroll_up(moved * char_h, @window.width, (rows - moved) * char_h, moved * char_h)
+      # Repaint the rows that scrolled into view at the bottom.
+      (rows - moved...rows).each { |sy| repaint_view_row(sy) }
+      @buffer.draw_flush
+      @window.flush
+      reapply_selection
+    end
+    # Explicitly force cursor to be redrawn if exiting scrollback mode
+    if exited
+      @term.clear_cursor
+      @term.draw_cursor
+      @buffer.draw_flush
+      @window.flush
+    end
+  end
+
+  # Repaint one on-screen row from the buffer at the current view offset
+  # (blank cells paint as spaces, so this also erases stale pixels).
+  def repaint_view_row(sy)
+    sb = @window.scrollback_count
+    (0...@term.width).each { |x| @buffer.redraw_display(x, sy, sb) }
+  end
+
   def redraw_positions(positions) = positions.each { |pos| @buffer.redraw(*pos) }
 
   # The selection's [start, end] boundary pairs, expanded so a double-width
@@ -500,6 +556,19 @@ class RubyTerm
     shift = pkt.state.anybits?(0x01) # ShiftMask
     case shift ? nil : @term.mouse_mode
     when nil
+      # Wheel ticks (buttons 4/5) scroll the local scrollback view, the way
+      # every other terminal scrolls natively - this is what an app that
+      # does not grab the mouse (e.g. a shell, or claude's inline mode)
+      # relies on. Handled before the selection logic below so a wheel tick
+      # never starts or clears a selection. With Shift held this branch is
+      # forced even when an app owns the mouse, so Shift+wheel always
+      # scrolls history - the same override as Shift+select.
+      if button >= 4
+        return if release   # each tick is a press+release pair; act on press
+        scrollback_view_up(WHEEL_SCROLL_LINES)   if button == 4
+        scrollback_view_down(WHEEL_SCROLL_LINES) if button == 5
+        return
+      end
       # Selection coordinates are cell *boundaries* (round to the nearest
       # column edge, not the floor cell), so dragging across a single cell
       # selects exactly that cell and a click (no boundary crossed) selects

data/lib/rubyterm/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class RubyTerm
-  VERSION = "0.2.7"
+  VERSION = "0.2.8"
 end

data/lib/window.rb

@@ -41,31 +41,19 @@ class Window
     @buffer.scrollback_size
   end
   
-  # Increase scrollback counter
-  def scrollback_page_up
-    # Get current scrollback buffer size
-    max_scrollback = scrollback_buffer_size
-    return if max_scrollback == 0
-    
-    # Store previous count for calculating how many new lines to clear
-    previous_count = @scrollback_count
-    
-    # Limit scrollback count to available lines
-    @scrollback_count += 10
-    if @scrollback_count > max_scrollback
-      @scrollback_count = max_scrollback
-    end
-    
-    # Calculate how many new lines we've scrolled and clear them
-    new_lines = @scrollback_count - previous_count
-    if new_lines > 0
-      # Clear the area where new scrollback lines will appear
-      clear(0, 0, @width, new_lines * char_h)
-    end
-    
-    draw_scrollback_indicator if @scrollback_count <= 10
+  # Move the scrollback view by +lines+ (positive = further back into
+  # history, negative = towards the live screen), clamped to
+  # [0, history size]. This is a pure model update - repainting (a blit of
+  # the surviving rows plus a repaint of the exposed ones, or a full
+  # redraw) is the caller's job. Returns the number of lines actually
+  # moved, 0 when already at the corresponding end.
+  def scrollback_scroll(lines)
+    was = @scrollback_count
+    @scrollback_count = (was + lines).clamp(0, scrollback_buffer_size)
+    (@scrollback_count - was).abs
   end
-  
+
+
   # Snap straight back to the live screen (bottom of scrollback). Returns
   # true if we were scrolled back, so the caller knows a redraw is needed.
   def scrollback_reset
@@ -84,32 +72,6 @@ class Window
     @scrollback_count += 1
   end
 
-  # Decrease scrollback counter
-  def scrollback_page_down
-    return false if @scrollback_count <= 0
-    
-    # Remember previous count
-    previous_count = @scrollback_count
-    
-    @scrollback_count -= 10
-    if @scrollback_count <= 0
-      # Exiting scrollback mode
-      @scrollback_count = 0
-      @dirty = true
-      
-      # Clear entire scrollback area that was showing
-      clear(0, 0, @width, previous_count * char_h)
-      return true
-    else
-      # Clear area that was occupied by lines no longer in scrollback
-      lines_removed = previous_count - @scrollback_count
-      if lines_removed > 0
-        clear(0, 0, @width, lines_removed * char_h)
-      end
-    end
-    false
-  end
-
   def initialize(**opts)
     @scrollback_count = 0
     

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubyterm
 version: !ruby/object:Gem::Version
-  version: 0.2.7
+  version: 0.2.8
 platform: ruby
 authors:
 - Vidar Hokstad