harfbuzz-ruby 1.0.0

data/lib/harfbuzz/ot/meta.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module HarfBuzz
+  module OT
+    # OpenType Meta table API
+    module Meta
+      module_function
+
+      # Returns the tags of all meta table entries
+      # @param face [Face] Font face
+      # @return [Array<Integer>] Entry tags
+      def entry_tags(face)
+        count_ptr = FFI::MemoryPointer.new(:uint)
+        count_ptr.write_uint(0)
+        C.hb_ot_meta_get_entry_tags(face.ptr, 0, count_ptr, nil)
+        count = count_ptr.read_uint
+        return [] if count.zero?
+
+        tags_ptr = FFI::MemoryPointer.new(:uint32, count)
+        count_ptr.write_uint(count)
+        C.hb_ot_meta_get_entry_tags(face.ptr, 0, count_ptr, tags_ptr)
+        tags_ptr.read_array_of_uint32(count_ptr.read_uint)
+      end
+
+      # Returns the blob for a meta entry
+      # @param face [Face] Font face
+      # @param tag [Symbol] Entry tag (:design_languages or :supported_languages)
+      # @return [Blob] Entry data blob
+      def entry(face, tag)
+        Blob.wrap_owned(C.hb_ot_meta_reference_entry(face.ptr, tag))
+      end
+    end
+  end
+end

data/lib/harfbuzz/ot/metrics.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module HarfBuzz
+  module OT
+    # OpenType Metrics API
+    module Metrics
+      module_function
+
+      # Returns a metric position value (returns nil if not available)
+      # @param font [Font] Sized font
+      # @param tag [Integer] Metric tag
+      # @return [Integer, nil] Position or nil
+      def position(font, tag)
+        pos_ptr = FFI::MemoryPointer.new(:int32)
+        ok = C.hb_ot_metrics_get_position(font.ptr, tag, pos_ptr)
+        ok.zero? ? nil : pos_ptr.read_int32
+      end
+
+      # Returns a metric position with fallback (always returns a value)
+      # @param font [Font] Sized font
+      # @param tag [Integer] Metric tag
+      # @return [Integer] Position
+      def position_with_fallback(font, tag)
+        pos_ptr = FFI::MemoryPointer.new(:int32)
+        C.hb_ot_metrics_get_position_with_fallback(font.ptr, tag, pos_ptr)
+        pos_ptr.read_int32
+      end
+
+      # Returns a metric float variation value
+      # @param font [Font] Sized font
+      # @param tag [Integer] Metric tag
+      # @return [Float] Variation value
+      def variation(font, tag)
+        C.hb_ot_metrics_get_variation(font.ptr, tag)
+      end
+
+      # Returns the X variation for a metric
+      # @param font [Font] Sized font
+      # @param tag [Integer] Metric tag
+      # @return [Integer] X variation
+      def x_variation(font, tag)
+        C.hb_ot_metrics_get_x_variation(font.ptr, tag)
+      end
+
+      # Returns the Y variation for a metric
+      # @param font [Font] Sized font
+      # @param tag [Integer] Metric tag
+      # @return [Integer] Y variation
+      def y_variation(font, tag)
+        C.hb_ot_metrics_get_y_variation(font.ptr, tag)
+      end
+    end
+  end
+end

