emfsvg 0.1.2 → 0.1.4

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

@@ -3,62 +3,74 @@
 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).
+      # Resolve supported commands to absolute points without joining figures.
       class PathFlattener
-        Result = Struct.new(:shape_kind, :points, :bounds, keyword_init: true)
+        Result = Struct.new(:shape_kind, :points, :bounds, :segments, keyword_init: true)
 
-        def self.flatten(commands)
-          new.flatten(commands)
+        def self.flatten(commands, preserve_initial_line: false)
+          new.flatten(commands, preserve_initial_line: preserve_initial_line)
         end
 
-        def flatten(commands)
+        def flatten(commands, preserve_initial_line: false)
           pen = PenState.new
-          closed = false
-          has_curve = false
-          points = []
-
+          subpaths = []
+          segments = []
           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
+            letter = command.letter.upcase
+            if letter == "M" && segments.any?
+              subpaths << build_result(segments)
+              segments = []
             end
-          end
+            if segments.empty? && letter != "M" && !(preserve_initial_line && subpaths.empty? && letter == "L")
+              segments << ["M", [pen.current.dup]]
+            end
+            if letter == "A"
+              segments.concat(resolve_arc(pen, command))
+              next
+            end
+            points = resolve_command(pen, command)
+            segments << [letter, points] if points
+            next unless letter == "Z"
 
-          Result.new(
-            shape_kind: shape_kind(closed, has_curve),
-            points: points,
-            bounds: bounds_for(points)
-          )
+            pen.close_to(segments.first.last.first)
+            subpaths << build_result(segments)
+            segments = []
+          end
+          subpaths << build_result(segments) unless segments.empty?
+          subpaths
         end
 
         private
 
-        def shape_kind(closed, has_curve)
-          return :polybezier if has_curve
+        def resolve_arc(pen, command)
+          arc_segments = EllipticalArc.to_cubics(pen.current, command.args, absolute: command.absolute?)
+          pen.set_current(command.args.last(2), absolute: command.absolute?)
+          arc_segments.map { |kind, points| [kind == :line ? "L" : "C", points] }
+        end
+
+        def resolve_command(pen, command)
+          case command.letter.upcase
+          when "M", "L" then pen.line_to(command, absolute: command.absolute?)
+          when "H" then pen.h_line_to(command, absolute: command.absolute?)
+          when "V" then pen.v_line_to(command, absolute: command.absolute?)
+          when "C"
+            pen.cubic_to(command, absolute: command.absolute?)
+            return pen.flush_curve_points
+          when "Z" then return []
+          else return nil
+          end
+          [pen.current.dup]
+        end
 
-          closed ? :polygon : :polyline
+        def build_result(segments)
+          points = segments.flat_map(&:last)
+          letters = segments.map(&:first)
+          kind = if letters.include?("C")
+                   (letters - %w[M C]).empty? ? :polybezier : :path
+                 else
+                   letters.last == "Z" ? :polygon : :polyline
+                 end
+          Result.new(shape_kind: kind, points: points, bounds: bounds_for(points), segments: segments)
         end
 
         # Bounds holds raw decimal values (NOT pre-scaled to int). The
@@ -69,9 +81,15 @@ module Emfsvg
         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)
+          left = right = points[0][0]
+          top = bottom = points[0][1]
+          points.each do |x, y|
+            left = x if x < left
+            right = x if x > right
+            top = y if y < top
+            bottom = y if y > bottom
+          end
+          Bounds.new(left: left, top: top, right: right, bottom: bottom)
         end
       end
 
@@ -85,9 +103,12 @@ module Emfsvg
           @pending_curve_points = []
         end
 
-        def move_to(command, absolute:)
-          x, y = command.args
-          @current = absolute ? [x, y] : [@current[0] + x, @current[1] + y]
+        def close_to(point)
+          @current = point.dup
+        end
+
+        def set_current(point, absolute:)
+          @current = absolute ? point.dup : @current.zip(point).map { |origin, delta| origin + delta }
         end
 
         def line_to(command, absolute:)

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

@@ -8,9 +8,8 @@ module Emfsvg
       # 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.
