raindown 0.7.0 → 0.8.0

data/lib/raindown/tui/navigator/navigator.rb

@@ -4,13 +4,14 @@ require_relative '../file_tree'
 require_relative 'commands'
 require_relative '../endpoints'
 require_relative 'focus'
+require_relative 'mouse'
 require_relative '../events'
 require_relative '../views/outline_view'
 require_relative '../views/list_view'
 require_relative 'project_menu'
-require_relative 'search'
+require_relative 'teleport'
 require_relative 'views'
-require_relative '../workers/workers'
+require_relative '../project'
 
 module Raindown
   module TUI
@@ -21,26 +22,31 @@ module Raindown
       include Commands
       include Views
       include ProjectMenu
-      include Search
+      include Teleport
       include Focus
+      include Mouse
 
       # Keys of the events that move the cursor or the focus, and those that act on what's selected.
       MOVES = { up: -1, down: 1 }.freeze
       PANES = { tab: nil, left: :nav, right: :main }.freeze
       ACTIONS = { execute: :execute, edit: :edit, write_back: :write_back, reload: :reload, tick: :refresh }.freeze
-      # Keys that open the search, the project menu, the Dashboard or Code feelings, from anywhere.
-      OPENERS = { search: :open_search, projects: :toggle_menu, dashboard: :toggle_dashboard, feelings: :open_feelings }.freeze
+      # Keys that open Teleport, the project menu, the Dashboard, Code feelings or Blueprints, from anywhere.
+      OPENERS = { search: -> { open_teleport }, projects: -> { toggle_menu }, dashboard: -> { toggle_dashboard },
+                  feelings: -> { open_view(feelings) }, blueprints: -> { open_view(blueprints) } }.freeze
 
       attr_reader :focus, :status
-      # What the mouse is over, which a click there would send, like a Click on a method's cells, or nil.
-      attr_reader :hovered
 
-      def initialize(root:, path: nil, workers: Workers.new(root:))
+      # Saves tells of the files saved in the folder, which are written back on the next tick, like when it's watched,
+      # running endpoints with no response as they are when it runs_endpoints, like with -x.
+      def initialize(root:, path: nil, workers: Project.workers(root:), saves: nil, runs_endpoints: false)
         @workers = workers
+        @saves = saves
+        @runs_endpoints = runs_endpoints
         @files = FileTree.new(root:, workers:)
         @endpoints = Endpoints.new(workers:)
         @dashboard = DashboardView.new(root:, workers:)
         @feelings = FeelingsView.new(root:)
+        @blueprints = BlueprintsView.new(root:)
         @nav = ListView.new { nav_rows }
         first = Projects.files(root, nested: true).first
         # The dashboard is the first page, unless a file is asked for, and "d" goes from it to the first file.
@@ -55,6 +61,7 @@ module Raindown
         when Click then click(event)
         when Type then type(event)
         when Hover then hover(event)
+        when Drag then drag(event)
         else route(event)
         end
       end
@@ -73,57 +80,39 @@ module Raindown
       # The folder the files are shown from: the chosen project's, or the root's.
       def base = @files.base
 
-      # While the search, or the view, like a feeling's note, takes what's typed, rather than keys' events.
-      def typing? = searching? || view.typing?
+      # While Teleport, or the view, like a feeling's note, takes what's typed, rather than keys' events.
+      def typing? = teleporting? || view.typing?
 
-      # While the view wants drawing faster than the ticks, like Code feelings' rain.
-      def animating? = view.animating?
+      # How often the screen's drawn, which is up to the view, like faster for Code feelings' rain.
+      def pace = view.pace(hovered)
 
       # What's in a pane: the nav's ListView on the left, or the view on the right, which keeps its own cursor.
       def content(pane) = pane == :nav ? @nav : view
 
       private
 
-      def hover(hover)
-        @hovered = hover.target
-        nil
-      end
-
-      # A typed character goes to the search, or to the view while it's typing.
+      # A typed character goes to Teleport, or to the view while it's typing.
       def type(event)
-        return type_query(query + event.text) if searching?
+        return type_query(query + event.text) if teleporting?
 
         view.next_step(event)&.take(self) if view.typing?
       end
 
       def route(name)
         return :quit if name == :quit
-        return search_event(name) if searching?
+        return teleport_event(name) if teleporting?
         return menu_event(name) if menu