data/lib/harfbuzz/ot/name.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module HarfBuzz
+  module OT
+    # OpenType Name table API
+    module Name
+      module_function
+
+      # Returns all name entries from the name table
+      # @param face [Face] Font face
+      # @return [Array<C::HbOtNameEntryT>] Name entries
+      def list(face)
+        count_ptr = FFI::MemoryPointer.new(:uint)
+        entries_ptr = C.hb_ot_name_list_names(face.ptr, count_ptr)
+        count = count_ptr.read_uint
+        return [] if count.zero? || entries_ptr.null?
+
+        count.times.map { |i| C::HbOtNameEntryT.new(entries_ptr + i * C::HbOtNameEntryT.size) }
+      end
+
+      # Returns a name as a UTF-8 string
+      # @param face [Face] Font face
+      # @param name_id [Integer] Name ID
+      # @param language [FFI::Pointer, nil] Language pointer (nil = default)
+      # @return [String, nil] Name string or nil if not found
+      def get_utf8(face, name_id, language = nil)
+        lang = language || C.hb_language_get_default
+        buf_size = FFI::MemoryPointer.new(:uint)
+        buf_size.write_uint(0)
+        C.hb_ot_name_get_utf8(face.ptr, name_id, lang, buf_size, nil)
+        size = buf_size.read_uint
+        return nil if size.zero?
+
+        buf = FFI::MemoryPointer.new(:char, size + 1)
+        buf_size.write_uint(size + 1)
+        C.hb_ot_name_get_utf8(face.ptr, name_id, lang, buf_size, buf)
+        buf.read_string(size)
+      end
+
+      # Returns a name as a UTF-16 encoded string
+      # @param face [Face] Font face
+      # @param name_id [Integer] Name ID
+      # @param language [FFI::Pointer, nil] Language pointer (nil = default)
+      # @return [String, nil] UTF-16LE encoded string or nil if not found
+      def get_utf16(face, name_id, language = nil)
+        lang = language || C.hb_language_get_default
+        buf_size = FFI::MemoryPointer.new(:uint)
+        buf_size.write_uint(0)
+        C.hb_ot_name_get_utf16(face.ptr, name_id, lang, buf_size, nil)
+        size = buf_size.read_uint
+        return nil if size.zero?
+
+        buf = FFI::MemoryPointer.new(:uint16, size + 1)
+        buf_size.write_uint(size + 1)
+        C.hb_ot_name_get_utf16(face.ptr, name_id, lang, buf_size, buf)
+        actual = buf_size.read_uint
+        buf.read_bytes(actual * 2).force_encoding("UTF-16LE")
+      end
+
+      # Returns a name as a UTF-32 encoded string
+      # @param face [Face] Font face
+      # @param name_id [Integer] Name ID
+      # @param language [FFI::Pointer, nil] Language pointer (nil = default)
+      # @return [String, nil] UTF-32LE encoded string or nil if not found
+      def get_utf32(face, name_id, language = nil)
+        lang = language || C.hb_language_get_default
+        buf_size = FFI::MemoryPointer.new(:uint)
+        buf_size.write_uint(0)
+        C.hb_ot_name_get_utf32(face.ptr, name_id, lang, buf_size, nil)
+        size = buf_size.read_uint
+        return nil if size.zero?
+
+        buf = FFI::MemoryPointer.new(:uint32, size + 1)
+        buf_size.write_uint(size + 1)
+        C.hb_ot_name_get_utf32(face.ptr, name_id, lang, buf_size, buf)
+        actual = buf_size.read_uint
+        buf.read_bytes(actual * 4).force_encoding("UTF-32LE")
+      end
+    end
+  end
+end

data/lib/harfbuzz/ot/shape.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module HarfBuzz
+  module OT
+    # OpenType Shape query API
+    module Shape
+      module_function
+
+      # Returns the set of glyphs that could be produced by the given buffer
+      # @param font [Font] Sized font
+      # @param buffer [Buffer] Text buffer
+      # @param features [Array<Feature>] Features to apply
+      # @return [HarfBuzz::Set] Set of glyph IDs
+      def glyphs_closure(font, buffer, features = [])
+        set = HarfBuzz::Set.new
+        features_ptr = HarfBuzz.send(:build_features_ptr, features)
+        C.hb_ot_shape_glyphs_closure(
+          font.ptr, buffer.ptr, features_ptr, features.size, set.ptr
+        )
+        set
+      end
+
+      # Returns the lookup indices used by a shape plan for a given table
+      # @param plan [ShapePlan] Shape plan
+      # @param table_tag [Integer] GSUB or GPOS tag
+      # @return [HarfBuzz::Set] Set of lookup indices
+      def plan_collect_lookups(plan, table_tag)
+        set = HarfBuzz::Set.new
+        C.hb_ot_shape_plan_collect_lookups(plan.ptr, table_tag, set.ptr)
+        set
+      end
+    end
+  end
+end

