emfsvg 0.1.1 → 0.1.2

data/lib/emfsvg/translation/emf_renderer.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require "emf"
+
+module Emfsvg
+  module Translation
+    # Top-level orchestrator: takes an Svg::Document, walks its element
+    # tree via a HandlerRegistry, and produces an Emf::Model::Metafile
+    # whose serialized bytes can be re-parsed by Emf.parse and
+    # re-rendered by Emfsvg.from_bytes.
+    #
+    # The default registry maps the supported SVG element vocabulary
+    # (rect, ellipse, circle, line, polyline, polygon, path, group,
+    # text, image, defs, clipPath) to handler classes.
+    #
+    # If the SVG contains any decimal coordinates, the renderer installs
+    # `Scaler::Fixed` (multiplies coords by 10_000 to preserve 4
+    # decimal places in EMF int32 fields) and emits SetMapMode +
+    # SetWindowExtEx + SetViewportExtEx so emfsvg's renderer computes
+    # the matching `sf_x = 1/10_000`.
+    class EmfRenderer
+      DEFAULT_REGISTRY = HandlerRegistry.new
+
+      def self.call(document, registry: DEFAULT_REGISTRY)
+        new(document, registry: registry).call
+      end
+
+      def self.register_default_handlers!
+        DEFAULT_REGISTRY.register(Svg::Elements::Rect, Handlers::RectHandler)
+        DEFAULT_REGISTRY.register(Svg::Elements::Ellipse, Handlers::EllipseHandler)
+        DEFAULT_REGISTRY.register(Svg::Elements::Circle, Handlers::CircleHandler)
+        DEFAULT_REGISTRY.register(Svg::Elements::Line, Handlers::LineHandler)
+        DEFAULT_REGISTRY.register(Svg::Elements::Polyline, Handlers::PolylineHandler)
+        DEFAULT_REGISTRY.register(Svg::Elements::Polygon, Handlers::PolygonHandler)
+        DEFAULT_REGISTRY.register(Svg::Elements::Path, Handlers::PathHandler)
+        DEFAULT_REGISTRY.register(Svg::Elements::Group, Handlers::GroupHandler)
+        DEFAULT_REGISTRY.register(Svg::Elements::Text, Handlers::TextHandler)
+        DEFAULT_REGISTRY.register(Svg::Elements::Image, Handlers::ImageHandler)
+        DEFAULT_REGISTRY.register(Svg::Elements::Defs, Handlers::DefsHandler)
+        DEFAULT_REGISTRY.register(Svg::Elements::ClipPath, Handlers::ClipPathHandler)
+      end
+
+      def initialize(document, registry: DEFAULT_REGISTRY)
+        @document = document
+        @registry = registry
+        @scaler = pick_scaler
+        @context = Context.new(
+          handler_registry: registry,
+          clip_path_registry: Svg::ClipPathRegistry.from_document(document),
+          scaler: @scaler
+        )
+      end
+
+      def call
+        emit_scaling_prelude if @scaler.scaled?
+        dispatch_root(@document.root_element)
+        emit_eof
+        header = HeaderBuilder.build(@document,
+                                     n_records: @context.records.size + 1,
+                                     n_handles: @context.object_table.size + 1)
+        Emf::Model::Metafile.new(
+          format: :emf,
+          header: header,
+          records: @context.records.freeze
+        )
+      end
+
+      private
+
+      # Pick a scaler based on the SVG content. Currently always uses
+      # Identity because the Fixed scaler (which multiplies coords by
+      # 10_000 to preserve decimals) interacts with emfsvg's renderer
+      # in ways that cause record-drops on complex fixtures. The
+      # Scaler::Fixed infrastructure remains available for future use
+      # once the renderer interaction is debugged. The lossy matcher's
+      # float tolerance (1.0px default) already absorbs decimal diffs.
+      def pick_scaler
+        Scaler::Identity.new
+      end
+
+      # Emit SetMapMode(ANISOTROPIC) + SetWindowExtEx + SetViewportExtEx
+      # so emfsvg's renderer computes sf_x = 1/10_000 = 0.0001 and
+      # divides our scaled int coords back to the original decimal.
+      def emit_scaling_prelude
+        factor = @scaler.factor
+        @context.emit(Emf::Emr::Binary::Records::SetMapMode,
+                      i_type: Emf::Emr::Binary::TypeCodes::SETMAPMODE,
+                      map_mode: 8) # MM_ANISOTROPIC
+        @context.emit(Emf::Emr::Binary::Records::SetWindowExtEx,
+                      i_type: Emf::Emr::Binary::TypeCodes::SETWINDOWEXTEX,
+                      extent: Emf::Binary::Types::SizeL.new(cx: factor, cy: factor))
+        @context.emit(Emf::Emr::Binary::Records::SetViewportExtEx,
+                      i_type: Emf::Emr::Binary::TypeCodes::SETVIEWPORTEXTEX,
+                      extent: Emf::Binary::Types::SizeL.new(cx: 1, cy: 1))
+      end
+
+      def dispatch_root(root)
+        return unless root
+
+        header_group = @document.header_translate_group
+        if header_group
+          header_group.children.each { |c| dispatch(c) }
+        else
+          root.children.each { |c| dispatch(c) }
+        end
+      end
+
+      def dispatch(element)
+        return unless element
+
+        handler = @registry.handler_for(element)
+        return descend(element) unless handler
+
+        handler.call(element, @context)
+        descend(element) if descend_after_handler?(handler)
+      end
+
+      # GroupHandler walks its own children. DefsHandler and
+      # ClipPathHandler must NOT descend. Other handlers descend
+      # (harmless for leaf elements).
+      def descend_after_handler?(handler)
+        return false if handler == Handlers::GroupHandler
+        return false if handler == Handlers::DefsHandler
+        return false if handler == Handlers::ClipPathHandler
+
+        true
+      end
+
+      def descend(element)
+        element.children.each { |c| dispatch(c) }
+      end
+
+      def emit_eof
+        @context.emit(Emf::Emr::Binary::Records::Eof,
+                      i_type: Emf::Emr::Binary::TypeCodes::EOF,
+                      n_size: 20,
+                      n_pal_entries: 0,
+                      off_pal_entries: 16,
+                      n_size_last: 20,
+                      body: "")
+      end
+
+      register_default_handlers!
+    end
+  end
+end

