emfsvg 0.1.3 → 0.1.4

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,

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

@@ -25,32 +25,71 @@ module Emfsvg
         end
 
         def translate(element, context)
-          return if element.content.nil? || element.content.empty?
+          return if element.content.nil?
+          return if element.content.empty? && !element.empty_cdata_content && !element.font_size.zero?
 
           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
+          signature = clip_scope_signature(element, context, clip_bounds)
+          reuse_clip = context.reuse_clip_scope?(signature)
+          emit_save_dc(context) if (wrap_with_clip || transformed) && !reuse_clip
           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
+          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
-          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
+          emit_mapped_text(element, context, reuse: !wrap_with_clip && !transformed)
+          return unless wrap_with_clip || transformed
+
+          restore = emit_restore_dc(context)
+          context.remember_clip_scope(signature, restore)
         end
 
         private
 
+        def emit_mapped_text(element, context, reuse:)
+          rotation = element.canonical_text_rotation
+          @text_scaler = context.scaler
+          if rotation&.native_height && context.scaler.scaled?
+            finer = Scaler::Fixed.new(1_000_000)
+            values = [element.x, rotation.native_y, rotation.native_height,
+                      element.x + (element.content.length * element.font_size * 0.6), element.y - element.font_size]
+            @text_scaler = finer unless values.any? { |value| finer.unsafe?(value) }
+          end
+          return emit_text(element, context, reuse: reuse) if @text_scaler.equal?(context.scaler)
+
+          emit_save_dc(context)
+          context.emit(Emf::Emr::Binary::Records::SetWindowExtEx,
+                       i_type: SETWINDOWEXTEX, extent: { cx: @text_scaler.factor, cy: @text_scaler.factor })
+          emit_text(element, context, reuse: false)
+          # Both renderers keep mapping extents outside the saved drawing state.
+          context.emit(Emf::Emr::Binary::Records::SetWindowExtEx,
+                       i_type: SETWINDOWEXTEX, extent: { cx: context.scaler.factor, cy: context.scaler.factor })
+          emit_restore_dc(context)
+        end
+
+        def emit_text(element, context, reuse:)
+          # Packed LOGFONT includes rotation, weight, size, family and italic;
+          # positions and content may vary without changing selected GDI state.
+          signature = [build_logfont(element, context), element.fill.color.wire_attrs, text_align(element)] if reuse
+          font_handle = context.reuse_text_state(signature)
+          unless font_handle
+            font_handle = emit_create_font(element, context)
+            emit_set_text_color(element, context)
+            emit_set_text_align(element, context)
+          end
+          emit_ext_text_out_w(element, context)
+          deletion = emit_delete(context, font_handle)
+          context.remember_text_state(signature, font_handle, deletion)
+        end
+
         def emit_create_font(element, context)
           handle = context.allocate_handle
           logfont_bytes = build_logfont(element, context)
@@ -65,52 +104,78 @@ module Emfsvg
         end
 
         def emit_set_text_color(element, context)
-          color = element.fill.color.to_emf_wire.to_wire
+          color = element.fill.color.wire_attrs
           context.emit(Emf::Emr::Binary::Records::SetTextColor,
                        i_type: SETTEXTCOLOR,
                        color: color)
         end
 
+        def text_align(element)
+          vertical = element.canonical_text_rotation&.vertical_alignment == :top ? 0 : 0x18
+          horizontal = case element.text_anchor
+                       when "middle" then 0x06
+                       when "end" then 0x02
+                       else 0
+                       end
+          vertical | horizontal
+        end
+
+        def emit_set_text_align(element, context)
+          context.emit(Emf::Emr::Binary::Records::SetTextAlign,
+                       i_type: SETTEXTALIGN,
+                       text_align_mode: text_align(element))
+        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)
+          # The Dx array starts on a DWORD boundary, including after odd-length text.
+          off_dx = (off_string + text_utf16.bytesize + 3) & ~3
           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),
+                       ptl_reference: {
+                         x: @text_scaler.to_int(element.x), y: @text_scaler.to_int(reference_y(element))
+                       },
                        n_chars: n_chars,
                        off_string: off_string,
                        f_options: 0,
