harfbuzz-ruby 1.0.0

data/lib/harfbuzz/font.rb

@@ -0,0 +1,404 @@
+# frozen_string_literal: true
+
+module HarfBuzz
+  # Wraps hb_font_t — a sized, positioned font instance
+  class Font
+    attr_reader :ptr
+
+    # Creates a Font from a Face
+    # @param face [Face] Font face
+    def initialize(face)
+      @face = face
+      @ptr = C.hb_font_create(face.ptr)
+      raise AllocationError, "Failed to create font" if @ptr.null?
+
+      register_finalizer
+    end
+
+    # Attaches a FontFuncs callback table to this font
+    # @param funcs [FontFuncs] Font funcs object (should be immutable)
+    # @param font_data [FFI::Pointer] User data pointer passed to callbacks (optional)
+    # @return [self]
+    def set_funcs(funcs, font_data: FFI::Pointer::NULL)
+      C.hb_font_set_funcs(@ptr, funcs.ptr, font_data, nil)
+      @funcs = funcs  # keep alive
+      self
+    end
+
+    # Sets the font funcs (setter alias for set_funcs without font_data)
+    # @param funcs [FontFuncs] FontFuncs object
+    def funcs=(funcs)
+      set_funcs(funcs)
+    end
+
+    # Creates a sub-font of this font
+    # @return [Font]
+    def create_sub_font
+      ptr = C.hb_font_create_sub_font(@ptr)
+      self.class.wrap_owned(ptr)
+    end
+
+    # Returns the singleton empty font
+    # @return [Font]
+    def self.empty
+      wrap_borrowed(C.hb_font_get_empty)
+    end
+
+    # Returns the face this font was created from (borrowed reference)
+    # @return [Face]
+    def face
+      ptr = C.hb_font_get_face(@ptr)
+      Face.wrap_borrowed(ptr)
+    end
+
+    # Returns scale as [x_scale, y_scale]
+    # @return [Array<Integer>]
+    def scale
+      x_ptr = FFI::MemoryPointer.new(:int)
+      y_ptr = FFI::MemoryPointer.new(:int)
+      C.hb_font_get_scale(@ptr, x_ptr, y_ptr)
+      [x_ptr.read_int, y_ptr.read_int]
+    end
+
+    # Sets font scale
+    # @param xy [Array<Integer>, Integer] [x, y] or single value for both
+    def scale=(xy)
+      x, y = Array(xy).length == 2 ? xy : [xy, xy]
+      C.hb_font_set_scale(@ptr, x, y)
+    end
+
+    # Returns pixels per em as [x_ppem, y_ppem]
+    # @return [Array<Integer>]
+    def ppem
+      x_ptr = FFI::MemoryPointer.new(:uint)
+      y_ptr = FFI::MemoryPointer.new(:uint)
+      C.hb_font_get_ppem(@ptr, x_ptr, y_ptr)
+      [x_ptr.read_uint, y_ptr.read_uint]
+    end
+
+    # Sets pixels per em
+    # @param xy [Array<Integer>] [x_ppem, y_ppem]
+    def ppem=(xy)
+      x, y = xy
+      C.hb_font_set_ppem(@ptr, x, y)
+    end
+
+    # @return [Float] Points per em
+    def ptem
+      C.hb_font_get_ptem(@ptr)
+    end
+
+    # @param pt [Float] Points per em
+    def ptem=(pt)
+      C.hb_font_set_ptem(@ptr, pt)
+    end
+
+    # Returns synthetic bold as [x_embolden, y_embolden, in_place]
+    # @return [Array]
+    def synthetic_bold
+      x_ptr = FFI::MemoryPointer.new(:float)
+      y_ptr = FFI::MemoryPointer.new(:float)
+      ip_ptr = FFI::MemoryPointer.new(:int)
+      C.hb_font_get_synthetic_bold(@ptr, x_ptr, y_ptr, ip_ptr)
+      [x_ptr.read_float, y_ptr.read_float, C.from_hb_bool(ip_ptr.read_int)]
+    end
+
+    # Sets synthetic bold
+    # @param xyz [Array] [x_embolden, y_embolden, in_place]
+    def synthetic_bold=(xyz)
+      x, y, ip = xyz
+      C.hb_font_set_synthetic_bold(@ptr, x, y, C.to_hb_bool(ip))
+    end
+
+    # @return [Float] Synthetic slant
+    def synthetic_slant
+      C.hb_font_get_synthetic_slant(@ptr)
+    end
+
+    # @param slant [Float] Synthetic slant
+    def synthetic_slant=(slant)
+      C.hb_font_set_synthetic_slant(@ptr, slant)
+    end
+
+    # Sets variation axis values from an array of Variation objects
+    # @param variations [Array<Variation>]
+    def variations=(variations)
+      structs = variations.map(&:to_struct)
+      ptr = FFI::MemoryPointer.new(C::HbVariationT, structs.size)
+      structs.each_with_index do |s, i|
+        ptr.put_bytes(i * C::HbVariationT.size,
+                      s.to_ptr.read_bytes(C::HbVariationT.size))
+      end
+      C.hb_font_set_variations(@ptr, ptr, structs.size)
+    end
+
+    # Sets a single variation axis value
+    # @param tag [Integer] Axis tag
+    # @param value [Float] Axis value
+    def set_variation(tag, value)
+      C.hb_font_set_variation(@ptr, tag, value)
+    end
+
+    # Sets design-space variation coordinates
+    # @param coords [Array<Float>]
+    def var_coords_design=(coords)
+      ptr = FFI::MemoryPointer.new(:float, coords.size)
+      ptr.put_array_of_float(0, coords)
+      C.hb_font_set_var_coords_design(@ptr, ptr, coords.size)
+    end
+
+    # Returns design-space variation coordinates
+    # @return [Array<Float>]
+    def var_coords_design
+      count_ptr = FFI::MemoryPointer.new(:uint)
+      coords_ptr = C.hb_font_get_var_coords_design(@ptr, count_ptr)
+      count = count_ptr.read_uint
+      return [] if coords_ptr.null? || count.zero?
+
+      coords_ptr.read_array_of_float(count)
+    end
+
+    # Sets normalized variation coordinates
+    # @param coords [Array<Integer>]
+    def var_coords_normalized=(coords)
+      ptr = FFI::MemoryPointer.new(:int32, coords.size)
+      ptr.put_array_of_int32(0, coords)
+      C.hb_font_set_var_coords_normalized(@ptr, ptr, coords.size)
+    end
+
+    # Returns normalized variation coordinates
+    # @return [Array<Integer>]
+    def var_coords_normalized
+      count_ptr = FFI::MemoryPointer.new(:uint)
+      coords_ptr = C.hb_font_get_var_coords_normalized(@ptr, count_ptr)
+      count = count_ptr.read_uint
+      return [] if coords_ptr.null? || count.zero?
+
+      coords_ptr.read_array_of_int32(count)
+    end
+
+    # @return [Boolean] true if font is immutable
+    def immutable?
+      C.from_hb_bool(C.hb_font_is_immutable(@ptr))
+    end
+
+    # Makes the font immutable (thread-safe to share after this)
+    # @return [self]
+    def make_immutable!
+      C.hb_font_make_immutable(@ptr)
+      self
+    end
+
+    # Returns glyph ID for a codepoint (with optional variation selector)
+    # @param cp [Integer] Unicode codepoint
+    # @param variation_selector [Integer] Variation selector codepoint (0 = none)
+    # @return [Integer, nil] Glyph ID or nil if not found
+    def glyph(cp, variation_selector = 0)
+      glyph_ptr = FFI::MemoryPointer.new(:uint32)
+      ok = C.hb_font_get_glyph(@ptr, cp, variation_selector, glyph_ptr)
+      ok.zero? ? nil : glyph_ptr.read_uint32
+    end
+
+    # Returns glyph ID for a nominal (non-variation) codepoint
+    # @param cp [Integer] Unicode codepoint
+    # @return [Integer, nil] Glyph ID or nil if not found
+    def nominal_glyph(cp)
+      glyph_ptr = FFI::MemoryPointer.new(:uint32)
+      ok = C.hb_font_get_nominal_glyph(@ptr, cp, glyph_ptr)
+      ok.zero? ? nil : glyph_ptr.read_uint32
+    end
+
+    # Returns nominal glyph IDs for multiple codepoints in a single call
+    # @param codepoints [Array<Integer>] Unicode codepoints
+    # @return [Array<Integer>] Glyph IDs (0 for unmapped codepoints)
+    def nominal_glyphs(codepoints)
+      count = codepoints.size
+      return [] if count.zero?
+
+      cp_ptr = FFI::MemoryPointer.new(:uint32, count)
+      cp_ptr.put_array_of_uint32(0, codepoints)
+      glyph_ptr = FFI::MemoryPointer.new(:uint32, count)
+      C.hb_font_get_nominal_glyphs(@ptr, count, cp_ptr, 4, glyph_ptr, 4)
+      glyph_ptr.read_array_of_uint32(count)
+    end
+
+    # Returns glyph ID for a variation sequence
+    # @param cp [Integer] Unicode codepoint
+    # @param selector [Integer] Variation selector
+    # @return [Integer, nil] Glyph ID or nil if not found
+    def variation_glyph(cp, selector)
+      glyph_ptr = FFI::MemoryPointer.new(:uint32)
+      ok = C.hb_font_get_variation_glyph(@ptr, cp, selector, glyph_ptr)
+      ok.zero? ? nil : glyph_ptr.read_uint32
+    end
+
+    # @param glyph [Integer] Glyph ID
+    # @return [Integer] Horizontal advance in font units
+    def glyph_h_advance(glyph)
+      C.hb_font_get_glyph_h_advance(@ptr, glyph)
+    end
+
+    # @param glyph [Integer] Glyph ID
+    # @return [Integer] Vertical advance in font units
+    def glyph_v_advance(glyph)
+      C.hb_font_get_glyph_v_advance(@ptr, glyph)
+    end
+
+    # Returns horizontal advances for multiple glyphs
+    # @param glyphs [Array<Integer>] Glyph IDs
+    # @return [Array<Integer>] Advances
+    def glyph_h_advances(glyphs)
+      count = glyphs.size
+      glyph_ptr = FFI::MemoryPointer.new(:uint32, count)
+      glyph_ptr.put_array_of_uint32(0, glyphs)
+      advance_ptr = FFI::MemoryPointer.new(:int32, count)
+      C.hb_font_get_glyph_h_advances(@ptr, count, glyph_ptr, 4, advance_ptr, 4)
+      advance_ptr.read_array_of_int32(count)
+    end
+
+    # Returns vertical advances for multiple glyphs
+    # @param glyphs [Array<Integer>] Glyph IDs
+    # @return [Array<Integer>] Advances
+    def glyph_v_advances(glyphs)
+      count = glyphs.size
+      glyph_ptr = FFI::MemoryPointer.new(:uint32, count)
+      glyph_ptr.put_array_of_uint32(0, glyphs)
+      advance_ptr = FFI::MemoryPointer.new(:int32, count)
+      C.hb_font_get_glyph_v_advances(@ptr, count, glyph_ptr, 4, advance_ptr, 4)
+      advance_ptr.read_array_of_int32(count)
+    end
+
+    # Returns horizontal origin for a glyph
+    # @param glyph [Integer] Glyph ID
+    # @return [Array<Integer>, nil] [x, y] or nil
+    def glyph_h_origin(glyph)
+      x_ptr = FFI::MemoryPointer.new(:int32)
+      y_ptr = FFI::MemoryPointer.new(:int32)
+      ok = C.hb_font_get_glyph_h_origin(@ptr, glyph, x_ptr, y_ptr)
+      ok.zero? ? nil : [x_ptr.read_int32, y_ptr.read_int32]
+    end
+
+    # Returns vertical origin for a glyph
+    # @param glyph [Integer] Glyph ID
+    # @return [Array<Integer>, nil] [x, y] or nil
+    def glyph_v_origin(glyph)
+      x_ptr = FFI::MemoryPointer.new(:int32)
+      y_ptr = FFI::MemoryPointer.new(:int32)
+      ok = C.hb_font_get_glyph_v_origin(@ptr, glyph, x_ptr, y_ptr)
+      ok.zero? ? nil : [x_ptr.read_int32, y_ptr.read_int32]
+    end
+
+    # Returns horizontal kerning between two glyphs
+    # @param left [Integer] Left glyph ID
+    # @param right [Integer] Right glyph ID
+    # @return [Integer] Kerning value
+    def glyph_h_kerning(left, right)
+      C.hb_font_get_glyph_h_kerning(@ptr, left, right)
+    end
+
+    # Returns glyph extents
+    # @param glyph [Integer] Glyph ID
+    # @return [C::HbGlyphExtentsT, nil] Extents or nil
+    def glyph_extents(glyph)
+      extents = C::HbGlyphExtentsT.new
+      ok = C.hb_font_get_glyph_extents(@ptr, glyph, extents)
+      ok.zero? ? nil : extents
+    end
+
+    # Returns a contour point for a glyph
+    # @param glyph [Integer] Glyph ID
+    # @param idx [Integer] Contour point index
+    # @return [Array<Integer>, nil] [x, y] or nil
+    def glyph_contour_point(glyph, idx)
+      x_ptr = FFI::MemoryPointer.new(:int32)
+      y_ptr = FFI::MemoryPointer.new(:int32)
+      ok = C.hb_font_get_glyph_contour_point(@ptr, glyph, idx, x_ptr, y_ptr)
+      ok.zero? ? nil : [x_ptr.read_int32, y_ptr.read_int32]
+    end
+
+    # Returns the glyph name
+    # @param glyph [Integer] Glyph ID
+    # @return [String, nil] Glyph name or nil
+    def glyph_name(glyph)
+      buf = FFI::MemoryPointer.new(:char, 64)
+      ok = C.hb_font_get_glyph_name(@ptr, glyph, buf, 64)
+      ok.zero? ? nil : buf.read_string
+    end
+
+    # Returns the glyph ID for a name
+    # @param name [String] Glyph name
+    # @return [Integer, nil] Glyph ID or nil
+    def glyph_from_name(name)
+      glyph_ptr = FFI::MemoryPointer.new(:uint32)
+      ok = C.hb_font_get_glyph_from_name(@ptr, name, name.bytesize, glyph_ptr)
+      ok.zero? ? nil : glyph_ptr.read_uint32
+    end
+
+    # Returns glyph advance for a direction as [x, y]
+    # @param glyph [Integer] Glyph ID
+    # @param dir [Symbol] Direction (:ltr, :rtl, :ttb, :btt)
+    # @return [Array<Integer>] [x_advance, y_advance]
+    def glyph_advance_for_direction(glyph, dir)
+      x_ptr = FFI::MemoryPointer.new(:int32)
+      y_ptr = FFI::MemoryPointer.new(:int32)
+      C.hb_font_get_glyph_advance_for_direction(@ptr, glyph, dir, x_ptr, y_ptr)
+      [x_ptr.read_int32, y_ptr.read_int32]
+    end
+
+    # Returns font extents for a direction
+    # @param dir [Symbol] Direction (:ltr, :rtl, :ttb, :btt)
+    # @return [C::HbFontExtentsT]
+    def extents_for_direction(dir)
+      extents = C::HbFontExtentsT.new
+      C.hb_font_get_extents_for_direction(@ptr, dir, extents)
+      extents
+    end
+
+    # Draws the outline of a glyph using DrawFuncs callbacks
+    # @param glyph [Integer] Glyph ID
+    # @param draw_funcs [DrawFuncs] Draw callbacks object
+    def draw_glyph(glyph, draw_funcs)
+      C.hb_font_draw_glyph(@ptr, glyph, draw_funcs.ptr, nil)
+    end
+
+    # Paints a glyph using PaintFuncs callbacks
+    # @param glyph [Integer] Glyph ID
+    # @param paint_funcs [PaintFuncs] Paint callbacks object
+    # @param palette_index [Integer] Color palette index (default 0)
+    # @param foreground [Integer] Foreground color as RGBA uint32 (default 0xFF000000)
+    def paint_glyph(glyph, paint_funcs, palette_index: 0, foreground: 0xFF000000)
+      C.hb_font_paint_glyph(@ptr, glyph, paint_funcs.ptr, nil, palette_index, foreground)
+    end
+
+    def inspect
+      "#<HarfBuzz::Font scale=#{scale} ppem=#{ppem} immutable=#{immutable?}>"
+    end
+
+    def self.wrap_owned(ptr)
+      obj = allocate
+      obj.instance_variable_set(:@ptr, ptr)
+      obj.send(:register_finalizer)
+      obj
+    end
+
+    def self.wrap_borrowed(ptr)
+      obj = allocate
+      obj.instance_variable_set(:@ptr, ptr)
+      obj.instance_variable_set(:@borrowed, true)
+      obj
+    end
+
+    private
+
+    def register_finalizer
+      return if instance_variable_defined?(:@borrowed) && @borrowed
+
+      HarfBuzz::Font.define_finalizer(self, @ptr)
+    end
+
+    def self.define_finalizer(obj, ptr)
+      destroy = C.method(:hb_font_destroy)
+      ObjectSpace.define_finalizer(obj, proc { destroy.call(ptr) })
+    end
+  end
+end

