tui_tui 0.1.0

data/examples/life.rb

@@ -0,0 +1,144 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Conway's Game of Life: a tick-driven, full-screen cellular automaton with no
+# widgets and no domain. It shows TuiTui's renderer under heavy load — every
+# generation repaints many cells, and the CanvasCompositor only writes the rows
+# that changed — plus `wants_tick?` animation. Cells are a space in a background
+# color (ASCII-only, N7). The grid is toroidal (wraps at the edges).
+#
+#   ruby examples/life.rb
+#
+# Mouse: click or drag to add cells (right-drag removes) — pause to draw a pattern.
+# Keys: Space pause/resume, s single-step (while paused), +/- speed (generations
+# per frame), r reseed, q quit. Rendering runs at ~60 fps (tick 1/60); a frame —
+# step + view + diff — measures well under the 16 ms budget even on a large, dense
+# board, so the CPU is not the limit. +/- accelerates the simulation (more
+# generations per frame) without redrawing more often.
+
+require "set"
+require_relative "../lib/tui_tui"
+
+module LifeSample
+  CELL = TuiTui::Style.new(bg: :green)
+  BAR = TuiTui::Style.new(attrs: [:reverse])
+  GLIDER = [[0, 1], [1, 2], [2, 0], [2, 1], [2, 2]].freeze
+
+  class Life
+    def initialize(rows: 24, cols: 80)
+      @rows = rows
+      @cols = cols
+      @paused = false
+      @gen = 0
+      @speed = 1 # generations advanced per tick (render stays one frame per tick)
+      reseed
+    end
+
+    # Idle while paused; otherwise the Runtime ticks us to advance generations.
+    def wants_tick? = !@paused
+
+    def update(event)
+      case event
+      when TuiTui::KeyEvent then handle_key(event.key)
+      when TuiTui::MouseEvent then handle_mouse(event)
+      when TuiTui::ResizeEvent then resize(event.size)
+      when TuiTui::TickEvent then advance
+      else self
+      end
+    end
+
+    def view(size)
+      @rows = size.rows
+      @cols = size.cols
+      canvas = TuiTui::Canvas.blank(size)
+      @alive.each do |(row, col)|
+        canvas.text(row, col, " ", CELL) if row.between?(1, size.rows - 1) && col.between?(1, size.cols)
+      end
+      draw_status(canvas, size)
+      canvas
+    end
+
+    private
+
+    def handle_key(key)
+      case key
+      when "q", TuiTui::KeyCode::CTRL_C then return :quit
+      when " " then @paused = !@paused
+      when "s" then step if @paused # single-step
+      when "r" then reseed
+      when "+", "=" then @speed += 1
+      when "-", "_" then @speed = [@speed - 1, 1].max
+      end
+      self
+    end
+
+    def resize(size)
+      @rows = size.rows
+      @cols = size.cols
+      self
+    end
+
+    # Click or drag to bring cells to life (right button kills them). Pause first
+    # to draw a pattern; while running a lone cell dies next generation, as Life
+    # demands. The status row is left alone.
+    def handle_mouse(event)
+      return self unless %i[press drag].include?(event.action)
+      return self unless event.row.between?(1, @rows - 1)
+
+      cell = [event.row, event.col]
+      event.button == :right ? @alive.delete(cell) : @alive.add(cell)
+      self
+    end
+
+    # Render is one frame per tick; the simulation runs `@speed` generations in
+    # between, which decouples animation speed from the render frame rate.
+    def advance
+      @speed.times { step }
+      self
+    end
+
+    # One generation (B3/S23) on a toroidal grid: a cell lives next gen with 3
+    # live neighbors, or 2 if already alive.
+    def step
+      counts = Hash.new(0)
+      @alive.each { |(r, c)| neighbors(r, c).each { |cell| counts[cell] += 1 } }
+      @alive = counts.filter_map { |cell, n| cell if n == 3 || (n == 2 && @alive.include?(cell)) }.to_set
+      @gen += 1
+    end
+
+    def neighbors(row, col)
+      result = []
+      (-1..1).each do |dr|
+        (-1..1).each do |dc|
+          next if dr.zero? && dc.zero?
+
+          result << [(row + dr - 1) % @rows + 1, (col + dc - 1) % @cols + 1]
+        end
+      end
+      result
+    end
+
+    # Scatter a few gliders so there is immediate, visible motion.
+    def reseed
+      @gen = 0
+      @alive = Set.new
+      [[3, 3], [3, 30], [12, 50], [16, 10]].each { |r0, c0| place(GLIDER, r0, c0) }
+    end
+
+    def place(pattern, row0, col0)
+      pattern.each { |dr, dc| @alive << [((row0 + dr - 1) % @rows) + 1, ((col0 + dc - 1) % @cols) + 1] }
+    end
+
+    def draw_status(canvas, size)
+      state = @paused ? "paused" : "running"
+      text = " gen #{@gen}  (#{@alive.size} alive, #{state}, #{@speed}x)  " \
+             "click=draw  Space=pause  s=step  +/-=speed  r=reseed  q=quit"
+      rect = TuiTui::Rect.new(row: size.rows, col: 1, rows: 1, cols: size.cols)
+      TuiTui::StatusBar.draw(canvas, rect, left: text, style: BAR)
+    end
+  end
+end
+
+if $PROGRAM_NAME == __FILE__
+  TuiTui::Runtime.new(LifeSample::Life.new).run(tick: 1.0 / 60) # ~60 fps render
+end

