skrift-x11 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a75688a1a4f9e322d33c58a9b0a29b2fb26c27536a137e33dd97c340a491dd98
-  data.tar.gz: 87a5c7f3f29918f0031e637acbc4d08a6d8d6f122b3112c597515086fa1d0317
+  metadata.gz: ed8b7aa32d9e1eb6984384f6f22488d3d6f5be7f5eef1c671c0226cf7ff431c5
+  data.tar.gz: cee3cb6866a431e8f8c2d0e4543a1eed56f85883098b1561902dd52e0641386e
 SHA512:
-  metadata.gz: 7db2e7d2a63a2afa679ca83652136e13e954b3eee2c11d55c5734c48ed10be641a8fee0eca3d1df779a1d4c19c7a4172027d9aea1659f4bb8f4728f6de3ded3e
-  data.tar.gz: 4014ba510524d9921c9eb67986b137151f98aca2cd71427e431fdcefe776c5c869e45b45de09d3a692fe77976f82da4c7df6bdb08ca687736301d43a45f5af12
+  metadata.gz: be22707412fa343bb25f8a9ddbd754801090ccf1458041aeb91c18513d8a963d2121eeae293a65d34d6c782d9d7d166f57b8448bb30dd755ae6452a0a3c9bc27
+  data.tar.gz: 84b80afb3b159bfbdc5733a397c670305b7c6dfc4d37a8e9cfac57bdb12b775703bf65ddbf62ef5a0eeab32ccad3a8ce270b9eec7cd15b99708f196b2454f2ea

data/lib/skrift/x11/glyphs.rb

@@ -1,9 +1,15 @@
+require 'skrift/boxdrawing'
 
-require_relative 'boxdrawing'
+# Colour-glyph support is optional: only needed when a `color:` font is given.
+begin
+  require 'skrift/color'
+rescue LoadError
+  # skrift-color not installed; colour rendering will be unavailable.
+end
 
 module X11
   # XRender constants currently not defined in pure-x11.
-  # FIXME.
+  # FIXME: these are generic XRender enumerants and belong in pure-x11.
   module Form
     PictOpSrc=1
     PictOpOver=3
@@ -13,70 +19,49 @@ end
 
 module Skrift
   module X11
-    
+    # Thin XRender adapter over Skrift::GlyphCache. Monochrome glyphs go into an
+    # A8 glyph set (coloured at composite time by a solid fill); colour glyphs
+    # (emoji, via the skrift-color delegate) go into an ARGB32 glyph set and are
+    # composited with a neutral white source so their own colours show. A string
+    # is drawn as runs of like-typed glyphs, one composite per run. All the
+    # platform-independent work (fallback, rasterisation, layout, caching, box
+    # drawing, colour delegation) lives in skrift core + the plugins.
     class Glyphs
       attr_reader :fixed_width
-      attr_accessor :maxheight
-      
-      def load_font(index)
-        return @fonts[index] if @fonts[index]
-        f = @fontset[index]
-        return nil if !f
-        return @fonts[index] = Font.load(f) if File.exist?(f)
-
-        # FIXME: Do proper resolution of XDG dirs
-        fn = File.expand_path("~/.local/share/fonts/#{f}")
-        return @fonts[index] = Font.load(fn) if File.exist?(fn)
-
-        fn = `fc-match --format='%{file}\n' #{fn}`.split("\n").first
-        return @fonts[index] = Font.load(fn) if File.exist?(fn)
-        return nil
-      end
-
-      def inspect
-        "<Glyphs #{object_id}"
-      end
-      
-      def initialize dpy, font=nil, fontset: nil, x_scale:, y_scale:, pic: nil, fixed: nil, maxheight: nil, fit: false
-        @fontset = fontset
-        @fonts = @fontset ? [] : [font]
-        @font = font || load_font(0)
-        @maxheight = maxheight
+      attr_accessor :maxheight, :lm
 
+      # +color+ (optional) is a font (path, name or Skrift::Font) providing
+      # colour glyphs, e.g. an emoji font; requires the skrift-color gem.
+      def initialize(dpy, font=nil, fontset: nil, x_scale:, y_scale:, pic: nil, fixed: nil, maxheight: nil, fit: false, color: nil)
         @dpy = dpy