-                       rcl: context.rect_l(0, 0, 0, 0),
+                       rcl: context.rect_attrs(0, 0, 0, 0),
                        off_dx: off_dx,
-                       trailing: text_utf16 + dx_bytes)
+                       trailing: text_utf16.ljust(off_dx - off_string, "\x00") + dx_bytes)
+        end
+
+        def reference_y(element)
+          rotation = element.canonical_text_rotation
+          return rotation.native_y if rotation&.native_y && @text_scaler.scaled? && @text_scaler.factor == 1_000_000
+          return element.y unless rotation&.vertical_alignment == :top
+
+          element.y - (element.font_size * 0.9)
         end
 
         # Pack a LOGFONT struct (92 bytes) per MS-WMF 2.2.13.
-        def build_logfont(element, context)
+        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)
+          height = if @text_scaler.scaled? && @text_scaler.factor == 1_000_000
+                     element.canonical_text_rotation&.native_height || element.font_size
+                   else
+                     element.font_size
+                   end
+          scaled_height = @text_scaler.to_int(height)
           [
             scaled_height, # lfHeight (scaled)
-            0,                                # lfWidth
-            0,                                # lfEscapement
+            0, # lfWidth
+            element.canonical_text_rotation&.escapement || (-element.font.rotation.to_i * 10), # tenths of a degree
             0,                                # lfOrientation
             element.font_weight.to_i,         # lfWeight
             element.italic? ? 1 : 0,          # lfItalic
@@ -124,12 +189,10 @@ module Emfsvg
           ].pack("l<l<l<l<l<CCCCCCCC") + face_bytes
         end
 
-        def text_bounds(element, context)
+        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
-          )
+          { left: @text_scaler.to_int(element.x), top: @text_scaler.to_int(element.y - element.font_size),
+            right: @text_scaler.to_int(element.x + width), bottom: @text_scaler.to_int(element.y) }
         end
       end
     end

data/lib/emfsvg/translation/handlers.rb

@@ -14,6 +14,11 @@ module Emfsvg
       autoload :PolylineHandler, "emfsvg/translation/handlers/polyline_handler"
       autoload :PolygonHandler, "emfsvg/translation/handlers/polygon_handler"
       autoload :PathHandler, "emfsvg/translation/handlers/path_handler"
+      autoload :MappedCircularArc, "emfsvg/translation/handlers/mapped_circular_arc"
+      autoload :MappedArc, "emfsvg/translation/handlers/mapped_arc"
+      autoload :MappedPie, "emfsvg/translation/handlers/mapped_pie"
+      autoload :CircularArc, "emfsvg/translation/handlers/circular_arc"
+      autoload :EllipticalArc, "emfsvg/translation/handlers/elliptical_arc"
       autoload :PathFlattener, "emfsvg/translation/handlers/path_flattener"
       autoload :GroupHandler, "emfsvg/translation/handlers/group_handler"
       autoload :TextHandler, "emfsvg/translation/handlers/text_handler"

data/lib/emfsvg/translation/header_builder.rb

@@ -42,6 +42,8 @@ module Emfsvg
       end
 
       def bounds_for(document)
+        return legacy_bounds_for(document) if legacy_header?(document)
+
         min_x, min_y, w, h = document.bounds
         Emf::Model::Geometry::Rect.new(
           left: min_x.to_i,
@@ -51,6 +53,24 @@ module Emfsvg
         )
       end
 
+      # Legacy broken-Y header: the original signed bounds are not
+      # recoverable, so emit the canonical equivalent [-1, -1, w-2, h-2],
+      # which renders back to the same header and viewport. Only for
+      # integral dimensions greater than 2; anything else keeps the
+      # ordinary path.
+      def legacy_header?(document)
+        document.view_box.nil? &&
+          document.legacy_broken_y_header? &&
+          [document.width, document.height].all? { |d| (d % 1).zero? && d > 2 }
+      end
+
+      def legacy_bounds_for(document)
+        Emf::Model::Geometry::Rect.new(
+          left: -1, top: -1,
+          right: document.width.to_i - 2, bottom: document.height.to_i - 2
+        )
+      end
+
       # Frame is the bounding rectangle in 0.01mm units. Computed from
       # bounds (pixels) using the document's effective DPI.
       def frame_for(bounds)