+      # control points and canonical circular arcs are preserved; other
+      # arcs and quads remain unsupported. Separate figures retain their closure and order.
       class PathHandler
         include SharedGdi
         include Emf::Emr::Binary::TypeCodes
@@ -20,28 +19,184 @@ module Emfsvg
         end
 
         def translate(element, context)
-          return if element.commands.empty?
+          return if element.commands.empty? && element.path_record_kind != :stroke_path
 
           with_gdi_state(element, context) do
-            flattened = PathFlattener.flatten(element.commands)
-            emit_path(flattened, element, context)
+            context.with_local_origin(LocalOrigin.for_path(element, context.scaler)) do
+              translate_geometry(element, context)
+            end
           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)
+        def translate_geometry(element, context)
+          if %i[arc chord pie].include?(element.path_record_kind)
+            arc = CircularArc.from_commands(element.commands, kind: element.path_record_kind)
+            if element.path_record_kind == :arc
+              arc ||= MappedArc.from_commands(element.commands, scaler: context.scaler)
+            end
+            if element.path_record_kind == :pie
+              arc ||= MappedPie.from_commands(element.commands,
+                                              scaler: context.scaler)
+            end
           end
+          if arc&.safe_for?(context)
+            arc.emit(context)
+            return
+          end
+
+          flattened = PathFlattener.flatten(element.commands,
+                                            preserve_initial_line: element.path_record_kind == :stroke_path)
+          if element.path_record_kind == :bitblt
+            emit_bitblt(flattened.first, context)
+            return
+          end
+          return emit_current_curve(flattened, context) if element.path_record_kind == :polybezier_to
+          return emit_current_polyline(flattened.first, context) if element.line_record_kind == :polyline_to
+
+          if %i[end_path fill_path stroke_path stroke_and_fill_path].include?(element.path_record_kind)
+            emit_figures(flattened, context, stroke_null: element.stroke.paint.null?, unfilled: element.fill.null?,
+                                             pending: element.path_record_kind == :end_path)
+            return
+          end
+          emit_subpaths(flattened, context,
+                        unfilled: element.fill.null?, stroke_null: element.stroke.paint.null?,
+                        line_record_kind: element.line_record_kind,
+                        path_record_kind: element.path_record_kind)
+        end
+
+        def emit_bitblt(path, context)
+          left, top = path.points.first
+          right, bottom = path.points[2]
+          position = context.point_attrs(left, top)
+          size = context.size_attrs(right - left, bottom - top)
+          context.emit(Emf::Emr::Binary::Records::BitBlt,
+                       i_type: BITBLT, rcl_bounds: context.rect_attrs(left, top, right, bottom),
+                       x_dest: position[:x], y_dest: position[:y],
+                       cx_dest: size[:cx], cy_dest: size[:cy],
+                       dw_rop: 0x00F00021, cb_bits_src: 0)
+        end
+
+        def emit_subpaths(subpaths, context, unfilled:, stroke_null:, line_record_kind:, path_record_kind:)
+          kinds = subpaths.map(&:shape_kind).uniq
+          if unfilled && prefixed_polybezier?(subpaths)
+            first = subpaths.first.points.first
+            context.emit(Emf::Emr::Binary::Records::MoveToEx, i_type: MOVETOEX,
+                                                              origin: context.point_attrs(*first))
+            emit_poly(Emf::Emr::Binary::Records::PolyBezier, POLYBEZIER, subpaths.last, context)
+          elsif subpaths.size > 1 && kinds.size == 1 && %i[polygon polyline].include?(kinds.first)
+            emit_multi(subpaths, kinds.first == :polygon, context)
+          elsif canonical_poly_polygon?(subpaths, path_record_kind, kinds)
+            emit_multi(subpaths, true, context)
+          elsif line_record_kind != :polyline && single_line_path?(subpaths)
+            subpaths.first.segments.each { |letter, points| emit_segment(letter, points, subpaths.first, context) }
+          elsif subpaths.size > 1 || kinds == [:path]
+            emit_figures(subpaths, context, stroke_null: stroke_null, unfilled: unfilled)
+          else
+            flattened = subpaths.first
+            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
+        end
+
+        def prefixed_polybezier?(subpaths)
+          subpaths.size == 2 && subpaths.first.segments.map(&:first) == ["M"] &&
+            subpaths.last.shape_kind == :polybezier
+        end
+
+        def single_line_path?(subpaths)
+          return false unless subpaths.size == 1
+
+          segments = subpaths.first.segments
+          segments.size == 2 && segments.first.first == "M" &&
+            %w[L H V].include?(segments.last.first)
+        end
+
+        def canonical_poly_polygon?(subpaths, path_record_kind, kinds)
+          path_record_kind == :polypolygon && subpaths.size == 1 && kinds == [:polygon]
+        end
+
+        def emit_multi(subpaths, closed, context)
+          points = subpaths.flat_map(&:points).map { |x, y| context.point_attrs(x, y) }
+          context.emit(closed ? Emf::Emr::Binary::Records::PolyPolygon : Emf::Emr::Binary::Records::PolyPolyline,
+                       i_type: closed ? POLYPOLYGON : POLYPOLYLINE,
+                       rcl_bounds: combined_bounds(subpaths, context),
+                       n_polys: subpaths.size, c_ptl_total: points.size,
+                       a_poly_counts: subpaths.map { |path| path.points.size }, aptl: points)
+        end
+
+        def emit_current_curve(subpaths, context)
+          subpaths.each do |path|
+            context.emit(Emf::Emr::Binary::Records::MoveToEx, i_type: MOVETOEX,
+                                                              origin: context.point_attrs(*path.points.first))
+            emit_polybezier_to(path, context)
+          end
+        end
+
+        def emit_polybezier_to(path, context)
+          curve = PathFlattener::Result.new(points: path.points.drop(1), bounds: path.bounds)
+          emit_poly(Emf::Emr::Binary::Records::PolyBezierTo, POLYBEZIERTO, curve, context)
+        end
+
+        def emit_figures(subpaths, context, stroke_null:, unfilled:, pending: false)
+          context.emit(Emf::Emr::Binary::Records::BeginPath, i_type: BEGINPATH)
+          if pending && subpaths.size > 1 && subpaths.all? { |path| path.shape_kind == :polygon }
+            emit_multi(subpaths, true, context)
+          else
+            subpaths.each do |path|
+              path.segments.each { |letter, points| emit_segment(letter, points, path, context) }
+            end
+          end
+          context.emit(Emf::Emr::Binary::Records::EndPath, i_type: ENDPATH)
+          return if pending
+
+          action, i_type = if stroke_null && !unfilled
+                             [Emf::Emr::Binary::Records::FillPath, FILLPATH]
+                           elsif unfilled && !stroke_null
+                             [Emf::Emr::Binary::Records::StrokePath, STROKEPATH]
+                           else
+                             [Emf::Emr::Binary::Records::StrokeAndFillPath, STROKEANDFILLPATH]
+                           end
+          context.emit(action, i_type: i_type, rcl_bounds: combined_bounds(subpaths, context))
+        end
+
+        def emit_segment(letter, points, path, context)
+          case letter
+          when "M", "L", "H", "V"
+            context.emit(letter == "M" ? Emf::Emr::Binary::Records::MoveToEx : Emf::Emr::Binary::Records::LineTo,
+                         i_type: letter == "M" ? MOVETOEX : LINETO,
+                         origin: context.point_attrs(*points.first))
+          when "C"
+            curve = PathFlattener::Result.new(points: points, bounds: path.bounds)
+            emit_poly(Emf::Emr::Binary::Records::PolyBezierTo, POLYBEZIERTO, curve, context)
+          when "Z"
+            context.emit(Emf::Emr::Binary::Records::CloseFigure, i_type: CLOSEFIGURE)
+          end
+        end
+
+        def combined_bounds(subpaths, context)
+          return context.rect_attrs(0, 0, 0, 0) if subpaths.empty?
+
+          bounds = subpaths.map(&:bounds)
+          context.rect_attrs(bounds.map(&:left).min, bounds.map(&:top).min,
+                             bounds.map(&:right).max, bounds.map(&:bottom).max)
         end
 
         def emit_polygon(flattened, context)
           emit_poly(Emf::Emr::Binary::Records::Polygon, POLYGON, flattened, context)
         end
 