-        @sft = SFT.new(@font)
-        @sft.x_scale = x_scale
-        @sft.y_scale = y_scale
         @pic = pic
-        @fixed = fixed
-        # When set (with a fixed cell), glyphs whose natural size exceeds the
-        # cell are scaled down to fit and centred instead of being clamped
-        # (and distorted) at the cell edge by the rasteriser.
-        @fit = fit
-
-        g = @sft.gmetrics(@sft.lookup("M".ord))
-        if !g
-          g = @sft.gmetrics(0)
-        end
-        if g
-          @fixed_width = g.advance_width.ceil
-        else
-          @fixed_width = x_scale
-        end
+        @maxheight = maxheight
 
-        @nextgid = 1
-        @glyphcache = {}
-        @colcache   = {}
-        @chcache = {}
+        color_renderer = build_color_renderer(color, x_scale, y_scale)
+        @cache = Skrift::GlyphCache.new(fontset || font,
+                                        x_scale: x_scale, y_scale: y_scale,
+                                        fixed: fixed, maxheight: maxheight, fit: fit,
+                                        special: ->(cp) { @boxes.glyph(cp) },
+                                        color: color_renderer)
+        @boxes = Skrift::BoxDrawing.new(@cache.cell_width, @cache.cell_height)
+        @fixed_width = @cache.cell_width
+        @lm = Skrift::LMetrics.new(@cache.ascent, @cache.descent, @cache.line_gap)
 
-        @lm = @sft.lmetrics
+        @colcache = {}
+        @gids     = {}        # codepoint -> [:mono|:color, glyph-set id]
+        @nextgid  = 1
 
-        # The glyph set
         @gfmt     = @dpy.render_find_standard_format(:a8).id
         @glyphset = @dpy.render_create_glyph_set(@gfmt)
+
+        if color_renderer
+          @cfmt      = @dpy.render_find_standard_format(:argb24).id
+          @cglyphset = @dpy.render_create_glyph_set(@cfmt)
+          @white     = @dpy.render_create_solid_fill(0xffff, 0xffff, 0xffff, 0xffff)
+        end
       end
 
-      attr_accessor :lm
+      def inspect = "<Glyphs #{object_id}>"
 
       def fill_for_col(col)
         return @colcache[col] if @colcache[col]
@@ -86,166 +71,109 @@ module Skrift
         g |= g << 8
         b = col & 0xff
         b |= b << 8
-        
-        @colcache[col] ||= @dpy.render_create_solid_fill(r,g,b,0xffff)
+        @colcache[col] = @dpy.render_create_solid_fill(r, g, b, 0xffff)
+      end
+
+      def text_width(str) = @cache.text_width(str)
+
+      # Draw +str+ as one composite per run of same-typed glyphs (mono vs
+      # colour). Each rendered glyph advances the pen by one cell, so a pure-text
+      # string is a single A8 composite exactly as before; emoji break the run.
+      def render_str(pic, col, x, y, str)
+        glyphs   = str.to_s.each_char.map { |ch| gsgid_for(ch.ord) }
+        rendered = 0
+        i = 0
+        while i < glyphs.length
+          (i += 1; next) if glyphs[i].nil? # unmapped: skip, no advance
+          type   = glyphs[i].first
+          run_x  = x + rendered * @fixed_width
+          ids    = []
+          while i < glyphs.length && glyphs[i] && glyphs[i].first == type
+            ids << glyphs[i].last
+            rendered += 1
+            i += 1
+          end
+          composite_run(type, pic, col, run_x, y, ids)
+        end
       end
 
       private
 
-      def boxw   = @fixed_width
-      def stride = (@fixed_width +3)&~3
-      def boxh
-        @boxh ||= [@maxheight, @lm.ascender.ceil-@lm.descender.ceil].compact.min
+      def build_color_renderer(color, x_scale, y_scale)
+        return nil unless color
+        # A caller can pass its own delegate (e.g. one that gates which
+        # codepoints render in colour); we use it as-is. Otherwise treat the
+        # argument as a font and build an ungated Color::Renderer from it.
+        return color if color.respond_to?(:render)
+        unless defined?(Skrift::Color::Renderer)
+          raise "colour glyphs require the skrift-color gem"
+        end
+        font = Skrift::FontSet.new(color)[0]
+        Skrift::Color::Renderer.new(font, x_scale: x_scale, y_scale: y_scale)
       end
