zaniah 0.1.0

data/lib/zaniah/layout/tree.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Zaniah
+  module Layout
+    class Tree
+      attr_reader :nodes
+
+      def initialize = @nodes = []
+      def new_node(**options) = @nodes.push(Node.new(**options)).length - 1
+      def add_child(parent, child) = @nodes.fetch(parent).add(@nodes.fetch(child))
+      def set_style(id, **style) = @nodes.fetch(id).style = @nodes.fetch(id).style.merge(**style)
+      def compute(id, width:, height:) = Engine.new.compute(@nodes.fetch(id), width: width, height: height)
+      def bounds(id) = @nodes.fetch(id).bounds
+    end
+  end
+end

data/lib/zaniah/layout.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative "layout/available_space"
+require_relative "layout/style"
+require_relative "layout/node"
+require_relative "layout/engine"
+require_relative "layout/tree"
+
+module Zaniah
+  LayoutTree = Layout::Tree
+end

data/lib/zaniah/length.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Zaniah
+  Length = Data.define(:value, :unit) do
+    def resolve(available, rem: 16)
+      case unit
+      when :px then value
+      when :percent then available * value / 100.0
+      when :rem then rem * value
+      else raise ArgumentError, "unknown length unit #{unit}"
+      end
+    end
+  end
+end

data/lib/zaniah/length_units.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Zaniah
+  module LengthUnits
+    def px(value) = Length.new(value, :px)
+    def rems(value) = Length.new(value, :rem)
+    def percent(value) = Length.new(value, :percent)
+  end
+end

data/lib/zaniah/list/height_index.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Zaniah
+  class List
+    class HeightIndex
+      attr_reader :count
+
+      def initialize(count, estimate)
+        raise ArgumentError, "count must be a nonnegative integer" unless count.is_a?(Integer) && count >= 0
+        raise ArgumentError, "height must be finite and positive" unless estimate.is_a?(Numeric) && estimate.finite? && estimate.positive?
+        @count, @estimate, @values = count, estimate.to_f, {}
+        @tree = Array.new(count + 1) { |index| (index & -index) * @estimate }
+      end
+
+      def [](index)
+        validate_index(index)
+        @values.fetch(index, @estimate)
+      end
+
+      def update(index, height)
+        validate_index(index)
+        raise ArgumentError, "height must be finite and positive" unless height.is_a?(Numeric) && height.finite? && height.positive?
+        delta = height.to_f - self[index]
+        height == @estimate ? @values.delete(index) : @values[index] = height.to_f
+        cursor = index + 1
+        while cursor <= @count
+          @tree[cursor] += delta
+          cursor += cursor & -cursor
+        end
+        delta
+      end
+
+      def prefix(index)
+        raise IndexError, "row boundary outside list" unless index.is_a?(Integer) && index.between?(0, @count)
+        total = 0.0
+        while index.positive?
+          total += @tree[index]
+          index -= index & -index
+        end
+        total
+      end
+
+      def total = prefix(@count)
+
+      # Index containing y; count is the sentinel at/beyond the bottom edge.
+      def index_at(y)
+        raise ArgumentError, "row offset must be finite" unless y.is_a?(Numeric) && y.finite?
+        return 0 if y <= 0
+        index, accumulated = 0, 0.0
+        bit = 1 << @count.bit_length
+        while bit.positive?
+          candidate = index + bit
+          if candidate <= @count && accumulated + @tree[candidate] <= y
+            index, accumulated = candidate, accumulated + @tree[candidate]
+          end
+          bit >>= 1
+        end
+        index
+      end
+
+      private
+
+      def validate_index(index)
+        raise IndexError, "row outside list" unless index.is_a?(Integer) && index.between?(0, @count - 1)
+      end
+    end
+  end
+end

