emfsvg 0.1.2 → 0.1.4

data/lib/emfsvg/visitors/emr_visitor.rb

@@ -95,7 +95,6 @@ module Emfsvg
         Emf::Emr::Binary::Records::DrawEscape => :visit_draw_escape,
         Emf::Emr::Binary::Records::ExtEscape => :visit_ext_escape,
         Emf::Emr::Binary::Records::NamedEscape => :visit_named_escape,
-        Emf::Emr::Binary::Records::SmallTextOut => :visit_small_text_out,
         Emf::Emr::Binary::Records::SetLinkedUfis => :visit_set_linked_ufis,
         Emf::Emr::Binary::Records::ForceUfiMapping => :visit_force_ufi_mapping,
         Emf::Emr::Binary::Records::ColorCorrectPalette => :visit_color_correct_palette,
@@ -129,9 +128,16 @@ module Emfsvg
         Emf::Emr::Binary::Records::PaintRgn => :visit_paint_rgn
       }.freeze
 
+      # Output-space mapping shared by every record: the bounds-to-image
+      # scale, the reference origin and the device pixels per millimetre.
+      Frame = Struct.new(:scaling, :ref_x, :ref_y, :px_per_mm, keyword_init: true) do
+        def initialize(scaling: 1.0, ref_x: 0.0, ref_y: 0.0, px_per_mm: 1.0)
+          super
+        end
+      end
+
       def initialize(builder, dc, object_table, transform_stack, bounds, fix_y, options,
-                     scaling: 1.0, ref_x: 0.0, ref_y: 0.0, px_per_mm: 1.0,
-                     path_actions: {}, path_transforms: {})
+                     frame: Frame.new, path_actions: {}, path_transforms: {})
         @builder = builder
         @dc = dc
         @object_table = object_table
@@ -139,10 +145,10 @@ module Emfsvg
         @bounds = bounds
         @fix_y = fix_y
         @options = options
-        @scaling = scaling
-        @ref_x = ref_x
-        @ref_y = ref_y
-        @px_per_mm = px_per_mm
+        @scaling = frame.scaling
+        @ref_x = frame.ref_x
+        @ref_y = frame.ref_y
+        @px_per_mm = frame.px_per_mm
         @path_actions = path_actions
         @path_transforms = path_transforms
         @current_x = 0
@@ -171,17 +177,24 @@ module Emfsvg
 
       # The Emf wire-record-adapter calls this. Dispatch by wire class.
       def visit_emr_wire_record(adapter)
-        wire = adapter.wire
-        method_name = HANDLERS[wire.class]
+        pending_hint = @pending_drawing_hint
+        @pending_drawing_hint = nil
+        @drawing_hint = pending_hint if pending_hint && pending_hint["record"] == DrawingHint.fingerprint(adapter)
+        klass = RecordAccess.wire_class(adapter)
+        method_name = HANDLERS[klass]
         if method_name
-          send(method_name, wire)
+          send(method_name, RecordAccess.fields(adapter, klass))
         elsif @options.verbose
-          warn "emfsvg: no handler for #{wire.class.name&.split('::')&.last}"
+          warn "emfsvg: no handler for #{klass.name&.split('::')&.last}"
         end
+      rescue ParseError
+        raise
       rescue StandardError => e
         raise unless @options.verbose
 
         warn "emfsvg: handler #{method_name} raised #{e.class}: #{e.message}"
+      ensure
+        @drawing_hint = nil
       end
 
       def flush_open_groups
@@ -237,6 +250,15 @@ module Emfsvg
         FormatHelpers.fmt_xy(x, y)
       end
 
+      # Record fields come back from the parser as BinData primitives, or as
+      # plain numbers from a value view. Device context state is compared
+      # against integer constants on every drawn point, and each such
+      # comparison on a BinData value goes through BinData::Base#==. Unwrap
+      # once when the state is set instead.
+      def int(value)
+        value.is_a?(Numeric) ? value : value.snapshot
+      end
+
       # C integer division truncates toward zero; Ruby's Integer#/ floors.
       # For negative operands the results differ (e.g. -333/2: C=-166,
       # Ruby=-167). This helper replicates C's truncation semantics.
@@ -257,11 +279,11 @@ module Emfsvg
       end
 
       def visit_set_bk_mode(wire)
-        @dc.bk_mode = wire.bk_mode
+        @dc.bk_mode = int(wire.bk_mode)
       end
 
       def visit_set_map_mode(wire)
