rubyterm 0.1.2 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: add0fe16033c81c852e4605472ffee6aa840f4639864f04bbbadcbe15dcca024
-  data.tar.gz: 238ffdf540e08d38630c89034256826975250fb7ed13825d96a73fb7e50e51a9
+  metadata.gz: b689e43998c1e63f2cd607d3200aeb67d7cf49d6a1ce685ab532ea525132b41c
+  data.tar.gz: a6b2201c362d87c3114762e30cc55a2b90af4bd3d7ceec2fe4b14beaabc61d72
 SHA512:
-  metadata.gz: 71ca07c93b9e67c83a1385bb49d5dd5063e1d56e03f257bc2f8d8e93acde384fe23a8e4cb45fc19ce307dffb7373b9c6aa8edcee17d82dc774f9ad0baf4be49a
-  data.tar.gz: d9d84c93ec626ca6e44d197a257b19bd33769c800452c16c9effed0c1b61e377c4fd28a2073f2dce20bff70374489cca25065ce27c47e96547d42e751ef4a267
+  metadata.gz: 005e2010106589917df481c5ae217959114a8f80a7ce5787855dab5ef9ed69fa14b9c840781899e609e0d795f39f022fe60ff46448960dd0f2a713dc00c4a2f4
+  data.tar.gz: e6182b8a2b492e41777386c0a2cc8626d3e5195a89b14b6e46639cb5e5f7e1baa2abde4b1a135bba08004f78a5077075dcebf089b790cf9fcd27296ec011031a

data/lib/bitmapwindow.rb

@@ -1,5 +1,13 @@
 require 'skrift'
 require 'zlib'
+require_relative 'charwidth'
+
+# Colour-glyph (emoji) support is optional.
+begin
+  require 'skrift/color'
+rescue LoadError
+  # skrift-color not installed; emoji render monochrome (or as tofu).
+end
 
 # A third implementation of the drawing interface WindowAdapter targets
 # (alongside the X11 Window and the harness's VirtualWindow): it rasterises
@@ -15,21 +23,27 @@ require 'zlib'
 class BitmapWindow
   attr_reader :width, :height, :pixels
 
-  DEFAULT_FONT = "/usr/share/fonts/truetype/dejavu/DejaVuSansMono.ttf"
+  DEFAULT_FONT  = "/usr/share/fonts/truetype/dejavu/DejaVuSansMono.ttf"
+  DEFAULT_EMOJI = "/usr/share/fonts/truetype/noto/NotoColorEmoji.ttf"
+
+  # Routes emoji codepoints to a colour renderer and leaves everything else to
+  # the monochrome path. The emoji? gate (Unicode classification) keeps text
+  # that a colour font happens to map — digits, '#', '*' — rendering as text.
+  ColourDelegate = Struct.new(:renderer) do
+    def render(cp) = CharWidth.emoji?(cp) ? renderer.render(cp) : nil
+  end
 
   def initialize(cols, rows, font: DEFAULT_FONT, size: 16,
-                 fg: 0xcccccc, bg: 0x000000)
-    @font = Font.load(font)
-    @sft = SFT.new(@font)
-    @sft.x_scale = size
-    @sft.y_scale = size
-    lm = @sft.lmetrics
-    @char_h   = (lm.ascender - lm.descender + lm.line_gap).ceil
-    @baseline = lm.ascender.round
-    @char_w   = @sft.gmetrics(@sft.lookup("M".ord)).advance_width.round
+                 fg: 0xcccccc, bg: 0x000000, emoji: DEFAULT_EMOJI)
+    # The glyph pipeline (rasterise + cache + metrics) lives in skrift's
+    # GlyphCache; colour emoji come from an optional colour delegate.
+    @cache    = Skrift::GlyphCache.new(font, x_scale: size, y_scale: size,
+                                       color: colour_delegate(emoji, size))
+    @char_w   = @cache.cell_width
+    @char_h   = @cache.cell_height
+    @baseline = @cache.baseline
     @cols, @rows = cols, rows
     @fg, @bg = fg, bg
-    @glyphs = {}
     resize(cols * @char_w, rows * @char_h)
   end
 