-      
-
-      def cache_special(ch)
-        # Box drawing
-        return nil if !((0x2500 .. 0x257f) === ch.ord)
 
+      def composite_run(type, pic, col, x, y, ids)
+        if type == :color
+          @dpy.render_composite_glyphs32(:PictOpOver, @white, pic, @cfmt, @cglyphset, 0, 0, [x, y, ids])
+        else
+          @dpy.render_composite_glyphs32(:PictOpOver, fill_for_col(col), pic, @gfmt, @glyphset, 0, 0, [x, y, ids])
+        end
+      end
 
-        img = cache_box(ch.ord)
+      # [:mono|:color, glyph-set id] for a codepoint, uploading on first use, or
+      # nil for a codepoint no font maps (and which isn't box drawing/colour).
+      def gsgid_for(cp)
+        return @gids[cp] if @gids.key?(cp)
+        @gids[cp] = upload(cp)
+      end
 
+      def upload(cp)
+        # NUL doubles as the double-width spacer (the trailing cell of a wide
+        # glyph): a blank cell that only advances, letting the wide glyph in the
+        # previous cell overflow into it.
+        return upload_blank if cp.zero?
 
-        data = img.pixels.pack("C*")
-        info = ::X11::Form::GlyphInfo.new(
-          img.width,              # w
-          img.height,             # h
-          0, # x
-          0,          # y
-          fixed_width,
-          0
-        )
+        g = @cache.glyph(cp)
+        return nil unless g
 
         gsgid = @nextgid
         @nextgid += 1
-        @dpy.render_add_glyphs(@glyphset, gsgid, info, data)
-        @glyphcache[gsgid] = fixed_width
-        @chcache[ch] = {gsgid: gsgid}
-      end
-
-      def cache_glyph(gsgid,gid, baseline)
-        return if gid.nil?
-        mtx = @sft.gmetrics(gid)
-        scaled = false
-        saved  = nil
-
-        # Oversized glyph in a fixed cell: re-render it at a reduced scale so
-        # it fits the cell, then position it through the normal
-        # baseline-relative path below (no vertical shift). Otherwise the
-        # rasteriser clamps the overflow at the cell edge and distorts the
-        # shape. Only glyphs clearly wider/taller than the cell are scaled -
-        # a marginal overshoot (e.g. a 'W' a pixel past the cell) is left to
-        # the clamp, so ordinary text is untouched.
-        if @fit && @fixed && mtx
-          sx = (mtx.min_width  || 0) > boxw * 1.1 ? boxw.to_f / mtx.min_width  : 1.0
-          sy = (mtx.min_height || 0) > boxh * 1.1 ? boxh.to_f / mtx.min_height : 1.0
-          s  = [sx, sy].min
-          if s < 1.0
-            saved = [@sft.x_scale, @sft.y_scale]
-            @sft.x_scale = @sft.x_scale * s
-            @sft.y_scale = @sft.y_scale * s
-            mtx = @sft.gmetrics(gid)
-            scaled = true
-          end
-        end
-
-        # FIXME: Not sure what to do if mtx.nil? here.
-        # Maybe use x/y scale?
-        if @fixed
-          w = fixed_width
+        if g.color?
+          @dpy.render_add_glyphs(@cglyphset, gsgid, glyph_info(g), argb_data(g.rgba))
+          [:color, gsgid]
+        elsif g.alpha
+          @dpy.render_add_glyphs(@glyphset, gsgid, glyph_info(g), g.alpha.pack("C*"))
+          [:mono, gsgid]
         else
-          w = mtx.min_width || 0
+          upload_blank # no outline (e.g. space)
         end
-        h = [mtx&.min_height || 1, @maxheight].compact.min
-        #p [w,h]
-        img = Image.new((w+3)&~3, h)
-        if !@sft.render(gid, img)
-          #STDERR.puts "Unable to render #{gid}\n"
-          data = "\0"*(w*h)
-        else
-          data = img.pixels.pack("C*")
-        end
-
-        yoff = mtx.y_offset || baseline
-
-        info = ::X11::Form::GlyphInfo.new(
-          img.width,              # w
-          img.height,             # h
-          -mtx.left_side_bearing, # x
-          yoff-baseline,          # y
-          fixed_width || mtx.advance_width, # || mtx.advance_width,      # x_off
-          0
-        )
-
-        @dpy.render_add_glyphs(@glyphset, gsgid, info, data)
-        @glyphcache[gsgid] = scaled ? (fixed_width || mtx.advance_width) : mtx.advance_width
-      ensure
-        @sft.x_scale, @sft.y_scale = saved if saved
       end
 
