zaniah 0.6.1 → 0.6.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bf9a2c8a283e0a76e76d5c3e8bd3f10c8a54d6da3fd4736e96d5f9ad5c35a50a
-  data.tar.gz: 1374f35e06698a1e3ba7dd793a7189339adc8bb57035a1c6032c96264afc4550
+  metadata.gz: d5d0895db7cb838e553fc0e7de6c20df016c9c56d3938cfaa94dc99cc47f2ab2
+  data.tar.gz: ef786f1e8ee6e87da921f317bd7901d97553e1fbe9e3e6969bb5df588a300754
 SHA512:
-  metadata.gz: bace7f7d90e3f029821584b609c22af25f9281cabde5e4a8ce1082aa98a05423e3f994dcc0f3890ee16fc6631e7acd006ec1040e8a56ae62734bb74645989de3
-  data.tar.gz: d0d64e184d2f2930eeb4264e58b9f6687af8fa466a65de07560a8931f5327122332959e85ad2496c48fbc8e1c6e0f02456d9c3979d62182117092e46d654bcb7
+  metadata.gz: e784d7df56037b50a88e4e8e4fdccbba5f9544b5e7d56b88480f78468627210919f8a87093ea6d461ba56355bb179c7fbe96d8d52d7990a6107d96ce73fc9872
+  data.tar.gz: e9e9726a52da9e277d6ebc56f6587a08ca0550e4fbfd83fbb25ef8fe75b58cb8badc976af92b179e530342d9da96aeda8f91332d395f12c77963bfee1c808f19

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 0.6.3 — 2026-09-23
+
+- Render supplied text grid cells directly as cell surfaces, avoiding an extra wrapper per visible cell.
+- Add a two-axis virtualized UI grid with frozen panes, range selection, variable sizing, resize, and fill callbacks.
+- Preserve explicit grid row/column sizes across viewport rebuilds and support validated, batched row/column hide and unhide.
+- Add editable rich text with style spans, paragraph alignment/lists, selection, caret, and IME composition.
+- Decode baseline 8-bit JPEG images, including Exif orientation, grayscale, RGB, and common YCbCr sampling modes; detect JPEG images from bytes.
+- Allow Alhena 0.3 while retaining compatibility with the existing Alhena 0.2 API.
+
+## 0.6.2 — 2026-09-21
+
+- Add GIF decoding and a damage-aware terminal grid view.
+
 ## 0.6.1 — 2026-09-21
 
 - Add a deterministic headless demo image and regeneration task.

data/README.md

@@ -42,7 +42,9 @@ the editor, providing the native rendering layer for its UI.
 - Scroll views, inertial input, and uniform or variable-height virtual lists
 - Stable-ID pointer and keyboard reordering without materializing virtual collections
 - Stable-ID split-pane grids with fixed, fractional, and minmax tracks
+- Two-axis virtual data grids with frozen panes, range selection, and editable rich text with IME
 - OpenType shaping, font fallback, Japanese wrapping, text overlays, low-resolution text caching, selection, editing, and IME
+- PNG, GIF, and baseline JPEG image decoding with Exif orientation
 - Themes, state styles, keyed animation, springs, and reduced-motion support
 - Opt-in controls, overlays, tables, externally completable lazy virtual trees, charts, forms, and terminal fallbacks
 - Spatial keyboard focus and a stable-ID, event-diffed cross-platform accessibility tree
@@ -114,10 +116,17 @@ For an interactive window, choose `backend: :mac`, `:linux`, `:windows`, or
 Native backends use the operating system libraries through Ruby's Fiddle. See
 [Native backends](docs/native.md) for platform requirements and checks.
 
+Native macOS, Windows, and X11 windows can be moved to a display returned by
+`Zaniah::Platform.displays` with `window.move_to_display(display)`. Headless and
+terminal windows cannot be placed on physical displays. Wayland does not permit
+arbitrary client window placement; its `fullscreen_on(display)` asks the
+compositor to fullscreen on that output, but the compositor may choose otherwise.
+
 ## Documentation
 
 - [Native backends](docs/native.md) — windows, displays, file watching, and terminals
 - [Text system](docs/text.md) — font discovery, shaping, rasterization, and caching