@@ -70,8 +84,9 @@ class BitmapWindow
   def draw(x, y, str, fg, bg, _lineattrs = nil)
     fillrect(x, y, str.length * @char_w, @char_h, bg)
     str.each_char.with_index do |ch, i|
-      next if ch == " "
-      blit_glyph(ch.ord, x + i * @char_w, y, fg)
+      cp = ch.ord
+      next if cp == 32 || cp == CharWidth::WIDE_SPACER # space / wide-glyph tail
+      blit_glyph(cp, x + i * @char_w, y, fg)
     end
   end
 
@@ -109,6 +124,12 @@ class BitmapWindow
 
   private
 
+  def colour_delegate(emoji, size)
+    return nil unless emoji && File.exist?(emoji) && defined?(Skrift::Color::Renderer)
+    cr = Skrift::Color::Renderer.new(Skrift::Font.load(emoji), x_scale: size, y_scale: size)
+    cr.color? ? ColourDelegate.new(cr) : nil
+  end
+
   def png_chunk(type, data)
     body = type.b + data.b
     [data.bytesize].pack("N") + body + [Zlib.crc32(body)].pack("N")
@@ -126,10 +147,20 @@ class BitmapWindow
   end
 
   def blit_glyph(codepoint, cx, cy, fg)
-    alpha, gw, gh, lsb, yoff = glyph(codepoint)
-    return unless alpha
-    gx = cx + lsb
-    gy = cy + @baseline - yoff
+    g = @cache.glyph(codepoint)
+    return unless g
+    if g.color?
+      blit_rgba(g, codepoint, cx, cy)
+    elsif g.alpha
+      blit_alpha(g, cx, cy, fg)
+    end
+  end
+
+  # Monochrome glyph: alpha mask tinted with the foreground colour.
+  def blit_alpha(g, cx, cy, fg)
+    alpha, gw, gh = g.alpha, g.width, g.height
+    gx = cx + g.left_side_bearing
+    gy = cy + @baseline - g.y_offset
     gh.times do |row|
       py = gy + row
       next if py < 0 || py >= @height
@@ -146,6 +177,29 @@ class BitmapWindow
     end
   end
 
+  # Colour glyph (emoji): RGBA bitmap composited over the cells, centred in its
+  # cell span (emoji are double-width, so span is two cells).
+  def blit_rgba(g, codepoint, cx, cy)
+    span = CharWidth.width(codepoint) * @char_w
+    gx = cx + (span - g.width) / 2
+    gy = cy + (@char_h - g.height) / 2
+    g.height.times do |row|
+      py = gy + row
+      next if py < 0 || py >= @height
+      base = py * @width
+      grow = row * g.width
+      g.width.times do |col|
+        px = gx + col
+        next if px < 0 || px >= @width
+        rgba = g.rgba[grow + col]
+        a = rgba & 0xff
+        next if a.zero?
+        idx = base + px
+        @pixels[idx] = a == 255 ? (rgba >> 8) : over_rgb(rgba >> 8, a, @pixels[idx])
+      end
+    end
+  end
+
   # fg over dst, coverage a (0-255).
   def blend(dst, fg, a)
     ia = 255 - a
@@ -155,22 +209,12 @@ class BitmapWindow
     (r << 16) | (g << 8) | b
   end
 
-  # [alpha_bytes, width, height, left_bearing, y_offset] for a codepoint,
-  # cached; or [nil] if it has no outline (e.g. space).
-  def glyph(codepoint)
-    @glyphs[codepoint] ||= begin
-      gid = @sft.lookup(codepoint)
-      m = gid && @sft.gmetrics(gid)
-      if m.nil? || m.min_width.nil? || m.min_height.nil?
-        [nil]
-      else
-        img = Image.new((m.min_width + 3) & ~3, m.min_height)
-        if @sft.render(gid, img) && img.pixels
-          [img.pixels, img.width, img.height, m.left_side_bearing.round, m.y_offset]
-        else
-          [nil]
-        end
-      end
-    end
+  # src (0xRRGGBB) over dst with alpha a (0-255).
+  def over_rgb(src, a, dst)
+    ia = 255 - a
+    r = ((src >> 16 & 0xff) * a + (dst >> 16 & 0xff) * ia) / 255
+    g = ((src >> 8 & 0xff) * a + (dst >> 8 & 0xff) * ia) / 255
+    b = ((src & 0xff) * a + (dst & 0xff) * ia) / 255
+    (r << 16) | (g << 8) | b
   end
 end

