emfsvg 0.1.1 → 0.1.2

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "emf"
+
+module Emfsvg
+  module Translation
+    module Handlers
+      # Translate <polyline> to EMR_POLYLINE.
+      class PolylineHandler
+        include SharedGdi
+        include Emf::Emr::Binary::TypeCodes
+
+        def self.call(element, context)
+          new.translate(element, context)
+        end
+
+        def translate(element, context)
+          return if element.points.empty?
+
+          with_gdi_state(element, context) do
+            emit_poly(element.points, element, context)
+          end
+        end
+
+        private
+
+        def emit_poly(points, element, context)
+          bounds = bounding_box(points, context)
+          wire_points = points.map { |x, y| context.point_l(x, y) }
+          record_class = if element.is_a?(Svg::Elements::Polygon)
+                           Emf::Emr::Binary::Records::Polygon
+                         else
+                           Emf::Emr::Binary::Records::Polyline
+                         end
+          i_type = element.is_a?(Svg::Elements::Polygon) ? POLYGON : POLYLINE
+          context.emit(record_class,
+                       i_type: i_type,
+                       rcl_bounds: bounds,
+                       cptl: wire_points.size,
+                       aptl: wire_points)
+        end
+
+        def bounding_box(points, context)
+          xs = points.map { |x, _| x }
+          ys = points.map { |_, y| y }
+          context.rect_l(xs.min, ys.min, xs.max, ys.max)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "emf"
+
+module Emfsvg
+  module Translation
+    module Handlers
+      # Translate <rect> to EMR_RECTANGLE or EMR_ROUNDRECT.
+      class RectHandler
+        include SharedGdi
+        include Emf::Emr::Binary::TypeCodes
+
+        def self.call(element, context)
+          handler = new
+          handler.translate(element, context)
+        end
+
+        def translate(element, context)
+          with_gdi_state(element, context) do
+            emit_rect(element, context)
+          end
+        end
+
+        private
+
+        def emit_rect(element, context)
+          box = context.rect_l(element.x, element.y,
+                               element.x + element.width,
+                               element.y + element.height)
+
+          if element.rounded?
+            corner = context.size_l(element.rx * 2, element.ry * 2)
+            context.emit(Emf::Emr::Binary::Records::RoundRect,
+                         i_type: ROUNDRECT, rcl_box: box, szl_corner: corner)
+          else
+            context.emit(Emf::Emr::Binary::Records::Rectangle,
+                         i_type: RECTANGLE, rcl_box: box)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "emf"
+
+module Emfsvg
+  module Translation
+    module Handlers
+      # Mixed into element handlers. Provides the per-element GDI object
+      # lifecycle: Create+Select before the block, Delete after.
+      #
+      # Strategy (v1): always emit CreatePen + CreateBrushIndirect +
+      # SelectObject + (draw) + DeleteObject, even when the SVG value
+      # is "none". This produces a literal 1:1 mapping of the SVG tree
+      # to EMF records and is what the round-trip test exercises.
+      #
+      # If the element has a rectangular clip-path, the entire draw is
+      # wrapped in SaveDC + IntersectClipRect + RestoreDC so the clip
+      # is scoped to this element only.
+      module SharedGdi
+        include Emf::Emr::Binary::TypeCodes
+
+        def with_gdi_state(element, context)
+          clip_bounds = clip_bounds_for(element, context)
+          wrap_with_clip = !clip_bounds.nil?
+
+          emit_save_dc(context) if wrap_with_clip
+          pen_handle = emit_create_pen(context, element.stroke) if element.stroke
+          brush_handle = emit_create_brush(context, element.fill) if element.fill
+          if wrap_with_clip
+            context.emit(Emf::Emr::Binary::Records::IntersectClipRect,
+                         i_type: INTERSECTCLIPRECT,
+                         rcl_clip: context.rect_l(*clip_bounds))
+          end
+          yield
+          emit_delete(context, pen_handle) if pen_handle
+          emit_delete(context, brush_handle) if brush_handle
+          emit_restore_dc(context) if wrap_with_clip
+        end
+
+        def clip_bounds_for(element, context)
+          return nil if context.clip_path_registry.nil?
+
+          attr = element.clip_path
+          return nil if attr.nil?
+
+          clip = context.clip_path_registry.lookup(attr)
+          return nil unless clip
+
+          clip.clip_bounds
+        end
+
+        def emit_save_dc(context)
+          context.emit(Emf::Emr::Binary::Records::SaveDc, i_type: SAVEDC)
+        end
+
+        def emit_restore_dc(context)
+          context.emit(Emf::Emr::Binary::Records::RestoreDc,
+                       i_type: RESTOREDC, saved_dc: -1)
+        end
+
+        def emit_create_pen(context, stroke)
+          handle = context.allocate_handle
+          context.emit(Emf::Emr::Binary::Records::CreatePen,
+                       i_type: CREATEPEN,
+                       ih_pen: handle,
+                       pen_style: stroke.pen_style,
+                       width: context.point_l(stroke.width, 0),
+                       color: stroke.paint.color.to_emf_wire.to_wire)
+          context.emit(Emf::Emr::Binary::Records::SelectObject,
+                       i_type: SELECTOBJECT,
+                       ih_object: handle)
+          handle
+        end
+
+        def emit_create_brush(context, paint)
+          handle = context.allocate_handle
+          context.emit(Emf::Emr::Binary::Records::CreateBrushIndirect,
+                       i_type: CREATEBRUSHINDIRECT,
+                       ih_brush: handle,
+                       brush_style: paint.style,
+                       color: paint.color.to_emf_wire.to_wire,
+                       brush_hatch: 0)
+          context.emit(Emf::Emr::Binary::Records::SelectObject,
+                       i_type: SELECTOBJECT,
+                       ih_object: handle)
+          handle
+        end
+
+        def emit_delete(context, handle)
+          context.emit(Emf::Emr::Binary::Records::DeleteObject,
+                       i_type: DELETEOBJECT,
+                       ih_object: handle)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require "emf"
+
+module Emfsvg
+  module Translation
+    module Handlers
+      # Translate <text> to CreateFontIndirectW + SetTextColor +
+      # ExtTextOutW + DeleteObject.
+      #
+      # v1 limitations:
+      #   * ASCII / BMP characters only (UTF-16LE encoding).
+      #   * No glyph-index path (ETO_GLYPH_INDEX).
+      #   * No Dx array (character spacing defaults to natural advance).
+      #   * LOGFONT built with default OutPrecision/ClipPrecision/Quality.
+      class TextHandler
+        include SharedGdi
+        include Emf::Emr::Binary::TypeCodes
+
+        LOGFONT_SIZE = 92
+        EXTTEXTOUTW_FIXED_SIZE = 76
+
+        def self.call(element, context)
+          new.translate(element, context)
+        end
+
+        def translate(element, context)
+          return if element.content.nil? || element.content.empty?
+
+          clip_bounds = clip_bounds_for(element, context)
+          wrap_with_clip = !clip_bounds.nil?
+          transformed = element.transformed?
+
+          emit_save_dc(context) if wrap_with_clip || transformed
+          if transformed
+            context.emit(Emf::Emr::Binary::Records::SetWorldTransform,
+                         i_type: SETWORLDTRANSFORM,
+                         xform: context.xform_wire_from(element.transform_matrix))
+          end
+          if wrap_with_clip
+            context.emit(Emf::Emr::Binary::Records::IntersectClipRect,
+                         i_type: INTERSECTCLIPRECT,
+                         rcl_clip: context.rect_l(*clip_bounds))
+          end
+          font_handle = emit_create_font(element, context)
+          emit_set_text_color(element, context)
+          emit_ext_text_out_w(element, context)
+          emit_delete(context, font_handle)
+          emit_restore_dc(context) if wrap_with_clip || transformed
+        end
+
+        private
+
+        def emit_create_font(element, context)
+          handle = context.allocate_handle
+          logfont_bytes = build_logfont(element, context)
+          context.emit(Emf::Emr::Binary::Records::CreateFontIndirectW,
+                       i_type: EXTCREATEFONTINDIRECTW,
+                       ih_object: handle,
+                       body: logfont_bytes)
+          context.emit(Emf::Emr::Binary::Records::SelectObject,
+                       i_type: SELECTOBJECT,
+                       ih_object: handle)
+          handle
+        end
+
+        def emit_set_text_color(element, context)
+          color = element.fill.color.to_emf_wire.to_wire
+          context.emit(Emf::Emr::Binary::Records::SetTextColor,
+                       i_type: SETTEXTCOLOR,
+                       color: color)
+        end
+
+        def emit_ext_text_out_w(element, context)
+          text_utf16 = element.content.encode("UTF-16LE").force_encoding("ASCII-8BIT")
+          n_chars = element.content.length
+          off_string = EXTTEXTOUTW_FIXED_SIZE
+          off_dx = off_string + (n_chars * 2)
+          dx_bytes = ("\x00" * 4) * n_chars # zero Dx — natural advance
+
+          bounds = text_bounds(element, context)
+          # emfsvg's EMF→SVG renderer adds (lfHeight * 0.9) to the
+          # stored y when text-align is TA_TOP (default). Reverse
+          # that adjustment using the SAME scaled lfHeight that
+          # emfsvg will read back so the round-trip y matches.
+          stored_font_height = context.scaler.to_int(element.font_size)
+          adjusted_y = element.y - (stored_font_height * 0.9 / context.scaler.factor)
+          context.emit(Emf::Emr::Binary::Records::ExtTextOutW,
+                       i_type: EXTTEXTOUTW,
+                       rcl_bounds: bounds,
+                       i_graphics_mode: 2, # GM_COMPATIBLE
+                       ex_scale: 1.0,
+                       ey_scale: 1.0,
+                       ptl_reference: context.point_l(element.x, adjusted_y),
+                       n_chars: n_chars,
+                       off_string: off_string,
+                       f_options: 0,
+                       rcl: context.rect_l(0, 0, 0, 0),
+                       off_dx: off_dx,
+                       trailing: text_utf16 + dx_bytes)
+        end
+
+        # Pack a LOGFONT struct (92 bytes) per MS-WMF 2.2.13.
+        def build_logfont(element, context)
+          face_utf16 = (element.font_family || "").encode("UTF-16LE")
+          face_padded = face_utf16.ljust(64, "\x00".encode("UTF-16LE"))
+          face_bytes = face_padded.bytes.pack("C*")[0, 64]
+
+          scaled_height = context.scaler.to_int(element.font_size)
+          [
+            scaled_height, # lfHeight (scaled)
+            0,                                # lfWidth
+            0,                                # lfEscapement
+            0,                                # lfOrientation
+            element.font_weight.to_i,         # lfWeight
+            element.italic? ? 1 : 0,          # lfItalic
+            0,                                # lfUnderline
+            0,                                # lfStrikeOut
+            0,                                # lfCharSet
+            0,                                # lfOutPrecision
+            0,                                # lfClipPrecision
+            0,                                # lfQuality
+            0                                 # lfPitchAndFamily
+          ].pack("l<l<l<l<l<CCCCCCCC") + face_bytes
+        end
+
+        def text_bounds(element, context)
+          width = element.content.length * element.font_size * 0.6
+          context.rect_l(
+            element.x, element.y - element.font_size,
+            element.x + width, element.y
+          )
+        end
+      end
+    end
+  end
+end