-      public
-
-      def text_width(str)
-        # We *presume* that if you call text_width, you intend
-        # to render the string. Maybe we shouldn't?
-        gl = cache_glyphs(str)
-        gl.inject(0) {|sum,gl|
-          @glyphcache[gl].to_i + sum
-        }
-      end
-      
-      private
-      def each_font
-        Array(@fontset).each_index do |i|
-          yield load_font(i)
-        end
+      # A blank glyph that only advances one cell.
+      def upload_blank
+        gsgid = @nextgid
+        @nextgid += 1
+        info = ::X11::Form::GlyphInfo.new(0, 0, 0, 0, @fixed_width, 0)
+        @dpy.render_add_glyphs(@glyphset, gsgid, info, "".b)
+        [:mono, gsgid]
       end
-      
-      def cache_glyphs(str)
-        gl = str.to_s.each_char.map do |ch|
-
-          cache = @chcache[ch]
-
-          if cache.nil?
-            cache = cache_special(ch)
-          end
-          
-          if cache.nil?
-            each_font do |font|
-              # FIXME: This is stupid and must be untangled
-              @sft.font = font
-              gid = @sft.lookup(ch.ord)
-              if gid
-                cache = @chcache[ch] = {font: font, gid: gid, gsgid: @nextgid}
-                @nextgid += 1
-                break
-              end
-            end
-          end
-
-          if cache
-            data = @glyphcache[cache[:gsgid]]
-            if !data
-              @sft.font = cache[:font]
-              data = cache_glyph(cache[:gsgid], cache[:gid], @lm.ascender)
-            end
 
-            cache[:gsgid]
-          else
-            0
-          end
-        end
+      def glyph_info(g)
+        ::X11::Form::GlyphInfo.new(g.width, g.height,
+                                   -g.left_side_bearing, g.y_offset - @cache.baseline,
+                                   @fixed_width, 0)
       end
 
-      public
-      def render_str(pic, col, x,y, str)
-        fill = fill_for_col(col)
-        gl = cache_glyphs(str)
-        @dpy.render_composite_glyphs32(
-          :PictOpOver, fill, pic, @gfmt,
-          @glyphset, 0,0, [x, y, gl]
-        )
+      # Pack straight-alpha 0xRRGGBBAA pixels as premultiplied ARGB32 in the
+      # little-endian byte order XRender's argb format expects (B, G, R, A).
+      def argb_data(rgba)
+        rgba.map do |px|
+          a = px & 0xff
+          r = (((px >> 24) & 0xff) * a) / 255
+          g = (((px >> 16) & 0xff) * a) / 255
+          b = (((px >> 8) & 0xff) * a) / 255
+          (a << 24) | (r << 16) | (g << 8) | b
+        end.pack("L<*")
       end
     end
   end

data/lib/skrift/x11/version.rb

@@ -2,6 +2,6 @@
 
 module Skrift
   module X11
-    VERSION = "0.2.2"
+    VERSION = "0.3.0"
   end
 end

data/skrift-x11.gemspec

@@ -34,7 +34,8 @@ Gem::Specification.new do |spec|
 
   # Uncomment to register a new dependency of your gem
   # spec.add_dependency "example-gem", "~> 1.0"
-  spec.add_dependency "skrift"
+  spec.add_dependency "skrift", ">= 0.3.0"
+  spec.add_dependency "skrift-boxdrawing", ">= 0.2.0"
   spec.add_dependency "pure-x11"
 
   # For more information and examples about making a new gem, check out our

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: skrift-x11
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.0
 platform: ruby
 authors:
 - Vidar Hokstad
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2026-06-13 00:00:00.000000000 Z
+date: 2026-06-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: skrift
@@ -16,14 +16,28 @@ dependencies:
     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-boxdrawing
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.0
 - !ruby/object:Gem::Dependency
   name: pure-x11
   requirement: !ruby/object:Gem::Requirement