data/examples/paint.rb

@@ -0,0 +1,246 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# A mouse demo + color/style showcase. Drag in the canvas to paint cells;
+# right-drag erases. Press `p` (or click the color swatch) to open a color
+# picker dialog — a grid of all 256 terminal colors, choosable by arrows+Enter
+# or a mouse click, and movable by dragging its title bar. The header row shows
+# the text attributes as live samples.
+# Cells (and swatches) are a space in a background color (ASCII-only, N7).
+#
+#   ruby examples/paint.rb
+#
+# Mouse: drag = paint, right-drag = erase, click the swatch = open colors.
+# Keys: p colors, [ / ] brush size, c clear, q (or Ctrl-C) quit.
+
+require_relative "../lib/tui_tui"
+
+module PaintSample
+  DIM = TuiTui::Style.new(attrs: [:dim])
+  BAR = TuiTui::Style.new(attrs: [:reverse])
+  TITLE = TuiTui::Style.new(attrs: [:bold])
+  ATTRS = %i[bold dim italic underline reverse].freeze
+
+  STYLES_ROW = 1
+  STATUS_ROW = 2
+  PAINT_TOP = 3
+  SWATCH_COL = " color: ".length + 1 # the status-row swatch column (click to open)
+
+  # A modal color picker: the 256 terminal colors as a 16-wide grid, chosen with
+  # the arrow keys + Enter, or a mouse click. `handle` / `handle_mouse` return the
+  # chosen color index, :cancel, or nil while still open. The grid geometry is
+  # recorded at draw time so a click can be hit-tested against the current frame.
+  class ColorPicker
+    COLS = 16
+    COUNT = 256
+    SW = 2 # swatch width
+
+    attr_reader :pos # [row, col] top-left, or nil if never moved (so the app can reopen it in place)
+
+    def initialize(current: 0, pos: nil)
+      @cursor = current
+      @pos = pos  # [row, col] top-left once the dialog has been moved; nil = centered
+      @rect = nil # the current frame rect, recorded at draw time for hit-testing
+      @drag = nil # [dy, dx]: the pointer's offset within the dialog while dragging it
+    end
+
+    def handle(key)
+      case key
+      when :left then move(-1)
+      when :right then move(1)
+      when :up then move(-COLS)
+      when :down then move(COLS)
+      when "\r", " " then @cursor
+      when :escape, TuiTui::KeyCode::CTRL_C then :cancel
+      end
+    end
+
+    # Press on the title bar -> start moving the dialog; press on a swatch -> pick
+    # it; drag -> move; release -> stop. Returns the chosen index, or nil (open).
+    def handle_mouse(event)
+      case event.action
+      when :press then press(event)
+      when :drag then continue_drag(event)
+      when :release then end_drag
+      end
+    end
+
+    def draw(canvas, size)
+      @rect = frame_rect(size)
+      canvas.frame(@rect)
+      title = TuiTui::DisplayText.new("pick a color: #{@cursor}  (drag title to move)")
+      canvas.text(@rect.row + 1, @rect.col + 2, title.truncate(@rect.cols - 4), TITLE)
+      COUNT.times { |i| draw_swatch(canvas, i) }
+      canvas
+    end
+
+    private
+
+    def frame_rect(size)
+      width = (COLS * SW) + 4
+      height = (COUNT / COLS) + 4
+      return TuiTui::Rect.centered(size, cols: width, rows: height) unless @pos
+
+      TuiTui::Rect.new(
+        row: @pos[0].clamp(1, [size.rows - height + 1, 1].max),
+        col: @pos[1].clamp(1, [size.cols - width + 1, 1].max),
+        rows: height, cols: width
+      )
+    end
+
+    def grid_top = @rect.row + 3
+    def grid_left = @rect.col + 2
+
+    def draw_swatch(canvas, index)
+      row = grid_top + (index / COLS)
+      col = grid_left + ((index % COLS) * SW)
+      if index == @cursor
+        canvas.text(row, col, "[]", TuiTui::Style.new(bg: index, fg: :bright_white))
+      else
+        canvas.text(row, col, "  ", TuiTui::Style.new(bg: index))
+      end
+    end
+
+    def press(event)
+      if on_title_bar?(event)
+        @drag = [event.row - @rect.row, event.col - @rect.col] # pointer offset within the dialog
+        nil
+      else
+        hit(event.row, event.col)
+      end
+    end
+
+    def continue_drag(event)
+      return nil unless @drag
+
+      @pos = [event.row - @drag[0], event.col - @drag[1]] # keep the grab point under the pointer
+      nil
+    end
+
+    def end_drag
+      @drag = nil
+      nil
+    end
+
+    # The top border + title row: grabbing here moves the dialog.
+    def on_title_bar?(event)
+      @rect && event.row.between?(@rect.row, @rect.row + 1) &&
+        event.col.between?(@rect.col, @rect.col + @rect.cols - 1)
+    end
+
+    def move(delta)
+      @cursor = (@cursor + delta).clamp(0, COUNT - 1)
+      nil
+    end
+
+    def hit(row, col)
+      grow = row - grid_top
+      gcol = (col - grid_left) / SW
+      return nil unless col >= grid_left && grow.between?(0, (COUNT / COLS) - 1) && gcol.between?(0, COLS - 1)
+
+      (grow * COLS) + gcol
+    end
+  end
+
+  class Paint
+    def initialize
+      @cells = {} # [row, col] => color index
+      @color = 9  # bright red
+      @brush = 1
+      @rows = 24
+      @modal = nil
+      @picker_pos = nil # where the picker was last left, so it reopens in place
+    end
+
+    def update(event)
+      case event
+      when TuiTui::KeyEvent then @modal ? route(@modal.handle(event.key)) : handle_key(event.key)
+      when TuiTui::MouseEvent then @modal ? route(@modal.handle_mouse(event)) : handle_mouse(event)
+      else self
+      end
+    end
+
+    def view(size)
+      @rows = size.rows
+      canvas = TuiTui::Canvas.blank(size)
+      @cells.each do |(row, col), color|
+        next unless row.between?(PAINT_TOP, size.rows) && col.between?(1, size.cols)
+
+        canvas.text(row, col, " ", TuiTui::Style.new(bg: color))
+      end
+      draw_styles(canvas)
+      draw_status(canvas, size)
+      @modal&.draw(canvas, size)
+      canvas
+    end
+
+    private
+
+    # Resolve a modal result: an Integer is the picked color; :cancel keeps the
+    # current one; nil means the dialog is still open.
+    def route(result)
+      return self if result.nil?
+
+      @color = result if result.is_a?(Integer)
+      @picker_pos = @modal.pos # remember where it was so the next open lands there
+      @modal = nil
+      self
+    end
+
+    def handle_key(key)
+      case key
+      when "q", TuiTui::KeyCode::CTRL_C then return :quit
+      when "p" then @modal = ColorPicker.new(current: @color, pos: @picker_pos)
+      when "c" then @cells = {}
+      when "]" then @brush += 1
+      when "[" then @brush = [@brush - 1, 1].max
+      end
+      self
+    end
+
+    def handle_mouse(event)
+      return self unless %i[press drag].include?(event.action)
+
+      if event.row == STATUS_ROW && (SWATCH_COL..SWATCH_COL + 1).cover?(event.col)
+        @modal = ColorPicker.new(current: @color, pos: @picker_pos)
+      elsif event.row >= PAINT_TOP
+        stroke(event)
+      end
+      self
+    end
+
+    # Paint (or erase) a brush-sized square centered on the pointer.
+    def stroke(event)
+      top = event.row - ((@brush - 1) / 2)
+      left = event.col - ((@brush - 1) / 2)
+      @brush.times do |dr|
+        @brush.times do |dc|
+          row = top + dr
+          col = left + dc
+          next unless row.between?(PAINT_TOP, @rows) && col >= 1
+
+          cell = [row, col]
+          event.button == :right ? @cells.delete(cell) : @cells[cell] = @color
+        end
+      end
+    end
+
+    def draw_styles(canvas)
+      spans = [TuiTui::Span["styles: ", DIM]]
+      ATTRS.each { |attr| spans << TuiTui::Span[attr.to_s, TuiTui::Style.new(attrs: [attr])] << TuiTui::Span["  "] }
+      canvas.line(STYLES_ROW, 1, spans) # Canvas advances the column per span
+    end
+
+    def draw_status(canvas, size)
+      canvas.fill(TuiTui::Rect.new(row: STATUS_ROW, col: 1, rows: 1, cols: size.cols), BAR)
+      canvas.text(STATUS_ROW, 1, " color: ", BAR)
+      canvas.text(STATUS_ROW, SWATCH_COL, "  ", TuiTui::Style.new(bg: @color))
+      hints = "  ##{@color}  brush #{@brush}  p=colors  [ ]=size  right-drag=erase  c=clear  q=quit"
+      canvas.text(STATUS_ROW, SWATCH_COL + 2, TuiTui::DisplayText.new(hints).truncate(size.cols - SWATCH_COL - 1), BAR)
+    end
+  end
+end
+
+if $PROGRAM_NAME == __FILE__
+  TuiTui::Runtime.new(PaintSample::Paint.new).run
+end

