skrift-x11 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 92507a6b036b8ab2eb0145017a938019111e2ea17c4e001a693529d2518876f3
-  data.tar.gz: 2da4b5247c4e4b085a4f4591594d09f69f2f35a93c7fe43210b68f7efbfe3798
+  metadata.gz: a75688a1a4f9e322d33c58a9b0a29b2fb26c27536a137e33dd97c340a491dd98
+  data.tar.gz: 87a5c7f3f29918f0031e637acbc4d08a6d8d6f122b3112c597515086fa1d0317
 SHA512:
-  metadata.gz: 8bac35a07d623a9f27539ec68d2a2cc4eb2cc906e788660a7cbea25323d55ff30ada7ac1474f92c7caa4b8c92a50a509bf6eaf25550c5e04d6e273a13aebe15f
-  data.tar.gz: c35c1e39c5b5ef7daf70257dc14e0930ac70607e78b6bc8397563964377d8e090b4472162fbbb061c05c584553ae6d0b7e937e7d3ecc156f534b6eed518c41e5
+  metadata.gz: 7db2e7d2a63a2afa679ca83652136e13e954b3eee2c11d55c5734c48ed10be641a8fee0eca3d1df779a1d4c19c7a4172027d9aea1659f4bb8f4728f6de3ded3e
+  data.tar.gz: 4014ba510524d9921c9eb67986b137151f98aca2cd71427e431fdcefe776c5c869e45b45de09d3a692fe77976f82da4c7df6bdb08ca687736301d43a45f5af12

data/example.rb

@@ -52,7 +52,7 @@ f = Font.load("resources/FiraGO-Regular_extended_with_NotoSansEgyptianHieroglyph
 $skrift = Skrift::X11::Glyphs.new(dpy, f, x_scale: 40, y_scale: 40)
 
 def redraw(dpy, wid, gc)
-  dpy.poly_fill_rectangle(wid, gc, [X11::Form::Rectangle.new(20,45, 400, 400)])
+  dpy.poly_fill_rectangle(wid, gc, [20,45, 400, 400])
   $skrift.render_str($pic, 0xffffff, 50,90, 'Pure Ruby w/Skrift!')
   $skrift.render_str($pic, 0xffffff, 50,140, "And unicode:")
   $skrift.render_str($pic, 0xff00ff, 50,200, "Μπορώ να φάω σπασμένα γυαλιά χωρίς να πάθω τίποτα.")

data/lib/skrift/x11/boxdrawing.rb

@@ -0,0 +1,198 @@
+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

data/lib/skrift/x11/glyphs.rb

@@ -1,23 +1,70 @@
 
-require 'skrift'
-module Skrift
-  module X11
-    # XRender constants currently not defined in pure-x11.
-    # FIXME.
+require_relative 'boxdrawing'
+
+module X11
+  # XRender constants currently not defined in pure-x11.
+  # FIXME.
+  module Form
     PictOpSrc=1
     PictOpOver=3
     CPRepeat = 1
+  end
+end
 
+module Skrift
+  module X11
+    
     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
 
-      def initialize dpy, font, x_scale:, y_scale:, pic: nil, fixed: nil
         @dpy = dpy
-        @sft = SFT.new(font)
+        @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
+
+        @nextgid = 1
         @glyphcache = {}
         @colcache   = {}
         @chcache = {}
@@ -30,11 +77,6 @@ module Skrift
       end
 
       attr_accessor :lm
-      def gm(ch)
-        gid = @sft.lookup(ch.ord)
-        @sft.gmetrics(gid)
-      end
-    
 
       def fill_for_col(col)
         return @colcache[col] if @colcache[col]
@@ -48,26 +90,74 @@ module Skrift
         @colcache[col] ||= @dpy.render_create_solid_fill(r,g,b,0xffff)
       end
 
-      def fixed_width
-        return @fixed_width if @fixed_width
-        if @fixed
-          # *Ensure* that the glyphs are equal width.
-          g = gm("M")
-          @fixed_width = g.advance_width.ceil
-        else
-          nil
-        end
+      private
+
+      def boxw   = @fixed_width
+      def stride = (@fixed_width +3)&~3
+      def boxh
+        @boxh ||= [@maxheight, @lm.ascender.ceil-@lm.descender.ceil].compact.min
       end
-    
-  
-      def cache_glyph(gid, baseline)
+      
+
+      def cache_special(ch)
+        # Box drawing
+        return nil if !((0x2500 .. 0x257f) === ch.ord)
+
+
+        img = cache_box(ch.ord)
+
+
+        data = img.pixels.pack("C*")
+        info = ::X11::Form::GlyphInfo.new(
+          img.width,              # w
+          img.height,             # h
+          0, # x
+          0,          # y
+          fixed_width,
+          0
+        )
+
+        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?
-        w = fixed_width || mtx.min_width || 0
-        h = mtx.min_height || 1
+        if @fixed
+          w = fixed_width
+        else
+          w = mtx.min_width || 0
+        end
+        h = [mtx&.min_height || 1, @maxheight].compact.min
         #p [w,h]
         img = Image.new((w+3)&~3, h)
         if !@sft.render(gid, img)
@@ -76,9 +166,9 @@ module Skrift
         else
           data = img.pixels.pack("C*")
         end
-        
+
         yoff = mtx.y_offset || baseline
-        
+
         info = ::X11::Form::GlyphInfo.new(
           img.width,              # w
           img.height,             # h
@@ -88,43 +178,72 @@ module Skrift
           0
         )
 
-        @dpy.render_add_glyphs(@glyphset, gid, info, data)
-        @glyphcache[gid] = mtx.advance_width#-mtx.left_side_bearing
+        @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)
-        gl = map_glyphs(str)
         # We *presume* that if you call text_width, you intend
         # to render the string. Maybe we shouldn't?