data/lib/emfsvg/translation/handlers.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Emfsvg
+  module Translation
+    # Handlers are stateless callables that translate one Svg::Element
+    # subclass into EMF records, operating on a Context. They are
+    # registered in a HandlerRegistry, keyed by element class.
+    module Handlers
+      autoload :SharedGdi, "emfsvg/translation/handlers/shared_gdi"
+      autoload :RectHandler, "emfsvg/translation/handlers/rect_handler"
+      autoload :EllipseHandler, "emfsvg/translation/handlers/ellipse_handler"
+      autoload :CircleHandler, "emfsvg/translation/handlers/circle_handler"
+      autoload :LineHandler, "emfsvg/translation/handlers/line_handler"
+      autoload :PolylineHandler, "emfsvg/translation/handlers/polyline_handler"
+      autoload :PolygonHandler, "emfsvg/translation/handlers/polygon_handler"
+      autoload :PathHandler, "emfsvg/translation/handlers/path_handler"
+      autoload :PathFlattener, "emfsvg/translation/handlers/path_flattener"
+      autoload :GroupHandler, "emfsvg/translation/handlers/group_handler"
+      autoload :TextHandler, "emfsvg/translation/handlers/text_handler"
+      autoload :ImageHandler, "emfsvg/translation/handlers/image_handler"
+      autoload :DefsHandler, "emfsvg/translation/handlers/defs_handler"
+      autoload :ClipPathHandler, "emfsvg/translation/handlers/clip_path_handler"
+    end
+  end
+end