data/lib/harfbuzz/ot/var.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module HarfBuzz
+  module OT
+    # OpenType Variable Fonts API
+    module Var
+      module_function
+
+      # @param face [Face] Font face
+      # @return [Boolean] true if the face has variation data
+      def has_data?(face)
+        C.from_hb_bool(C.hb_ot_var_has_data(face.ptr))
+      end
+
+      # @param face [Face] Font face
+      # @return [Integer] Number of variation axes
+      def axis_count(face)
+        C.hb_ot_var_get_axis_count(face.ptr)
+      end
+
+      # Returns information about all variation axes
+      # @param face [Face] Font face
+      # @return [Array<C::HbOtVarAxisInfoT>] Axis info array
+      def axis_infos(face)
+        count = axis_count(face)
+        return [] if count.zero?
+
+        count_ptr = FFI::MemoryPointer.new(:uint)
+        count_ptr.write_uint(count)
+        infos_ptr = FFI::MemoryPointer.new(C::HbOtVarAxisInfoT, count)
+        C.hb_ot_var_get_axis_infos(face.ptr, 0, count_ptr, infos_ptr)
+        actual = count_ptr.read_uint
+        actual.times.map { |i| C::HbOtVarAxisInfoT.new(infos_ptr + i * C::HbOtVarAxisInfoT.size) }
+      end
+
+      # Finds a specific axis by tag
+      # @param face [Face] Font face
+      # @param tag [Integer] Axis tag (e.g., HarfBuzz.tag("wght"))
+      # @return [C::HbOtVarAxisInfoT, nil] Axis info or nil
+      def find_axis_info(face, tag)
+        info = C::HbOtVarAxisInfoT.new
+        ok = C.hb_ot_var_find_axis_info(face.ptr, tag, info)
+        ok.zero? ? nil : info
+      end
+
+      # @param face [Face] Font face
+      # @return [Integer] Number of named instances
+      def named_instance_count(face)
+        C.hb_ot_var_get_named_instance_count(face.ptr)
+      end
+
+      # @param face [Face] Font face
+      # @param idx [Integer] Instance index
+      # @return [Integer] Name ID for the subfamily name
+      def named_instance_subfamily_name_id(face, idx)
+        C.hb_ot_var_named_instance_get_subfamily_name_id(face.ptr, idx)
+      end
+
+      # @param face [Face] Font face
+      # @param idx [Integer] Instance index
+      # @return [Integer] Name ID for the PostScript name
+      def named_instance_postscript_name_id(face, idx)
+        C.hb_ot_var_named_instance_get_postscript_name_id(face.ptr, idx)
+      end
+
+      # Returns design coordinates for a named instance
+      # @param face [Face] Font face
+      # @param idx [Integer] Instance index
+      # @return [Array<Float>] Design coordinates
+      def named_instance_design_coords(face, idx)
+        count = axis_count(face)
+        return [] if count.zero?
+
+        count_ptr = FFI::MemoryPointer.new(:uint)
+        count_ptr.write_uint(count)
+        coords_ptr = FFI::MemoryPointer.new(:float, count)
+        C.hb_ot_var_named_instance_get_design_coords(face.ptr, idx, count_ptr, coords_ptr)
+        coords_ptr.read_array_of_float(count_ptr.read_uint)
+      end
+
+      # Normalizes variation axis values
+      # @param face [Face] Font face
+      # @param variations [Array<Variation>] Design-space variation values
+      # @return [Array<Integer>] Normalized coordinates
+      def normalize_variations(face, variations)
+        count = C.hb_ot_var_get_axis_count(face.ptr)
+        return [] if count.zero?
+
+        var_structs = variations.map(&:to_struct)
+        var_ptr = FFI::MemoryPointer.new(C::HbVariationT, variations.size)
+        var_structs.each_with_index do |s, i|
+          var_ptr.put_bytes(i * C::HbVariationT.size,
+                            s.to_ptr.read_bytes(C::HbVariationT.size))
+        end
+        coords_ptr = FFI::MemoryPointer.new(:int32, count)
+        C.hb_ot_var_normalize_variations(face.ptr, var_ptr, variations.size, coords_ptr, count)
+        coords_ptr.read_array_of_int32(count)
+      end
+
+      # Normalizes design-space coordinates to normalized space
+      # @param face [Face] Font face
+      # @param coords [Array<Float>] Design coordinates
+      # @return [Array<Integer>] Normalized coordinates
+      def normalize_coords(face, coords)
+        count = axis_count(face)
+        return [] if count.zero?
+
+        in_ptr = FFI::MemoryPointer.new(:float, coords.size)
+        in_ptr.put_array_of_float(0, coords)
+        out_ptr = FFI::MemoryPointer.new(:int32, count)
+        C.hb_ot_var_normalize_coords(face.ptr, coords.size, in_ptr, out_ptr)
+        out_ptr.read_array_of_int32(count)
+      end
+    end
+  end
+end