-        @dc.map_mode = wire.map_mode
+        @dc.map_mode = int(wire.map_mode)
       end
 
       def visit_set_rop2(wire)
@@ -269,15 +291,15 @@ module Emfsvg
       end
 
       def visit_set_poly_fill_mode(wire)
-        @dc.poly_fill_mode = wire.poly_fill_mode
+        @dc.poly_fill_mode = int(wire.poly_fill_mode)
       end
 
       def visit_set_text_align(wire)
-        @dc.text_align = wire.text_align_mode
+        @dc.text_align = int(wire.text_align_mode)
       end
 
       def visit_set_stretch_blt_mode(wire)
-        @dc.stretch_mode = wire.stretch_mode
+        @dc.stretch_mode = int(wire.stretch_mode)
       end
 
       def visit_save_dc(_wire)
@@ -319,10 +341,10 @@ module Emfsvg
       }.freeze
 
       def visit_select_object(wire)
-        ih = wire.ih_object
+        ih = int(wire.ih_object)
 
         # Stock object?
-        if (ih & STOCK_OBJECT_FLAG).positive?
+        if ih.anybits?(STOCK_OBJECT_FLAG)
           index = ih & 0x7FFFFFFF
           apply_stock_object(index)
           return
@@ -363,48 +385,48 @@ module Emfsvg
       end
 
       def visit_delete_object(wire)
-        @object_table.delete(wire.ih_object)
+        @object_table.delete(int(wire.ih_object))
       end
 
       def visit_create_pen(wire)
         pen = Pen.new(
-          style: wire.pen_style,
-          width: wire.width.x,
+          style: int(wire.pen_style),
+          width: int(wire.width.x),
           color: Emf::Model::Geometry::Color.from_wire(wire.color)
         )
-        @object_table.store(wire.ih_pen, :pen, pen)
+        @object_table.store(int(wire.ih_pen), :pen, pen)
       end
 
       def visit_create_brush_indirect(wire)
         brush = Brush.new(
-          style: wire.brush_style,
+          style: int(wire.brush_style),
           color: Emf::Model::Geometry::Color.from_wire(wire.color),
-          hatch: wire.brush_hatch
+          hatch: int(wire.brush_hatch)
         )
-        @object_table.store(wire.ih_brush, :brush, brush)
+        @object_table.store(int(wire.ih_brush), :brush, brush)
       end
 
       def visit_set_window_org_ex(wire)
-        @dc.window_org = [wire.origin.x, wire.origin.y]
+        @dc.window_org = [int(wire.origin.x), int(wire.origin.y)]
       end
 
       def visit_set_window_ext_ex(wire)
-        @dc.window_ext = [wire.extent.cx, wire.extent.cy]
+        @dc.window_ext = [int(wire.extent.cx), int(wire.extent.cy)]
         @dc.window_ext_set = true
       end
 
       def visit_set_viewport_org_ex(wire)
-        @dc.viewport_org = [wire.origin.x, wire.origin.y]
+        @dc.viewport_org = [int(wire.origin.x), int(wire.origin.y)]
       end
 
       def visit_set_viewport_ext_ex(wire)
-        @dc.viewport_ext = [wire.extent.cx, wire.extent.cy]
+        @dc.viewport_ext = [int(wire.extent.cx), int(wire.extent.cy)]
         @dc.viewport_ext_set = true
       end
 
       def visit_move_to_ex(wire)
-        @current_x = wire.origin.x
-        @current_y = wire.origin.y
+        @current_x = int(wire.origin.x)
+        @current_y = int(wire.origin.y)
         return unless @in_path
 
         # In path: emit `M X,Y ` directly to the open d-string.
@@ -416,9 +438,9 @@ module Emfsvg
         if @in_path
           # In path: emit `L X,Y ` to the open d-string, no wrapping.
           @builder.raw("L ")
-          @builder.raw(fmt_xy(cal_x(wire.origin.x), cal_y(wire.origin.y)))
-          @current_x = wire.origin.x
-          @current_y = wire.origin.y
+          @builder.raw(fmt_xy(cal_x(int(wire.origin.x)), cal_y(int(wire.origin.y))))
+          @current_x = int(wire.origin.x)
+          @current_y = int(wire.origin.y)
           return
         end
 