data/lib/charwidth.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+# Character-cell width and emoji classification, by Unicode codepoint.
+#
+# Terminal column width must be a property of the codepoint (not the rendered
+# glyph), so that applications running inside the terminal — which compute their
+# own layout from the same Unicode width — stay in sync. These tables are the
+# canonical East Asian Wide/Fullwidth + emoji blocks (UCD 13.0), curated to the
+# substantial ranges; they're a couple of KB and drive two decisions:
+#
+#   * width(cp)  -> 1 or 2 cells (wide = CJK/Hangul/Kana/fullwidth + emoji)
+#   * emoji?(cp) -> whether to render in colour (the non-CJK wide blocks)
+#
+# Combining marks (width 0) are deliberately not handled yet (treated as 1).
+module CharWidth
+  # Codepoint stored in the second cell of a double-width glyph: a blank,
+  # advancing placeholder. The terminal writes it after a wide char so the
+  # next column is reserved; the X11 backend renders codepoint 0 as a blank
+  # advancing glyph and the bitmap/virtual backends skip it.
+  WIDE_SPACER = 0
+
+  # Wide (two-cell) blocks: CJK, Hangul, Kana, fullwidth forms, and emoji.
+  WIDE = [
+    0x1100..0x115F, 0x231A..0x232A, 0x23E9..0x23F3, 0x25FD..0x27BF,
+    0x2B1B..0x2B55, 0x2E80..0xA4C6, 0xA960..0xA97C, 0xAC00..0xD7A3,
+    0xF900..0xFAD9, 0xFE10..0xFE6B, 0xFF01..0xFF60, 0xFFE0..0xFFE6,
+    0x16FE0..0x18D08, 0x1B000..0x1B2FB, 0x1F18E..0x1F19A, 0x1F200..0x1F265,
+    0x1F300..0x1F5A4, 0x1F5FB..0x1F6FC, 0x1F7E0..0x1F7EB, 0x1F90C..0x1F9FF,
+    0x1FA70..0x1FAD6, 0x20000..0x2EBE0, 0x2F800..0x2FA1D, 0x30000..0x3134A
+  ].freeze
+
+  # The emoji subset of WIDE (excludes CJK/Hangul/Kana/fullwidth): these render
+  # in colour when a colour font provides them. Digits, '#', '*' etc. are not
+  # here, so they stay as ordinary text even though Noto maps colour keycaps.
+  EMOJI = [
+    0x231A..0x232A, 0x23E9..0x23F3, 0x25FD..0x27BF, 0x2B1B..0x2B55,
+    0x1F18E..0x1F19A, 0x1F200..0x1F265, 0x1F300..0x1F5A4, 0x1F5FB..0x1F6FC,
+    0x1F7E0..0x1F7EB, 0x1F90C..0x1F9FF, 0x1FA70..0x1FAD6
+  ].freeze
+
+  module_function
+
+  # Number of terminal cells a codepoint occupies (1 or 2).
+  def width(cp)
+    return 1 if cp < 0x1100      # fast path: ASCII/Latin and most text
+    in_ranges?(WIDE, cp) ? 2 : 1
+  end
+
+  def wide?(cp) = width(cp) == 2
+
+  # Whether a codepoint should render as a colour emoji (when the font has it).
+  def emoji?(cp)
+    return false if cp < 0x231A
+    in_ranges?(EMOJI, cp)
+  end
+
+  # Binary search over a sorted array of non-overlapping ranges.
+  def in_ranges?(ranges, cp)
+    lo = 0
+    hi = ranges.length - 1
+    while lo <= hi
+      mid = (lo + hi) / 2
+      r = ranges[mid]
+      if cp < r.begin then hi = mid - 1
+      elsif cp > r.end then lo = mid + 1
+      else return true
+      end
+    end
+    false
+  end
+end

data/lib/controller.rb