@@ -51,7 +65,6 @@ files:
 - example.png
 - example.rb
 - lib/skrift/x11.rb
-- lib/skrift/x11/boxdrawing.rb
 - lib/skrift/x11/glyphs.rb
 - lib/skrift/x11/version.rb
 - resources/FiraGO-Regular_extended_with_NotoSansEgyptianHieroglyphs-Regular.ttf

data/lib/skrift/x11/boxdrawing.rb

@@ -1,198 +0,0 @@
-module Skrift
-  module X11
-    class Glyphs
-      
-      def empty_box_image
-        img = Image.new(stride, boxh)
-        img.pixels = Array.new(img.width*img.height,0x00)
-        img
-      end
-
-
-      def cache_box(ch)
-        @boxcache ||= {}
-        c = @boxcache[ch] if @boxcache[ch]
-
-        hx = (boxw+1)/2
-        hy = (boxh+1)/2
-        yoff = hy*stride
-        img = nil
-        h = 1 # 1/3 width of "heavy" line
-
-        lh = light_h = [-255,   0,255,  0, 255]; hh = heavy_h = [-255,  -h,255,  h, 255]
-        lv = light_v = [   0,-255,  0,255, 255]; hv = heavy_v = [  -h,-255,  h,255, 255]
-
-        ll = light_l = [-255,   0,  0,  0, 255]; hl = heavy_l = [-255,  -h,  0,  h, 255]
-        lu = light_u = [   0,-255,  0,  0, 255]; hu = heavy_u = [  -h,-255,  h,  0, 255]
-        lr = light_r = [   0,   0,255,  0, 255]; hr = heavy_r = [   0,  -h,255,  h, 255]
-        ld = light_d = [   0,   0,  0,255, 255]; hd = heavy_d = [  -h,   0,  h,255, 255]
-
-        hc      = [  -h,  -h,  h,  h, 255] # Heavy centre
-
-        d = 2
-        dblc = [-d+1, -d+1, d-1, d-1, 0] # Gap in centre of double lines.
-        light_vc = [0, -d, 0, d, 255] # Light vertical crossing centre of double line.
-
-        dh = double_h = [-255,-d,255,-d, 255] + [-255, d,255, d, 255]
-        dv = double_v = [-d,-255,-d,255, 255] + [d,-255,d,255, 255]
-
-        mask_vbar = [-d+1,-255,d-1,255,0]
-        mask_hbar = [-255,-d+1,255,d-1,0]
-
-        mt= masktop    = [-255,-255, 255,  -1, 0]; maskdtop   = [-255,-255, 255,-d-1, 0]
-        ml=maskleft   = [-255,-255,  -1, 255, 0]; maskdleft  = [-255,-255,-d-1, 255, 0]
-        mb=maskbottom = [-255,   1, 255, 255, 0]; maskdbottom= [-255, d+1, 255, 255, 0]
-        mr=maskright  = [   1,-255, 255, 255, 0]; maskdright = [ d+1,-255, 255, 255, 0]
-
-        mask_lbar = [-255,-d+1,d-1,d-1, 0]; dlbar=double_lbar = [-255,-d,d,d, 255]
-        mask_tbar = [-d+1,-255,d-1,d-1, 0]; dtbar=double_tbar = [-d,-255,d,d, 255]
-        mask_rbar = [-d+1,-d+1,255,d-1, 0]; drbar=double_rbar = [-d,-d,255,d, 255]
-        mask_dbar = [-d+1,-d+1,d-1,255, 0]; ddbar=double_dbar = [-d,-d,d,255, 255]
-
-        mask_c = [0,0,0,0,0]
-
-        hdl = heavy_dl = [heavy_d, heavy_l, hc]
-        hdr = heavy_dr = [heavy_d, heavy_r, hc]
-        hlu = heavy_lu = [heavy_l, heavy_u, hc]
-        hru = heavy_ru = [heavy_r, heavy_u, hc]
-        ldl = light_dl = [light_d, light_l]
-        ldr = light_dr = [light_d, light_r]
-        llu = light_lu = [light_l, light_u]
-        lru = light_ru = [light_r, light_u]
-
-        # FIXME Makes stipples wider when tx/ty etc. are big enough
-        tx = hx - boxw / 3
-        mv2 = mask_v2 = [[-tx, -255, -tx, 255, 0], [tx, -255, tx, 255,0]]
-
-        ty = hy - boxh / 3
-        mh2 = mask_h2 = [[-255,-ty, 255,-ty,0], [-255,ty,255,ty,0]]
-
-        rects = {
-          0x2500 => lh,       0x2501 => hh,       0x2502 => lv,       0x2503 => hv,
-          0x2504 => lh + mv2, 0x2505 => hh + mv2, 0x2506 => lv + mh2, 0x2507 => hv + mv2,
-          0x2508 => lh,  # FIXME: Stippled
-          0x2509 => hh,  # FIXME: Stippled
-          0x250A => lv,  # FIXME: Stippled
-          0x250B => hv,  # FIXME: Stippled
-
-          0x250C => ldr,       0x250D => hr + ld,  0x250E => hd + lr,  0x250F => hdr,
-          0x2510 => ldl,       0x2511 => hl + ld,  0x2512 => [hd, ll], 0x2513 => hdl,
-          0x2514 => lru,       0x2515 => lu + hr,  0x2516 => lr + hu,  0x2517 => hru,
-          0x2518 => llu,       0x2519 => [hl, lu], 0x251a => [ll, hu], 0x251b => hlu,
-          0x251c => lv+lr,     0x251d => [lv, hr], 0x251e => ldr + hu, 0x251f => [lru, hd],
-
-          0x2520 => hv  +  lr, 0x2521 => hru +  ld, 0x2522 => hdr +  lu, 0x2523 => hv  + hr,
-          0x2524 => ll  +  lv, 0x2525 => hl  +  lv, 0x2526 => hu  + ldl, 0x2527 => hd  +  lu,
-          0x2528 => hv  +  ll, 0x2529 => hlu +  ld, 0x252a => hdl+lu,    0x252b => hl + hv,
-          0x252c => lh  +  ld, 0x252d => [hl, ldr], 0x252e => [hr, ldr], 0x252f => [hh, ld],
-
-          0x2530 => [lh, hd],  0x2531 => [hdl, lr], 0x2532 => [ll, hdr],  0x2533 => [hh, hd],
-          0x2534 => [lh, lu],  0x2535 => [lru, hl], 0x2536 => [llu, hr], 0x2537 => [hh, lu],
-          0x2538 => [lh, hu],  0x2539 => [hlu, lr], 0x253a => [hru, ll], 0x253b => [hh, hu],
-          0x253c => [lv, lh],  0x253d => lv+lr+hl,  0x253e => ll+lv+hr,  0x253f => [lv, hh],
-
-          0x2540 => [lh, ld, hu], 0x2541 => [light_h, light_u, heavy_d], 0x2542 => [heavy_v, light_h], 0x2543 => [heavy_l, heavy_u, hc, light_d, light_r],
-          0x2544 => [ll, ld, hru], 0x2545 => [heavy_dl, light_ru], 0x2546 => [light_lu, heavy_dr], 0x2547 => [heavy_h, heavy_u, light_d],
-          0x2548 => [hh, hd, light_u], 0x2549 => [heavy_v, heavy_l, light_r], 0x254a => [heavy_v, light_l, heavy_r], 0x254b => [heavy_v, heavy_h],
-          0x254c => [lh, dblc], 0x254d => [heavy_h, dblc], 0x254e => [light_v, dblc], 0x254f => [heavy_v, dblc],
-
-          0x2550 => dh, 0x2551 => dv, 0x2552 => [dh, lv, ml, maskdtop], 0x2553 => [dv, lh, mt, maskdleft],
-          0x2554 => [ddbar, drbar, mask_dbar, mask_rbar], 0x2555 => [dh, mr, lv, maskdtop],
-          0x2556 => [dv, lh,maskdright,mt], 0x2557 => [double_dbar, double_lbar, mask_dbar, mask_lbar],
-          0x2558 => [lv, dh, ml,  maskdbottom], 0x2559 => [lh, dv, maskdleft, mb],
-          0x255A => [dtbar, double_rbar, mask_tbar, mask_rbar], 0x255B => [dh, lv, maskdbottom, mr],
-          0x255C => [dv, lh, mb,  maskdright], 0x255D => [dtbar, dlbar, mask_tbar, mask_lbar],
-          0x255e => [lv, dh, maskleft], 0x255f => [lh, dv, dblc, maskdleft],
-          0x2560 => [dv, drbar, mask_rbar, mask_vbar], 0x2561 => [lv, dh, maskright],
-          0x2562 => [dv, ll, dblc], 0x2563 => [dlbar, dv, mask_lbar, mask_vbar],
-          0x2564 => [dh, ld, dblc], 0x2565 => [lh, dv, mt],
-          0x2566 => [dh, ddbar,mask_hbar, mask_dbar], 0x2567 => [dh, light_u,dblc],
-          0x2568 => [lh, dv, mb],   0x2569 => [dh, double_tbar, mask_hbar, mask_tbar],
-          0x256A => dh+lv, 0x256b => dv+lh, 0x256c => [dh, dv, mask_hbar, mask_vbar],
-
-          # 256d, 256e, 256f, 2570 => curves
-          # FIXME: Current is just very slightly rounded.
-          0x256d => [ldr, mask_c], 0x256e => [ldl, mask_c], 0x256f => [llu, mask_c], 0x2570 => [lru, mask_c],
-
-          # 2571, 2572. 2573 => diagonals, handled below.
-          0x2571 => nil, 0x2572 => nil, 0x2573 => nil,
-
-          0x2574 => ll,      0x2575 => lu,      0x2576 => lr,      0x2577 => ld,
-          0x2578 => hl,      0x2579 => hu,      0x257a => hr,      0x257b => hd,
-          0x257c => ll + hr, 0x257d => lu + hd, 0x257e => hl + lr, 0x257f => hu + ld
-
-        }
-
-        r = rects[ch.ord]
-        if r
-          img = empty_box_image
-          r.flatten.each_slice(5) do |rect|
-            p rect
-            x1,y1,x2,y2, col = *rect
-            x1 = (x1+hx).clamp(0,boxw-1)
-            x2 = (x2+hx).clamp(0,boxw-1)
-            y1 = (y1+hy).clamp(0,boxh-1)
-            y2 = (y2+hy).clamp(0,boxh-1)
-            col ||= 255
-
-            a = Array.new(x2-x1+1,col)
-
-            (y1..y2).each do |y|
-              img.pixels[y*stride + x1 .. y*stride + x2] = a
-            end
-          end
-          return img
-        end
-
-        if ch.ord == 0x2571
-          img = empty_box_image
-          slope = boxw.to_f / boxh
-          x = boxw.to_f-1
-          (0...boxh).each do |y|
-            err = x - x.to_i
-            img.pixels[y*stride+x.ceil] = 255 #(255*(1-err)).floor
-            img.pixels[y*stride+x.ceil-1] = (255*err).floor if x > 0
-            x-= slope
-          end
-          return img
-        end
-
-        # FIXME: If size is *at* certain levels level, this, and the next one fails?
-
-        if ch.ord == 0x2572
-          img = empty_box_image
-          slope = boxw.to_f / boxh
-          x = boxw.to_f-1
-          (0...boxh).each do |y|
-            err = x - x.to_i
-            img.pixels[y*stride+boxw-x.ceil-1]   = 255
-            img.pixels[y*stride+boxw-x.ceil] = (255*err).floor if x > 0
-            x-= slope
-          end
-          return img
-        end
-
-        if ch.ord == 0x2573
-          img = empty_box_image
-          slope = boxw.to_f / boxh
-          x = boxw.to_f-1
-          (0...boxh).each do |y|
-            err = x - x.to_i
-            img.pixels[y*stride+boxw-x.ceil-1]   = 255
-            img.pixels[y*stride+boxw-x.ceil] = (255*err).floor if x > 0
-            img.pixels[y*stride+x.ceil-1] = (255*err).floor if x > 0
-            img.pixels[y*stride+x.ceil] = 255 #(255*(1-err)).floor
-            x-= slope
-          end
-          return img
-        end
-
-        if img
-          img = img.dup
-          img.pixels = img.pixels.dup
-        end
-        img || empty_box_image
-      end
-    end
-  end
-end