data/lib/zaniah/list.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Zaniah
+  # A variable-height, viewport-only list. Unknown rows use estimated_height;
+  # measuring visible rows refines the prefix sums without moving the anchor.
+  class List < Element
+    attr_reader :scroll_y, :visible_range, :heights
+
+    def initialize(count:, estimated_height: 24, overscan: 2, &render_item)
+      super()
+      raise ArgumentError, "a row renderer is required" unless render_item
+      raise ArgumentError, "overscan must be a nonnegative integer" unless overscan.is_a?(Integer) && overscan >= 0
+      @heights, @overscan, @render_item = HeightIndex.new(count, estimated_height), overscan, render_item
+      @scroll_y, @viewport, @visible_range = 0.0, 0.0, 0...0
+      style(overflow: :hidden)
+      on_scroll_wheel do |event, cx|
+        self.scroll_y = @scroll_y + event.delta.y
+        cx.window.request_frame
+      end
+    end
+
+    def total_height = @heights.total
+
+    def scroll_y=(value)
+      raise ArgumentError, "scroll offset must be finite" unless value.is_a?(Numeric) && value.finite?
+      @scroll_y = value.to_f.clamp(0, [total_height - @viewport, 0].max)
+    end
+
+    def update_height(index, height)
+      anchor = @heights.index_at(@scroll_y)
+      delta = @heights.update(index, height)
+      self.scroll_y = @scroll_y + (index < anchor ? delta : 0)
+      self
+    end
+
+    def scroll_to(index, align: :start)
+      height, top = @heights[index], @heights.prefix(index)
+      offset = case align
+      when :start then top
+      when :center then top - (@viewport - height) / 2
+      when :end then top + height - @viewport
+      when :nearest
+        top < @scroll_y ? top : (top + height > @scroll_y + @viewport ? top + height - @viewport : @scroll_y)
+      else raise ArgumentError, "unknown alignment #{align.inspect}"
+      end
+      self.scroll_y = offset
+      self
+    end
+
+    def request_layout(cx)
+      @state = cx.state(@key, &@state_initializer) if @key && @state_initializer
+      @viewport = dimension(:height, cx.window.content_size.height)
+      width = dimension(:width, cx.window.content_size.width)
+      self.scroll_y = @scroll_y
+      anchor = @heights.index_at(@scroll_y)
+      within = @scroll_y - @heights.prefix(anchor)
+      measured, engine = {}, Layout::Engine.new
+      loop do
+        @visible_range = viewport_range
+        missing = @visible_range.reject { |index| measured.key?(index) }
+        break if missing.empty?
+        missing.each do |index|
+          element = @render_item.call(index)
+          raise TypeError, "row renderer must return an Element" unless element.is_a?(Element)
+          node = element.request_layout(cx)
+          _natural_width, height = engine.measure(node, width: width, height: @viewport)
+          @heights.update(index, [height, 1.0].max)
+          measured[index] = [element, node]
+        end
+        self.scroll_y = @heights.prefix(anchor) + [within, anchor < @heights.count ? @heights[anchor] : 0].min
+      end
+      @children = @visible_range.map { |index| measured.fetch(index).first }
+      nodes = @visible_range.map do |index|
+        node = measured.fetch(index).last
+        node.style = node.style.merge(position: :absolute, left: 0, right: 0,
+                                     top: @heights.prefix(index) - @scroll_y, height: @heights[index])
+        node
+      end
+      @layout_node = Layout::Node.new(style: @style, children: nodes,
+                                     measure: ->(_width, _height) { [width, @viewport] })
+    end
+
+    private
+
+    def dimension(property, available)
+      value = @style[property]
+      value = value.resolve(available) if value.is_a?(Length)
+      value.is_a?(Numeric) ? [value, 0].max : available
+    end
+
+    def viewport_range
+      return 0...0 if @heights.count.zero? || @viewport.zero?
+      first = [@heights.index_at(@scroll_y) - @overscan, 0].max
+      last = [@heights.index_at(@scroll_y + @viewport) + 1 + @overscan, @heights.count].min
+      first...last
+    end
+  end
+
+end
+
+require_relative "list/height_index"