+        def emit_current_polyline(path, context)
+          context.emit(Emf::Emr::Binary::Records::MoveToEx, i_type: MOVETOEX,
+                                                            origin: context.point_attrs(*path.points.first))
+          line = PathFlattener::Result.new(points: path.points.drop(1), bounds: path.bounds)
+          emit_poly(Emf::Emr::Binary::Records::PolylineTo, POLYLINETO, line, context)
+        end
+
         def emit_polyline(flattened, context)
           emit_poly(Emf::Emr::Binary::Records::Polyline, POLYLINE, flattened, context)
         end
@@ -55,14 +210,14 @@ module Emfsvg
           if first
             context.emit(Emf::Emr::Binary::Records::MoveToEx,
                          i_type: MOVETOEX,
-                         origin: context.point_l(first[0], first[1]))
+                         origin: context.point_attrs(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(
+          points = flattened.points.map { |x, y| context.point_attrs(x, y) }
+          scaled_bounds = context.rect_attrs(
             flattened.bounds.left, flattened.bounds.top,
             flattened.bounds.right, flattened.bounds.bottom
           )

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

@@ -26,7 +26,7 @@ module Emfsvg
 
         def emit_poly(points, element, context)
           bounds = bounding_box(points, context)
-          wire_points = points.map { |x, y| context.point_l(x, y) }
+          wire_points = points.map { |x, y| context.point_attrs(x, y) }
           record_class = if element.is_a?(Svg::Elements::Polygon)
                            Emf::Emr::Binary::Records::Polygon
                          else
@@ -43,7 +43,7 @@ module Emfsvg
         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)
+          context.rect_attrs(xs.min, ys.min, xs.max, ys.max)
         end
       end
     end

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

@@ -24,12 +24,23 @@ module Emfsvg
         private
 
         def emit_rect(element, context)
-          box = context.rect_l(element.x, element.y,
-                               element.x + element.width,
-                               element.y + element.height)
+          box = context.rect_attrs(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)
+          if raster_fill?(element)
+            # Rectangle's NULL-pen fallback adds a brush-colored outline.
+            # A source-free raster fill retains SVG's fill-only boundary.
+            position = context.point_attrs(element.x, element.y)
+            size = context.size_attrs(element.width, element.height)
+            context.emit(Emf::Emr::Binary::Records::BitBlt,
+                         i_type: BITBLT, rcl_bounds: box,
+                         x_dest: position[:x], y_dest: position[:y],
+                         cx_dest: size[:cx], cy_dest: size[:cy],
+                         dw_rop: 0x00F00021, cb_bits_src: 0)
+          elsif element.rounded?
+            # The pinned C renderer emits szlCorner directly as SVG rx/ry.
+            corner = context.size_attrs(element.rx, element.ry)
             context.emit(Emf::Emr::Binary::Records::RoundRect,
                          i_type: ROUNDRECT, rcl_box: box, szl_corner: corner)
           else
@@ -37,6 +48,11 @@ module Emfsvg
                          i_type: RECTANGLE, rcl_box: box)
           end
         end
