emfsvg 0.1.0

data/lib/emfsvg/clip_region.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Emfsvg
+  # Immutable clip region value object. Holds either a rectangular
+  # bounds (most common case) or a complex path (for SelectClipPath
+  # with arbitrary paths).
+  #
+  # Combine modes per MS-WMF 2.1.5:
+  #   RGN_AND=1, RGN_OR=2, RGN_XOR=3, RGN_DIFF=4, RGN_COPY=5
+  class ClipRegion
+    RGN_AND = 1
+    RGN_OR = 2
+    RGN_XOR = 3
+    RGN_DIFF = 4
+    RGN_COPY = 5
+
+    def initialize(bounds: nil, path_d: nil)
+      @bounds = bounds
+      @path_d = path_d
+    end
+
+    attr_reader :bounds, :path_d
+
+    def empty?
+      bounds.nil? && path_d.nil?
+    end
+
+    # SVG element body for the clip shape: `<rect .../>` or `<path .../>`.
+    def to_svg_element(builder)
+      if path_d
+        builder.tag("path", { "d" => path_d }, single: true)
+      elsif bounds
+        builder.tag("rect", rect_attrs(bounds), single: true)
+      end
+    end
+
+    # Combine with another region per the given mode.
+    # For MVP we approximate: only AND and COPY are handled precisely;
+    # OR/XOR/DIFF fall back to the new region's bounds.
+    def combine(other, mode)
+      case mode
+      when RGN_AND
+        return other if empty?
+        return self if other.empty?
+
+        ClipRegion.new(bounds: intersect_rects(bounds, other.bounds))
+      else # RGN_COPY, RGN_OR, RGN_XOR, RGN_DIFF — MVP: use new region
+        other
+      end
+    end
+
+    private
+
+    def rect_attrs(rect)
+      {
+        "x" => rect.left,
+        "y" => rect.top,
+        "width" => rect.right - rect.left,
+        "height" => rect.bottom - rect.top
+      }
+    end
+
+    def intersect_rects(a, b)
+      return b unless a
+      return a unless b
+
+      Emf::Model::Geometry::Rect.new(
+        left: [a.left, b.left].max,
+        top: [a.top, b.top].max,
+        right: [a.right, b.right].min,
+        bottom: [a.bottom, b.bottom].min
+      )
+    end
+  end
+end