@@ -426,10 +448,10 @@ module Emfsvg
         # C's startPathDraw creates U_POINT (int32) from cur_x/cur_y,
         # truncating any fractional part before point_cal. We must match.
         d = "M #{fmt(cal_x(@current_x.to_i))},#{fmt(cal_y(@current_y.to_i))} "
-        d << "L #{fmt(cal_x(wire.origin.x))},#{fmt(cal_y(wire.origin.y))} "
+        d << "L #{fmt(cal_x(int(wire.origin.x)))},#{fmt(cal_y(int(wire.origin.y)))} "
         emit_path_element(d, closed: false, leading_fill_space: true)
-        @current_x = wire.origin.x
-        @current_y = wire.origin.y
+        @current_x = int(wire.origin.x)
+        @current_y = int(wire.origin.y)
       end
 
       def visit_rectangle(wire)
@@ -473,7 +495,8 @@ module Emfsvg
         end
         rx = scale_dim_x(wire.szl_corner.cx.to_i)
         ry = scale_dim_x(wire.szl_corner.cy.to_i)
-        geom = "x=\"#{fmt(lt_x)}\" y=\"#{fmt(lt_y)}\" width=\"#{fmt(dim_x)}\" height=\"#{fmt(dim_y)}\" rx=\"#{fmt(rx)}\" ry=\"#{fmt(ry)}\""
+        geom = "x=\"#{fmt(lt_x)}\" y=\"#{fmt(lt_y)}\" width=\"#{fmt(dim_x)}\" height=\"#{fmt(dim_y)}\" " \
+               "rx=\"#{fmt(rx)}\" ry=\"#{fmt(ry)}\""
         emit_shape_element("rect", geom)
       end
 
@@ -528,8 +551,8 @@ module Emfsvg
             @builder.raw("L ")
             @builder.raw(point_str(p))
           end
-          @current_x = points.last.x
-          @current_y = points.last.y
+          @current_x = int(points.last.x)
+          @current_y = int(points.last.y)
           return
         end
 
@@ -540,8 +563,8 @@ module Emfsvg
           d << point_str(p)
         end
         emit_path_element(d, closed: false, leading_fill_space: true)
-        @current_x = points.last.x
-        @current_y = points.last.y
+        @current_x = int(points.last.x)
+        @current_y = int(points.last.y)
       end
 
       def visit_poly_bezier(wire)
@@ -580,8 +603,8 @@ module Emfsvg
           end
           emit_bezier_points(points, starting_point: starting_point)
           if points.last
-            @current_x = points.last.x
-            @current_y = points.last.y
+            @current_x = int(points.last.x)
+            @current_y = int(points.last.y)
           end
           return
         end
@@ -595,8 +618,8 @@ module Emfsvg
         emit_path_element(d, closed: false, leading_fill_space: true)
         return unless points.last
 
-        @current_x = points.last.x
-        @current_y = points.last.y
+        @current_x = int(points.last.x)
+        @current_y = int(points.last.y)
       end
 
       # Emit "C p1 p2 p3 C p4 p5 p6 ..." matching cubic_bezier*_draw's
@@ -748,26 +771,30 @@ module Emfsvg
         pt = entry[key]
         return unless pt
 
-        if pt.mode.nil? || pt.mode.zero?
-          @dc.world_transform = pt.matrix
-        else
-          @dc.world_transform = case pt.mode
+        @dc.world_transform = if pt.mode.nil? || pt.mode.zero?
+                                pt.matrix
+                              else
+                                case pt.mode
                                 when 1 then Emf::Model::Geometry::Matrix.identity
                                 when 2 then multiply_matrix(pt.matrix, @dc.world_transform)
                                 when 3 then multiply_matrix(@dc.world_transform, pt.matrix)
                                 else pt.matrix
                                 end
-        end
+                              end
         emit_transform_group(@dc.world_transform)
       end
 
       def visit_set_miter_limit(wire)
-        # MS-EMF spec: iMiterLimit is a uint32 (miter length ratio). The emf
-        # wire parses it as IEEE float, so convert bits back to uint32.
-        @dc.miter_limit = [wire.miter_limit.to_f].pack("f").unpack1("V")
+        limit = wire.miter_limit.to_f
+        # libemf2svg-produced EMFs store this field as the integer payload's
+        # float bit pattern, while native SetMiterLimit records store a float.
+        limit = [limit].pack("f").unpack1("L<") if limit.abs < 1.1754943508222875e-38
+        @dc.miter_limit = limit
       end
 