data/examples/todo.rb

@@ -0,0 +1,250 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# A small but usable todo list. It demonstrates a typical TuiTui app shape:
+# a ScrollList-backed main view, styled rows built from Line/Span, modal widgets
+# for add/edit/delete/help, and width-safe rendering for Japanese text.
+#
+#   ruby examples/todo.rb
+#
+# Keys: j/k (or ↑/↓) move, Space toggle, a add, e edit, d delete, f filter,
+# c clear filter, ? help, q (or Ctrl-C) quit.
+
+require_relative "../lib/tui_tui"
+
+module TodoSample
+  Todo = Data.define(:title, :done)
+
+  S = TuiTui::Style
+  STYLE = {
+    title: S.new(attrs: [:bold]),
+    dim: S.new(attrs: [:dim]),
+    done: S.new(fg: :green),
+    pending: S.new(fg: :yellow),
+    select: S.new(attrs: [:reverse]),
+    select_pending: S.new(fg: :yellow, attrs: [:reverse]),
+    select_done: S.new(fg: :green, attrs: [:reverse]),
+    empty: S.new(fg: :bright_black, attrs: [:italic]),
+    filter: S.new(fg: :cyan, attrs: [:bold]),
+  }.freeze
+
+  HELP = [
+    ["j / k  ↑ / ↓", "move"],
+    ["Space", "toggle done"],
+    ["a", "add a todo"],
+    ["e", "edit selected todo"],
+    ["d", "delete selected todo"],
+    ["f", "filter by text"],
+    ["c", "clear filter"],
+    ["g / G", "top / bottom"],
+    ["?", "this help"],
+    ["q", "quit"],
+  ].freeze
+
+  SEED = [
+    Todo.new("Add a useful example", false),
+    Todo.new("Keep rendering width-safe", true),
+    Todo.new("日本語のタスクも崩れない", false),
+  ].freeze
+
+  class App
+    def initialize(todos = SEED)
+      @todos = todos.dup
+      @list = TuiTui::ScrollList.new
+      @filter = ""
+      @modal = nil
+      @on_result = nil
+      @toast = nil
+      sync_list
+    end
+
+    # Keep ticking only while a toast is showing, so it auto-dismisses.
+    def wants_tick? = !@toast.nil?
+
+    def update(event)
+      @toast = nil if @toast&.expired?
+      return self unless event.is_a?(TuiTui::KeyEvent)
+      return route_modal(event.key) if @modal
+
+      handle_key(event.key)
+    end
+
+    def view(size)
+      canvas = TuiTui::Canvas.blank(size)
+      body_rows = [size.rows - 4, 1].max
+      body = TuiTui::Rect.new(row: 3, col: 2, rows: body_rows, cols: [size.cols - 2, 1].max)
+
+      draw_header(canvas, size)
+      draw_list(canvas, body)
+      draw_status(canvas, size)
+      @toast&.draw(canvas, size, style: STYLE[:select])
+      @modal&.draw(canvas, size)
+      canvas
+    end
+
+    private
+
+    def toast(message) = @toast = TuiTui::Toast.new(message)
+
+    def handle_key(key)
+      case key
+      when "q", TuiTui::KeyCode::CTRL_C then return :quit
+      when "?" then open_modal(TuiTui::Help.new("Todo keys", HELP)) { nil }
+      when "a" then prompt_add
+      when "e" then prompt_edit
+      when "d" then confirm_delete
+      when "f" then prompt_filter
+      when "c" then clear_filter
+      when " ", "\r" then toggle
+      when "j", :down then @list.move(1)
+      when "k", :up then @list.move(-1)
+      when "g", :home then @list.to_top
+      when "G", :end then @list.to_end
+      end
+      self
+    end
+
+    def open_modal(widget, &on_result)
+      @modal = widget
+      @on_result = on_result
+    end
+
+    def route_modal(key)
+      result = @modal.handle(key)
+      return self if result.nil?
+
+      @modal = nil
+      @on_result.call(result)
+      sync_list
+      self
+    end
+
+    def prompt_add
+      open_modal(TuiTui::Prompt.new("New todo:")) do |result|
+        next unless result.is_a?(Array) && result.first == :ok
+
+        title = result.last.strip
+        next if title.empty?
+
+        @todos << Todo.new(title, false)
+        toast("added: #{title}")
+      end
+    end
+
+    def prompt_edit
+      index = selected_index
+      return unless index
+
+      open_modal(TuiTui::Prompt.new("Edit todo:", value: @todos[index].title)) do |result|
+        next unless result.is_a?(Array) && result.first == :ok
+
+        title = result.last.strip
+        next if title.empty?
+
+        @todos[index] = @todos[index].with(title: title)
+        toast("updated")
+      end
+    end
+
+    def prompt_filter
+      open_modal(TuiTui::Prompt.new("Filter:", value: @filter)) do |result|
+        next unless result.is_a?(Array) && result.first == :ok
+
+        @filter = result.last.strip
+      end
+    end
+
+    def confirm_delete
+      index = selected_index
+      return unless index
+
+      title = TuiTui::DisplayText.new(@todos[index].title).truncate(30)
+      open_modal(TuiTui::Confirm.new("Delete #{title}?", ok: "Delete")) do |result|
+        next unless result == :ok
+
+        @todos.delete_at(index)
+        toast("deleted")
+      end
+    end
+
+    def clear_filter
+      @filter = ""
+      sync_list
+    end
+
+    def toggle
+      index = selected_index
+      return unless index
+
+      todo = @todos[index]
+      @todos[index] = todo.with(done: !todo.done)
+      toast(todo.done ? "reopened" : "done")
+    end
+
+    def draw_header(canvas, size)
+      canvas.text(1, 2, "Todo list", STYLE[:title])
+      if @filter.empty?
+        canvas.text(1, 14, "#{open_count} open / #{@todos.size} total", STYLE[:dim])
+      else
+        canvas.text(1, 14, "filter: #{@filter}", STYLE[:filter])
+      end
+      canvas.hline(2, 1, size.cols, "-", STYLE[:dim])
+    end
+
+    def draw_list(canvas, rect)
+      sync_list
+      if visible.empty?
+        message = @filter.empty? ? "No todos. Press a to add one." : "No matches. Press c to clear the filter."
+        canvas.text(rect.row, rect.col, message, STYLE[:empty])
+        return
+      end
+
+      TuiTui::List.new(@list).draw(canvas, rect, highlight: STYLE[:select]) do |visible_index, selected|
+        todo = @todos[visible[visible_index]]
+        row_line(todo, selected)
+      end
+    end
+
+    def row_line(todo, selected)
+      marker = todo.done ? "[x] " : "[ ] "
+      state = row_state(todo, selected)
+      text = todo.done ? STYLE[:dim] : nil
+
+      TuiTui::Line[
+        TuiTui::Span[marker, state],
+        TuiTui::Span[todo.title, selected ? STYLE[:select] : text],
+      ]
+    end
+
+    def row_state(todo, selected)
+      return todo.done ? STYLE[:select_done] : STYLE[:select_pending] if selected
+
+      todo.done ? STYLE[:done] : STYLE[:pending]
+    end
+
+    def draw_status(canvas, size)
+      status = " a add   e edit   d delete   f filter   Space toggle   ? help   q quit"
+      canvas.hline(size.rows - 1, 1, size.cols, "-", STYLE[:dim]) if size.rows > 1
+      canvas.text(size.rows, 1, status, STYLE[:dim])
+    end
+
+    def selected_index = visible[@list.cursor]
+
+    def visible
+      return (0...@todos.size).to_a if @filter.empty?
+
+      needle = @filter.downcase
+      @todos.each_index.select { |index| @todos[index].title.downcase.include?(needle) }
+    end
+
+    def sync_list
+      @list.count = visible.size
+    end
+
+    def open_count = @todos.count { |todo| !todo.done }
+  end
+end
+
+if $PROGRAM_NAME == __FILE__
+  TuiTui::Runtime.new(TodoSample::App.new).run
+end