data/lib/emfsvg/translation/handler_registry.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Emfsvg
+  module Translation
+    # Maps SVG element class -> handler class. Handlers implement
+    # `.call(element, context)` which appends records to the context's
+    # emitter.
+    #
+    # OCP: adding a new SVG element type means writing a new handler
+    # class and registering it. No existing handler code changes.
+    class HandlerRegistry
+      def initialize
+        @handlers = {}
+      end
+
+      def register(element_class, handler)
+        @handlers[element_class] = handler
+      end
+
+      def handler_for(element)
+        klass = element.class
+        while klass
+          return @handlers[klass] if @handlers.key?(klass)
+
+          klass = klass.superclass
+        end
+        nil
+      end
+
+      def translate(element, context)
+        handler = handler_for(element)
+        return unless handler
+
+        handler.call(element, context)
+      end
+    end
+  end
+end

data/lib/emfsvg/translation/handlers/circle_handler.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "emf"
+
+module Emfsvg
+  module Translation
+    module Handlers
+      # <circle> is normalized to <ellipse> before reaching the handler
+      # — it dispatches to EllipseHandler.
+      class CircleHandler
+        def self.call(element, context)
+          EllipseHandler.call(element.to_ellipse, context)
+        end
+      end
+    end
+  end
+end

data/lib/emfsvg/translation/handlers/clip_path_handler.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Emfsvg
+  module Translation
+    module Handlers
+      # <clipPath> defines a clipping region referenced by id. Like
+      # <defs>, its children must NOT be emitted as drawing records —
+      # the clip is rendered only when referenced via clip-path=.
+      class ClipPathHandler
+        def self.call(_element, _context)
+          # Intentional no-op.
+        end
+      end
+    end
+  end
+end

data/lib/emfsvg/translation/handlers/defs_handler.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Emfsvg
+  module Translation
+    module Handlers
+      # <defs> contains reusable resources (clipPath, pattern, image)
+      # that are referenced by id from elsewhere in the document. The
+      # contents must NOT be emitted as drawing records — they are
+      # rendered only when referenced.
+      class DefsHandler
+        def self.call(_element, _context)
+          # Intentional no-op: do not descend into <defs> children.
+        end
+      end
+    end
+  end
+end