-      def visit_comment(_wire); end
+      def visit_comment(wire)
+        @pending_drawing_hint = DrawingHint.decode(wire)
+      end
 
       def visit_set_pixel_v(_wire)
         # FLAG_IGNORED in libemf2svg — emits nothing.
@@ -776,7 +803,7 @@ module Emfsvg
       def visit_create_font_indirect_w(wire)
         body = wire.body.to_s
         font = parse_logfont(body, utf16: true)
-        @object_table.store(wire.ih_object, :font, font)
+        @object_table.store(int(wire.ih_object), :font, font)
       end
 
       # Parse a LOGFONT struct from body bytes (MS-WMF 2.2.13).
@@ -796,8 +823,8 @@ module Emfsvg
 
         height = body.unpack1("l<")
         _width = body.unpack("l<", offset: 4)[0]
-        # libemf2svg reduces lfEscapement modulo 3600 (so 3600 → 0, no rotation).
-        escapement = body.unpack("l<", offset: 8)[0] % 3600
+        # C remainder preserves the dividend sign (so -2700 stays -2700).
+        escapement = body.unpack("l<", offset: 8)[0].remainder(3600)
         weight = body.unpack("l<", offset: 16)[0]
         italic = body.getbyte(20) != 0
         underline = body.getbyte(21) != 0
@@ -828,8 +855,8 @@ module Emfsvg
         # Per MS-EMF 2.3.5.37: ETO_NO_RECT (0x100) UNSET means a U_RECTL
         # (16 bytes) precedes the text. ETO_SMALL_CHARS (0x200) selects
         # 8-bit per char instead of 16-bit.
-        text_offset = (fu & 0x100).zero? ? 16 : 0
-        small_chars = (fu & 0x200).positive? # ETO_SMALL_CHARS = 0x200
+        text_offset = fu.nobits?(0x100) ? 16 : 0
+        small_chars = fu.anybits?(0x200) # ETO_SMALL_CHARS = 0x200
         c_chars = wire.c_chars.to_i
         bytes_per_char = small_chars ? 1 : 2
         text_bytes = body[text_offset, c_chars * bytes_per_char]
@@ -852,7 +879,7 @@ module Emfsvg
         if small_chars
           bytes.force_encoding("CP1252").encode("UTF-8", undef: :replace, replace: "?")
         else
-          bytes.force_encoding("UTF-16LE").encode("UTF-8", undef: :replace, replace: "?")
+          decode_utf16_text(bytes)
         end
       end
 
@@ -1098,7 +1125,7 @@ module Emfsvg
         brush = Brush.new(style: Brush::MONOPATTERN,
                           color: @dc.brush.color,
                           image_id: image_id)
-        @object_table.store(wire.ih_brush, :brush, brush)
+        @object_table.store(int(wire.ih_brush), :brush, brush)
       end
 
       # Emit <defs><image id="img-N" .../><pattern id="img-N-ref"
@@ -1166,9 +1193,9 @@ module Emfsvg
             width: width,
             color: Emf::Model::Geometry::Color.new(red: r, green: g, blue: b)
           )
-          @object_table.store(wire.ih_pen, :pen, pen)
+          @object_table.store(int(wire.ih_pen), :pen, pen)
         else
-          @object_table.store(wire.ih_pen, :pen, Pen.new)
+          @object_table.store(int(wire.ih_pen), :pen, Pen.new)
         end
       end
 
@@ -1366,14 +1393,20 @@ module Emfsvg
           region.path_d
         elsif region.bounds
           b = region.bounds
-          pts = [[b.left, b.top], [b.right, b.top],
-                 [b.right, b.bottom], [b.left, b.bottom], [b.left, b.top]]
+          x_left = cal_x(b.left)
+          x_right = cal_x(b.right)
+          y_top = cal_y(b.top)
+          y_bottom = cal_y(b.bottom)
           d = +"M "
-          d << fmt_xy(cal_x(pts.first[0]), cal_y(pts.first[1]))
-          pts[1..].each do |x, y|
-            d << "L "
-            d << fmt_xy(cal_x(x), cal_y(y))
-          end
+          FormatHelpers.append_xy(d, x_left, y_top)
+          d << "L "
+          FormatHelpers.append_xy(d, x_right, y_top)
+          d << "L "
+          FormatHelpers.append_xy(d, x_right, y_bottom)
+          d << "L "
+          FormatHelpers.append_xy(d, x_left, y_bottom)
+          d << "L "
+          FormatHelpers.append_xy(d, x_left, y_top)
           d << "Z "
           d
         else