data/lib/emfsvg/translation/header_builder.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "emf"
+
+module Emfsvg
+  module Translation
+    # Constructs Emf::Emr::Binary::Header values from a Svg::Document's
+    # viewport. The header carries the bounds/frame rectangle, device
+    # dimensions, and record counts that the EMF format requires.
+    #
+    # Round-trip contract: the bounds we emit must reproduce the input
+    # SVG's viewport when emfsvg's EMF→SVG renderer reads it back.
+    module HeaderBuilder
+      DEFAULT_DPI = 96.0
+      MM_PER_INCH = 25.4
+
+      module_function
+
+      def build(document, n_records:, n_handles:)
+        bounds = bounds_for(document)
+        frame = frame_for(bounds)
+        Emf::Model::Emr::Header.new(
+          bounds: bounds,
+          frame: frame,
+          signature: 0x464D4520, # " EMF"
+          version: 0x00010000,
+          n_bytes: 0, # filled in by serializer; placeholder
+          n_records: n_records,
+          n_handles: n_handles,
+          s_reserved: 0,
+          n_description: 0,
+          off_description: 0,
+          n_pal_entries: 0,
+          device_pixels: device_pixels_for(document),
+          device_mm: device_mm_for(document),
+          cb_pixel_format: 0,
+          off_pixel_format: 0,
+          b_open_gl: 0,
+          szl_micrometers: device_micrometers_for(document),
+          n_size: 88
+        )
+      end
+
+      def bounds_for(document)
+        min_x, min_y, w, h = document.bounds
+        Emf::Model::Geometry::Rect.new(
+          left: min_x.to_i,
+          top: min_y.to_i,
+          right: (min_x + w).to_i,
+          bottom: (min_y + h).to_i
+        )
+      end
+
+      # Frame is the bounding rectangle in 0.01mm units. Computed from
+      # bounds (pixels) using the document's effective DPI.
+      def frame_for(bounds)
+        units_per_pixel = (100.0 * MM_PER_INCH) / DEFAULT_DPI # 0.01mm per pixel
+        Emf::Model::Geometry::Rect.new(
+          left: (bounds.left * units_per_pixel).to_i,
+          top: (bounds.top * units_per_pixel).to_i,
+          right: (bounds.right * units_per_pixel).to_i,
+          bottom: (bounds.bottom * units_per_pixel).to_i
+        )
+      end
+
+      def device_pixels_for(document)
+        Emf::Model::Geometry::Size.new(
+          cx: document.width.to_i,
+          cy: document.height.to_i
+        )
+      end
+
+      def device_mm_for(document)
+        px_per_mm = DEFAULT_DPI / MM_PER_INCH
+        Emf::Model::Geometry::Size.new(
+          cx: (document.width / px_per_mm).to_i,
+          cy: (document.height / px_per_mm).to_i
+        )
+      end
+
+      def device_micrometers_for(document)
+        Emf::Model::Geometry::Size.new(
+          cx: ((document.width / DEFAULT_DPI) * MM_PER_INCH * 1000).to_i,
+          cy: ((document.height / DEFAULT_DPI) * MM_PER_INCH * 1000).to_i
+        )
+      end
+    end
+  end
+end

