idml 0.1.0

data/lib/idml/render/color.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+# DEPRECATED: This module is superseded by ColorHelper + Canvas
+# fill_color/stroke_color methods. Kept for backward compatibility.
+
+module Idml
+  module Render
+    # Converts IDML color values to PDF content-stream operators.
+    module Color
+      module_function
+
+      # RGB fill: `r g b rg`. Values 0.0–1.0.
+      def fill_rgb(r, g, b)
+        format("%<r>.4f %<g>.4f %<b>.4f rg", r: r, g: g, b: b)
+      end
+
+      # RGB stroke: `r g b RG`.
+      def stroke_rgb(r, g, b)
+        format("%<r>.4f %<g>.4f %<b>.4f RG", r: r, g: g, b: b)
+      end
+
+      # CMYK fill: `c m y k k`.
+      def fill_cmyk(c, m, y, k)
+        format("%<c>.4f %<m>.4f %<y>.4f %<k>.4f k", c: c, m: m, y: y, k: k)
+      end
+
+      # CMYK stroke: `c m y k K`.
+      def stroke_cmyk(c, m, y, k)
+        format("%<c>.4f %<m>.4f %<y>.4f %<k>.4f K", c: c, m: m, y: y, k: k)
+      end
+
+      # Parse IDML color space value (space-separated 0–255 or 0–100
+      # depending on model) to normalized 0.0–1.0.
+      def normalize_channel(value, max = 255)
+        value.to_f / max
+      end
+
+      # Black fill (common default).
+      def black_fill
+        "0 g"
+      end
+
+      # White fill.
+      def white_fill
+        "1 g"
+      end
+
+      # Dispatch: accepts a color hash ({ model:, r:, g:, b: } or
+      # { model:, c:, m:, y:, k: }) and returns the appropriate
+      # fill operator string.
+      def fill_op(color)
+        case color[:model]
+        when :rgb then fill_rgb(color[:r], color[:g], color[:b])
+        when :cmyk then fill_cmyk(color[:c], color[:m], color[:y], color[:k])
+        end
+      end
+
+      # Dispatch: accepts a color hash and returns the appropriate
+      # stroke operator string.
+      def stroke_op(color)
+        case color[:model]
+        when :rgb then stroke_rgb(color[:r], color[:g], color[:b])
+        when :cmyk then stroke_cmyk(color[:c], color[:m], color[:y],
+                                    color[:k])
+        end
+      end
+    end
+  end
+end

data/lib/idml/render/color_helper.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Idml
+  module Render
+    # Converts IDML color hashes to pdfrb Canvas color arrays.
+    # Centralizes the mapping so all renderers use a consistent format.
+    module ColorHelper
+      module_function
+
+      # Accepts a ColorResolver hash ({ model: :rgb, r:, g:, b: } or
+      # { model: :cmyk, c:, m:, y:, k: }) and returns the pdfrb Canvas
+      # array format ([:rgb, r, g, b] or [:cmyk, c, m, y, k]).
+      def to_canvas(color)
+        return nil unless color
+
+        case color[:model]
+        when :rgb then [:rgb, color[:r], color[:g], color[:b]]
+        when :cmyk then [:cmyk, color[:c], color[:m], color[:y], color[:k]]
+        end
+      end
+    end
+  end
+end

data/lib/idml/render/color_resolver.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Idml
+  module Render
+    # Resolves IDML color references to concrete RGB or CMYK values.
+    # Looks up color names in the package's Resources/Graphic.xml part.
+    class ColorResolver
+      SPECIAL_NONE = "Color/None"
+      SPECIAL_REGISTRATION = "Color/[Registration]"
+
+      def initialize(graphic_part)
+        @graphic = graphic_part
+        @cache = {}
+      end
+
+      # Resolve a color name like "Color/Red" to a hash:
+      #   { model: :rgb, r:, g:, b: }     (0.0–1.0)
+      #   { model: :cmyk, c:, m:, y:, k: } (0.0–1.0)
+      # Returns nil for [None] or unknown colors.
+      def resolve(name)
+        return nil if name.nil? || name == SPECIAL_NONE
+        return registration_black if name == SPECIAL_REGISTRATION
+
+        @cache[name] ||= lookup(name)
+      end
+
+      private
+
+      def lookup(name)
+        entry = find_color(name) || find_swatch(name)
+        return nil unless entry
+
+        parse_color(entry)
+      end
+
+      def find_color(name)
+        @graphic.color.find { |c| c.self_attr == name }
+      end
+
+      def find_swatch(name)
+        @graphic.swatch.find { |s| s.self_attr == name }
+      end
+
+      def parse_color(entry)
+        values = (entry.color_value || "").split(/\s+/).map(&:to_f)
+        case entry.space
+        when "RGB"
+          { model: :rgb,
+            r: normalize(values[0], 255),
+            g: normalize(values[1], 255),
+            b: normalize(values[2], 255) }
+        when "CMYK"
+          { model: :cmyk,
+            c: normalize(values[0], 100),
+            m: normalize(values[1], 100),
+            y: normalize(values[2], 100),
+            k: normalize(values[3], 100) }
+        end
+      end
+
+      def normalize(value, max)
+        return 0.0 unless value
+
+        (value / max).clamp(0.0, 1.0)
+      end
+
+      def registration_black
+        { model: :cmyk, c: 1.0, m: 1.0, y: 1.0, k: 1.0 }
+      end
+    end
+  end
+end