data/lib/emfsvg/compat.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+# Compares emfsvg's output against libemf2svg's reference output for the
+# same EMF input. Used by spec/compat_with_libemf2svg_spec.rb.
+#
+# This is NOT a "must produce identical SVG" test — emfsvg is a clean-room
+# rewrite that handles a subset of EMF records. It IS:
+#   - a structural-equivalence check for the records emfsvg handles
+#   - a quantification of the gap (compatibility ratio per fixture)
+#   - a regression guard so the ratio doesn't shrink over time
+#
+# Usage:
+#   Emfsvg::Compat::Comparator.call(fixtures_glob, ref_dir, out_dir)
+#
+# Requires the libemf2svg-conv binary (or our emf2svg_ref wrapper) at
+# Emfsvg::Compat::LIBEMF2SVG_REF_PATH. The spec auto-skips if missing.
+
+require "open3"
+require "fileutils"
+require "tmpdir"
+require "rexml/document"
+
+module Emfsvg
+  module Compat
+    REF_BINARY_DEFAULT = "/Users/mulgogi/src/claricle/libemf2svg/emf2svg_ref"
+    REF_LIB_DIR_DEFAULT = "/Users/mulgogi/src/claricle/libemf2svg/build"
+
+    module_function
+
+    def ref_binary_available?
+      path = ENV.fetch("EMF2SVG_REF_PATH", REF_BINARY_DEFAULT)
+      File.executable?(path)
+    end
+
+    # Generate a reference SVG using libemf2svg. Returns the SVG bytes,
+    # or nil if generation failed.
+    def generate_reference(emf_path, output_path = nil)
+      binary = ENV.fetch("EMF2SVG_REF_PATH", REF_BINARY_DEFAULT)
+      lib_dir = ENV.fetch("EMF2SVG_REF_LIB_DIR", REF_LIB_DIR_DEFAULT)
+      env = { "DYLD_LIBRARY_PATH" => lib_dir }
+      output_path ||= "#{Dir.mktmpdir}/#{File.basename(emf_path, '.emf')}.svg"
+      _, _, status = Open3.capture3(env, binary, emf_path, output_path)
+      return nil unless status.success?
+
+      File.binread(output_path)
+    ensure
+      File.delete(output_path) if output_path && !block_given?
+    end
+
+    # Generate emfsvg output. Requires the emfsvg gem to be loaded.
+    def generate_emfsvg(emf_path, options = {})
+      Emfsvg.from_file(emf_path, **options)
+    end
+
+    # Normalise an SVG document for structural comparison:
+    # - parse to REXML
+    # - return the root element
+    def parse_svg(svg_string)
+      REXML::Document.new(svg_string).root
+    rescue REXML::ParseException
+      nil
+    end
+
+    # Count drawing elements in an SVG. Returns a hash like
+    # { "rect" => 3, "path" => 17, "ellipse" => 2 }.
+    def count_elements(svg_root)
+      counts = Hash.new(0)
+      return counts unless svg_root
+
+      REXML::XPath.each(svg_root, "descendant-or-self::*") do |el|
+        counts[el.name] += 1
+      end
+      counts
+    end
+
+    # Per-fixture comparison result.
+    Result = Struct.new(:fixture, :ref_bytes, :emfsvg_bytes, :ref_elements,
+                        :emfsvg_elements, keyword_init: true) do
+      def byte_ratio
+        ref_bytes.zero? ? 0.0 : (emfsvg_bytes.to_f / ref_bytes * 100).round(1)
+      end
+
+      def element_overlap
+        return 0.0 if emfsvg_elements.empty?
+
+        shared = emfsvg_elements.keys & ref_elements.keys
+        shared.sum { |k| [emfsvg_elements[k], ref_elements[k]].min }.to_f /
+          emfsvg_elements.values.sum
+      end
+
+      def to_s
+        format("%-40s ref=%8d out=%7d (%5.1f%%) elements_overlap=%.1f",
+               fixture, ref_bytes, emfsvg_bytes, byte_ratio, element_overlap * 100)
+      end
+    end
+
+    # Walk a fixtures glob, produce both outputs, return Result array.
+    def compare_glob(fixtures_glob)
+      results = []
+      Dir.glob(fixtures_glob).each do |emf|
+        ref_svg = generate_reference(emf)
+        next unless ref_svg
+
+        emfsvg_svg = begin
+          generate_emfsvg(emf)
+        rescue StandardError
+          nil
+        end
+        next unless emfsvg_svg
+
+        results << Result.new(
+          fixture: File.basename(emf),
+          ref_bytes: ref_svg.bytesize,
+          emfsvg_bytes: emfsvg_svg.bytesize,
+          ref_elements: count_elements(parse_svg(ref_svg)),
+          emfsvg_elements: count_elements(parse_svg(emfsvg_svg))
+        )
+      end
+      results
+    end
+
+    # Summary across many results.
+    def summarize(results)
+      return "no results" if results.empty?
+
+      total_ref = results.sum(&:ref_bytes)
+      total_out = results.sum(&:emfsvg_bytes)
+      ratio = total_ref.zero? ? 0 : (total_out.to_f / total_ref * 100).round(1)
+      avg_overlap = results.sum(&:element_overlap) / results.size
+      format("fixtures=%d  total_ref=%d  total_out=%d  byte_ratio=%.1f%%  avg_element_overlap=%.1f%%",
+             results.size, total_ref, total_out, ratio, avg_overlap * 100)
+    end
+  end
+end