data/lib/zaniah/overlay.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Zaniah
+  class Overlay < Div
+    def initialize
+      super
+      style(position: :absolute, left: 0, right: 0, top: 0, bottom: 0)
+    end
+  end
+end

data/lib/zaniah/platform/display.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Zaniah
+  module Platform
+    Display = Data.define(:id, :name, :bounds, :scale_factor, :primary)
+  end
+end

data/lib/zaniah/platform/file_event.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Zaniah
+  module Platform
+    FileEvent = Data.define(:kind, :path, :old_path) unless const_defined?(:FileEvent)
+  end
+end

data/lib/zaniah/platform/headless/window.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+module Zaniah
+  module Platform
+    module Headless
+      class Window
+        attr_reader :content_size, :scene, :device, :dispatcher, :scale_factor, :text_runs
+        attr_accessor :text_system, :ime_state, :title
+
+        def initialize(width: 800, height: 600, title: "Zaniah UI", scale_factor: 1)
+          @content_size, @scale_factor, @title = Size.new(width, height), scale_factor, title
+          @scene, @device, @dispatcher = Scene.new, GPU::Software.new(width, height), Input::Dispatcher.new
+          @state, @used_state, @text_runs = {}, {}, []
+          @dirty, @closed = true, false
+        end
+
+        def on_input(&block) = @on_input = block
+        def on_resize(&block) = @on_resize = block
+        def on_close(&block) = @on_close = block
+        def on_moved(&block) = @on_moved = block
+        def on_tick(&block) = @on_tick = block
+        def draw(&block) = @draw = block
+        def request_frame = @dirty = true
+        def dirty? = @dirty
+        def closed? = @closed
+        def displays = [Display.new(0, "Headless", Bounds.new(0, 0, @content_size.width, @content_size.height), @scale_factor, true)]
+
+        def resize(width, height)
+          @content_size = Size.new(width, height)
+          @device.resize(width, height)
+          @on_resize&.call(@content_size)
+          request_frame
+        end
+
+        def input(event)
+          return if popup_input(event)
+          @tooltip_offered = false if event.is_a?(Input::MouseMove)
+          @tooltip = nil if event.is_a?(Input::MouseDown) || event.is_a?(Input::KeyDown)
+          @on_input&.call(event)
+          if event.respond_to?(:position)
+            @dispatcher.mouse(event)
+          elsif event.is_a?(Input::KeyDown)
+            @dispatcher.key(event.keystroke)
+          end
+          @tooltip = nil if event.is_a?(Input::MouseMove) && !@tooltip_offered
+          request_frame
+        end
+
+        def offer_tooltip(text, position:, delay: 0.5)
+          @tooltip_offered = true
+          return if @tooltip && @tooltip[:text] == text
+          @tooltip = {text: text.to_s, position: position, at: Process.clock_gettime(Process::CLOCK_MONOTONIC) + delay, shown: false}
+        end
+
+        def context_menu(items, position: Point.new(0, 0))
+          raise ArgumentError, "menu items must be label/callback pairs" unless items.is_a?(Array) && items.all? { |item| item.is_a?(Array) && item.length == 2 && item.first.is_a?(String) && (item.last.nil? || item.last.respond_to?(:call)) }
+          @menu = {items: items.map(&:dup), position: position, index: items.index { |_, callback| callback } || 0}
+          @tooltip = nil
+          request_frame
+        end
+
+        def close
+          return if @closed
+          return false if @on_close && @on_close.call == false
+          @closed = true
+          @device.release
+          @text_system.close if @text_system.respond_to?(:close)
+          true
+        end
+
+        def tick
+          @on_tick&.call
+          if @tooltip && !@tooltip[:shown] && Process.clock_gettime(Process::CLOCK_MONOTONIC) >= @tooltip[:at]
+            @tooltip[:shown] = true
+            request_frame
+          end
+          return unless @dirty && !@closed
+          @dirty = false
+          result = @draw&.call(self)
+          render(result) if result.is_a?(Element)
+          @device.render(result) if result.is_a?(Scene)
+        end
+
+        def render(element, clear: "#181b20", present: true)
+          @text_system.scale_factor = @scale_factor if @text_system.respond_to?(:scale_factor=)
+          @scene.clear
+          @text_runs.clear
+          @text_system.start_frame if @text_system.respond_to?(:start_frame)
+          @used_state.clear
+          @dispatcher.clear_hits
+          cx = FrameContext.new(self)
+          root = element.request_layout(cx)
+          Layout::Engine.new.compute(root, width: @content_size.width, height: @content_size.height)
+          element.prepaint(root.bounds, nil, cx)
+          element.paint(root.bounds, nil, nil, cx)
+          paint_popups
+          @state.delete_if { |key, _| !@used_state[key] }
+          @device.render(@scene, clear: clear) if present
+          @text_system.end_frame if @text_system.respond_to?(:end_frame)
+        end
+
+        def element_state(key)
+          @used_state[key] = true
+          return @state[key] if @state.key?(key)
+          @state[key] = yield
+        end
+
+        def write_png(path) = @device.write_png(path)
+
+        private
+
+        def popup_input(event)
+          return false unless @menu
+          if event.is_a?(Input::KeyDown)
+            key = Input::Keystroke.normalize(event.keystroke)
+            if key == "esc"
+              @menu = nil
+            elsif key == "enter"
+              callback = @menu[:items][@menu[:index]]&.last
+              @menu = nil
+              callback&.call
+            elsif ["up", "down"].include?(key) && !@menu[:items].empty?
+              step = key == "up" ? -1 : 1
+              @menu[:items].length.times do
+                @menu[:index] = (@menu[:index] + step) % @menu[:items].length
+                break if @menu[:items][@menu[:index]].last
+              end
+            end
+          elsif event.is_a?(Input::MouseDown)
+            box = popup_bounds(@menu)
+            index = ((event.position.y - box.y - 4) / 26).floor
+            callback = @menu[:items][index]&.last if box.contains?(event.position) && index >= 0
+            @menu = nil
+            callback&.call
+          elsif event.is_a?(Input::MouseMove)
+            box = popup_bounds(@menu)
+            index = ((event.position.y - box.y - 4) / 26).floor
+            @menu[:index] = index if box.contains?(event.position) && index.between?(0, @menu[:items].length - 1)
+          end
+          request_frame
+          true
+        end
+
+        def popup_bounds(menu)
+          width = [menu[:items].map { |label, _| label.length * 8 + 24 }.max || 80, @content_size.width].min
+          height = [menu[:items].length * 26 + 8, @content_size.height].min
+          Bounds.new(menu[:position].x.clamp(0, @content_size.width - width), menu[:position].y.clamp(0, @content_size.height - height), width, height)
+        end
+
+        def popup_text(text, x, y, color)
+          if @text_system
+            line = @text_system.layout_line(text, size: 13)
+            @text_system.paint_line(@scene, line, x: x, y: y + line.ascent, color: color)
+          end
+          @text_runs << [x, y, text, color]
+        end
+
+        def paint_popups
+          if @menu
+            box = popup_bounds(@menu)
+            @scene.layer(1_000_000) do
+              @scene.quad(box.x, box.y, box.width, box.height, color: "#202936", radius: 4, border_width: 1, border_color: "#526176")
+              @scene.clip(box) do
+                @menu[:items].each_with_index do |(label, callback), index|
+                  y = box.y + 4 + index * 26
+                  @scene.quad(box.x + 3, y, box.width - 6, 26, color: "#345477") if index == @menu[:index]
+                  popup_text(label, box.x + 12, y + 4, callback ? "#edf2f7" : "#8997aa")
+                end
+              end
+            end
+          elsif @tooltip && @tooltip[:shown]
+            text = @tooltip[:text]
+            position = @tooltip[:position]
+            width = [text.length * 8 + 20, @content_size.width].min
+            x, y = position.x.clamp(0, @content_size.width - width), (position.y + 20).clamp(0, [@content_size.height - 30, 0].max)
+            @scene.layer(1_000_000) do
+              @scene.quad(x, y, width, 28, color: "#202936", radius: 4, border_width: 1, border_color: "#526176")
+              @scene.clip(Bounds.new(x, y, width, 28)) { popup_text(text, x + 10, y + 5, "#edf2f7") }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/zaniah/platform/linux/appearance_aware.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module Zaniah
+  module Platform
+    module Linux
+      module AppearanceAware
+        PORTAL = ["--session", "--dest", "org.freedesktop.portal.Desktop", "--object-path", "/org/freedesktop/portal/desktop"].freeze
+        def appearance
+          output, status = Open3.capture2e("gdbus", "call", *PORTAL, "--timeout", "1", "--method", "org.freedesktop.portal.Settings.Read", "org.freedesktop.appearance", "color-scheme")
+          return :dark if status.success? && output.match?(/uint32\s+1\b/)
+          return :light if status.success? && output.match?(/uint32\s+2\b/)
+          output, status = Open3.capture2e("gsettings", "get", "org.gnome.desktop.interface", "color-scheme")
+          status.success? && output.include?("prefer-dark") ? :dark : :light
+        rescue Errno::ENOENT
+          ENV.fetch("GTK_THEME", "").downcase.include?("dark") ? :dark : :light
+        end
+
+        def on_appearance(&block)
+          @on_appearance = block
+          close_appearance
+          return unless block
+          stdin, @appearance_io, @appearance_process = Open3.popen2e("gdbus", "monitor", *PORTAL)
+          stdin.close
+          @appearance_buffer = +""
+        rescue Errno::ENOENT
+          # Minimal desktops without GIO still use the initial GTK_THEME value.
+          nil
+        end
+
+        def poll_appearance
+          return unless @appearance_io
+          data = @appearance_io.read_nonblock(8192, exception: false)
+          return close_appearance if data.nil?
+          return unless data.is_a?(String)
+          @appearance_buffer << data
+          while (newline = @appearance_buffer.index("\n"))
+            line = @appearance_buffer.slice!(0, newline + 1)
+            next unless line.include?("SettingChanged") && line.include?("color-scheme")
+            @on_appearance&.call(line.match?(/uint32\s+1\b/) ? :dark : :light)
+            request_frame
+          end
+          @appearance_buffer.clear if @appearance_buffer.bytesize > 65_536
+        rescue IOError
+          close_appearance
+        end
+
+        def close_appearance
+          @appearance_io&.close unless @appearance_io&.closed?
+          if @appearance_process&.alive?
+            Process.kill("TERM", @appearance_process.pid) rescue Errno::ESRCH
+            @appearance_process.join(0.2)
+          end
+          @appearance_io = @appearance_process = nil
+        end
+      end
+    end
+  end
+end