@@ -1416,7 +1449,7 @@ module Emfsvg
           decoded = raw.pack("C*").force_encoding("UTF-16LE").encode("UTF-8",
                                                                      undef: :replace,
                                                                      replace: "?")
-          if (nul = decoded.index(""))
+          if (nul = decoded.index("\0"))
             decoded = decoded[0, nul]
           end
           decoded.empty? ? nil : decoded
@@ -1435,39 +1468,42 @@ module Emfsvg
 
         (0...bytes.size).step(2).each do |i|
           code = bytes[i] | (bytes[i + 1] << 8)
-          return false if code >= 0xD800 && code <= 0xDFFF
+          return false if code.between?(0xD800, 0xDFFF)
         end
         true
       end
 
-      def emit_ext_text(wire, utf16:)
+      # Decodes the string carried by an EXTTEXTOUT record; "" when the
+      # record holds no (in-range) string bytes.
+      def ext_text_content(wire, utf16:)
         record_bytes = wire.to_binary_s
         off_string = wire.off_string
         n_chars = wire.n_chars
-        f_options = wire.f_options.to_i
-
-        text = if off_string && off_string.positive? && off_string < record_bytes.bytesize
-                 string_bytes = record_bytes[off_string, utf16 ? n_chars * 2 : n_chars]
-                 if string_bytes && !string_bytes.empty?
-                   if (f_options & GlyphIndexMapper::ETO_GLYPH_INDEX).positive?
-                     decode_glyph_indices(string_bytes, n_chars)
-                   elsif utf16
-                     string_bytes.force_encoding("UTF-16LE")
-                                 .encode("UTF-8", undef: :replace, replace: "?")
-                   else
-                     cleaned = string_bytes.bytes.map { |b| b > 0x7F ? 0x20 : b }
-                     cleaned.pack("C*").force_encoding("UTF-8")
-                   end
-                 else
-                   ""
-                 end
-               else
-                 ""
-               end
+        return "" unless off_string&.positive? && off_string < record_bytes.bytesize
+
+        string_bytes = record_bytes[off_string, utf16 ? n_chars * 2 : n_chars]
+        return "" if string_bytes.nil? || string_bytes.empty?
+
+        if wire.f_options.to_i.anybits?(GlyphIndexMapper::ETO_GLYPH_INDEX)
+          decode_glyph_indices(string_bytes, n_chars)
+        elsif utf16
+          decode_utf16_text(string_bytes)
+        else
+          cleaned = string_bytes.bytes.map { |b| b > 0x7F ? 0x20 : b }
+          cleaned.pack("C*").force_encoding("UTF-8")
+        end
+      end
+
+      def decode_utf16_text(string_bytes)
+        string_bytes.force_encoding("UTF-16LE").encode("UTF-8", invalid: :replace, undef: :replace, replace: "?")
+      end
+
+      def emit_ext_text(wire, utf16:)
+        text = ext_text_content(wire, utf16: utf16)
 
         # libemf2svg emits the <text> element even when the string is empty.
-        x = cal_x(wire.ptl_reference.x)
-        y = cal_y(wire.ptl_reference.y)
+        x = cal_x(int(wire.ptl_reference.x))
+        y = cal_y(int(wire.ptl_reference.y))
 
         font = @dc.font
         font_height = scale_dim_x(font.height.to_i).abs
@@ -1490,13 +1526,14 @@ module Emfsvg
         @builder.raw("font-family=\"#{font.face_name}\" ") if font.face_name
         @builder.raw("fill=\"#{rgb_hex(@dc.text_color)}\" ")
 
-        orientation = sf_y > 0 ? -1 : 1
+        orientation = sf_y.positive? ? -1 : 1
         if font.escapement != 0
           # C's integer division truncates toward zero; Ruby's Integer#/ floors.
           # Use float division + truncate to match C exactly for negative values.
           rotation = (orientation.to_f * font.escapement / 10).truncate
           adj_y = y + (font_height * 0.9)
-          @builder.raw("transform=\"rotate(#{rotation}, #{fmt(x)}, #{fmt(adj_y)}) translate(0, #{fmt(font_height * 0.9)})\" ")
+          @builder.raw("transform=\"rotate(#{rotation}, #{fmt(x)}, #{fmt(adj_y)}) " \
+                       "translate(0, #{fmt(font_height * 0.9)})\" ")
         end
 
         @builder.raw("font-style=\"italic\" ") if font.italic