data/lib/emfsvg/translation/record_emitter.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "emf"
+
+module Emfsvg
+  module Translation
+    # Builds and collects Emf::Model::Emr::Records::WireAdapter instances.
+    # Each wire record class (Emf::Emr::Binary::Records::*) is constructed
+    # via keyword args; the emitter assigns i_type and computes n_size
+    # from the resulting binary length.
+    #
+    # The emitter is the only place that knows how to construct wire
+    # records — handlers call emitter.build_record(klass, **attrs) and
+    # don't need to manage i_type / n_size / wrapping themselves.
+    class RecordEmitter
+      def initialize
+        @records = []
+      end
+
+      attr_reader :records
+
+      def emit(wire_class, **attrs)
+        record = build(wire_class, **attrs)
+        @records << record
+        record
+      end
+
+      # Construct without appending. Useful for inline inspection in tests.
+      def build(wire_class, **attrs)
+        wire = wire_class.new(**attrs)
+        wire.n_size = wire.to_binary_s.bytesize
+        Emf::Model::Emr::Records::WireAdapter.new(wire: wire)
+      end
+    end
+  end
+end

data/lib/emfsvg/translation/scaler/fixed.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Emfsvg
+  module Translation
+    module Scaler
+      # Fixed-factor scaler: multiplies SVG decimal coords by
+      # `FACTOR` (default 10_000) so 4 decimal places are preserved
+      # as integer fractions in EMF int32 fields. emfsvg's renderer
+      # computes `sf_x = viewport_ext / window_ext = 1 / FACTOR` and
+      # divides back to recover the decimal.
+      #
+      # Choice of 10_000 matches emfsvg's `%.4f` formatting exactly.
+      # Larger factors risk int32 overflow on big coords (max safe
+      # SVG coord ~ 214_000 with FACTOR=10_000).
+      class Fixed
+        FACTOR = 10_000
+        MAX_SAFE_INPUT = 214_748 # (2**31 - 1) / FACTOR, with margin
+
+        attr_reader :factor
+
+        def initialize(factor = FACTOR)
+          @factor = factor
+        end
+
+        def to_int(decimal)
+          (decimal.to_f * factor).round
+        end
+
+        def scaled?
+          true
+        end
+
+        # True if `value` would overflow int32 when scaled. The
+        # renderer falls back to Identity when ANY coord is unsafe.
+        def unsafe?(value)
+          value.to_f.abs > MAX_SAFE_INPUT
+        end
+      end
+    end
+  end
+end