@@ -16,7 +16,7 @@ class Controller
 
   def run(*args)
     cmd = args.empty? ? @shell : [@shell, '-c', args.join(' ')]
-    @master, @wr, @pid = *PTY.spawn(*cmd)
+    @master, @wr, @pid = *spawn_child(cmd)
 
     Thread.new do
       loop do
@@ -33,6 +33,19 @@ class Controller
     end
   end
 
+  # Spawn the child shell/command with the user's own gem environment, not
+  # rubyterm's bundle: when rubyterm runs under `bundle exec`, BUNDLE_GEMFILE /
+  # GEM_PATH leak into children, so a Bundler-based shell (or any tool relying
+  # on the system gems) fails to load its gems and exits immediately. Stripping
+  # the bundle env restores the pre-bundle-exec behaviour.
+  def spawn_child(cmd)
+    if defined?(Bundler)
+      Bundler.with_unbundled_env { PTY.spawn(*cmd) }
+    else
+      PTY.spawn(*cmd)
+    end
+  end
+
   def read
     @master.read_nonblock(128)
   rescue IO::EAGAINWaitReadable

data/lib/keymap.rb

@@ -24,7 +24,7 @@ def update_keymap(dpy)
         (c-0x01000100).
         chr(Encoding::UTF_32) rescue c.to_s(16)
       else
-        STDERR.puts "keymap: unknown_#{c.to_s(16)}"
+        STDERR.puts "keymap: unknown_#{c.to_s(16)}" rescue nil
       end
     end.each_slice(reply.keysyms_per_keycode).to_a
     #ks = ks.map {|s| s.compact.sort_by{|x| x.to_s}.uniq }.to_a # This is for testing/ease of reading only

data/lib/rubyterm/app.rb

@@ -382,6 +382,25 @@ class RubyTerm
 
   def redraw_positions(positions) = positions.each { |pos| @buffer.redraw(*pos) }
 
+  # The selection's [start, end] boundary pairs, expanded so a double-width
+  # glyph is always whole: if the first selected cell is a WIDE_SPACER tail,
+  # include its head; if the last selected cell is a wide head, include its
+  # tail. So clipping a selection to either half of an emoji still selects the
+  # whole emoji. Returns the raw pair unchanged when there is no selection.
+  def selection_bounds
+    s, e = @select_startpos, @select_endpos
+    return [s, e] unless s && e
+    lo, hi = [s, e].sort_by { |x, y| [y, x] }
+    # Boundaries -> inclusive cell range: a selection from boundary lo to hi
+    # covers cells [lo .. hi-1].
+    hi = [hi[0] - 1, hi[1]]
+    c = @buffer.get(lo[0], lo[1])
+    lo = [lo[0] - 1, lo[1]] if lo[0] > 0 && c && c[0] == CharWidth::WIDE_SPACER
+    last = @buffer.get(hi[0], hi[1])
+    hi = [hi[0] + 1, hi[1]] if last && last[0] && CharWidth.width(last[0]) == 2
+    [lo, hi]
+  end
+
   # Re-stamp the active selection highlight on top of freshly drawn
   # content. The selection is an overlay that is NOT stored in the buffer,
   # so any output - or a full redraw - that repaints those cells erases the
@@ -390,8 +409,10 @@ class RubyTerm
   # app), which a one-shot paint at mouse-time cannot do.
   def reapply_selection
     return unless @select_startpos && @select_endpos
+    return if @select_startpos == @select_endpos   # zero-width (click): nothing selected
     sb = @window.scrollback_count
-    @buffer.each_character_between(@select_startpos[0]..@select_startpos[1], @select_endpos[0]..@select_endpos[1]) do |x,y,cell|
+    spos, epos = selection_bounds
+    @buffer.each_character_between(spos[0]..spos[1], epos[0]..epos[1]) do |x,y,cell|
       sy = y + sb
       next if sy < 0 || sy >= @term.height
       @buffer.redraw_cell_at(x, sy, cell, fg: 0xffffff, bg: 0xff00ff)
@@ -408,11 +429,16 @@ class RubyTerm
     sb = @window.scrollback_count
     olddamage = @selection_damage || Set.new
     @selection_damage = Set.new