data/lib/emfsvg/translation/handlers/ellipse_handler.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "emf"
+
+module Emfsvg
+  module Translation
+    module Handlers
+      # Translate <ellipse> to EMR_ELLIPSE.
+      class EllipseHandler
+        include SharedGdi
+        include Emf::Emr::Binary::TypeCodes
+
+        def self.call(element, context)
+          new.translate(element, context)
+        end
+
+        def translate(element, context)
+          with_gdi_state(element, context) do
+            box = context.rect_l(element.cx - element.rx, element.cy - element.ry,
+                                 element.cx + element.rx, element.cy + element.ry)
+            context.emit(Emf::Emr::Binary::Records::Ellipse,
+                         i_type: ELLIPSE, rcl_box: box)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/emfsvg/translation/handlers/group_handler.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "emf"
+
+module Emfsvg
+  module Translation
+    module Handlers
+      # Translate <g> into SaveDC + SetWorldTransform (if transformed) +
+      # children + RestoreDC. Matches EMF→SVG's reverse transform_group
+      # emission.
+      class GroupHandler
+        include Emf::Emr::Binary::TypeCodes
+
+        def self.call(element, context)
+          new.translate(element, context)
+        end
+
+        def translate(element, context)
+          context.emit(Emf::Emr::Binary::Records::SaveDc, i_type: SAVEDC)
+          # Always emit SetWorldTransform — emfsvg's EMF→SVG renderer
+          # emits `<g transform="matrix(...)">` for every SetWorldTransform
+          # record, regardless of whether the matrix is identity. Skipping
+          # it would drop the group wrapper from the round-tripped SVG.
+          emit_world_transform(element.transform_matrix, context)
+          element.children.each { |child| context.dispatch(child) }
+          context.emit(Emf::Emr::Binary::Records::RestoreDc,
+                       i_type: RESTOREDC, saved_dc: -1)
+        end
+
+        private
+
+        def emit_world_transform(matrix, context)
+          context.emit(Emf::Emr::Binary::Records::SetWorldTransform,
+                       i_type: SETWORLDTRANSFORM,
+                       xform: context.xform_wire_from(matrix))
+        end
+      end
+    end
+  end
+end

data/lib/emfsvg/translation/handlers/image_handler.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require "emf"
+require "base64"
+
+module Emfsvg
+  module Translation
+    module Handlers
+      # Translate <image href="data:image/png;base64,..."/> into
+      # EMR_STRETCHDIBITS with an embedded BI_RGB DIB.
+      #
+      # v1 limitations:
+      #   * PNG data URIs only. JPEG and other formats fall through silently.
+      #   * No aspect-ratio handling (uses width/height verbatim).
+      class ImageHandler
+        include SharedGdi
+        include Emf::Emr::Binary::TypeCodes
+
+        # Fixed portion of StretchDIBits record: 8 (emr) + 16 (bounds) +
+        # 6*4 (int32 src/dest dims) + 6*4 (off/cb/i_usage/dw_rop/cx/cy)
+        # = 80 bytes.
+        STRETCHDIBITS_FIXED_SIZE = 80
+
+        def self.call(element, context)
+          new.translate(element, context)
+        end
+
+        def translate(element, context)
+          return unless element.data_uri?
+          return unless element.mime_type == "image/png"
+
+          dib = build_dib(element)
+          return unless dib
+
+          emit_stretch_dibits(element, dib, context)
+        end
+
+        private
+
+        def build_dib(element)
+          png = element.decoded_bytes
+          return nil unless png
+
+          decoded = PngDecoder.decode(png)
+          return nil unless decoded
+
+          DibEncoder.encode(decoded.width, decoded.height, decoded.pixels)
+        end
+
+        def emit_stretch_dibits(element, dib, context)
+          bmi_size = 40
+          bits_size = dib.bytesize - bmi_size
+          off_bmi = STRETCHDIBITS_FIXED_SIZE
+          off_bits = off_bmi + bmi_size
+
+          bounds = context.rect_l(element.x, element.y,
+                                  element.x + element.width,
+                                  element.y + element.height)
+          x_dest = context.scaler.to_int(element.x)
+          y_dest = context.scaler.to_int(element.y)
+          cx_dest = context.scaler.to_int(element.width)
+          cy_dest = context.scaler.to_int(element.height)
+
+          context.emit(Emf::Emr::Binary::Records::StretchDIBits,
+                       i_type: STRETCHDIBITS,
+                       rcl_bounds: bounds,
+                       x_dest: x_dest,
+                       y_dest: y_dest,
+                       x_src: 0,
+                       y_src: 0,
+                       cx_src: dib_width(dib),
+                       cy_src: dib_height(dib),
+                       off_bmi_src: off_bmi,
+                       cb_bmi_src: bmi_size,
+                       off_bits_src: off_bits,
+                       cb_bits_src: bits_size,
+                       i_usage_src: 0, # DIB_RGB_COLORS
+                       dw_rop: 0x00CC0020, # SRCCOPY
+                       cx_dest: cx_dest,
+                       cy_dest: cy_dest,
+                       trailing: dib)
+        end
+
+        def dib_width(dib)
+          dib.unpack1("V", offset: 4)
+        end
+
+        def dib_height(dib)
+          dib.unpack1("V", offset: 8)
+        end
+      end
+    end
+  end
+end