@@ -1517,9 +1554,9 @@ module Emfsvg
         # libemf2svg checks both U_TA_CENTER (0x06) AND U_TA_CENTER2 (0x04)
         # for "middle" anchor. Mask 0x06 doesn't include 0x04, so handle
         # both explicitly to match C.
-        anchor = if (align & 0x06) == 0x06 || (align & 0x04) == 0x04
+        anchor = if align.allbits?(0x06) || align.allbits?(0x04)
                    "middle"
-                 elsif (align & 0x02) == 0x02
+                 elsif align.allbits?(0x02)
                    "end"
                  else
                    "start"
@@ -1528,7 +1565,7 @@ module Emfsvg
 
         # Vertical position: TA_BOTTOM (0x08) or TA_BASELINE (0x18) use Org.y;
         # otherwise add font_height * 0.9.
-        y_pos = if (align & 0x18) == 0x18 || (align & 0x18) == 0x08
+        y_pos = if align.allbits?(0x18) || (align & 0x18) == 0x08
                   y
                 else
                   y + (font_height * 0.9)
@@ -1600,15 +1637,15 @@ module Emfsvg
       # floors. For negative sums (e.g. (-161 + -172) / 2), C gives -166
       # but Ruby gives -167 — a 1-pixel offset. We must replicate C's
       # truncation by converting to float and truncating.
-      def int_el_rad(pt, rect)
+      def int_el_rad(point, rect)
         center_x = c_int_div(rect.right + rect.left, 2)
         center_y = c_int_div(rect.bottom + rect.top, 2)
         radii_x = c_int_div(rect.right - rect.left, 2)
         radii_y = c_int_div(rect.bottom - rect.top, 2)
         return [center_x, center_y] if radii_x.zero? || radii_y.zero?
 
-        pt_no_x = pt.x.to_f - center_x
-        pt_no_y = pt.y.to_f - center_y
+        pt_no_x = point.x.to_f - center_x
+        pt_no_y = point.y.to_f - center_y
 
         if pt_no_x.zero?
           return [center_x, ((pt_no_y.negative? ? -1 : 1) * radii_y) + center_y]
@@ -1697,10 +1734,10 @@ module Emfsvg
         end
         # Mirror libemf2svg's point*_draw: the final emitted point becomes
         # the new current position for subsequent drawing records.
-        if last_pt
-          @current_x = last_pt.x
-          @current_y = last_pt.y
-        end
+        return unless last_pt
+
+        @current_x = int(last_pt.x)
+        @current_y = int(last_pt.y)
       end
 
       def emit_poly_draw(points, types, _point_size:)
@@ -1719,15 +1756,15 @@ module Emfsvg
           i += 1
           case t & 0x07
           when pt_moveto
-            d << "M #{fmt(cal_x(pt.x))} #{fmt(cal_y(pt.y))} "
+            d << "M #{fmt(cal_x(int(pt.x)))} #{fmt(cal_y(int(pt.y)))} "
           when pt_lineto
-            d << "L #{fmt(cal_x(pt.x))} #{fmt(cal_y(pt.y))} "
+            d << "L #{fmt(cal_x(int(pt.x)))} #{fmt(cal_y(int(pt.y)))} "
           when pt_bezierto
             bezier_buf << pt
             if bezier_buf.size == 3
-              d << "C #{fmt(cal_x(bezier_buf[0].x))} #{fmt(cal_y(bezier_buf[0].y))} "
-              d << "#{fmt(cal_x(bezier_buf[1].x))} #{fmt(cal_y(bezier_buf[1].y))} "
-              d << "#{fmt(cal_x(bezier_buf[2].x))} #{fmt(cal_y(bezier_buf[2].y))} "
+              d << "C #{fmt(cal_x(int(bezier_buf[0].x)))} #{fmt(cal_y(int(bezier_buf[0].y)))} "
+              d << "#{fmt(cal_x(int(bezier_buf[1].x)))} #{fmt(cal_y(int(bezier_buf[1].y)))} "
+              d << "#{fmt(cal_x(int(bezier_buf[2].x)))} #{fmt(cal_y(int(bezier_buf[2].y)))} "
               bezier_buf.clear
             end
           end