-    @buffer.each_character_between(@select_startpos[0]..@select_startpos[1], @select_endpos[0]..@select_endpos[1]) do |x,y,cell|
-      sy = y + sb
-      next if sy < 0 || sy >= @term.height
-      @selection_damage << [x,sy]
-      @buffer.redraw_cell_at(x, sy, cell, fg: 0xffffff, bg: 0xff00ff)
+    # A zero-width (click) selection highlights nothing, but still falls
+    # through to clear any previous highlight below.
+    unless @select_startpos == @select_endpos
+      spos, epos = selection_bounds
+      @buffer.each_character_between(spos[0]..spos[1], epos[0]..epos[1]) do |x,y,cell|
+        sy = y + sb
+        next if sy < 0 || sy >= @term.height
+        @selection_damage << [x,sy]
+        @buffer.redraw_cell_at(x, sy, cell, fg: 0xffffff, bg: 0xff00ff)
+      end
     end
     # Repaint cells that left the selection with their displayed content.
     (olddamage - @selection_damage).each { |x,sy| @buffer.redraw_display(x, sy, sb) }
@@ -421,14 +447,15 @@ class RubyTerm
   end
 
   def get_selection
-    startpos = @select_startpos
-    endpos   = @select_endpos
+    startpos, endpos = selection_bounds
     str = ""
     ypos = nil
     @buffer.each_character_between(startpos[0]..startpos[1], endpos[0]..endpos[1]) do |x,y,cell|
       str += "\n" if ypos && y != ypos
       ypos = y
-      str << (cell[0].chr(Encoding::UTF_8) rescue "")
+      cp = cell && cell[0]
+      next if cp == CharWidth::WIDE_SPACER   # tail of a double-width glyph: its head already emitted the char
+      str << (cp.chr(Encoding::UTF_8) rescue "")
     end
     str
   end
@@ -454,6 +481,11 @@ class RubyTerm
     shift = pkt.state.anybits?(0x01) # ShiftMask
     case shift ? nil : @term.mouse_mode
     when nil
+      # 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
+      # none. Mouse reporting below keeps the floor cell index.
+      x = (pkt.event_x + char_w / 2) / char_w
       # Selection works in buffer coordinates: when scrolled back, the
       # row under the pointer is a scrollback line (buffer row
       # screen_y - scrollback_count, negative for scrollback). Without
@@ -523,7 +555,12 @@ class RubyTerm
     Thread.new do
       loop do
         pkt = @window.dpy.next_packet
-        process(pkt)
+        begin
+          process(pkt)
+        rescue => e
+          # One bad event must not kill the terminal (abort_on_exception is on).
+          warn("rubyterm: #{e.class}: #{e.message}") rescue nil
+        end
         Thread.pass
       end
     end
@@ -531,24 +568,6 @@ class RubyTerm
 
 
   def run(args)
-    # A launcher (e.g. a menu) can hand us stdout/stderr on a pipe that closes
-    # once it exits. Our own debug/error output (keymap warnings etc.) would then
-    # raise Errno::EPIPE, and with Thread.abort_on_exception on (below) that
-    # would kill the terminal — and the user's window — on the next keypress.
-    # If either is a pipe, route our output to a log file so a closed pipe can
-    # never crash us. A real tty or plain-file launch is already safe, so leave
-    # it alone.
-    if [$stdout, $stderr].any? { |io| io.stat.pipe? rescue false }
-      begin
-        log = File.open(File.expand_path(ENV["RUBYTERM_LOG"] || "~/.rubyterm.log"), "a")
-        $stdout.reopen(log); $stderr.reopen(log)
-        $stdout.sync = $stderr.sync = true
-      rescue SystemCallError
-        $stdout.reopen(File::NULL, "w") rescue nil
-        $stderr.reopen(File::NULL, "w") rescue nil
-      end
-    end
-
     @controller = Controller.new(self, @config)
     @controller.run(*args)
     @term.responder = @controller

data/lib/rubyterm/version.rb

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

data/lib/term.rb

@@ -2,6 +2,7 @@ require_relative 'palette'      # PALETTE_BASIC, FG, BG
 require_relative 'escapeparser'
 require_relative 'utf8decoder'
 require_relative 'charsets'