-        return send(OPENERS[name]) if OPENERS.key?(name)
+        return instance_exec(&OPENERS[name]) if opener?(name)
         return view.next_step(name)&.take(self) if @focus == :main && view.next_step?(name)
 
         browser_event(name)
       end
 
-      # A click moves the cursor where it's clicked, and does the click's action there, like a key, unless that would
-      # leave the terminal UI, like for the editor, so a stray click only moves the cursor.
-      # While the project menu or the search is open, only its items are clicked.
-      def click(click)
-        return if menu && click.pane != :menu
-        return if searching? && click.pane != :search
-
-        point(click)
-        effect = route(click.action)
-        effect unless effect.is_a?(Run)
-      end
-
-      def point(click)
-        return @menu = click.index if click.pane == :menu
-        return @match = click.index if click.pane == :search
+      # Whether the key opens something from anywhere, unless the view's focused and keeps the key, like f in Blueprints.
+      def opener?(name)
+        return false if @focus == :main && view.respond_to?(:own_key?) && view.own_key?(name)
 
-        content(click.pane).cursor = click.index
-        @focus = click.pane
+        OPENERS.key?(name)
       end
 
       def browser_event(name)
@@ -134,13 +123,20 @@ module Raindown
         send(ACTIONS[name]) if ACTIONS.key?(name)
       end
 
-      # The Dashboard and Code feelings, whose emoji every terminal draws two columns wide, then the files and the
-      # endpoints, with a blank line between each section that has rows.
+      # The Dashboard, Code feelings and Blueprints, then the files and the endpoints, with a blank line between each section that
+      # has rows.
       def nav_rows
-        pages = { '📊 Dashboard' => dashboard, '🎭 Feelings' => feelings }.map do |text, view|
-          Row.new(text:, depth: 0, kind: :page, target: view, open: OpenView.new(view:))
-        end
-        [pages, @files.rows, @endpoints.rows].reject(&:empty?).flat_map { [Row::SEPARATOR, *it] }.drop(1)
+        rows = pages.map { |text, view| Row.new(text:, depth: 0, kind: :page, target: view, open: OpenView.new(view:)) }
+        [rows, @files.rows, @endpoints.rows].reject(&:empty?).flat_map { [Row::SEPARATOR, *it] }.drop(1)
+      end
+
+      # The pages above the files, by how they're shown, in the files and Teleport, with emoji every terminal draws two
+      # columns wide. Blueprints is listed once the project has some, from Claude Code or its code's comments.
+      def pages
+        pages = { '📊 Dashboard' => dashboard, '🎭 Feelings' => feelings }
+        return pages unless blueprints.any?
+
+        pages.merge('🌀 Blueprints' => blueprints)
       end
 
       def selected

data/lib/raindown/tui/navigator/{search.rb → teleport.rb}

@@ -2,14 +2,14 @@
 
 require_relative '../events'
 require_relative '../views/endpoint_view'
-require_relative '../workers/worker'
+require_relative '../../workers/worker'
 
 module Raindown
   module TUI
     # Teleport: "/" opens a search of the Dashboard, Code feelings, every file, heading and directive in the files, and every endpoint,
     # matched as it's typed by letters in order, so "stp" finds "## Setup". Up and down move between the matches,
     # Enter or a click opens the one selected, and Esc closes it. Other keys and clicks do nothing while it's open.
-    module Search
+    module Teleport
       # The most matches it shows.
       LIMIT = 10
 
@@ -45,10 +45,13 @@ module Raindown
         end
       end
 
-      # What's typed, while the search is open, and the selected match.
+      # What's typed, while Teleport is open, and the selected match.
       attr_reader :query, :match
 
-      def searching? = !query.nil?
+      def teleporting? = !query.nil?
+
+      # The first match the box lists, as it lists them all.
+      def first_match = 0
 
       # The places that match what's typed, best first, then in the order they're in the files.
       def matches
@@ -58,18 +61,18 @@ module Raindown
 
       private
 
-      def open_search
+      def open_teleport
         @places = places
         @match = 0
         @query = ''
         nil
       end
 
-      def search_event(name)
+      def teleport_event(name)
         case name
         when :up, :down then move_match(name == :up ? -1 : 1)
         when :enter then teleport
-        when :escape then close_search
+        when :escape then close_teleport
         when :backspace then type_query(query[0...-1])
         end
       end
@@ -87,18 +90,17 @@ module Raindown
 
       def teleport
         place = matches[@match]
-        close_search
+        close_teleport
         place&.open&.take(self)
       end
 
