emfsvg 0.1.2 → 0.1.4

data/lib/emfsvg/svg_builder.rb

@@ -6,7 +6,8 @@ module Emfsvg
   #   - self-closing elements use `/>` (no leading space)
   #   - callers control newlines explicitly via `rawln` / `newline`
   class SvgBuilder
-    def initialize
+    def initialize(max_output_bytes: Renderer::MAX_OUTPUT_BYTES)
+      @max_output_bytes = max_output_bytes
       @out = (+"").force_encoding("ASCII-8BIT")
     end
 
@@ -22,24 +23,25 @@ module Emfsvg
     end
 
     def text(content)
-      @out << escape_text(content)
+      append(escape_text(content))
       self
     end
 
     # Raw append, no newline.
     def raw(string)
-      @out << string
+      append(string)
       self
     end
 
     # Raw append with trailing newline.
     def rawln(string)
-      @out << string << "\n"
+      append(string)
+      append("\n")
       self
     end
 
     def newline
-      @out << "\n"
+      append("\n")
       self
     end
 
@@ -50,20 +52,46 @@ module Emfsvg
     private
 
     def open_tag(name, attrs, single:)
-      @out << "<" << name
+      append("<")
+      append(name)
       attrs.each do |k, v|
         next if v.nil?
 
-        @out << " " << k.to_s << '="' << escape_attr(v.to_s) << '"'
+        append(" ")
+        append(k.to_s)
+        append('="')
+        append(escape_attr(v.to_s))
+        append('"')
       end
-      @out << (single ? "/>" : ">")
+      append(single ? "/>" : ">")
     end
 
     def close_tag(name)
-      @out << "</" << name << ">"
+      append("</")
+      append(name)
+      append(">")
+    end
+
+    def append(string)
+      check_budget(string.bytesize)
+      @out << string
+    end
+
+    def check_budget(additional_bytes)
+      actual = @out.bytesize + additional_bytes
+      return if actual <= @max_output_bytes
+
+      raise ResourceLimitError.new(resource: :output_bytes, limit: @max_output_bytes, actual: actual)
+    end
+
+    def check_escaped_budget(value, attribute: false)
+      additional_bytes = value.bytesize + (value.count("&") * 4) + (value.count("<>") * 3)
+      additional_bytes += value.count('"') * 5 if attribute
+      check_budget(additional_bytes)
     end
 
     def escape_attr(value)
+      check_escaped_budget(value, attribute: true)
       value.gsub("&", "&amp;")
            .gsub("<", "&lt;")
            .gsub(">", "&gt;")
@@ -71,6 +99,7 @@ module Emfsvg
     end
 
     def escape_text(value)
+      check_escaped_budget(value)
       value.gsub("&", "&amp;").gsub("<", "&lt;").gsub(">", "&gt;")
     end
   end

data/lib/emfsvg/translation/context.rb

@@ -16,7 +16,7 @@ module Emfsvg
     # their children uniformly.
     class Context
       attr_reader :device_context, :object_table, :transform_stack, :emitter,