+require_relative 'charwidth'    # CharWidth.width / WIDE_SPACER
 
 # The escape/control interpreter: it turns a byte stream into operations on
 # a buffer, and knows *nothing* about X11, windows, or how its buffer is
@@ -544,17 +545,29 @@ class Term
       scroll_if_needed
       return if ch == 127   # DEL is ignored in the data stream
 
+      cw = CharWidth.width(ch)
+      # A double-width glyph can't straddle the right margin: if only one
+      # column is left, blank it and wrap so the glyph starts the next line.
+      if cw == 2 && @wraparound && @x == line_width - 1
+        @buffer.set(@x, @y, ' ', fg, bg, @mode)
+        @x = line_width
+        wrap_if_needed
+        scroll_if_needed
+      end
+
       # IRM (insert mode): shift the rest of the line right and repaint it,
-      # then drop the new glyph into the gap.
+      # then drop the new glyph (and its spacer, if wide) into the gap.
       if @irm
-        @buffer.insert(@x, @y, 1, [32,0,0,0])
+        @buffer.insert(@x, @y, cw, [32,0,0,0])
         @buffer.set(@x, @y, charset[ch], fg, bg, @mode)
+        @buffer.set(@x + 1, @y, CharWidth::WIDE_SPACER, fg, bg, @mode) if cw == 2
         redraw_line_from_cursor
       else
         @buffer.set(@x, @y, charset[ch], fg, bg, @mode)
+        @buffer.set(@x + 1, @y, CharWidth::WIDE_SPACER, fg, bg, @mode) if cw == 2
       end
       @y = clamph(@y)
-      @x += 1
+      @x += cw
       scroll_if_needed
     end
   end

data/lib/termbuffer.rb

@@ -228,7 +228,10 @@ class TermBuffer
     xend, ymax = epos.first, epos.end
     (spos.end..ymax).each do |y|
       line = line_at(y) || ""
-      xmax = y == ymax ? xend + 1 : line.length - 1
+      # Inclusive of the end column: a range sx..ex on one row covers cells
+      # sx through ex. (Callers convert the half-open boundary selection to an
+      # inclusive cell range before calling.)
+      xmax = y == ymax ? xend : line.length - 1
       xmax = [xmax, line.length - 1].min
       xmax = 0 if xmax < 0
       while x <= xmax

data/lib/trackchanges.rb

@@ -1,4 +1,6 @@
 
+require_relative 'charwidth'   # CharWidth.width / WIDE_SPACER
+
 # FIXME: Roll this into the actual buffer.
 class TrackChanges
   # The cursor is rendered as an overlay - a cell repainted with this
@@ -144,7 +146,28 @@ class TrackChanges
     draw_flush
   end
 
-  def redraw(x,y) = draw_buffered(x,y, @buffer.get(x,y), true)
+  # The screen-column span [x0,x1] of the glyph occupying (x, buffer_y). A
+  # double-width glyph is stored as [head, WIDE_SPACER tail]; redrawing either
+  # cell on its own leaves the other half stale (cursor move, blink, a
+  # single-cell damage update), so every redraw path expands to the whole
+  # glyph. cell[0] is an integer codepoint (or nil for an unset cell).
+  def glyph_span(x, buffer_y)
+    cell = @buffer.get(x, buffer_y)
+    cp   = cell && cell[0]
+    if cp == CharWidth::WIDE_SPACER && x > 0 &&
+       (h = @buffer.get(x - 1, buffer_y)) && h[0] && CharWidth.width(h[0]) == 2
+      [x - 1, x]
+    elsif cp && CharWidth.width(cp) == 2
+      [x, x + 1]
+    else
+      [x, x]
+    end
+  end
+
+  def redraw(x,y)
+    x0, x1 = glyph_span(x, y)
+    (x0..x1).each { |xx| draw_buffered(xx, y, @buffer.get(xx, y), true) }
+  end
 
   # Render the cursor overlay at (x,y) if +visible+, after restoring the
   # cell under its previous position. A no-op while scrolled back, so the
@@ -174,11 +197,14 @@ class TrackChanges
   end
 
   def redraw_with(x,y, fg: nil, bg: nil)