-        cache_glyphs(gl)
+        gl = cache_glyphs(str)
         gl.inject(0) {|sum,gl|
           @glyphcache[gl].to_i + sum
         }
       end
       
-      def map_glyphs(str)
-        # FIXME: Should probably cache by character rather than
-        # glyph
-        str.to_s.each_char.map do |ch|
-          @chcache[ch] ||= @sft.lookup(ch.ord).to_i
+      private
+      def each_font
+        Array(@fontset).each_index do |i|
+          yield load_font(i)
         end
       end
       
-      def cache_glyphs(gl)
-        gl.each do |gid|
-          data = @glyphcache[gid]
-          if !data
-            data = cache_glyph(gid, @lm.ascender)
+      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
       end
-      
+
+      public
       def render_str(pic, col, x,y, str)
         fill = fill_for_col(col)
-        gl = map_glyphs(str)
-        cache_glyphs(gl)
+        gl = cache_glyphs(str)
         @dpy.render_composite_glyphs32(
-          PictOpOver, fill, pic, @gfmt,
+          :PictOpOver, fill, pic, @gfmt,
           @glyphset, 0,0, [x, y, gl]
         )
       end

data/lib/skrift/x11/version.rb

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

data/skrift-x11.gemspec

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "lib/skrift/x11/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "skrift-x11"
+  spec.version = Skrift::X11::VERSION
+  spec.authors = ["Vidar Hokstad"]
+  spec.email = ["vidar@hokstad.com"]
+
+  spec.summary = "Helpers to use the pure-Ruvy TrueType engine Skrift with pure Pure-X11 X bindings"
+  #spec.description = "TODO: Write a longer description or delete this line."
+  #spec.homepage = "TODO: Put your gem's website or public repo URL here."
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 2.6.0"
+
+  #spec.metadata["allowed_push_host"] = "TODO: Set to your gem server 'https://example.com'"
+
+  #spec.metadata["homepage_uri"] = spec.homepage
+  #spec.metadata["source_code_uri"] = "TODO: Put your gem's public repo URL here."
+  #spec.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here."
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) ||
+        f.start_with?(*%w[bin/ test/ spec/ features/ .git .circleci appveyor Gemfile])
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Uncomment to register a new dependency of your gem
+  # spec.add_dependency "example-gem", "~> 1.0"
+  spec.add_dependency "skrift"
+  spec.add_dependency "pure-x11"
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: skrift-x11
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
 platform: ruby
 authors:
 - Vidar Hokstad
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-11-12 00:00:00.000000000 Z
+date: 2026-06-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: skrift
@@ -51,10 +51,12 @@ 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
 - sig/skrift/x11.rbs
+- skrift-x11.gemspec
 homepage: 
 licenses:
 - MIT