+
+        def raster_fill?(element)
+          !element.rounded? && element.clip_path.nil? &&
+            element.stroke.paint.null? && element.fill.style == Svg::Paint::SOLID
+        end
       end
     end
   end

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

@@ -14,27 +14,72 @@ module Emfsvg
       # 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.
+      # wrapped in SaveDC + IntersectClipRect + RestoreDC. Adjacent built-in
+      # drawings that install all state they read can share that single scope.
       module SharedGdi
         include Emf::Emr::Binary::TypeCodes
 
-        def with_gdi_state(element, context)
+        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
+          signature = clip_scope_signature(element, context, clip_bounds)
+          reuse_clip = context.reuse_clip_scope?(signature)
+          emit_save_dc(context) if wrap_with_clip && !reuse_clip
+          if element.stroke && !element.stroke.paint.null?
+            context.emit(Emf::Emr::Binary::Records::SetMiterLimit,
+                         i_type: SETMITERLIMIT,
+                         miter_limit: serialized_miter_limit(element))
+          end
           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
+          brush = element.stroke&.fallback_brush || element.fill
+          brush_handle = emit_create_brush(context, brush) if brush
+          if wrap_with_clip && !reuse_clip
             context.emit(Emf::Emr::Binary::Records::IntersectClipRect,
                          i_type: INTERSECTCLIPRECT,
-                         rcl_clip: context.rect_l(*clip_bounds))
+                         rcl_clip: context.rect_attrs(*clip_bounds))
           end