+- [Images](docs/images.md) — PNG, GIF, baseline JPEG, and orientation support
 - [SVG and lists](docs/vector_and_list.md) — static vector icons and virtual lists
 - [Drag-and-drop reordering](docs/drag_drop.md) — stable IDs, virtual targets, and keyboard access
 - [Layout and scrolling](docs/layout.md) — Grid, resizable pane grids, scrolling, sticky positioning, and RTL foundations

data/docs/adr/012-productivity-components.md

@@ -0,0 +1,25 @@
+# ADR 012: Keep productivity components separate from existing controls
+
+- Status: Accepted
+- Date: 2026-09-23
+
+## Context
+
+The spreadsheet and presentation applications need sparse two-axis grids and
+inline rich-text editing. `UI::Table` models records by column definitions;
+`List::HeightIndex` indexes one axis; and `UI::TextInputs` edits plain text.
+
+## Decision
+
+- Use a dedicated virtualized `UI::Grid`; `UI::Table` is not a substitute for
+  million-row sparse cell coordinates, range selection, or frozen panes.
+- Reuse `List::HeightIndex` independently for each grid axis rather than
+  generalizing it into a second indexing abstraction.
+- Keep `UI::TextInputs` unchanged and implement inline rich text in a separate
+  surface so existing plain-text editing behavior remains stable.
+
+## Consequences
+
+The productivity features stay additive and preserve existing table and text
+input APIs. The grid shares the tested prefix-index implementation while
+maintaining separate row and column state.

data/docs/components.md