data/lib/harfbuzz/paint_funcs.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module HarfBuzz
+  # Wraps hb_paint_funcs_t — callbacks for color glyph rendering (COLRv1)
+  class PaintFuncs
+    attr_reader :ptr
+
+    def initialize
+      @ptr = C.hb_paint_funcs_create
+      raise AllocationError, "Failed to create paint_funcs" if @ptr.null?
+
+      HarfBuzz::PaintFuncs.define_finalizer(self, @ptr)
+    end
+
+    # @return [Boolean] true if immutable
+    def immutable?
+      C.from_hb_bool(C.hb_paint_funcs_is_immutable(@ptr))
+    end
+
+    # Makes immutable
+    # @return [self]
+    def make_immutable!
+      C.hb_paint_funcs_make_immutable(@ptr)
+      self
+    end
+
+    # Sets push_transform callback
+    # @yield [xx, yx, xy, yy, dx, dy] 2D transform matrix components
+    def on_push_transform(&block)
+      @push_transform_callback = block
+      cb = FFI::Function.new(:void,
+        [:pointer, :pointer, :float, :float, :float, :float, :float, :float, :pointer]) do
+        |_pfuncs, _paint_data, xx, yx, xy, yy, dx, dy, _user_data|
+        block.call(xx, yx, xy, yy, dx, dy)
+      end
+      @push_transform_ffi = cb
+      C.hb_paint_funcs_set_push_transform_func(@ptr, cb, nil, nil)
+    end
+
+    # Sets pop_transform callback
+    # @yield Called when a transform is popped
+    def on_pop_transform(&block)
+      @pop_transform_callback = block
+      cb = FFI::Function.new(:void, [:pointer, :pointer, :pointer]) do
+        |_pfuncs, _paint_data, _user_data|
+        block.call
+      end
+      @pop_transform_ffi = cb
+      C.hb_paint_funcs_set_pop_transform_func(@ptr, cb, nil, nil)
+    end
+
+    # Sets push_clip_glyph callback
+    # @yield [glyph] Glyph ID used as clip mask
+    def on_push_clip_glyph(&block)
+      @push_clip_glyph_callback = block
+      cb = FFI::Function.new(:void, [:pointer, :pointer, :uint32, :pointer, :pointer]) do
+        |_pfuncs, _paint_data, glyph, _font, _user_data|
+        block.call(glyph)
+      end
+      @push_clip_glyph_ffi = cb
+      C.hb_paint_funcs_set_push_clip_glyph_func(@ptr, cb, nil, nil)
+    end
+
+    # Sets push_clip_rectangle callback
+    # @yield [xmin, ymin, xmax, ymax]
+    def on_push_clip_rectangle(&block)
+      @push_clip_rectangle_callback = block
+      cb = FFI::Function.new(:void,
+        [:pointer, :pointer, :float, :float, :float, :float, :pointer]) do
+        |_pfuncs, _paint_data, xmin, ymin, xmax, ymax, _user_data|
+        block.call(xmin, ymin, xmax, ymax)
+      end
+      @push_clip_rectangle_ffi = cb
+      C.hb_paint_funcs_set_push_clip_rectangle_func(@ptr, cb, nil, nil)
+    end
+
+    # Sets pop_clip callback
+    # @yield Called when clip is popped
+    def on_pop_clip(&block)
+      @pop_clip_callback = block
+      cb = FFI::Function.new(:void, [:pointer, :pointer, :pointer]) do
+        |_pfuncs, _paint_data, _user_data|
+        block.call
+      end
+      @pop_clip_ffi = cb
+      C.hb_paint_funcs_set_pop_clip_func(@ptr, cb, nil, nil)
+    end
+
+    # Sets color callback
+    # @yield [is_foreground, color] Color fill
+    def on_color(&block)
+      @color_callback = block
+      cb = FFI::Function.new(:void, [:pointer, :pointer, :int, :uint32, :pointer]) do
+        |_pfuncs, _paint_data, is_foreground, color, _user_data|
+        block.call(C.from_hb_bool(is_foreground), color)
+      end
+      @color_ffi = cb
+      C.hb_paint_funcs_set_color_func(@ptr, cb, nil, nil)
+    end
+
+    # Sets push_group callback
+    # @yield Called when a compositing group is started
+    def on_push_group(&block)
+      @push_group_callback = block
+      cb = FFI::Function.new(:void, [:pointer, :pointer, :pointer]) do
+        |_pfuncs, _paint_data, _user_data|
+        block.call
+      end
+      @push_group_ffi = cb
+      C.hb_paint_funcs_set_push_group_func(@ptr, cb, nil, nil)
+    end
+
+    # Sets pop_group callback
+    # @yield [mode] Composite mode
+    def on_pop_group(&block)
+      @pop_group_callback = block
+      cb = FFI::Function.new(:void, [:pointer, :pointer, :int, :pointer]) do
+        |_pfuncs, _paint_data, mode, _user_data|
+        block.call(mode)
+      end
+      @pop_group_ffi = cb
+      C.hb_paint_funcs_set_pop_group_func(@ptr, cb, nil, nil)
+    end
+
+    def inspect
+      "#<HarfBuzz::PaintFuncs immutable=#{immutable?}>"
+    end
+
+    def self.define_finalizer(obj, ptr)
+      destroy = C.method(:hb_paint_funcs_destroy)
+      ObjectSpace.define_finalizer(obj, proc { destroy.call(ptr) })
+    end
+  end
+end