-                  :handler_registry, :clip_path_registry, :scaler
+                  :handler_registry, :clip_path_registry, :scaler, :pattern_handles
 
       def initialize(handler_registry: EmfRenderer::DEFAULT_REGISTRY,
                      clip_path_registry: nil,
@@ -29,6 +29,9 @@ module Emfsvg
         @clip_path_registry = clip_path_registry
         @scaler = scaler
         @next_handle = 1
+        @pattern_handles = {}
+        @unused_clip_safe = true
+        @local_origin = [0, 0]
       end
 
       # Allocate the next 1-indexed GDI object handle. Always increments
@@ -39,37 +42,286 @@ module Emfsvg
         handle
       end
 
-      def emit(wire_class, **attrs)
-        @emitter.emit(wire_class, **attrs)
+      # Includes the reserved zero slot required by the EMF header.
+      def handle_table_size
+        @next_handle
+      end
+
+      CLIP_MUTATIONS = %i[INTERSECTCLIPRECT EXCLUDECLIPRECT EXTSELECTCLIPRGN
+                          OFFSETCLIPRGN SELECTCLIPPATH SETMETARGN].map do |name|
+        Emf::Emr::Binary::TypeCodes.const_get(name)
+      end.freeze
+
+      def emit(wire_class, attrs)
+        # Once an ordinary clip operation occurs, conservatively stop emitting
+        # unused resources. RestoreDC need not be modeled to prove a reset safe.
+        @unused_clip_safe = false if CLIP_MUTATIONS.include?(attrs[:i_type])
+        if @drawing_hint && DrawingHint::DRAW_TYPES.include?(attrs[:i_type])
+          kind, values = @drawing_hint
+          @drawing_hint = nil
+          record = @emitter.build(wire_class, attrs)
+          data = DrawingHint.encode(record, kind, values)
+          @emitter.emit(Emf::Emr::Binary::Records::Comment,
+                        i_type: Emf::Emr::Binary::TypeCodes::COMMENT,
+                        cb_data: data.bytesize, data: data.ljust((data.bytesize + 3) & ~3, "\x00"))
+        end
+        @emitter.emit(wire_class, attrs)
+      end
+
+      def with_drawing_hint(element)
+        @drawing_hint = DrawingHint.for_element(element)
+        yield
+      ensure
+        @drawing_hint = nil
+      end
+
+      def emit_unused_clip_rectangle(bounds)
+        return unless @unused_clip_safe
+
+        # These paired operations leave the known-empty clip unchanged and
+        # introduce no SaveDC snapshot into either native or reference stacks.
+        @emitter.emit(Emf::Emr::Binary::Records::IntersectClipRect,
+                      i_type: Emf::Emr::Binary::TypeCodes::INTERSECTCLIPRECT,
+                      rcl_clip: rect_attrs(*bounds))
+        @emitter.emit(Emf::Emr::Binary::Records::ExtSelectClipRgn,
+                      i_type: Emf::Emr::Binary::TypeCodes::EXTSELECTCLIPRGN,
+                      cb_rgn_data: 0, dw_mode: 5)
+      end
+
+      def preserve_unused_selected_clip(clip)
+        return unless @unused_clip_safe && @handler_registry.equal?(EmfRenderer::DEFAULT_REGISTRY)
+        return unless @clip_path_registry&.unused_selected_clip?(clip)
+
+        @emitter.emit(Emf::Emr::Binary::Records::SelectClipPath,
+                      i_type: Emf::Emr::Binary::TypeCodes::SELECTCLIPPATH, region_mode: 5)
+        @emitter.emit(Emf::Emr::Binary::Records::ExtSelectClipRgn,
+                      i_type: Emf::Emr::Binary::TypeCodes::EXTSELECTCLIPRGN,
+                      cb_rgn_data: 0, dw_mode: 5)
+        true
+      end
+
+      # Registry proves an exclusive drawing tail in a saved identity group.
+      # Its RestoreDC returns to the known-empty clip, so these selections do
+      # not disable preservation of later unused definitions.
+      def begin_selected_clip(group)
+        clip = @clip_path_registry&.selected_clip(group)
+        @selected_clip = clip if clip && @unused_clip_safe
+      end
+
+      def preserve_selected_clip(clip)
+        return unless clip && (@selected_clip.equal?(clip) || (@interval_clip.equal?(clip) && clip.selected_path_data))
+
+        @emitter.emit(Emf::Emr::Binary::Records::SelectClipPath,
+                      i_type: Emf::Emr::Binary::TypeCodes::SELECTCLIPPATH, region_mode: 5)
+        @active_selected_clip = clip
+        true
+      end
+
+      def selected_clip?(clip)
+        clip && @active_selected_clip.equal?(clip)
+      end
+
+      def finish_selected_clip(group)
+        clip = @clip_path_registry&.selected_clip(group)
+        return unless clip
+        return unless clip.equal?(@selected_clip)
+
+        @selected_clip = @active_selected_clip = nil
+      end
+
+      def carried_clip?(clip)
+        clip && @carried_clip.equal?(clip)
+      end
+
+      def carry_clip_from(group)
+        clip = @clip_path_registry&.exported_clip(group)
+        return unless clip && @unused_clip_safe
+
+        @carried_clip = clip
+        @emitter.emit(Emf::Emr::Binary::Records::IntersectClipRect,
+                      i_type: Emf::Emr::Binary::TypeCodes::INTERSECTCLIPRECT,
+                      rcl_clip: rect_attrs(*clip.unused_rectangle_bounds))
+      end
+
+      def finish_carried_clip(group)
+        clip = @clip_path_registry&.imported_clip(group)
+        return unless carried_clip?(clip)
+
+        @emitter.emit(Emf::Emr::Binary::Records::ExtSelectClipRgn,
+                      i_type: Emf::Emr::Binary::TypeCodes::EXTSELECTCLIPRGN,
+                      cb_rgn_data: 0, dw_mode: 5)
+        @carried_clip = nil
       end
 
       def records
         @emitter.records
       end
 
+      # Reuse only the exact tail restore from a compatible complete clipped draw.
+      # Keeping one outer SaveDC/RestoreDC pair also preserves native EMF
+      # popping semantics; nested saves cannot be coalesced this way.
+      def reuse_clip_scope?(signature)
+        previous = @clip_scope_tail
+        @clip_scope_tail = nil
+        return false unless signature && previous
+        return false unless previous[0] == signature && previous[1] == records.size - 1
+        return false unless records.last.equal?(previous[2])
+
+        records.pop
+        true
+      end
+
+      # Complete draws save the previously empty clip and restore it. Only the
+      # renderer's canonical rectangle provenance permits preserving subsequent
+      # unused definitions; ordinary clip mutations remain conservative.
+      def canonical_empty_clip_scope?(element)
+        return false unless @unused_clip_safe && !@carried_clip && !@active_selected_clip
+
+        clip = @clip_path_registry&.lookup(element.clip_path)
+        !!clip&.unused_rectangle_bounds
+      end
+
+      def remember_clip_scope(signature, restore)
+        @unused_clip_safe = true if signature && signature[2]
+        @clip_scope_tail = [signature, records.size - 1, restore] if signature
+      end
+
+      # Move only an adjacent identical text run's terminal deletion. Any
+      # intervening record, including a group boundary, ends the font lifetime.
+      def reuse_text_state(signature)
+        previous = @text_state_tail
+        @text_state_tail = nil
+        return unless signature && previous
+        return unless previous[0] == signature && previous[1] == records.size - 1
+        return unless records.last.equal?(previous[2])
+
+        records.pop
+        previous[3]
+      end
+
+      def remember_text_state(signature, handle, deletion)
+        @text_state_tail = [signature, records.size - 1, deletion, handle] if signature
+      end
+
+      def interval_clip?(clip)
+        clip && @interval_clip.equal?(clip)
+      end
+
+      def with_clip_interval(element)
+        empty_group = empty_interval_group?(element)
+        clip = @clip_path_registry&.interval_start(element) if @handler_registry.equal?(EmfRenderer::DEFAULT_REGISTRY)
+        if clip && (@unused_clip_safe || @interval_clip) && !@carried_clip && !@active_selected_clip
+          @clip_scope_tail = nil
+          (@interval_stack ||= []) << [@interval_clip, @unused_clip_safe]
+          @interval_clip = clip
+          emit(Emf::Emr::Binary::Records::SaveDc, i_type: Emf::Emr::Binary::TypeCodes::SAVEDC)
+          if clip.unused_rectangle_bounds
+            emit(Emf::Emr::Binary::Records::IntersectClipRect,
+                 i_type: Emf::Emr::Binary::TypeCodes::INTERSECTCLIPRECT,
+                 rcl_clip: rect_attrs(*clip.unused_rectangle_bounds))
+          end
+        end
+        yield
+        finish_clip_interval if @interval_clip && @clip_path_registry.interval_end(element).equal?(@interval_clip)
+        # A nested interval leaves snapshots in reference readers. The group's
+        # native RestoreDC returns to its proven empty entry clip.
+        reset_empty_clip if empty_group && empty_clip?
+      end
+
+      def finish_clip_interval
+        emit(Emf::Emr::Binary::Records::RestoreDc,
+             i_type: Emf::Emr::Binary::TypeCodes::RESTOREDC, saved_dc: -1)
+        # Native RestoreDC pops the interval; the reference renderer retains
+        # snapshots. Explicitly resetting its clip agrees with native empty state.
+        @active_selected_clip = nil if @active_selected_clip.equal?(@interval_clip)
+        @interval_clip, @unused_clip_safe = @interval_stack.pop
+        unless @interval_clip
+          reset_empty_clip
+          @unused_clip_safe = true
+        end
+        @clip_scope_tail = nil
+      end
+
+      def empty_interval_group?(element)
+        @handler_registry.equal?(EmfRenderer::DEFAULT_REGISTRY) &&
+          @clip_path_registry&.interval_group?(element) && empty_clip?
+      end
+
+      def empty_clip?
+        @unused_clip_safe && !@interval_clip && !@carried_clip && !@active_selected_clip
+      end
+
+      def reset_empty_clip
+        emit(Emf::Emr::Binary::Records::ExtSelectClipRgn,
+             i_type: Emf::Emr::Binary::TypeCodes::EXTSELECTCLIPRGN, cb_rgn_data: 0, dw_mode: 5)
+      end
+
       # Dispatch an element through the registry. Container handlers
       # (e.g. GroupHandler) call this to recurse into their children.
       def dispatch(element)
         handler = @handler_registry.handler_for(element)
-        handler&.call(element, self)
+        with_clip_interval(element) { handler&.call(element, self) }
       end
 
       # ---- Coordinate-scaled wire helpers (DRY: handlers route all
       # coords through these so the scaler affects everything) ----
 
       def point_l(x, y)
-        Emf::Binary::Types::PointL.new(x: scale_int(x), y: scale_int(y))
+        Emf::Binary::Types::PointL.new(**point_attrs(x, y))
       end
 
       def rect_l(left, top, right, bottom)
-        Emf::Binary::Types::RectL.new(
-          left: scale_int(left), top: scale_int(top),
-          right: scale_int(right), bottom: scale_int(bottom)
-        )
+        Emf::Binary::Types::RectL.new(**rect_attrs(left, top, right, bottom))
       end
 
       def size_l(cx, cy)
-        Emf::Binary::Types::SizeL.new(cx: scale_int(cx), cy: scale_int(cy))
+        Emf::Binary::Types::SizeL.new(**size_attrs(cx, cy))
+      end
+
+      # Viewport origins use device units, while the line's coordinates retain
+      # the fixed logical scale. Explicit reset also supports readers whose
+      # mapping origins are not part of their saved device context.
+      def with_local_origin(origin)
+        return yield unless origin
+
+        previous = @local_origin
+        emit(Emf::Emr::Binary::Records::SaveDc, i_type: Emf::Emr::Binary::TypeCodes::SAVEDC)
+        emit_viewport_origin(origin)
+        @local_origin = origin
+        begin
+          yield
+        ensure
+          @local_origin = previous
+          emit_viewport_origin(previous)
+          emit(Emf::Emr::Binary::Records::RestoreDc,
+               i_type: Emf::Emr::Binary::TypeCodes::RESTOREDC, saved_dc: -1)
+        end
+      end
+
+      def emit_viewport_origin(origin)
+        emit(Emf::Emr::Binary::Records::SetViewportOrgEx,
+             i_type: Emf::Emr::Binary::TypeCodes::SETVIEWPORTORGEX,
+             origin: { x: origin[0], y: origin[1] })
+      end
+      private :emit_viewport_origin
+
+      # Attribute-hash forms of the helpers above. A record field accepts
+      # a Hash and builds its nested value in place, which avoids
+      # constructing a throwaway BinData object per coordinate that the
+      # record would only copy. Handlers use these when emitting.
+      def point_attrs(x, y)
+        { x: scale_int(x - @local_origin[0]), y: scale_int(y - @local_origin[1]) }
+      end
+
+      def rect_attrs(left, top, right, bottom)
+        {
+          left: scale_int(left - @local_origin[0]), top: scale_int(top - @local_origin[1]),
+          right: scale_int(right - @local_origin[0]), bottom: scale_int(bottom - @local_origin[1])
+        }
+      end
+
+      def size_attrs(cx, cy)
+        { cx: scale_int(cx), cy: scale_int(cy) }
       end
 
       # Convert a Matrix to its wire form, scaling the translation

data/lib/emfsvg/translation/decimal_detector.rb

@@ -26,11 +26,13 @@ module Emfsvg
       def any_decimal?(element)
         return false unless element
 
+        return true if explicit_cosmetic_pixel_stroke?(element)
+
         element_attrs = decimal_attrs_for(element)
-        return true if element_attrs.any? { |attr| has_decimal?(element.send(attr)) }
+        return true if element_attrs.any? { |attr| decimal?(element.send(attr)) }
 
         path = path_commands(element)
-        return true if path && path.any? { |cmd| cmd.args.any? { |a| a.is_a?(Float) && a != a.to_i } }
+        return true if path&.any? { |cmd| decimal?(cmd.args) }
 
         element.children.any? { |c| any_decimal?(c) }
       end
@@ -38,15 +40,27 @@ module Emfsvg
       def any_unsafe?(element, scaler)
         return false unless element
 
+        return false if LocalOrigin.for_path(element, scaler)
+
         element_attrs = decimal_attrs_for(element)
         return true if element_attrs.any? { |attr| unsafe_value?(element.send(attr), scaler) }
 
         path = path_commands(element)
-        return true if path && path.any? { |cmd| cmd.args.any? { |a| scaler.unsafe?(a) } }
+        return true if path&.any? { |cmd| cmd.args.any? { |a| scaler.unsafe?(a) } }
 
         element.children.any? { |c| any_unsafe?(c, scaler) }
       end
 
+      # The EMF renderer preserves a cosmetic 1px width only when the
+      # translator uses a map scale. Explicit cap/join attributes
+      # distinguish real pens from the renderer's NULL-pen fallback.
+      def explicit_cosmetic_pixel_stroke?(element)
+        stroke = element.stroke if element.respond_to?(:stroke)
+        stroke && stroke.raw_width == "1px" &&
+          (stroke.line_cap_explicit || stroke.line_join_explicit) &&
+          !stroke.paint.null?
+      end
+
       # Coordinate-bearing attributes per element class. Returns [] for
       # elements with no coords (Group, Defs, etc).
       def decimal_attrs_for(element)
@@ -71,19 +85,23 @@ module Emfsvg
 
       # `value` may be: Float, Integer, Array of [x,y] pairs, Array of
       # PathData::Command, or nil.
-      def has_decimal?(value)
+      def decimal?(value)
         return false if value.nil?
 
         case value
         when Float then !value.finite? || (value != value.to_i)
-        when Integer then false
         when Array
-          value.any? { |v| pair_or_command?(v) ? has_decimal?(v) : v.is_a?(Float) && v != v.to_i }
+          value.any? { |v| decimal?(v) }
+        when Svg::PathData::Command then decimal?(value.args)
         when String then value.match?(/\.\d/)
         else false
         end
       end
 
+      # Former name, kept so existing callers keep working.
+      alias has_decimal? decimal?
+      module_function :has_decimal?
+
       def pair_or_command?(value)
         value.is_a?(Array) || value.is_a?(Svg::PathData::Command)
       end
@@ -92,9 +110,9 @@ module Emfsvg
         return false if value.nil?
 
         case value
-        when Float then scaler.unsafe?(value)
-        when Integer then false
+        when Numeric then scaler.unsafe?(value)
         when Array then value.any? { |v| unsafe_value?(v, scaler) }
+        when Svg::PathData::Command then unsafe_value?(value.args, scaler)
         when String then extract_floats(value).any? { |f| scaler.unsafe?(f) }
         else false
         end

data/lib/emfsvg/translation/emf_renderer.rb

@@ -23,6 +23,10 @@ module Emfsvg
 
       def self.call(document, registry: DEFAULT_REGISTRY)
         new(document, registry: registry).call
+      rescue Scaler::Fixed::Overflow
+        # Derived bounds and relative path points may exceed the source values.
+        # Rebuild the entire record stream in the original unscaled coordinates.
+        new(document, registry: registry, scaler: Scaler::Identity.new).call
       end
 
       def self.register_default_handlers!
@@ -40,10 +44,10 @@ module Emfsvg
         DEFAULT_REGISTRY.register(Svg::Elements::ClipPath, Handlers::ClipPathHandler)
       end
 
-      def initialize(document, registry: DEFAULT_REGISTRY)
+      def initialize(document, registry: DEFAULT_REGISTRY, scaler: nil)
         @document = document
         @registry = registry
-        @scaler = pick_scaler
+        @scaler = scaler || pick_scaler
         @context = Context.new(
           handler_registry: registry,
           clip_path_registry: Svg::ClipPathRegistry.from_document(document),
@@ -57,7 +61,7 @@ module Emfsvg
         emit_eof
         header = HeaderBuilder.build(@document,
                                      n_records: @context.records.size + 1,
-                                     n_handles: @context.object_table.size + 1)
+                                     n_handles: @context.handle_table_size)
         Emf::Model::Metafile.new(
           format: :emf,
           header: header,
@@ -67,15 +71,15 @@ module Emfsvg
 
       private
 
-      # Pick a scaler based on the SVG content. Currently always uses
-      # Identity because the Fixed scaler (which multiplies coords by
-      # 10_000 to preserve decimals) interacts with emfsvg's renderer
-      # in ways that cause record-drops on complex fixtures. The
-      # Scaler::Fixed infrastructure remains available for future use
-      # once the renderer interaction is debugged. The lossy matcher's
-      # float tolerance (1.0px default) already absorbs decimal diffs.
+      # Preserve decimal coordinates and explicit cosmetic 1px pens when
+      # every scaled coordinate fits an int32.
       def pick_scaler
-        Scaler::Identity.new
+        fixed = Scaler::Fixed.new
+        if DecimalDetector.needs_scaling?(@document) && DecimalDetector.safe_for_fixed_scale?(@document, fixed)
+          fixed
+        else
+          Scaler::Identity.new
+        end
       end
 
       # Emit SetMapMode(ANISOTROPIC) + SetWindowExtEx + SetViewportExtEx
@@ -111,7 +115,7 @@ module Emfsvg
         handler = @registry.handler_for(element)
         return descend(element) unless handler
 
-        handler.call(element, @context)
+        @context.with_clip_interval(element) { handler.call(element, @context) }
         descend(element) if descend_after_handler?(handler)
       end
 

data/lib/emfsvg/translation/handler_registry.rb

@@ -11,20 +11,19 @@ module Emfsvg
     class HandlerRegistry
       def initialize
         @handlers = {}
+        @resolved = {}
       end
 
       def register(element_class, handler)
+        @resolved.clear
         @handlers[element_class] = handler
       end
 
+      # Elements of one class share a handler, so each class is resolved
+      # (walking its ancestry) once, until the next registration.
       def handler_for(element)
         klass = element.class
-        while klass
-          return @handlers[klass] if @handlers.key?(klass)
-
-          klass = klass.superclass
-        end
-        nil
+        @resolved.fetch(klass) { @resolved[klass] = resolve(klass) }
       end
 
       def translate(element, context)
@@ -33,6 +32,17 @@ module Emfsvg
 
         handler.call(element, context)
       end
+
+      private
+
+      def resolve(klass)
+        while klass
+          return @handlers[klass] if @handlers.key?(klass)
+
+          klass = klass.superclass
+        end
+        nil
+      end
     end
   end
 end