data/lib/idml/render/font_embedder.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+# DEPRECATED: This module is superseded by PdfrbWriter.register_font.
+# Font embedding is now handled by pdfrb (Pdfrb::Document#fonts.add).
+
+module Idml
+  module Render
+    # Generates PDF font structures for embedded TrueType fonts.
+    # Produces the Widths array (WinAnsiEncoding 32–255), FontDescriptor
+    # metadata, and FontFile2 binary embedding.
+    module FontEmbedder
+      FIRST_CHAR = 32
+      LAST_CHAR = 255
+
+      # PDF WinAnsiEncoding = Code Page 1252. Bytes 0x80-0x9F differ
+      # from ISO-8859-1 and map to specific Unicode codepoints.
+      CP1252_SPECIAL = {
+        0x80 => 0x20AC, 0x82 => 0x201A, 0x83 => 0x0192, 0x84 => 0x201E,
+        0x85 => 0x2026, 0x86 => 0x2020, 0x87 => 0x2021, 0x88 => 0x02C6,
+        0x89 => 0x2030, 0x8A => 0x0160, 0x8B => 0x2039, 0x8C => 0x0152,
+        0x8E => 0x017D, 0x91 => 0x2018, 0x92 => 0x2019, 0x93 => 0x201C,
+        0x94 => 0x201D, 0x95 => 0x2022, 0x96 => 0x2013, 0x97 => 0x2014,
+        0x98 => 0x02DC, 0x99 => 0x2122, 0x9A => 0x0161, 0x9B => 0x203A,
+        0x9C => 0x0153, 0x9E => 0x017E, 0x9F => 0x0178
+      }.freeze
+
+      private_constant :CP1252_SPECIAL
+
+      module_function
+
+      # Widths array for WinAnsiEncoding (chars 32–255), in PDF text
+      # units (1000 units per em).
+      def widths_array(font_metrics)
+        (FIRST_CHAR..LAST_CHAR).map do |byte|
+          cp = winansi_to_unicode(byte)
+          raw = font_metrics.glyph_width(cp)
+          scale_to_text_units(raw, font_metrics.units_per_em)
+        end
+      end
+
+      # Map a WinAnsi (CP1252) byte value to its Unicode codepoint.
+      def winansi_to_unicode(byte)
+        CP1252_SPECIAL.fetch(byte, byte)
+      end
+
+      def scale_to_text_units(font_units, upem)
+        (font_units.to_f * 1000 / upem).round
+      end
+
+      # FontDescriptor metadata hash.
+      def descriptor(font_metrics)
+        upem = font_metrics.units_per_em
+        scale = 1000.0 / upem
+        ascent = font_metrics.ascent.to_f
+        descent = font_metrics.descent.to_f
+        {
+          font_name: font_metrics.postscript_name,
+          flags: 32,
+          font_bbox: [
+            (descent * scale).round,
+            0,
+            1000,
+            (ascent * scale).round,
+          ],
+          italic_angle: 0,
+          ascent: (ascent * scale).round,
+          descent: (descent * scale).round,
+          cap_height: (ascent * scale * 0.7).round,
+          stem_v: 80,
+        }
+      end
+
+      # Read raw font binary data from the FontMetrics source path.
+      def raw_font_data(font_metrics)
+        File.binread(font_metrics.path)
+      end
+    end
+  end
+end