-    cell = Array(@buffer.get(x,y)).dup
-    cell[0] ||= " "
-    cell[1] = fg if fg
-    cell[2] = bg if bg
-    draw_buffered(x,y, cell, true)
+    x0, x1 = glyph_span(x, y)
+    (x0..x1).each do |xx|
+      cell = Array(@buffer.get(xx, y)).dup
+      cell[0] ||= " "
+      cell[1] = fg if fg
+      cell[2] = bg if bg
+      draw_buffered(xx, y, cell, true)
+    end
   end
 
   # Draw an already-resolved cell at a *screen* position, optionally
@@ -197,7 +223,8 @@ class TrackChanges
   # content rather than the live buffer's).
   def redraw_display(screen_x, screen_y, scrollback_offset = 0)
     buffer_y = screen_y - scrollback_offset
-    draw_buffered(screen_x, screen_y, @buffer.get(screen_x, buffer_y), true)
+    x0, x1 = glyph_span(screen_x, buffer_y)
+    (x0..x1).each { |xx| draw_buffered(xx, screen_y, @buffer.get(xx, buffer_y), true) }
   end
 
   # Public flush point. In the default (eager) mode draws already happened

data/lib/utf8decoder.rb

@@ -29,48 +29,35 @@
       end
     end
 
-    # Split @buffer into a complete-sequence prefix and a saved leftover,
-    # then yield the prefix (encoding-tagged) to the caller's per-character
-    # iterator.
+    # Split @buffer into a complete-sequence prefix and a saved leftover, then
+    # yield the prefix (encoding-tagged) to the caller's per-character iterator.
+    # If the buffer ends partway through a multibyte sequence (it was split
+    # across a pty read), those trailing bytes are held back for next time;
+    # everything before them is yielded.
     private def decode
-      # We acknowledge that @buffer can contain
-      # sequences that are invalid UTF8, and we will
-      # do our best with them *unless*:
-      # * @buffer[-1] starts any multibyte sequence
-      # * @buffer[-2] starts a 3 or 4 byte sequence
-      # * @buffer[-3] starts a 4 byte sequence.
-      # In those cases, and those cases only, we
-      # save those bytes for next time.
-
       str = @buffer
       return nil if !str || str.empty?
-      last = str.length-1
+      yield_len = str.length
 
       if str[-1].ord >= 0x80
-        # -1 is part of a multibyte sequence (a continuation byte 0x80-0xBF
-        # or a lead byte 0xC0+). NB: this must be >= 0x80, not > 0x80 - a
-        # trailing 0x80 is the second byte of e.g. an em-dash (E2 80 94)
-        # split across a pty read; treating it as complete dropped the
-        # lead bytes and orphaned the final byte into the next chunk.
-        if str.length == 1
-          # Single byte that starts a multibyte sequence
-            last = -2  # Process nothing, save everything
-        elsif str[-2] && str[-2].ord & 0xe0 == 0xc0 # -2..-1 is a 2 byte sequence; we're good.
-        elsif str[-2] && str[-2].ord & 0xe0 == 0xe0 # Start of a 3 or 4 byte sequence
-          last = str.length-3
-        else # -2 is *part of a 3 or 4 byte sequence
-          if    str[-3] && str[-3].ord & 0xf0 == 0xe0 # -3 Starts a 3 byte sequence
-          elsif str[-3] && str[-3].ord & 0xf8 == 0xf0 # -3 starts a 4 byte sequence
-            last = str.length-4
-          else # -2 must be the final byte of something, so we only chop the last
-            last = str.length-2
+        # Find the lead byte of the final sequence by skipping back over up to
+        # three continuation bytes (0x80-0xBF). If that sequence isn't yet
+        # complete, hold it (and everything after the lead) for the next chunk.
+        j = str.length - 1
+        j -= 1 while j.positive? && (str[j].ord & 0xc0) == 0x80 && str.length - j < 4
+        lead = str[j].ord
+        needed =
+          if    lead & 0xe0 == 0xc0 then 2
+          elsif lead & 0xf0 == 0xe0 then 3
+          elsif lead & 0xf8 == 0xf0 then 4
+          else 0 # orphan continuation byte or not a lead - nothing to hold back
           end