data/lib/harfbuzz/font_funcs.rb

@@ -0,0 +1,286 @@
+# frozen_string_literal: true
+
+module HarfBuzz
+  # Wraps hb_font_funcs_t — customizable font callback table
+  #
+  # FontFuncs allows you to override how HarfBuzz queries glyph data from a font.
+  # This is used to implement custom font backends (e.g., connecting to FreeType,
+  # CoreText, or a custom renderer).
+  #
+  # @example Custom nominal glyph lookup
+  #   funcs = HarfBuzz::FontFuncs.new
+  #   funcs.on_nominal_glyph do |_font, codepoint|
+  #     my_cmap[codepoint]
+  #   end
+  #   funcs.make_immutable!
+  #   font.set_funcs(funcs)
+  class FontFuncs
+    attr_reader :ptr
+
+    def initialize
+      @ptr = C.hb_font_funcs_create
+      raise AllocationError, "Failed to create font funcs" if @ptr.null?
+
+      # Keep FFI::Function objects alive as long as this object is alive
+      @callbacks = {}
+      HarfBuzz::FontFuncs.define_finalizer(self, @ptr)
+    end
+
+    # Returns the singleton empty font funcs
+    # @return [FontFuncs]
+    def self.empty
+      obj = allocate
+      obj.instance_variable_set(:@ptr, C.hb_font_funcs_get_empty)
+      obj.instance_variable_set(:@borrowed, true)
+      obj.instance_variable_set(:@callbacks, {})
+      obj
+    end
+
+    # @return [Boolean] true if immutable
+    def immutable?
+      C.from_hb_bool(C.hb_font_funcs_is_immutable(@ptr))
+    end
+
+    # Makes the funcs table immutable (required before attaching to a font)
+    # @return [self]
+    def make_immutable!
+      C.hb_font_funcs_make_immutable(@ptr)
+      self
+    end
+
+    # Sets the horizontal font extents callback
+    # @yield [font] Called with the HarfBuzz font pointer
+    # @yieldreturn [Hash, nil] Hash with :ascender, :descender, :line_gap keys (in font units), or nil
+    def on_font_h_extents(&block)
+      cb = FFI::Function.new(:int, [:pointer, :pointer, :pointer, :pointer]) do |font_ptr, _font_data, extents_ptr, _user_data|
+        result = block.call(font_ptr)
+        next 0 unless result
+
+        extents = C::HbFontExtentsT.new(extents_ptr)
+        extents[:ascender] = result[:ascender] || 0
+        extents[:descender] = result[:descender] || 0
+        extents[:line_gap] = result[:line_gap] || 0
+        1
+      end
+      @callbacks[:font_h_extents] = cb
+      C.hb_font_funcs_set_font_h_extents_func(@ptr, cb, nil, nil)
+      self
+    end
+
+    # Sets the vertical font extents callback
+    # @yield [font] Called with the HarfBuzz font pointer
+    # @yieldreturn [Hash, nil] Hash with :ascender, :descender, :line_gap keys, or nil
+    def on_font_v_extents(&block)
+      cb = FFI::Function.new(:int, [:pointer, :pointer, :pointer, :pointer]) do |font_ptr, _font_data, extents_ptr, _user_data|
+        result = block.call(font_ptr)
+        next 0 unless result
+
+        extents = C::HbFontExtentsT.new(extents_ptr)
+        extents[:ascender] = result[:ascender] || 0
+        extents[:descender] = result[:descender] || 0
+        extents[:line_gap] = result[:line_gap] || 0
+        1
+      end
+      @callbacks[:font_v_extents] = cb
+      C.hb_font_funcs_set_font_v_extents_func(@ptr, cb, nil, nil)
+      self
+    end
+
+    # Sets the nominal glyph lookup callback
+    # @yield [font, codepoint] Called with font pointer and Unicode codepoint
+    # @yieldreturn [Integer, nil] Glyph ID or nil if not found
+    def on_nominal_glyph(&block)
+      cb = FFI::Function.new(:int, [:pointer, :pointer, :uint32, :pointer, :pointer]) do |font_ptr, _font_data, codepoint, glyph_out, _user_data|
+        glyph_id = block.call(font_ptr, codepoint)
+        next 0 unless glyph_id
+
+        glyph_out.write_uint32(glyph_id)
+        1
+      end
+      @callbacks[:nominal_glyph] = cb
+      C.hb_font_funcs_set_nominal_glyph_func(@ptr, cb, nil, nil)
+      self
+    end
+
+    # Sets the variation glyph lookup callback
+    # @yield [font, codepoint, variation_selector] Called with font pointer, codepoint, and selector
+    # @yieldreturn [Integer, nil] Glyph ID or nil if not found
+    def on_variation_glyph(&block)
+      cb = FFI::Function.new(:int, [:pointer, :pointer, :uint32, :uint32, :pointer, :pointer]) do |font_ptr, _font_data, codepoint, selector, glyph_out, _user_data|
+        glyph_id = block.call(font_ptr, codepoint, selector)
+        next 0 unless glyph_id
+
+        glyph_out.write_uint32(glyph_id)
+        1
+      end
+      @callbacks[:variation_glyph] = cb
+      C.hb_font_funcs_set_variation_glyph_func(@ptr, cb, nil, nil)
+      self
+    end
+
+    # Sets the horizontal glyph advance callback
+    # @yield [font, glyph] Called with font pointer and glyph ID
+    # @yieldreturn [Integer] Horizontal advance in font units
+    def on_glyph_h_advance(&block)
+      cb = FFI::Function.new(:int32, [:pointer, :pointer, :uint32, :pointer]) do |font_ptr, _font_data, glyph, _user_data|
+        block.call(font_ptr, glyph).to_i
+      end
+      @callbacks[:glyph_h_advance] = cb
+      C.hb_font_funcs_set_glyph_h_advance_func(@ptr, cb, nil, nil)
+      self
+    end
+
+    # Sets the vertical glyph advance callback
+    # @yield [font, glyph] Called with font pointer and glyph ID
+    # @yieldreturn [Integer] Vertical advance in font units
+    def on_glyph_v_advance(&block)
+      cb = FFI::Function.new(:int32, [:pointer, :pointer, :uint32, :pointer]) do |font_ptr, _font_data, glyph, _user_data|
+        block.call(font_ptr, glyph).to_i
+      end
+      @callbacks[:glyph_v_advance] = cb
+      C.hb_font_funcs_set_glyph_v_advance_func(@ptr, cb, nil, nil)
+      self
+    end
+
+    # Sets the horizontal glyph origin callback
+    # @yield [font, glyph] Called with font pointer and glyph ID
+    # @yieldreturn [Array<Integer>, nil] [x, y] origin or nil
+    def on_glyph_h_origin(&block)
+      cb = FFI::Function.new(:int, [:pointer, :pointer, :uint32, :pointer, :pointer, :pointer]) do |font_ptr, _font_data, glyph, x_out, y_out, _user_data|
+        result = block.call(font_ptr, glyph)
+        next 0 unless result
+
+        x_out.write_int32(result[0])
+        y_out.write_int32(result[1])
+        1
+      end
+      @callbacks[:glyph_h_origin] = cb
+      C.hb_font_funcs_set_glyph_h_origin_func(@ptr, cb, nil, nil)
+      self
+    end
+
+    # Sets the vertical glyph origin callback
+    # @yield [font, glyph] Called with font pointer and glyph ID
+    # @yieldreturn [Array<Integer>, nil] [x, y] origin or nil
+    def on_glyph_v_origin(&block)
+      cb = FFI::Function.new(:int, [:pointer, :pointer, :uint32, :pointer, :pointer, :pointer]) do |font_ptr, _font_data, glyph, x_out, y_out, _user_data|
+        result = block.call(font_ptr, glyph)
+        next 0 unless result
+
+        x_out.write_int32(result[0])
+        y_out.write_int32(result[1])
+        1
+      end
+      @callbacks[:glyph_v_origin] = cb
+      C.hb_font_funcs_set_glyph_v_origin_func(@ptr, cb, nil, nil)
+      self
+    end
+
+    # Sets the horizontal glyph kerning callback
+    # @yield [font, left_glyph, right_glyph] Called with font pointer and two glyph IDs
+    # @yieldreturn [Integer] Kerning value in font units
+    def on_glyph_h_kerning(&block)
+      cb = FFI::Function.new(:int32, [:pointer, :pointer, :uint32, :uint32, :pointer]) do |font_ptr, _font_data, left, right, _user_data|
+        block.call(font_ptr, left, right).to_i
+      end
+      @callbacks[:glyph_h_kerning] = cb
+      C.hb_font_funcs_set_glyph_h_kerning_func(@ptr, cb, nil, nil)
+      self
+    end
+
+    # Sets the glyph extents callback
+    # @yield [font, glyph] Called with font pointer and glyph ID
+    # @yieldreturn [Hash, nil] Hash with :x_bearing, :y_bearing, :width, :height keys, or nil
+    def on_glyph_extents(&block)
+      cb = FFI::Function.new(:int, [:pointer, :pointer, :uint32, :pointer, :pointer]) do |font_ptr, _font_data, glyph, extents_ptr, _user_data|
+        result = block.call(font_ptr, glyph)
+        next 0 unless result
+
+        extents = C::HbGlyphExtentsT.new(extents_ptr)
+        extents[:x_bearing] = result[:x_bearing] || 0
+        extents[:y_bearing] = result[:y_bearing] || 0
+        extents[:width] = result[:width] || 0
+        extents[:height] = result[:height] || 0
+        1
+      end
+      @callbacks[:glyph_extents] = cb
+      C.hb_font_funcs_set_glyph_extents_func(@ptr, cb, nil, nil)
+      self
+    end
+
+    # Sets the glyph name callback
+    # @yield [font, glyph] Called with font pointer and glyph ID
+    # @yieldreturn [String, nil] Glyph name or nil
+    def on_glyph_name(&block)
+      cb = FFI::Function.new(:int, [:pointer, :pointer, :uint32, :pointer, :uint, :pointer]) do |font_ptr, _font_data, glyph, name_buf, name_buf_size, _user_data|
+        name = block.call(font_ptr, glyph)
+        next 0 unless name
+
+        bytes = name.bytesize
+        size = [bytes, name_buf_size - 1].min
+        name_buf.put_bytes(0, name, 0, size)
+        name_buf.put_uint8(size, 0)  # null terminate
+        1
+      end
+      @callbacks[:glyph_name] = cb
+      C.hb_font_funcs_set_glyph_name_func(@ptr, cb, nil, nil)
+      self
+    end
+
+    # Sets the glyph-from-name lookup callback
+    # @yield [font, name] Called with font pointer and glyph name string
+    # @yieldreturn [Integer, nil] Glyph ID or nil if not found
+    def on_glyph_from_name(&block)
+      cb = FFI::Function.new(:int, [:pointer, :pointer, :pointer, :int, :pointer, :pointer]) do |font_ptr, _font_data, name_ptr, name_len, glyph_out, _user_data|
+        name = name_len < 0 ? name_ptr.read_string : name_ptr.read_bytes(name_len)
+        glyph_id = block.call(font_ptr, name)
+        next 0 unless glyph_id
+
+        glyph_out.write_uint32(glyph_id)
+        1
+      end
+      @callbacks[:glyph_from_name] = cb
+      C.hb_font_funcs_set_glyph_from_name_func(@ptr, cb, nil, nil)
+      self
+    end
+
+    # Sets the glyph contour point callback
+    # @yield [font, glyph, point_index] Called with font pointer, glyph ID, and point index
+    # @yieldreturn [Array<Integer>, nil] [x, y] contour point coordinates, or nil if not found
+    def on_glyph_contour_point(&block)
+      cb = FFI::Function.new(:int, [:pointer, :pointer, :uint32, :uint, :pointer, :pointer, :pointer]) do |font_ptr, _font_data, glyph, point_index, x_out, y_out, _user_data|
+        result = block.call(font_ptr, glyph, point_index)
+        next 0 unless result
+
+        x_out.write_int32(result[0])
+        y_out.write_int32(result[1])
+        1
+      end
+      @callbacks[:glyph_contour_point] = cb
+      C.hb_font_funcs_set_glyph_contour_point_func(@ptr, cb, nil, nil)
+      self
+    end
+
+    # Sets the draw glyph callback (called when font draws a glyph via draw funcs)
+    # @yield [font, glyph, draw_funcs_ptr, draw_data_ptr] Called with font pointer, glyph ID, and draw state
+    def on_draw_glyph(&block)
+      cb = FFI::Function.new(:void, [:pointer, :pointer, :uint32, :pointer, :pointer, :pointer]) do |font_ptr, _font_data, glyph, draw_funcs_ptr, draw_data_ptr, _user_data|
+        block.call(font_ptr, glyph, draw_funcs_ptr, draw_data_ptr)
+      end
+      @callbacks[:draw_glyph] = cb
+      C.hb_font_funcs_set_draw_glyph_func(@ptr, cb, nil, nil)
+      self
+    end
+
+    def inspect
+      "#<HarfBuzz::FontFuncs immutable=#{immutable?}>"
+    end
+
+    def self.define_finalizer(obj, ptr)
+      return if obj.instance_variable_defined?(:@borrowed) && obj.instance_variable_get(:@borrowed)
+
+      destroy = C.method(:hb_font_funcs_destroy)
+      ObjectSpace.define_finalizer(obj, proc { destroy.call(ptr) })
+    end
+  end
+end