@@ -1753,7 +1790,8 @@ module Emfsvg
         # libemf2svg's U_EMRSTRETCHDIBITS_draw uses point_cal for both size
         # (cDest) and position (Dest). Match that exactly so window/viewport
         # origins are applied to the dimensions too.
-        geom = "width=\"#{fmt(cal_x(width))}\" height=\"#{fmt(cal_y(height))}\" x=\"#{fmt(cal_x(x))}\" y=\"#{fmt(cal_y(y))}\""
+        geom = "width=\"#{fmt(cal_x(width))}\" height=\"#{fmt(cal_y(height))}\" " \
+               "x=\"#{fmt(cal_x(x))}\" y=\"#{fmt(cal_y(y))}\""
         @builder.raw("<image ")
         @builder.raw(geom)
         @builder.raw(" ")
@@ -1795,6 +1833,8 @@ module Emfsvg
           # chars instead of '=' (the C base64_encode allocates length+3
           # for nulls and the partial-triple bytes default to 0).
           jpeg = result.pixels.to_s
+          return "data:image/jpeg;base64,#{[jpeg].pack('m0')}" if @drawing_hint&.fetch("kind") == "jpeg"
+
           rem = jpeg.bytesize % 3
           jpeg << ("\x00" * ((3 - rem) % 3)) if rem != 0
           "data:image/jpg;base64,#{[jpeg].pack('m0')}"
@@ -1820,6 +1860,13 @@ module Emfsvg
         brush = @dc.brush
         return unless brush.style == Brush::SOLID
 
+        if legacy_rectangle?(wire)
+          values = @drawing_hint.fetch("values")
+          @builder.raw(%(<rect x="#{values[0]}" y="#{values[1]}" width="#{values[2]}" ))
+          @builder.raw(%(height="#{values[3]}" fill="#{values[4]}"/>))
+          return
+        end
+
         style = format("fill:#%02x%02x%02x", brush.color.red, brush.color.green, brush.color.blue)
         size_x = scale_dim_x(wire.cx_dest.to_i)
         size_y = scale_dim_y(wire.cy_dest.to_i)
@@ -1833,6 +1880,15 @@ module Emfsvg
         @builder.raw("Z\" />")
       end
 
+      def legacy_rectangle?(wire)
+        return false unless @drawing_hint&.fetch("kind") == "rect" && wire.dw_rop.to_i == 0x00F00021
+
+        values = @drawing_hint.fetch("values")
+        geometry = [cal_x(wire.x_dest), cal_y(wire.y_dest),
+                    scale_dim_x(wire.cx_dest.to_i), scale_dim_y(wire.cy_dest.to_i)]
+        values.first(4).map(&:to_f) == geometry && values.last == rgb_hex(@dc.brush.color)
+      end
+
       def emit_path_polygon(points, closed:)
         return if points.empty?
 
@@ -1849,8 +1905,8 @@ module Emfsvg
           # Mirror libemf2svg's point*_draw which updates cur_x,cur_y on
           # every emitted point — the LAST point becomes the new current
           # position, used by subsequent PolyBezier/LineTo/etc.
-          @current_x = points.last.x
-          @current_y = points.last.y
+          @current_x = int(points.last.x)
+          @current_y = int(points.last.y)
           return
         end
 
@@ -1861,8 +1917,8 @@ module Emfsvg
           d << point_str(p)
         end
         emit_path_element(d, closed: closed)
-        @current_x = points.last.x
-        @current_y = points.last.y
+        @current_x = int(points.last.x)
+        @current_y = int(points.last.y)
       end
 
       # Emits a <path> element matching libemf2svg's exact byte layout:
@@ -1916,13 +1972,22 @@ module Emfsvg
       end
 
       # Format a single point as libemf2svg's point_draw would: "X,Y "
-      def point_str(p)
-        fmt_xy(cal_x(p.x), cal_y(p.y))
+      def point_str(point)
+        fmt_xy(cal_x(int(point.x)), cal_y(int(point.y)))
       end
 
       # libemf2svg prints colors as `#RRGGBB` always (drops alpha/reserved).
+      # The text depends only on the three channels, so each distinct colour
+      # is formatted once and the frozen string is shared.
       def rgb_hex(color)