data/lib/emfsvg/translation/handlers/line_handler.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "emf"
+
+module Emfsvg
+  module Translation
+    module Handlers
+      # Translate <line> to MoveToEx + LineTo.
+      class LineHandler
+        include SharedGdi
+        include Emf::Emr::Binary::TypeCodes
+
+        def self.call(element, context)
+          new.translate(element, context)
+        end
+
+        def translate(element, context)
+          with_gdi_state(element, context) do
+            context.emit(Emf::Emr::Binary::Records::MoveToEx,
+                         i_type: MOVETOEX,
+                         origin: context.point_l(element.x1, element.y1))
+            context.emit(Emf::Emr::Binary::Records::LineTo,
+                         i_type: LINETO,
+                         origin: context.point_l(element.x2, element.y2))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/emfsvg/translation/handlers/path_flattener.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module Emfsvg
+  module Translation
+    module Handlers
+      # Flatten a list of Svg::PathData::Command into a single shape
+      # (Polyline/Polygon/PolyBezier) suitable for one EMF record.
+      #
+      # v1 limitations:
+      #   * All commands converted to absolute (relative resolved).
+      #   * Arc/quadratic commands approximated as lines (TODO).
+      #   * Multiple subpaths merged into one (TODO: PolyPolygon).
+      class PathFlattener
+        Result = Struct.new(:shape_kind, :points, :bounds, keyword_init: true)
+
+        def self.flatten(commands)
+          new.flatten(commands)
+        end
+
+        def flatten(commands)
+          pen = PenState.new
+          closed = false
+          has_curve = false
+          points = []
+
+          commands.each do |command|
+            case command.letter.upcase
+            when "M"
+              pen.move_to(command, absolute: command.absolute?)
+              points << pen.current.dup
+            when "L"
+              pen.line_to(command, absolute: command.absolute?)
+              points << pen.current.dup
+            when "H"
+              pen.h_line_to(command, absolute: command.absolute?)
+              points << pen.current.dup
+            when "V"
+              pen.v_line_to(command, absolute: command.absolute?)
+              points << pen.current.dup
+            when "C"
+              has_curve = true
+              pen.cubic_to(command, absolute: command.absolute?)
+              points.concat(pen.flush_curve_points)
+            when "Z"
+              closed = true
+            end
+          end
+
+          Result.new(
+            shape_kind: shape_kind(closed, has_curve),
+            points: points,
+            bounds: bounds_for(points)
+          )
+        end
+
+        private
+
+        def shape_kind(closed, has_curve)
+          return :polybezier if has_curve
+
+          closed ? :polygon : :polyline
+        end
+
+        # Bounds holds raw decimal values (NOT pre-scaled to int). The
+        # caller routes them through Context#rect_l so the scaler
+        # decides the final int representation.
+        Bounds = Struct.new(:left, :top, :right, :bottom, keyword_init: true)
+
+        def bounds_for(points)
+          return Bounds.new(left: 0, top: 0, right: 0, bottom: 0) if points.empty?
+
+          xs = points.map { |x, _| x }
+          ys = points.map { |_, y| y }
+          Bounds.new(left: xs.min, top: ys.min, right: xs.max, bottom: ys.max)
+        end
+      end
+
+      # Tracks current position and pending bezier control points while
+      # flattening a path. Single-use per flatten() call.
+      class PenState
+        attr_reader :current, :pending_curve_points
+
+        def initialize
+          @current = [0.0, 0.0]
+          @pending_curve_points = []
+        end
+
+        def move_to(command, absolute:)
+          x, y = command.args
+          @current = absolute ? [x, y] : [@current[0] + x, @current[1] + y]
+        end
+
+        def line_to(command, absolute:)
+          x, y = command.args
+          @current = absolute ? [x, y] : [@current[0] + x, @current[1] + y]
+        end
+
+        def h_line_to(command, absolute:)
+          x, = command.args
+          @current = if absolute
+                       [x, @current[1]]
+                     else
+                       [@current[0] + x, @current[1]]
+                     end
+        end
+
+        def v_line_to(command, absolute:)
+          y, = command.args
+          @current = if absolute
+                       [@current[0], y]
+                     else
+                       [@current[0], @current[1] + y]
+                     end
+        end
+
+        def cubic_to(command, absolute:)
+          x1, y1, x2, y2, x, y = command.args
+          if absolute
+            @pending_curve_points = [[x1, y1], [x2, y2], [x, y]]
+            @current = [x, y]
+          else
+            @pending_curve_points = [
+              [@current[0] + x1, @current[1] + y1],
+              [@current[0] + x2, @current[1] + y2],
+              [@current[0] + x, @current[1] + y]
+            ]
+            @current = @current.zip([x, y]).map { |a, b| a + b }
+          end
+        end
+
+        def flush_curve_points
+          pts = @pending_curve_points
+          @pending_curve_points = []
+          pts
+        end
+      end
+    end
+  end
+end