-      def close_search
+      def close_teleport
         @query = nil
         nil
       end
 
       def places
-        [Place.new(text: 'Dashboard', where: '', open: OpenView.new(view: dashboard)),
-         Place.new(text: 'Code feelings', where: '', open: OpenView.new(view: feelings)),
+        [*pages.map { |text, view| Place.new(text:, where: '', open: OpenView.new(view:)) },
          *@files.files.flat_map { file_places(it) },
          *@endpoints.all.map { Place.new(text: it.text, where: "#{relative(it.path)}:#{it.line}", open: open_endpoint(it)) }]
       end
@@ -110,7 +112,7 @@ module Raindown
         items = (outline.headings + outline.directives).sort_by(&:line)
         [Place.new(text: where, where: '', open: Open.new(path:, line: nil)),
          *items.map { Place.new(text: item_text(it), where: "#{where}:#{it.line}", open: Open.new(path:, line: it.line)) }]
-      rescue Worker::Error
+      rescue Workers::Worker::Error
         []
       end
 

data/lib/raindown/tui/navigator/views.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative '../views/dashboard_view'
+require_relative '../blueprints/blueprints_view'
 require_relative '../views/endpoint_view'
 require_relative '../feelings/feelings_view'
 require_relative '../views/outline_view'
@@ -12,7 +13,7 @@ module Raindown
     # A view has the pane that draws it, a next step for the keys it takes while it has the focus, and a target,
     # what's opened it in the files. It loads when it's opened, and again after a change.
     module Views
-      attr_reader :view, :dashboard, :feelings
+      attr_reader :view, :dashboard, :feelings, :blueprints
 
       # The path of the file the view shows, if any.
       def path = view.path
@@ -39,8 +40,6 @@ module Raindown
 
       private
 
-      def open_feelings = open_view(feelings)
-
       # Switches between the dashboard and the view before it.
       def toggle_dashboard
         return open_view(@previous) if view == dashboard && @previous

data/lib/raindown/tui/{workers/project.rb → project.rb}

@@ -1,19 +1,20 @@
 # frozen_string_literal: true
 
-require_relative '../../actions'
-require_relative '../../bare_directives'
-require_relative '../../chart/chart'
-require_relative '../../document'
-require_relative '../../front_matter'
-require_relative '../../node_blocks'
-require_relative '../../nodes'
-require_relative '../../pages'
-require_relative '../../projects'
-require_relative '../../stat'
-require_relative '../card'
-require_relative '../endpoint'
-require_relative '../../code_blocks'
-require_relative '../../endpoint/curl'
+require_relative '../actions'
+require_relative '../bare_directives'
+require_relative '../chart/chart'
+require_relative '../document'
+require_relative '../front_matter'
+require_relative '../node_blocks'
+require_relative '../nodes'
+require_relative '../pages'
+require_relative '../projects'
+require_relative '../workers/workers'
+require_relative '../stat'
+require_relative 'card'
+require_relative 'endpoint'
+require_relative '../code_blocks'
+require_relative '../endpoint/curl'
 
 module Raindown
   module TUI
@@ -24,9 +25,17 @@ module Raindown
 
       attr_reader :root
 
+      # Workers for the projects in the folder, each answering as a Project, which allows bare directives in any file,
+      # and runs endpoints with no response as it writes back, when asked, like with --bare and -x.
+      def self.workers(root:, bare: false, execute: false, **)
+        Workers.new(root:, **) { new(root: it, bare:, execute:) }
+      end
+
       # The projects inside this one have workers of their own, so their files are left out.
-      def initialize(root:)
+      def initialize(root:, bare: false, execute: false)
         @root = root
+        @bare = bare
+        @execute = execute
         @load_errors = []
         @file_errors = []
         Nodes.load(File.join(root, Nodes::FOLDER))
@@ -36,7 +45,7 @@ module Raindown
 
       # A file's lines, headings and directives.
       def outline(path)
-        document = Document.read(path)
+        document = Document.read(path, bare: @bare)
         Outline.new(lines: File.readlines(path, chomp: true), headings: document.headings, directives: document.directives)
       end
 
@@ -52,23 +61,25 @@ module Raindown
         { cards: drawn, errors: @load_errors + @file_errors }
       end
 
-      # Every endpoint in the project's files, by its request, leaving out the ones whose snippet can't be read.
+      # Every endpoint in the project's files that writes its response back, so it can run, by its request, leaving out
+      # the ones whose snippet can't be read.
       def endpoints
         Projects.files(root).flat_map do |path|
           lines = File.readlines(path, encoding: Encoding::UTF_8)
-          Document.read(path).directives.select(&:endpoint?).filter_map { |directive| endpoint(path, lines, directive) }
+          runnable = Document.read(path, bare: @bare).directives.select { it.endpoint? && it.writes }
+          runnable.filter_map { |directive| endpoint(path, lines, directive) }
         rescue StandardError
           []
         end
       end
 
       def write_back(path)
-        Actions.write_back(path)
+        Actions.write_back(path, bare: @bare, execute: @execute)
       end
 
       # Runs the endpoint on the line, replacing its response.
       def execute(path, line)
-        directive = Document.read(path).directives.find { it.line == line && it.endpoint? }
+        directive = Document.read(path, bare: @bare).directives.find { it.line == line && it.endpoint? }
         raise Actions::NotAnEndpoint, "There's no endpoint on line #{line}" unless directive
 
         Actions.execute(path, directive)
@@ -84,7 +95,7 @@ module Raindown
 
       def charts_in(path)
         content = File.read(path, encoding: Encoding::UTF_8)
-        bare = BareDirectives.enabled?(path:, content:)
+        bare = @bare || BareDirectives.enabled?(path:, content:)
         lines = content.lines
         headings = Document.parse(content, bare:).headings
 
@@ -106,7 +117,7 @@ module Raindown
 
       def chart(block, path:, lines:, headings:)
         line = block[:open] + 1
-        directive = lines[block[:open]].strip.delete_prefix('<{').delete_suffix('}>').strip
+        directive = Directives.text(lines[block[:open]])
 
         { path:, line:, heading: headings.select { it.line < line }.last&.text, directive:, node: block[:node] }
       end

data/lib/raindown/tui/{menu_overlay.rb → project_box.rb}

@@ -11,7 +11,7 @@ module Raindown
     #                 │ ~/dev/raindown       │
     #                 └──────────────────────┘
     # Each item is clicked to choose it.
-    class MenuOverlay
+    class ProjectBox
       include Text
 
       def initialize(navigator, width:, column:)

data/lib/raindown/tui/renderers/renderer.rb

@@ -7,6 +7,7 @@ require_relative '../text'
 module Raindown
   module TUI
     # Draws what's in a pane, :nav or :main, as lines of the pane's width and height, which the Layout puts in it.
+    # Like the Layout, it's made again for each draw, so it draws what the Navigator and its view hold then.
     Renderer = Struct.new(:navigator, :pane, :width, :height) do
       include Rows
       include Text

data/lib/raindown/tui/saves.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative '../watcher/changes'
+
+module Raindown
+  module TUI
+    # The files saved, added or removed in the terminal UI's folder, like when it's watched, but kept until the Navigator
+    # takes them on its next tick, as Listen tells of them in a thread of its own.
+    class Saves
+      def initialize(root)
+        @queue = Thread::Queue.new
+        @listener = Watcher.listen(root) { |paths| paths.each { @queue << it } }
+        @listener.start
+      end
+
+      # The paths saved since they were last taken, once each.
+      def take = Array.new(@queue.size) { @queue.pop }.uniq
+
+      def stop = @listener.stop
+    end
+  end
+end

data/lib/raindown/tui/{search_overlay.rb → search_box.rb}

@@ -5,30 +5,35 @@ require_relative 'text'
 
 module Raindown
   module TUI
-    # The search, drawn over the screen's lines in a box below the title: what's typed, then the places that match it,
-    # each with where it is, and the selected one highlighted:
-    #    ┌─ Teleport ───────────────────────────────┐
+    # A search in a box, like Teleport's, drawn over the screen's lines below the title: what's typed, then the places
+    # that match it, each with where it is, and the selected one highlighted:
+    #    ┌──────────────── Teleport ────────────────┐
     #    │ / stp▏                                   │
     #    │ ## Setup               guides/setup.md:3 │
     #    │ ## Steps                     notes.md:12 │
     #    └──────────────────────────────────────────┘
-    # Each place is clicked to open it.
-    class SearchOverlay
+    # Each place is clicked to open it. Another search, like Blueprints' filter, is drawn the same, under its own title,
+    # from its query, its matches, each with its text and where it is, from the first it lists, and its selected match,
+    # clicked in its pane.
+    class SearchBox
       include Text
 
       # The widest the box is, with its border.
       MAX_WIDTH = 72
 
-      def initialize(navigator, width:)
-        @navigator = navigator
+      def initialize(search, width:, title: 'Teleport', pane: :teleport, top: 1)
+        @search = search
+        @title = title
+        @pane = pane
+        @top = top
         @box_width = [width - 4, MAX_WIDTH].min
         @column = (width - @box_width) / 2
       end
 
-      # The lines with the box drawn over them, from the line below the title.
+      # The lines with the box drawn over them, from its top line, below the title.
       def apply(lines)
         box.each_with_index do |segments, offset|
-          row = offset + 1
+          row = offset + @top
           lines[row] = overlay_segments(lines[row], segments, column: @column) if lines[row]
         end
         lines
@@ -40,22 +45,23 @@ module Raindown
       def inner = @box_width - 4
 
       def box
-        [edge('┌─ Teleport ', '┐'), boxed(segment("/ #{@navigator.query}▏", :menu, width: inner)), *results, edge('└', '┘')]
+        [title_edge, boxed(segment("/ #{@search.query}▏", :menu, width: inner)), *results, edge('└', '┘')]
       end
 
       def results
-        matches = @navigator.matches
+        matches = @search.matches
         return [boxed(segment('No matches', :info, width: inner))] if matches.empty?
 
-        matches.each_with_index.map { |place, index| place_line(place, index) }
+        first = @search.first_match
+        matches.each_with_index.map { |place, index| place_line(place, first + index) }
       end
 
       # The place's text, then where it is, on the right, both highlighted when it's selected.
       def place_line(place, index)
         text_style = :menu
         where_style = :body
-        text_style = where_style = :selected if @navigator.match == index
-        event = Click.new(pane: :search, index:, action: :enter)
+        text_style = where_style = :selected if @search.match == index
+        event = Click.new(pane: @pane, index:, action: :enter)
         where = " #{place.where}"
         where_width = [display_width(where), inner / 2].min
 
@@ -65,6 +71,13 @@ module Raindown
 
       def boxed(*segments) = [segment('│ ', :border, width: 2), *segments, segment(' │', :border, width: 2)]
 
+      # The box's top, with its title in the middle.
+      def title_edge
+        title = " #{@title} "
+        left = (@box_width - 2 - display_width(title)) / 2
+        edge("┌#{'─' * left}#{title}", '┐')
+      end
+
       def edge(left, right)
         [segment("#{left}#{'─' * (@box_width - display_width(left) - 1)}#{right}", :border, width: @box_width)]
       end

data/lib/raindown/tui/terminal/input.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
 
 require 'curses'
-require 'unicode/display_width'
 
 require_relative '../events'
+require_relative '../text'
+require_relative 'quiet'
 
 module Raindown
   module TUI
@@ -12,12 +13,14 @@ module Raindown
       KEYS = {
         Curses::KEY_UP => :up, 'k' => :up, Curses::KEY_DOWN => :down, 'j' => :down,
         Curses::KEY_LEFT => :left, 'h' => :left, Curses::KEY_RIGHT => :right, 'l' => :right,
+        Curses::KEY_SLEFT => :scroll_left, Curses::KEY_SRIGHT => :scroll_right, Curses::KEY_SR => :scroll_up,
+        Curses::KEY_SF => :scroll_down,
         "\t" => :tab, Curses::KEY_BTAB => :tab, "\r" => :enter, "\n" => :enter, Curses::KEY_ENTER => :enter,
         ' ' => :toggle, 'x' => :execute, 'e' => :edit, 'w' => :write_back, 'r' => :reload, 'd' => :dashboard,
-        'p' => :projects, 'f' => :feelings, "\x14" => :celebrate, '/' => :search,
-        '1' => :bin1, '2' => :bin2, '3' => :bin3, '4' => :bin4, '5' => :bin5, '6' => :bin6, "\e" => :escape, 'q' => :quit
+        'p' => :projects, 'f' => :feelings, 'b' => :blueprints, "\x14" => :celebrate, '/' => :search,
+        '1' => :bin1, '2' => :bin2, '3' => :bin3, '4' => :bin4, '5' => :bin5, "\e" => :escape, 'q' => :quit
       }.freeze
-      # While typing, like in the search, printable characters are typed, and only these keys do anything else.
+      # While typing, like in Teleport, printable characters are typed, and only these keys do anything else.
       TYPING_KEYS = {
         Curses::KEY_UP => :up, Curses::KEY_DOWN => :down, "\r" => :enter, "\n" => :enter, Curses::KEY_ENTER => :enter,
         "\e" => :escape, Curses::KEY_BACKSPACE => :backspace, "\x7F" => :backspace, "\b" => :backspace
@@ -25,6 +28,24 @@ module Raindown
 
       module_function
 
+      # The next event, or :tick when no key is pressed within the timeout, in milliseconds, or nil for keys without one,
+      # like a resize, which clears the screen to draw it again.
+      def read(timeout, zones:, typing:)
+        Curses.stdscr.timeout = timeout
+        key = Curses.stdscr.getch
+        return :tick if key.nil?
+        return mouse(zones) if key == Curses::KEY_MOUSE
+
+        Curses.stdscr.clear if key == Curses::KEY_RESIZE
+        key_event(key, typing:)
+      end
+
+      # The curses gem warns the first time it makes a MouseEvent, that it's "undefining the allocator" of the class.
+      def mouse(zones)
+        event = Quiet.quietly { Curses.getmouse }
+        mouse_event(event, zones) if event
+      end
+
       # A key from getch, which is a string for a printable character and otherwise a number.
       # Letters are the same with Shift, as the buttons show them as capitals, unless they're being typed.
       def key_event(key, typing: false)
@@ -43,6 +64,10 @@ module Raindown
       # like macOS's, has no button for scrolling down, it can't be mistaken for a click.
       CLICKS = Curses::BUTTON1_PRESSED | Curses::BUTTON1_CLICKED
 
+      # Letting go of the button, which older ncurses, like macOS's, also reports for each move while it's held, as it
+      # doesn't know the moves terminals send then.
+      RELEASE = Curses::BUTTON1_RELEASED
+
       # Moving the mouse, which terminals report once they're asked to, with any motion tracking.
       MOTION = Curses::REPORT_MOUSE_POSITION
       ANY_MOTION = "\e[?1003h"
@@ -51,7 +76,7 @@ module Raindown
       # The terminal sends the app its mouse events, clicks and moves, so scrolling doesn't scroll the terminal either.
       # ncurses only asks some terminals to report every move, so it's asked directly too, until untrack_mouse.
       def track_mouse
-        Curses.mousemask(CLICKS | MOTION)
+        Curses.mousemask(CLICKS | RELEASE | MOTION)
         Curses.mouseinterval(0)
         $stdout.write(ANY_MOTION)
         $stdout.flush
@@ -62,20 +87,46 @@ module Raindown
         $stdout.flush
       end
 
-      # A click sends the event of what's under it, and moving the mouse a Hover of it.
+      # A click sends the event of what's under it, and moving the mouse a Hover of it, or a Drag by how far it's moved
+      # since the last event while the button's held. Terminals and ncurses versions report that in their own ways: a
+      # move the button's held for, a move after a press, until the release, or with older ncurses and some terminals,
+      # a release somewhere else than the last event, for each move. A release where the mouse already is, which ends a
+      # click or a drag, does nothing.
       def mouse_event(event, zones)
+        from = @last
+        @last = [event.x, event.y]
+        held = hold(event.bstate)
+        return drag(from, event) if from && dragged?(event, held:, moved: from != @last)
+        return if event.bstate.anybits?(RELEASE)
+
         target = click(zones, column: event.x, row: event.y)
         return target if event.bstate.anybits?(CLICKS)
 
         Hover.new(target:) if event.bstate.anybits?(MOTION)
       end
 
+      # Whether the button was held before this event, which holds it from a press until a release.
+      def hold(bstate)
+        held = @held
+        @held = bstate.anybits?(CLICKS) || (held && !bstate.anybits?(RELEASE))
+        held
+      end
+
+      def drag(from, event) = Drag.new(columns: event.x - from[0], rows: event.y - from[1])
+
+      def dragged?(event, held:, moved:)
+        bstate = event.bstate
+        return held || bstate.anybits?(Curses::BUTTON1_PRESSED) if bstate.anybits?(MOTION)
+
+        moved && bstate.anybits?(RELEASE)
+      end
+
       # Where each of a Layout's segments with an event is on the screen, as [row, columns, event].
       def zones(lines)
         lines.each_with_index.flat_map do |segments, row|
           column = 0
           segments.filter_map do |segment|
-            width = Unicode::DisplayWidth.of(segment.text)
+            width = Text.display_width(segment.text)
             zone = [row, column...(column + width), segment.event] if segment.event
             column += width
             zone