-          yield
+          context.with_drawing_hint(element, &)
           emit_delete(context, pen_handle) if pen_handle
           emit_delete(context, brush_handle) if brush_handle
-          emit_restore_dc(context) if wrap_with_clip
+          return unless wrap_with_clip
+
+          restore = emit_restore_dc(context)
+          context.remember_clip_scope(signature, restore)
+        end
+
+        def serialized_miter_limit(element)
+          limit = element.stroke.miter_limit
+          return limit unless element.is_a?(Svg::Elements::Path)
+
+          cubic_figure = element.path_record_kind == :stroke_path &&
+                         element.commands.any? { |command| command.letter == "C" }
+          return limit unless element.line_record_kind == :polyline_to || cubic_figure
+          return limit unless limit.between?(1, 0x7FFFFF) && limit == limit.to_i
+
+          # Canonical PolylineTo and cubic StrokePath use libuemf's integer wire contract.
+          # The dependency exposes a float field; subnormal bits preserve the
+          # integer payload, which our reader also recognizes. Other limits
+          # retain floats rather than truncating or exceeding that reader range.
+          [limit.to_i].pack("V").unpack1("e")
+        end
+
+        def clip_scope_signature(element, context, clip_bounds)
+          return unless clip_bounds && complete_draw_state?(element)
+
+          [:complete_draw, context.rect_attrs(*clip_bounds), context.canonical_empty_clip_scope?(element)]
+        end
+
+        def complete_draw_state?(element)
+          # Exact built-ins opt in: custom handlers may depend on inherited
+          # state. Shapes install pen/brush/miter and absolute geometry;
+          # untransformed text installs font/color/alignment and its position.
+          # Images use explicit DIB data and destination geometry.
+          return !element.transformed? if instance_of?(TextHandler)
+          return true if instance_of?(ImageHandler)
+
+          [PathHandler, RectHandler, EllipseHandler, LineHandler,
+           PolylineHandler, PolygonHandler].include?(self.class) && element.stroke && element.fill
         end
 
         def clip_bounds_for(element, context)
@@ -45,6 +90,7 @@ module Emfsvg
 
           clip = context.clip_path_registry.lookup(attr)
           return nil unless clip
+          return nil if context.carried_clip?(clip) || context.selected_clip?(clip) || context.interval_clip?(clip)
 
           clip.clip_bounds
         end
@@ -60,12 +106,20 @@ module Emfsvg
 
         def emit_create_pen(context, stroke)
           handle = context.allocate_handle
+          width = if stroke.canonical_cosmetic_dash
+                    # Cosmetic dash lengths use stored width without coordinate mapping.
+                    { x: stroke.canonical_cosmetic_dash[0], y: 0 }
+                  elsif stroke.cosmetic_pixel_width?
+                    { x: 1, y: 0 }
+                  else
+                    context.point_attrs(stroke.width, 0)
+                  end
           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)
+                       width: width,
+                       color: stroke.paint.color.wire_attrs)
           context.emit(Emf::Emr::Binary::Records::SelectObject,
                        i_type: SELECTOBJECT,
                        ih_object: handle)
@@ -73,12 +127,21 @@ module Emfsvg
         end
 
         def emit_create_brush(context, paint)
+          if paint.reference
+            handle = context.pattern_handles.fetch(paint.reference) do
+              raise FormatError, "undefined SVG pattern: #{paint.reference.inspect}"
+            end
+            context.emit(Emf::Emr::Binary::Records::SelectObject, i_type: SELECTOBJECT, ih_object: handle)
+            # Definition brushes remain available for subsequent draws.
+            return nil
+          end
+
           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,
+                       color: paint.color.wire_attrs,
                        brush_hatch: 0)
           context.emit(Emf::Emr::Binary::Records::SelectObject,
                        i_type: SELECTOBJECT,