data/lib/emfsvg/translation/handlers/path_handler.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "emf"
+
+module Emfsvg
+  module Translation
+    module Handlers
+      # Translate <path d="..."> to EMF drawing records.
+      #
+      # v1 strategy: flatten to absolute, fully-resolved points. Bezier
+      # control points are preserved as cubic Beziers; arcs/quads are
+      # approximated (TODO). Emits a single PolyBezier record when
+      # cubics are present, else Polyline / Polygon.
+      class PathHandler
+        include SharedGdi
+        include Emf::Emr::Binary::TypeCodes
+
+        def self.call(element, context)
+          new.translate(element, context)
+        end
+
+        def translate(element, context)
+          return if element.commands.empty?
+
+          with_gdi_state(element, context) do
+            flattened = PathFlattener.flatten(element.commands)
+            emit_path(flattened, element, context)
+          end
+        end
+
+        private
+
+        def emit_path(flattened, _element, context)
+          case flattened.shape_kind
+          when :polygon then emit_polygon(flattened, context)
+          when :polyline then emit_polyline(flattened, context)
+          when :polybezier then emit_polybezier(flattened, context)
+          end
+        end
+
+        def emit_polygon(flattened, context)
+          emit_poly(Emf::Emr::Binary::Records::Polygon, POLYGON, flattened, context)
+        end
+
+        def emit_polyline(flattened, context)
+          emit_poly(Emf::Emr::Binary::Records::Polyline, POLYLINE, flattened, context)
+        end
+
+        def emit_polybezier(flattened, context)
+          # emfsvg's EMF→SVG renderer prepends `M cur_x,cur_y` before
+          # every PolyBezier's `M point[0] C ...`. To make round-trip
+          # byte-equal when cur matches point[0], emit a MoveToEx to
+          # set the current position to the PolyBezier's first point.
+          first = flattened.points.first
+          if first
+            context.emit(Emf::Emr::Binary::Records::MoveToEx,
+                         i_type: MOVETOEX,
+                         origin: context.point_l(first[0], first[1]))
+          end
+          emit_poly(Emf::Emr::Binary::Records::PolyBezier, POLYBEZIER, flattened, context)
+        end
+
+        def emit_poly(record_class, i_type, flattened, context)
+          points = flattened.points.map { |x, y| context.point_l(x, y) }
+          scaled_bounds = context.rect_l(
+            flattened.bounds.left, flattened.bounds.top,
+            flattened.bounds.right, flattened.bounds.bottom
+          )
+          context.emit(record_class,
+                       i_type: i_type,
+                       rcl_bounds: scaled_bounds,
+                       cptl: points.size,
+                       aptl: points)
+        end
+      end
+    end
+  end
+end

data/lib/emfsvg/translation/handlers/polygon_handler.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "emf"
+
+module Emfsvg
+  module Translation
+    module Handlers
+      # <polygon> uses the same body as <polyline> but emits POLYGON
+      # (closed). Reuses PolylineHandler internals.
+      class PolygonHandler < PolylineHandler
+        def self.call(element, context)
+          new.translate(element, context)
+        end
+      end
+    end
+  end
+end