@@ -84,6 +84,7 @@ Zaniah::UI::Button.variants[:variant][:brand] = ->(theme) {
 | L3 | `DockPanel` | `(center:, top:, right:, bottom:, left:)` | five-region layout | group |
 | L3 | `ListView` | `(items, height:, row_height:, selected:)`; `on_select` | virtual rows and keyboard selection | list/listitem |
 | L4 | `Table`, `DataGrid` | `(rows, columns:, height:, selection:, row_key:)`; `on_sort`, `on_select`, `on_edit` | virtual rows, sorting, resizing, editing | table/row/cell |
+| L4 | `Grid` | `(rows:, columns:, row_height:, column_width:, frozen_rows:, frozen_columns:)`; `scroll_to`, range `selection`, `on_select`, `on_edit`, `on_fill`, `on_resize` | two-axis virtualization, frozen panes, visible-cell resize/fill callbacks | table |
 | L4 | `TreeView` | `(items, height:, selected:)`; `expand`, `collapse`, `replace`, `replace_children`, `invalidate`, lazy `children` proc | arrows/Home/End | tree/treeitem |
 | L5 | `Sparkline` | `(values, width:, height:, color:, label:)` | line + tooltip | image |
 | L5 | `LineChart`, `BarChart` | `(series, width:, height:, colors:, label:)` | axes, legend, tooltip | image |
@@ -91,12 +92,26 @@ Zaniah::UI::Button.variants[:variant][:brand] = ->(theme) {
 | L5 | `FormField` | `(name, value:, label:, control:, validation:, hint:)` | errors + describedby | group/control/alert |
 | L5 | `Form` | `field`, `on_change`, `on_submit`, `values`, `valid?` | validates before submit | form |
 | L5 | `CodeEditor` | `(value, language:, line_numbers:, read_only:)`; `on_change` | multiline editor with scrolling | textbox |
-| L5 | `RichText` | `(runs, selectable:)` | styled selectable runs | text |
+| L5 | `RichText` | `(runs, selectable:, editable:)`; `apply`, `insert`, `delete`, `replace`, `paragraph_style` | styled editing, IME, range selection and caret | text/textbox |
 
 All input components are keyboard operable. Disabled controls remain visible but are
 removed from focus traversal. Overlay components close on Esc; modal overlays restore
 the previous focus. See [TUI](tui.md) for terminal representations.
 
+`UI::RichText` accepts UTF-8 byte ranges at grapheme boundaries. Inline styles are
+`bold`, `italic`, `size`, `color`, `font`, and `link`; paragraphs support start,
+center, end, and non-final-line justification, plus bullet/ordered lists and levels.
+It is read-only by default; set `editable: true` to enable keyboard editing and IME.
+
+## Image decoding
+
+`Image.from_bytes(bytes)` detects PNG, GIF, and baseline JPEG by signature. Pass
+`format: :png`, `:gif`, or `:jpeg` to choose explicitly. JPEG supports 8-bit
+baseline grayscale and three-component RGB/YCbCr, JFIF frame dimensions, Exif
+orientation 1–8, and 4:4:4, 4:2:2, and 4:2:0 sampling. Progressive, CMYK,
+arithmetic-coded, and multi-scan JPEG files raise `JPEG::Error`; the default
+pixel limit is 16,777,216.
+
 Table columns are hashes with `key`, and optional `label`, `width`, `sortable`,
 `resizable`, `editable`, and `render`. Tree items accept hashes containing `id`,
 `label`, and either an array or lazy proc in `children`. A lazy proc receives the

data/docs/images.md

@@ -0,0 +1,18 @@
+# Images
+
+`Zaniah::Image` accepts PNG, GIF, and baseline JPEG data. Paths are read as
+bytes, then the format is selected from its signature; use `from_bytes` when
+the application already has the encoded data:
+
+```ruby
+image = Zaniah::Image.from_bytes(File.binread("photo.jpg"))
+explicit = Zaniah::Image.from_bytes(bytes, format: :jpeg)
+```
+
+JPEG decoding is pure Ruby and returns RGBA pixels. It supports 8-bit baseline
+grayscale, RGB (Adobe transform 0), and YCbCr, including JFIF frame dimensions,
+Exif orientation 1–8, and 4:4:4, 4:2:2, and 4:2:0 sampling. Progressive,
+extended, arithmetic-coded, CMYK, and multi-scan JPEGs are not supported;
+unsupported coding processes raise `Zaniah::JPEG::Error` instead of producing
+an incomplete image. `JPEG.decode` limits images to 16,777,216 pixels by
+default and accepts a different positive `max_pixels` limit explicitly.

data/docs/layout.md

@@ -37,6 +37,52 @@ stable accessibility IDs, focus state, value, orientation, and direct increment,
 decrement, minimum, and maximum actions use the same clamped resize path. Nested
 `PaneGrid` instances compose without owning editor, terminal, or document state.
 
+## Two-axis virtual grid
+
+`UI::Grid` virtualizes rows and columns independently. It uses estimated row and
+column sizes for a large sheet, calling the size procs only for frozen and
+visible cells. Use `frozen_rows` and `frozen_columns` for headers and key
+columns; cell ranges are represented by half-open integer ranges.
+
+```ruby
+grid = Zaniah::UI::Grid.new(
+  rows: 1_048_576, columns: 16_384,
+  row_height: ->(row) { row.zero? ? 32 : 24 },
+  column_width: ->(column) { column.zero? ? 180 : 96 },
+  frozen_rows: 1, frozen_columns: 1
+) do |row, column, bounds, cx|
+  Zaniah::UI::Label.new("#{row},#{column}")
+end
+
+grid.on_select { |areas, _event, _cx| p areas }
+grid.on_edit { |row, column, _event, _cx| edit_cell(row, column) }
+grid.on_fill { |source, destination, _cx| fill_cells(source, destination) }
+grid.on_resize { |axis, index, size, _cx| save_size(axis, index, size) }
+```
+
+The renderer returns an Element, String, Numeric, or `nil` for each visible
+cell. `bounds` is local to the grid viewport. Set `estimated_row_height` or
+`estimated_column_width` when proc-based sizes differ substantially from the
+defaults. `scroll_to(row:, column:)` ensures the target cell is visible.
+Resizing is available by dragging a visible cell's lower/right edge or by
+calling `set_row_height` / `set_column_width`; explicit size overrides persist
+when the virtualized viewport is rebuilt. `hide_row` / `unhide_row` and
+`hide_column` / `unhide_column` set or restore an axis entry's size to zero;
+indexes are validated against the grid and zero-sized entries are skipped by
+offset lookup. `hide_rows(indices, hidden:)` and `hide_columns(indices, hidden:)`
+apply a validated batch with a single frame request; `row_hidden?` and
+`column_hidden?` report current state. Fill only reports the source and
+destination areas; the application owns cell values and fill semantics. Shift
+extends a range; Cmd/Ctrl-click toggles an additional cell range.
+
+`bench/grid.rb` measures a headless 800×600 viewport over a 1,000,000×16,000
+grid at 23 sequential scroll positions, including cell construction, layout,
+prepaint, and paint. `BUDGET=1 ruby bench/grid.rb` asserts a 16.67 ms median
+frame limit. A local run on 2026-09-23 measured 12.964 ms and constructed an
+average of 250 cells per frame. This microbenchmark does not include an
+application's backing store, expensive cell renderers, or a native compositor;
+rerun it on target hardware for deployment decisions.
+
 `ScrollView` accepts one child and clips it to the viewport. Its `axis` is
 `:vertical`, `:horizontal`, or `:both`; use `scroll_to` for programmatic
 scrolling and `scroll_state` for offsets and edge checks.

data/docs/native.md

@@ -49,6 +49,15 @@ and [platform declarations](../sig/platform.rbs) for the exact API.
 call `poll(timeout:)` for events and `close` when finished. Overflow events mean
 the application should rescan the watched paths.
 
+macOS, Windows, and X11 windows support `move_to_display(display)`, using a
+fresh `Display` returned by `Platform.displays` for the matching backend. It
+moves the window frame to that display's top-left; it raises `Zaniah::Error` if
+the display is no longer available. Headless and TUI windows reject placement.
+Wayland has no arbitrary-position request: `move_to_display` raises, while
+`fullscreen_on(display)` sends a best-effort output preference that the
+compositor is free to ignore. Use `Platform.displays(backend: :linux,
+display_server: :wayland)` to select the output.
+
 On Windows, require `zaniah/platform/windows/terminal` to use
 `Zaniah::Platform::Windows::Terminal`, which wraps ConPTY. It supports starting
 a child process, nonblocking reads, writes, resizing, liveness checks, and

data/docs/text.md

@@ -142,6 +142,28 @@ boundaries. The string-backed buffer is intended for ordinary fields and
 documents up to tens of thousands of characters; a piece table is deliberately
 outside the current scope.
 
+`UI::RichText` manages a single text buffer with disjoint style spans. Its
+editing API uses UTF-8 byte ranges, and its surface lays out mixed-size runs on
+shared wrapped lines. Editable input is opt-in to preserve the old read-only
+component behavior:
+
+```ruby
+text = Zaniah::UI::RichText.new([
+  {text: "Quarterly ", bold: true},
+  {text: "report", italic: true, color: "#2563eb", size: 22}
+], editable: true).w(480)
+
+text.apply(0...10, color: "#2563eb")
+text.insert(text.text.bytesize, " — draft")
+text.paragraph_style(0...text.text.bytesize, align: :start, list: :bullet, level: 0)
+```
+
+Supported inline styles are `bold`, `italic`, `size`, `color`, `font`, and
+`link`. Paragraph styles support `align: :start/:center/:end/:justify`,
+`list: :none/:bullet/:ordered`, and nonnegative nesting levels. `on_change`
+receives `(text, rich_text)`; selection changes are reported by `on_select`.
+IME composition uses the existing `TextBuffer` composition path.
+
 ## Inline and block overlays
 
 Attach non-editable UI elements to text without inserting bytes into the source:

data/lib/zaniah/gif.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+module Zaniah
+  # Small, dependency-free GIF87a/GIF89a decoder. Frames are returned as RGBA
+  # snapshots so callers can choose whether to animate or keep the first frame.
+  module GIF
+    Frame = Data.define(:pixels, :delay, :disposal)
+    module_function
+
+    def decode(bytes, max_pixels: 16_777_216)
+      raise ArgumentError, "not a GIF" unless bytes.start_with?("GIF87a", "GIF89a")
+      reader = Reader.new(bytes)
+      reader.skip(6)
+      width, height, packed, background, = reader.bytes(7).unpack("vvCCC")
+      raise ArgumentError, "GIF too large" unless width.positive? && height.positive? && width * height <= max_pixels
+      global_palette = palette(reader, packed)
+      canvas = Array.new(width * height, [0, 0, 0, 0].freeze)
+      frames, gce = [], {delay: 0, disposal: 0, transparent: nil}
+
+      until reader.eof?
+        marker = reader.byte
+        case marker
+        when 0x3b then break
+        when 0x21
+          label = reader.byte
+          if label == 0xf9
+            reader.byte # block size
+            flags, delay, transparent = reader.bytes(4).unpack("CvvC")
+            reader.byte
+            gce = {delay: delay * 0.01, disposal: (flags >> 2) & 7, transparent: flags.anybits?(1) ? transparent : nil}
+          else
+            skip_subblocks(reader)
+          end
+        when 0x2c
+          frame = read_frame(reader, global_palette, width, height, canvas, gce)
+          frames << frame[:frame]
+          canvas = frame[:canvas]
+          gce = {delay: 0, disposal: 0, transparent: nil}
+        else
+          raise ArgumentError, "invalid GIF block"
+        end
+      end
+      raise ArgumentError, "GIF has no frames" if frames.empty?
+
+      [width, height, frames.freeze]
+    rescue IndexError => error
+      raise ArgumentError, "truncated GIF: #{error.message}"
+    end
+
+    def palette(reader, packed)
+      return [] unless packed.anybits?(0x80)
+      size = 2**((packed & 7) + 1)
+      reader.bytes(size * 3).bytes.each_slice(3).map { |rgb| [*rgb, 255].freeze }.freeze
+    end
+    private_class_method :palette
+
+    def read_frame(reader, global_palette, width, height, previous, gce)
+      left, top, frame_width, frame_height, packed = reader.bytes(9).unpack("vvvvC")
+      local_palette = palette(reader, packed)
+      palette = local_palette.empty? ? global_palette : local_palette
+      raise ArgumentError, "GIF frame has no palette" if palette.empty?
+      interlaced = packed.anybits?(0x40)
+      min_code_size = reader.byte
+      compressed = subblocks(reader)
+      indices = lzw_decode(compressed, min_code_size, frame_width * frame_height)
+      indices = deinterlace(indices, frame_width, frame_height) if interlaced
+      canvas = previous.map(&:dup)
+      saved = canvas.map(&:dup) if gce[:disposal] == 3
+      frame_height.times do |row|
+        frame_width.times do |column|
+          index = indices[row * frame_width + column]
+          next if index == gce[:transparent]
+          color = palette[index] || [0, 0, 0, 0].freeze
+          x, y = left + column, top + row
+          canvas[y * width + x] = color if x.between?(0, width - 1) && y.between?(0, height - 1)
+        end
+      end
+      pixels = canvas.flatten.pack("C*")
+      frame = Frame.new(pixels, gce[:delay], gce[:disposal])
+      disposed = case gce[:disposal]
+      when 2
+        canvas.map.with_index { |color, index| image_in_frame?(index, left, top, frame_width, frame_height, width) ? [0, 0, 0, 0].freeze : color }
+      when 3 then saved || canvas
+      else canvas
+      end
+      {frame: frame, canvas: disposed}
+    end
+    private_class_method :read_frame
+
+    def image_in_frame?(index, left, top, frame_width, frame_height, width)
+      x, y = index % width, index / width
+      x >= left && x < left + frame_width && y >= top && y < top + frame_height
+    end
+    private_class_method :image_in_frame?
+
+    def skip_subblocks(reader)
+      loop do
+        length = reader.byte
+        break if length.zero?
+        reader.skip(length)
+      end
+    end
+    private_class_method :skip_subblocks
+
+    def subblocks(reader)
+      result = +"".b
+      loop do
+        length = reader.byte
+        break if length.zero?
+        result << reader.bytes(length)
+      end
+      result
+    end
+    private_class_method :subblocks
+
+    def deinterlace(indices, width, height)
+      output = Array.new(indices.length)
+      offset = 0
+      [0, 4, 2, 1].zip([8, 8, 4, 2]).each do |start, step|
+        (start...height).step(step) do |row|
+          output[row * width, width] = indices[offset, width]
+          offset += width
+        end
+      end
+      output
+    end
+    private_class_method :deinterlace
+
+    def lzw_decode(bytes, minimum, expected)
+      raise ArgumentError, "invalid GIF LZW size" unless minimum.between?(2, 8)
+      clear, stop, code_size = 1 << minimum, (1 << minimum) + 1, minimum + 1
+      table = (0...clear).map { |value| [value] } + [nil, nil]
+      bit_offset, previous, output = 0, nil, []
+      read_code = lambda do
+        value = 0
+        code_size.times do |bit|
+          byte = bytes.getbyte((bit_offset + bit) / 8) || 0
+          value |= ((byte >> ((bit_offset + bit) % 8)) & 1) << bit
+        end
+        bit_offset += code_size
+        value
+      end
+      loop do
+        code = read_code.call
+        break if code == stop || output.length >= expected
+        if code == clear
+          table = (0...clear).map { |value| [value] } + [nil, nil]
+          code_size = minimum + 1
+          previous = nil
+          next
+        end
+        entry = if code < table.length && table[code]
+          table[code]
+        elsif previous
+          previous + [previous.first]
+        else
+          raise ArgumentError, "invalid GIF LZW code"
+        end
+        output.concat(entry)
+        if previous
+          table << previous + [entry.first]
+          code_size += 1 if table.length == (1 << code_size) && code_size < 12
+        end
+        previous = entry
+      end
+      raise ArgumentError, "truncated GIF image data" if output.length < expected
+      output.first(expected)
+    end
+    private_class_method :lzw_decode
+
+    class Reader
+      def initialize(bytes)
+        @bytes, @offset = bytes, 0
+      end
+
+      def eof? = @offset >= @bytes.bytesize
+      def byte = bytes(1).getbyte(0)
+      def bytes(length)
+        value = @bytes.byteslice(@offset, length)
+        raise IndexError, "unexpected end of input" unless value && value.bytesize == length
+        @offset += length
+        value
+      end
+      def skip(length)
+        bytes(length)
+      end
+    end
+  end
+end

data/lib/zaniah/image.rb

@@ -2,12 +2,31 @@
 
 module Zaniah
   class Image < Element
-    def initialize(path)
+    def self.from_bytes(bytes, format: :auto) = new(nil, bytes: bytes, format: format)
+
+    def initialize(path = nil, bytes: nil, format: :auto)
       super()
-      width, height, pixels = PNG.decode(File.binread(path))
+      bytes ||= File.binread(path)
+      raise ArgumentError, "image bytes must be a String" unless bytes.is_a?(String)
+      format = :jpeg if format == :jpg
+      format = detect_format(bytes) if format == :auto
+      width, height, pixels = case format
+      when :png
+        PNG.decode(bytes)
+      when :jpeg
+        JPEG.decode(bytes)
+      when :gif
+        gif_width, gif_height, frames = GIF.decode(bytes)
+        @frames = frames
+        [gif_width, gif_height, frames.first.pixels]
+      else
+        raise ArgumentError, "unsupported image format #{format.inspect}"
+      end
       @texture = GPU::Texture.new(width, height, data: pixels)
     end
 
+    attr_reader :frames
+
     def request_layout(_cx)
       @layout_node = Layout::Node.new(style: @style, measure: ->(_width, _height) { [@texture.width, @texture.height] })
     end
@@ -15,5 +34,14 @@ module Zaniah
     def paint(bounds, _state, _prepaint, cx)
       cx.scene.sprite(bounds.x, bounds.y, bounds.width, bounds.height, texture: @texture)
     end
+
+    private
+
+    def detect_format(bytes)
+      return :png if bytes.start_with?(PNG::SIGNATURE)
+      return :gif if bytes.start_with?("GIF87a", "GIF89a")
+      return :jpeg if bytes.start_with?("\xFF\xD8".b)
+      raise ArgumentError, "unsupported image format"
+    end
   end
 end

data/lib/zaniah/input/keymap.rb

@@ -74,6 +74,18 @@ module Zaniah
             .bind("pageup", :page_up, context: "in_table")
             .bind("pagedown", :page_down, context: "in_table")
             .bind("#{primary}-a", :select_all, context: "in_table")
+            .bind("up", :previous_option, context: "in_grid")
+            .bind("down", :next_option, context: "in_grid")
+            .bind("left", :previous_column, context: "in_grid")
+            .bind("right", :next_column, context: "in_grid")
+            .bind("shift-up", :extend_previous, context: "in_grid")
+            .bind("shift-down", :extend_next, context: "in_grid")
+            .bind("shift-left", :extend_column_previous, context: "in_grid")
+            .bind("shift-right", :extend_column_next, context: "in_grid")
+            .bind("home", :first, context: "in_grid")
+            .bind("end", :last, context: "in_grid")
+            .bind("enter", :activate, context: "in_grid")
+            .bind("#{primary}-a", :select_all, context: "in_grid")
             .bind("up", :previous_option, context: "in_combobox")
             .bind("down", :next_option, context: "in_combobox")
             .bind("home", :first, context: "in_combobox")