data/lib/zaniah/platform/linux/displays.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "fiddle/import"
+require_relative "../../ffi/library"
+
+module Zaniah
+  module Platform
+    module Linux
+      module MonitorTypes
+        extend Fiddle::Importer
+        Monitor = struct ["unsigned long name", "int primary", "int automatic", "int output_count", "int x", "int y", "int width", "int height", "int mm_width", "int mm_height", "void *outputs"]
+      end
+
+      def self.displays(display_server: :auto)
+        raise ArgumentError, "unknown Linux display server" unless [:auto, :x11, :wayland].include?(display_server)
+        if display_server == :wayland || (display_server == :auto && ENV["WAYLAND_DISPLAY"])
+          begin
+            require_relative "wayland_display_discovery"
+            return WaylandDisplayDiscovery.read
+          rescue LoadError, Error
+            raise if display_server == :wayland || !ENV["DISPLAY"]
+          end
+        end
+        ptype, long, int = Fiddle::TYPE_VOIDP, Fiddle::TYPE_LONG, Fiddle::TYPE_INT
+        library = FFI::Library.new("libX11.so.6")
+        display = library.fn(:XOpenDisplay, [ptype], ptype).call(0)
+        raise Error, "cannot open X display" if display.null?
+        root = library.fn(:XDefaultRootWindow, [ptype], long).call(display)
+        resources = library.fn(:XResourceManagerString, [ptype], ptype).call(display)
+        scale = resources.null? ? 1.0 : (resources.to_s[/Xft\.dpi:\s*(\d+(?:\.\d+)?)/, 1]&.to_f || 96) / 96.0
+        scale = scale.clamp(1.0, 4.0)
+        begin
+          randr = FFI::Library.new("libXrandr.so.2")
+        rescue LoadError
+          screen = library.fn(:XDefaultScreen, [ptype], int).call(display)
+          width = library.fn(:XDisplayWidth, [ptype, int], int).call(display, screen)
+          height = library.fn(:XDisplayHeight, [ptype, int], int).call(display, screen)
+          return [Display.new(root, "X11 screen", Bounds.new(0, 0, width / scale, height / scale), scale, true)]
+        end
+        count = [0].pack("i")
+        monitors = randr.fn(:XRRGetMonitors, [ptype, long, int, ptype], ptype).call(display, root, 1, count)
+        Array.new(count.unpack1("i")) do |index|
+          record = MonitorTypes::Monitor.new(monitors + index * MonitorTypes::Monitor.size)
+          name = library.fn(:XGetAtomName, [ptype, long], ptype).call(display, record.name)
+          text = name.null? ? "Display #{index}" : name.to_s.dup
+          library.fn(:XFree, [ptype], int).call(name) unless name.null?
+          Display.new(record.name, text, Bounds.new(record.x / scale, record.y / scale, record.width / scale, record.height / scale), scale, record.primary != 0)
+        end
+      ensure
+        randr&.fn(:XRRFreeMonitors, [ptype], Fiddle::TYPE_VOID)&.call(monitors) if monitors && !monitors.null?
+        library&.fn(:XCloseDisplay, [ptype], int)&.call(display) if display && !display.null?
+      end
+    end
+  end
+end