data/lib/emfsvg/device_context.rb

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+module Emfsvg
+  # Coordinate state that lives OUTSIDE the device-context stack in
+  # libemf2svg (MapMode, window/viewport extents and origins). The C
+  # code keeps these on drawingStates directly, NOT on
+  # EMF_DEVICE_CONTEXT, so SaveDC/RestoreDC never saves/restores them.
+  # They persist as global state for the duration of the render.
+  #
+  # This is a mutable struct shared by reference across every dup'd
+  # DeviceContext — when visit_set_map_mode changes the map mode, every
+  # DC observes the new value, even ones that were saved earlier.
+  class CoordinateState
+    attr_accessor :map_mode, :window_ext, :viewport_ext,
+                  :window_org, :viewport_org,
+                  :window_ext_set, :viewport_ext_set
+
+    def initialize
+      @map_mode = 1 # MM_TEXT
+      @window_ext = [0, 0]
+      @viewport_ext = [0, 0]
+      @window_org = [0, 0]
+      @viewport_org = [0, 0]
+      @window_ext_set = false
+      @viewport_ext_set = false
+    end
+  end
+
+  # Snapshot of GDI drawing state. Pushed onto TransformStack on SaveDC,
+  # popped on RestoreDC.
+  class DeviceContext
+    def initialize
+      @pen = Pen.default
+      @brush = Brush.default
+      @font = Font.default
+      @text_color = Emf::Model::Geometry::Color.black
+      @bk_color = Emf::Model::Geometry::Color.white
+      @bk_mode = 1 # TRANSPARENT
+      @poly_fill_mode = 1 # ALTERNATE (evenodd)
+      @text_align = 0
+      @stretch_mode = 1
+      @miter_limit = 10.0
+      @world_transform = Emf::Model::Geometry::Matrix.identity
+      @brush_origin = [0, 0]
+      @icm_mode = 0
+      @layout = 0
+      @mapper_flags = 0
+      @arc_direction = 0 # default; set by SetArcDirection (1=CW, -1=CCW in C)
+      @clip_region = nil
+      @clip_id = nil
+      # Coordinate state shared across all dup'd DCs (see CoordinateState).
+      @coordinate_state = CoordinateState.new
+    end
+
+    attr_accessor :pen, :brush, :font, :text_color, :bk_color, :bk_mode, :poly_fill_mode, :text_align, :stretch_mode, :miter_limit,
+                  :world_transform, :brush_origin, :icm_mode, :layout, :mapper_flags, :arc_direction, :clip_region, :clip_id, :coordinate_state
+
+    def map_mode
+      coordinate_state.map_mode
+    end
+
+    def map_mode=(value)
+      coordinate_state.map_mode = value
+    end
+
+    def window_ext
+      coordinate_state.window_ext
+    end
+
+    def window_ext=(value)
+      coordinate_state.window_ext = value
+    end
+
+    def viewport_ext
+      coordinate_state.viewport_ext
+    end
+
+    def viewport_ext=(value)
+      coordinate_state.viewport_ext = value
+    end
+
+    def window_org
+      coordinate_state.window_org
+    end
+
+    def window_org=(value)
+      coordinate_state.window_org = value
+    end
+
+    def viewport_org
+      coordinate_state.viewport_org
+    end
+
+    def viewport_org=(value)
+      coordinate_state.viewport_org = value
+    end
+
+    def window_ext_set?
+      coordinate_state.window_ext_set
+    end
+
+    def viewport_ext_set?
+      coordinate_state.viewport_ext_set
+    end
+
+    def window_ext_set=(value)
+      coordinate_state.window_ext_set = value
+    end
+
+    def viewport_ext_set=(value)
+      coordinate_state.viewport_ext_set = value
+    end
+
+    def dup
+      other = DeviceContext.allocate
+      other.pen = pen.dup
+      other.brush = brush.dup
+      other.font = font.dup
+      other.text_color = text_color
+      other.bk_color = bk_color
+      other.bk_mode = bk_mode
+      other.poly_fill_mode = poly_fill_mode
+      other.text_align = text_align
+      other.stretch_mode = stretch_mode
+      other.miter_limit = miter_limit
+      other.world_transform = world_transform
+      other.brush_origin = brush_origin.dup
+      other.icm_mode = icm_mode
+      other.layout = layout
+      other.mapper_flags = mapper_flags
+      other.arc_direction = arc_direction
+      other.clip_region = clip_region
+      other.clip_id = clip_id
+      # CoordinateState is shared by reference — SaveDC/RestoreDC must
+      # not snapshot/restore the coordinate state per libemf2svg.
+      other.coordinate_state = coordinate_state
+      other
+    end
+
+    protected :coordinate_state=
+  end
+
+  # Pen value object: style, width, color.
+  class Pen
+    SOLID = 0
+    DASH = 1
+    DOT = 2
+    DASHDOT = 3
+    DASHDOTDOT = 4
+    NULL = 5
+    INSIDEFRAME = 6
+
+    def initialize(style: SOLID, width: 1, color: Emf::Model::Geometry::Color.black)
+      @style = style
+      @width = width
+      @color = color
+    end
+
+    attr_reader :style, :width, :color
+
+    def self.default
+      new
+    end
+
+    def null?
+      style == NULL
+    end
+
+    def dup
+      Pen.new(style: style, width: width, color: color)
+    end
+  end
+
+  # Brush value object: style, color, hatch.
+  class Brush
+    SOLID = 0
+    NULL = 1
+    HATCHED = 2
+    PATTERN = 3
+    # MONOPATTERN: 8 (BS_MONOPATTERN / U_BS_MONOPATTERN in MS-WMF). Brush
+    # references a DIB image stored in the SVG <defs>; fill becomes
+    # `url(#img-N-ref)`. brush.image_id is the N.
+    MONOPATTERN = 8
+
+    def initialize(style: SOLID, color: Emf::Model::Geometry::Color.black, hatch: 0, image_id: nil)
+      @style = style
+      @color = color
+      @hatch = hatch
+      @image_id = image_id
+    end
+
+    attr_reader :style, :color, :hatch, :image_id
+
+    def self.default
+      new
+    end
+
+    def null?
+      style == NULL
+    end
+
+    def dup
+      Brush.new(style: style, color: color, hatch: hatch, image_id: image_id)
+    end
+  end
+
+  # Font value object: minimal subset of LOGFONT for text rendering.
+  class Font
+    DEFAULT_HEIGHT = 0
+
+    def initialize(face_name: nil, height: DEFAULT_HEIGHT, weight: 0,
+                   italic: false, underline: false, strikeout: false,
+                   escapement: 0, charset: 0)
+      @face_name = face_name
+      @height = height
+      @weight = weight
+      @italic = italic
+      @underline = underline
+      @strikeout = strikeout
+      @escapement = escapement
+      @charset = charset
+    end
+
+    attr_reader :face_name, :height, :weight, :italic, :underline, :strikeout, :escapement, :charset
+
+    def self.default
+      new
+    end
+
+    def bold?
+      weight >= 700
+    end
+
+    def dup
+      Font.new(face_name: face_name, height: height, weight: weight,
+               italic: italic, underline: underline, strikeout: strikeout,
+               escapement: escapement, charset: charset)
+    end
+  end
+end