data/lib/emfsvg/translation/scaler/identity.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Emfsvg
+  module Translation
+    module Scaler
+      # Default scaler: truncates SVG decimal coords to int32 1:1.
+      # Matches MM_TEXT map mode (no scaling records emitted).
+      class Identity
+        def to_int(decimal)
+          decimal.to_i
+        end
+
+        def factor
+          1
+        end
+
+        def scaled?
+          false
+        end
+      end
+    end
+  end
+end

data/lib/emfsvg/translation/scaler.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Emfsvg
+  module Translation
+    # Coordinate scalers convert SVG decimal coordinates to EMF int32
+    # coordinates. The default Identity scaler truncates (matching
+    # MM_TEXT mode 1:1). The Fixed scaler multiplies by a constant
+    # factor so decimal places are preserved as integer fractions.
+    #
+    # When the Fixed scaler is in use, the renderer also emits
+    # SetMapMode(MM_ANISOTROPIC) + SetWindowExtEx + SetViewportExtEx
+    # so emfsvg's EMF→SVG renderer computes `sf_x = 1 / factor` and
+    # divides back to recover the original decimal value.
+    module Scaler
+      autoload :Identity, "emfsvg/translation/scaler/identity"
+      autoload :Fixed, "emfsvg/translation/scaler/fixed"
+    end
+  end
+end

data/lib/emfsvg/translation.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Emfsvg
+  # SVG → EMF translation layer. Consumes Svg::* value objects,
+  # produces an Emf::Model::Metafile via wire record construction.
+  module Translation
+    autoload :EmfRenderer, "emfsvg/translation/emf_renderer"
+    autoload :HeaderBuilder, "emfsvg/translation/header_builder"
+    autoload :RecordEmitter, "emfsvg/translation/record_emitter"
+    autoload :Context, "emfsvg/translation/context"
+    autoload :HandlerRegistry, "emfsvg/translation/handler_registry"
+    autoload :Handlers, "emfsvg/translation/handlers"
+    autoload :Scaler, "emfsvg/translation/scaler"
+    autoload :DecimalDetector, "emfsvg/translation/decimal_detector"
+  end
+end

data/lib/emfsvg/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Emfsvg
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

data/lib/emfsvg.rb

@@ -6,6 +6,7 @@ module Emfsvg
   autoload :VERSION, "emfsvg/version"
   autoload :Error, "emfsvg/error"
   autoload :FormatError, "emfsvg/error"
+  autoload :ParseError, "emfsvg/error"
   autoload :RenderError, "emfsvg/error"
   autoload :Renderer, "emfsvg/renderer"
   autoload :DeviceContext, "emfsvg/device_context"
@@ -19,6 +20,10 @@ module Emfsvg
   autoload :BsdRand, "emfsvg/bsd_rand"
   autoload :FormatHelpers, "emfsvg/format_helpers"
   autoload :GlyphIndexMapper, "emfsvg/glyph_index_mapper"
+  autoload :PngDecoder, "emfsvg/png_decoder"
+  autoload :DibEncoder, "emfsvg/dib_encoder"
+  autoload :Svg, "emfsvg/svg"
+  autoload :Translation, "emfsvg/translation"
 
   class << self
     # Render an Emf::Model::Metafile to an SVG string.
@@ -44,5 +49,21 @@ module Emfsvg
     def from_file(path, **options)
       from_bytes(File.binread(path), **options)
     end
+
+    # Translate an Svg::Document to EMF bytes.
+    def to_emf(document)
+      metafile = Translation::EmfRenderer.call(document)
+      Emf.serialize(metafile)
+    end
+
+    # Parse SVG string and translate to EMF bytes.
+    def from_svg(svg_string)
+      to_emf(Svg::Parser.call(svg_string))
+    end
+
+    # Parse SVG from a file path and translate to EMF bytes.
+    def from_svg_file(path)
+      from_svg(File.read(path))
+    end
   end
 end