-        format("#%02X%02X%02X", color.red, color.green, color.blue)
+        red = color.red
+        green = color.green
+        blue = color.blue
+        return format("#%02X%02X%02X", red, green, blue) unless (red | green | blue).nobits?(-256)
+
+        @rgb_hex_cache ||= {}
+        @rgb_hex_cache[(red << 16) | (green << 8) | blue] ||=
+          format("#%02X%02X%02X", red, green, blue).freeze
       end
 
       # Mirror libemf2svg's clipset_draw: emits " clip-path=\"url(#clip-N)\" "
@@ -1959,19 +2024,16 @@ module Emfsvg
         when Brush::SOLID
           @builder.raw(fill_rule)
           @builder.raw(fill_color_attr(brush))
-          @last_fill_set = true
         when Brush::NULL
           @builder.raw("fill=\"none\" ")
-          @last_fill_set = true
         when Brush::MONOPATTERN
           @builder.raw("fill=\"#img-#{brush.image_id}-ref\" ")
-          @last_fill_set = true
         else
           # BS_HATCHED, BS_PATTERN, etc. — C's default branch emits ONLY the
           # fill attr (fill_rule is computed but discarded).
           @builder.raw(fill_color_attr(brush))
-          @last_fill_set = true
         end
+        @last_fill_set = true
       end
 
       def fill_color_attr(brush)
@@ -2016,7 +2078,8 @@ module Emfsvg
         when Pen::DASHDOT
           @builder.raw("stroke-dasharray=\"#{fmt(dash_len)},#{fmt(dash_len)},#{fmt(dot_len)},#{fmt(dash_len)}\" ")
         when Pen::DASHDOTDOT
-          @builder.raw("stroke-dasharray=\"#{fmt(dash_len)},#{fmt(dash_len)},#{fmt(dot_len)},#{fmt(dot_len)},#{fmt(dot_len)},#{fmt(dash_len)}\" ")
+          @builder.raw("stroke-dasharray=\"#{fmt(dash_len)},#{fmt(dash_len)},#{fmt(dot_len)}," \
+                       "#{fmt(dot_len)},#{fmt(dot_len)},#{fmt(dash_len)}\" ")
         end
 
         # Line cap (bits 8-11)
@@ -2042,7 +2105,10 @@ module Emfsvg
         w = [width.to_i, 1].max
         tmp_w = scale_dim_x(w)
         if (tmp_w / @scaling) < 1.0
-          @builder.raw("stroke-width=\"1px\" ")
+          legacy = @drawing_hint&.fetch("kind") == "stroke" &&
+                   @drawing_hint.fetch("values").first == rgb_hex(@dc.pen.color) &&
+                   (1..4).cover?(@dc.pen.style & 0xFF)
+          @builder.raw("stroke-width=\"#{legacy ? '1.0000' : '1px'}\" ")
         else
           @builder.raw("stroke-width=\"#{fmt(tmp_w)}\" ")
         end
@@ -2115,7 +2181,8 @@ module Emfsvg
         when Pen::DASHDOT
           attrs["stroke-dasharray"] = "#{fmt(dash_len)},#{fmt(dash_len)},#{fmt(dot_len)},#{fmt(dash_len)}"
         when Pen::DASHDOTDOT
-          attrs["stroke-dasharray"] = "#{fmt(dash_len)},#{fmt(dash_len)},#{fmt(dot_len)},#{fmt(dot_len)},#{fmt(dot_len)},#{fmt(dash_len)}"
+          attrs["stroke-dasharray"] =
+            "#{fmt(dash_len)},#{fmt(dash_len)},#{fmt(dot_len)},#{fmt(dot_len)},#{fmt(dot_len)},#{fmt(dash_len)}"
         end
 
         # Line cap (bits 8-11)
@@ -2204,7 +2271,8 @@ module Emfsvg
         end
         dx_scaled = matrix.dx * sf_x * @scaling
         dy_scaled = matrix.dy * sf_y * @scaling
-        @builder.rawln("<g transform=\"matrix(#{fmt(matrix.m11)} #{fmt(matrix.m12)} #{fmt(matrix.m21)} #{fmt(matrix.m22)} #{fmt(dx_scaled)} #{fmt(dy_scaled)})\">")
+        @builder.rawln("<g transform=\"matrix(#{fmt(matrix.m11)} #{fmt(matrix.m12)} #{fmt(matrix.m21)} " \
+                       "#{fmt(matrix.m22)} #{fmt(dx_scaled)} #{fmt(dy_scaled)})\">")
         @open_groups += 1
       end