-        end
+        yield_len = j if needed.positive? && (str.length - j) < needed
       end
-      @leftover = str[last+1..-1].b
-      complete = str[0..last].force_encoding("UTF-8")
-      yield complete
-      @buffer = @leftover
+
+      complete = str[0, yield_len].force_encoding("UTF-8")
+      @buffer  = str[yield_len..].b
+      yield complete unless complete.empty?
     end
 
   end

data/lib/window.rb

@@ -4,11 +4,26 @@
 
 require 'skrift'
 require 'skrift/x11'
+require_relative 'charwidth'
 #require 'pry'
 
+# Colour-glyph (emoji) support is optional.
+begin
+  require 'skrift/color'
+rescue LoadError
+end
+
 class Window
   attr_reader :dpy, :wid, :scrollback_count # FIXME
   attr_accessor :width, :height
+
+  DEFAULT_EMOJI = "/usr/share/fonts/truetype/noto/NotoColorEmoji.ttf"
+
+  # Gates a colour renderer to emoji codepoints, so text a colour font also
+  # maps (e.g. Noto's keycap digits) keeps rendering as ordinary text.
+  EmojiColour = Struct.new(:renderer) do
+    def render(cp) = CharWidth.emoji?(cp) ? renderer.render(cp) : nil
+  end
   
   # Get scrollback status
   def scrollback_mode
@@ -212,12 +227,29 @@ class Window
     xs = @col_scale || @scale
     # fit: scale oversized glyphs (e.g. wide spinner/symbol chars) down into
     # the fixed cell instead of letting them overflow/clamp at the edge.
-    @skr = Skrift::X11::Glyphs.new(@dpy, fontset: @fontset, x_scale: xs, y_scale: @scale, fixed: true, fit: true)
+    @skr = Skrift::X11::Glyphs.new(@dpy, fontset: @fontset, x_scale: xs, y_scale: @scale, fixed: true, fit: true,
+                                   color: colour_delegate(@scale))
     # FIXME: Maybe instantiate these as needed.
     @skr_dblheight = Skrift::X11::Glyphs.new(@dpy, fontset: @fontset, x_scale: xs*2, y_scale: @scale*2, fixed: true)
     @skr_dblwidth  = Skrift::X11::Glyphs.new(@dpy, fontset: @fontset, x_scale: xs*2, y_scale: @scale, fixed: true)
   end
 
+  # An emoji-gated colour delegate built from the first colour-capable font in
+  # the fontset (or a default emoji font), or nil if none / skrift-color is
+  # absent. Passed to the main Glyphs renderer so emoji draw in colour.
+  def colour_delegate(scale)
+    return nil unless defined?(Skrift::Color::Renderer)
+    fonts = Skrift::FontSet.new(Array(@fontset)).each.to_a
+    fonts << Skrift::Font.load(DEFAULT_EMOJI) if File.exist?(DEFAULT_EMOJI)
+    fonts.each do |f|
+      cr = Skrift::Color::Renderer.new(f, x_scale: scale, y_scale: scale)
+      return EmojiColour.new(cr) if cr.color?
+    end
+    nil
+  rescue StandardError
+    nil
+  end
+
   def adjust_fontsize(adj)
     @scale += adj
     @scale = @scale.clamp(5, 100)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubyterm
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.1
 platform: ruby
 authors:
 - Vidar Hokstad
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-06-20 00:00:00.000000000 Z
+date: 2026-06-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pure-x11
@@ -30,28 +30,42 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.4.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.4.0
 - !ruby/object:Gem::Dependency
   name: skrift-x11
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.3.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.3.0
+- !ruby/object:Gem::Dependency
+  name: skrift-color
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.0
 - !ruby/object:Gem::Dependency
   name: toml-rb
   requirement: !ruby/object:Gem::Requirement
@@ -86,6 +100,7 @@ files:
 - lib/ansibackend.rb
 - lib/bitmapwindow.rb
 - lib/charsets.rb
+- lib/charwidth.rb
 - lib/controller.rb
 - lib/escapeparser.rb
 - lib/keymap.rb