data/lib/idml/render/font_reference_resolver.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Idml
+  module Render
+    # Resolves IDML font references (family names, font Self IDs, or
+    # CharacterStyleRange#applied_font values) to PostScriptNames.
+    # Built from the document's Fonts.xml (FontFamily → Font entries).
+    # Used by TextFrameRenderer to select per-run fonts.
+    class FontReferenceResolver
+      def self.build(package)
+        new(build_table(package))
+      end
+
+      def self.build_table(package)
+        return {} unless package&.fonts
+
+        table = {}
+        package.fonts.font_family.each do |family|
+          register_family(table, family)
+        end
+        table
+      end
+
+      def self.register_family(table, family)
+        family.font.each do |font|
+          next unless font.post_script_name
+
+          # Map by FontFamily#name (e.g., "Minion Pro")
+          table[family.name] = font.post_script_name if family.name
+          # Map by Font#name (e.g., "Minion Pro Regular")
+          table[font.name] = font.post_script_name if font.name
+          # Map by Font#font_style_name (e.g., "Regular") within family
+          table[font.font_style_name] = font.post_script_name if font.font_style_name
+        end
+      end
+      private_class_method :register_family
+
+      def initialize(table)
+        @table = table
+      end
+
+      # Resolve a font reference (family name, font name, or Self ID).
+      # Returns the PostScriptName or nil if not found.
+      def resolve(reference)
+        return nil unless reference
+
+        @table[reference]
+      end
+    end
+  end
+end

data/lib/idml/render/gradient_resolver.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Idml
+  module Render
+    # Resolves IDML gradient references to discrete PDF gradient fills.
+    # A gradient is rendered as N thin colored rectangles that
+    # approximate the smooth gradient transition. This is not a true
+    # PDF shading pattern (which requires Function dictionaries), but
+    # produces a visually correct gradient without complex PDF structure.
+    class GradientResolver
+      SEGMENTS = 32
+
+      def self.build(graphic)
+        table = {}
+        return new(table) unless graphic&.gradient
+
+        graphic.gradient.each do |gradient|
+          table[gradient.self_attr] = gradient
+        end
+        new(table)
+      end
+
+      def initialize(table)
+        @table = table
+        @color_resolver = nil
+      end
+
+      # Detect if a color reference is a gradient.
+      def self.gradient?(name)
+        name.is_a?(String) && name.start_with?("Gradient/")
+      end
+
+      # Render a gradient fill as PDF operators. Returns nil if the
+      # color is not a gradient. The returned operators emit colored
+      # rectangles from y2 down to y1 (matching PDF Y-up coords).
+      def render_gradient(name, x:, y:, width:, height:, color_resolver:)
+        @color_resolver = color_resolver
+        gradient = @table[name]
+        return nil unless gradient
+
+        stops = gradient.gradient_stop
+        return nil if stops.length < 2
+
+        segment_height = height.to_f / SEGMENTS
+        ops = []
+        SEGMENTS.downto(1) do |i|
+          offset = (i - 1) / SEGMENTS.to_f
+          color = interpolate(stops, offset)
+          next unless color
+
+          ops << Render::Path.save_state
+          ops << Render::Color.fill_op(color)
+          ops << Render::Path.rectangle(x: x,
+                                        y: y + ((SEGMENTS - i) * segment_height),
+                                        width: width,
+                                        height: segment_height + 0.1)
+          ops << Render::Path.fill
+          ops << Render::Path.restore_state
+        end
+        ops.join("\n")
+      end
+
+      def interpolate(stops, offset)
+        next_stop = stops.find { |s| s.location >= offset } || stops.last
+        prev_stop = stops.reverse.find { |s| s.location <= offset } || stops.first
+        return resolve_color(next_stop.stop_color) if next_stop == prev_stop
+
+        blend_between(prev_stop, next_stop, offset)
+      end
+
+      def blend_between(prev_stop, next_stop, offset)
+        range = (next_stop.location - prev_stop.location)
+        range = 1.0 if range.zero?
+        local = (offset - prev_stop.location) / range
+
+        prev_color = resolve_color(prev_stop.stop_color)
+        next_color = resolve_color(next_stop.stop_color)
+        return prev_color unless prev_color && next_color
+        return next_color if local >= 1.0
+
+        blend(prev_color, next_color, local)
+      end
+
+      def resolve_color(name)
+        return nil unless @color_resolver && name
+
+        @color_resolver.resolve(name)
+      end
+
+      def blend(color_a, color_b, t)
+        case color_a[:model]
+        when :rgb
+          {
+            model: :rgb,
+            r: color_a[:r] + ((color_b[:r] - color_a[:r]) * t),
+            g: color_a[:g] + ((color_b[:g] - color_a[:g]) * t),
+            b: color_a[:b] + ((color_b[:b] - color_a[:b]) * t),
+          }
+        when :cmyk
+          {
+            model: :cmyk,
+            c: color_a[:c] + ((color_b[:c] - color_a[:c]) * t),
+            m: color_a[:m] + ((color_b[:m] - color_a[:m]) * t),
+            y: color_a[:y] + ((color_b[:y] - color_a[:y]) * t),
+            k: color_a[:k] + ((color_b[:k] - color_a[:k]) * t),
+          }
+        end
+      end
+    end
+  end
+end