data/lib/zaniah/platform/linux/free_type.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require "fiddle/import"
+require_relative "../../ffi/library"
+
+module Zaniah
+  module Platform
+    module Linux
+      class FreeType
+        module Types
+          extend Fiddle::Importer
+          Face = struct ["long num_faces", "long face_index", "long face_flags", "long style_flags", "long num_glyphs", "void *family_name", "void *style_name", "int num_fixed_sizes", "void *available_sizes", "int num_charmaps", "void *charmaps", "void *generic_data", "void *generic_finalizer", "long bbox[4]", "unsigned short units_per_em", "short ascender", "short descender", "short height", "short max_advance_width", "short max_advance_height", "short underline_position", "short underline_thickness", "void *glyph", "void *size", "void *charmap"]
+          Bitmap = struct ["unsigned int rows", "unsigned int width", "int pitch", "void *buffer", "unsigned short num_grays", "unsigned char pixel_mode", "unsigned char palette_mode", "void *palette"]
+          Slot = struct ["void *library", "void *face", "void *next", "unsigned int glyph_index", "void *generic_data", "void *generic_finalizer", "long metrics[8]", "long linear_hori_advance", "long linear_vert_advance", "long advance[2]", "unsigned int format", {bitmap: Bitmap}, "int bitmap_left", "int bitmap_top"]
+        end
+        P, I, L, U = Fiddle::TYPE_VOIDP, Fiddle::TYPE_INT, Fiddle::TYPE_LONG, Fiddle::TYPE_UINT
+        def initialize
+          require "alhena"
+          @lib = FFI::Library.new("libfreetype.so.6", "/opt/homebrew/lib/libfreetype.6.dylib", "/usr/local/lib/libfreetype.6.dylib", "freetype.dll")
+          pointer = [0].pack("J")
+          check(@lib.fn(:FT_Init_FreeType, [P], I).call(pointer))
+          @library, @faces = pointer.unpack1("J"), {}
+        end
+        def cache_key
+          raise IOError, "FreeType provider closed" unless @library
+          @cache_key ||= begin
+            major, minor, patch = [0].pack("i"), [0].pack("i"), [0].pack("i")
+            @lib.fn(:FT_Library_Version, [P, P, P, P], Fiddle::TYPE_VOID).call(@library, major, minor, patch)
+            "freetype/#{RUBY_PLATFORM}/#{[major, minor, patch].map { |value| value.unpack1('i') }.join('.')}".freeze
+          end
+        end
+        def rasterize(font, glyph, size:, subpixel_x: 0, hinting: false, **_options)
+          raise IOError, "FreeType provider closed" unless @library
+          raise ArgumentError, "invalid font size" unless size.is_a?(Numeric) && size.finite? && size.positive?
+          raise ArgumentError, "invalid glyph ID" unless glyph.is_a?(Integer) && glyph.between?(0, font.glyph_count - 1)
+          raise ArgumentError, "invalid subpixel position" unless subpixel_x.is_a?(Numeric) && subpixel_x.finite?
+          face = @faces[font] ||= begin
+            pointer = [0].pack("J")
+            check(@lib.fn(:FT_New_Memory_Face, [P, P, L, L, P], I).call(@library, font.data, font.data.bytesize, font.index, pointer))
+            handle = pointer.unpack1("J")
+            unless font.axis_values.empty?
+              coordinates = font.axes.map { |tag, axis| (font.axis_values.fetch(tag, axis[:default]).clamp(axis[:min], axis[:max]) * 65_536).round }.pack("l!*")
+              check(@lib.fn(:FT_Set_Var_Design_Coordinates, [P, U, P], I).call(handle, font.axes.length, coordinates))
+            end
+            handle
+          end
+          check(@lib.fn(:FT_Set_Char_Size, [P, L, L, U, U], I).call(face, 0, (size * 64).round, 72, 72))
+          delta = [(subpixel_x * 64).round, 0].pack("l!2")
+          @lib.fn(:FT_Set_Transform, [P, P, P], Fiddle::TYPE_VOID).call(face, 0, delta)
+          check(@lib.fn(:FT_Load_Glyph, [P, U, I], I).call(face, glyph, 4 | 8 | (hinting ? 0 : 2)))
+          slot = Types::Slot.new(Types::Face.new(Fiddle::Pointer.new(face)).glyph)
+          bitmap = slot.bitmap
+          raise Error, "FreeType bitmap exceeds size limit" if bitmap.width * bitmap.rows > 16_777_216
+          bytes = String.new(capacity: bitmap.width * bitmap.rows, encoding: Encoding::BINARY)
+          bitmap.rows.times do |row|
+            pointer = Fiddle::Pointer.new(bitmap.buffer.to_i + row * bitmap.pitch)
+            case bitmap.pixel_mode
+            when 2 then bytes << pointer[0, bitmap.width]
+            when 1
+              packed = pointer[0, (bitmap.width + 7) / 8]
+              bitmap.width.times { |column| bytes << ((packed.getbyte(column / 8) & (0x80 >> (column % 8))).zero? ? 0 : 255) }
+            else raise Error, "unsupported FreeType coverage mode #{bitmap.pixel_mode}"
+            end
+          end
+          Alhena::Bitmap.new(width: bitmap.width, height: bitmap.rows, left: slot.bitmap_left, top: slot.bitmap_top, coverage: bytes)
+        end
+        def check(code)
+          raise Error, "FreeType error #{code}" unless code.zero?
+        end
+        def close
+          return unless @library
+          @faces.each_value { |face| @lib.fn(:FT_Done_Face, [P], I).call(face) }
+          @faces.clear
+          @lib.fn(:FT_Done_FreeType, [P], I).call(@library)
+          @library = nil
+        end
+      end
+    end
+  end
+end