emf 0.1.2 → 0.2.0

data/lib/emf/model/emr/records.rb

@@ -13,16 +13,142 @@ module Emf
         # `offset` is the byte offset within the source stream (for diagnostics).
         class WireAdapter < Emf::Model::Record
           Emf::Model::Visitor.register_visit(:visit_emr_wire_record, self)
+          include Emf::Model::Emr::WireValues
 
-          def initialize(wire:, offset: nil)
+          # Internal native construction path; the source owns copied Ruby data only.
+          # One per parsed record, so it skips keyword construction; the suffix
+          # is the source's once the wire is made.
+          def self.lazy(source:, offset: nil)
+            allocate.__send__(:init_lazy, source, offset)
+          end
+
+          # Opt-in construction of a wire record from keyword attributes, with
+          # n_size set to the record's size, as `klass.new(**attrs)` followed by
+          # `n_size = num_bytes`. For a class with a PackPlan and attributes it
+          # accepts (values BinData stores unchanged), the adapter holds only the
+          # finished bytes; `to_binary_s` serves them until `#wire` is called,
+          # after which the adapter serializes that wire like any other. Any
+          # other class or attribute shape, or an error while packing, takes the
+          # BinData path unchanged, so the result and the errors are those of
+          # `klass.new`.
+          def self.build(klass, **attrs)
+            filler = Emf::Emr::Binary::FastFill.for_class(klass)
+            bytes = filler && packed_bytes(filler, attrs)
+            return allocate.__send__(:init_lazy, BuiltBytes.new(klass, filler, bytes), nil) if bytes
+
+            wire = klass.new(**attrs)
+            wire.n_size = wire.num_bytes
+            new(wire: wire)
+          end
+
+          def self.packed_bytes(filler, attrs)
+            filler.pack_plan&.pack(attrs)
+          rescue StandardError
+            nil
+          end
+          private_class_method :packed_bytes
+
+          # The lazy source of a record built by `build`: its bytes, and a
+          # wire read back from them when one is asked for.
+          class BuiltBytes
+            def initialize(klass, filler, bytes)
+              @klass = klass
+              @filler = filler
+              @bytes = (bytes.encoding == Encoding::BINARY ? bytes : bytes.b).freeze
+            end
+
+            def type_id
+              @bytes.unpack1("V")
+            end
+
+            def wire_class
+              @klass
+            end
+
+            def value_source
+              [@bytes, 0, true]
+            end
+
+            def to_binary_s
+              @bytes.dup
+            end
+
+            def append_to(out)
+              out << @bytes
+            end
+
+            def materialize
+              @filler.call_at(@bytes, 0, @bytes.bytesize)&.first || @klass.read(@bytes)
+            end
+
+            def suffix(_wire)
+              EMPTY_SUFFIX
+            end
+          end
+
+          # Bytes of a record that follow its typed layout (declared nSize larger
+          # than the layout consumes). Kept verbatim beside the wire.
+          EMPTY_SUFFIX = "".b.freeze
+          private_constant :EMPTY_SUFFIX
+
+          def self.suffix_of(record_bytes, wire)
+            extra = record_bytes.bytesize - wire.num_bytes
+            return EMPTY_SUFFIX unless extra.positive?
+
+            record_bytes.byteslice(-extra, extra).b.freeze
+          end
+
+          def initialize(wire:, offset: nil, suffix: EMPTY_SUFFIX)
             @wire = wire
             @offset = offset
+            @suffix = suffix
           end
 
-          attr_reader :wire, :offset
+          attr_reader :offset
+
+          def wire
+            return @wire if @wire
+
+            @wire = @wire_source.materialize
+            @suffix = @wire_source.suffix(@wire)
+            @wire_source = nil
+            @wire
+          end
+
+          def suffix
+            wire
+            @suffix
+          end
+
+          def to_binary_s
+            return @wire_source.to_binary_s unless @wire
+
+            bytes = @wire.to_binary_s
+            return bytes if @suffix.empty?
+
+            bytes[4, 4] = [bytes.bytesize + @suffix.bytesize].pack("V")
+            bytes + @suffix
+          end
+
+          # Appends this record's wire bytes to `out` (a binary String). A record
+          # still held as bytes appends them without a copy; once `#wire` has
+          # been made the wire is the truth and is packed, so an edit is never
+          # served from stale bytes.
+          def append_to(out)
+            return @wire_source.append_to(out) unless @wire
+
+            return out if @suffix.empty? && @wire.append_built_to?(out)
+
+            out << to_binary_s
+          end
 
           def type_id
-            @wire.i_type
+            @wire ? @wire.i_type : @wire_source.type_id
+          end
+
+          # The wire class of the record, without making the wire.
+          def wire_class
+            @wire ? @wire.class : @wire_source.wire_class
           end
 
           def accept(visitor)
@@ -30,16 +156,26 @@ module Emf
           end
 
           def ==(other)
-            other.is_a?(self.class) && wire.to_binary_s == other.wire.to_binary_s
+            other.is_a?(self.class) && to_binary_s == other.to_binary_s
           end
           alias eql? ==
 
           def hash
-            [self.class, wire.to_binary_s].hash
+            [self.class, to_binary_s].hash
           end
 
           def inspect
-            "#<#{self.class.name} type_id=#{type_id} (#{(@wire.class.name || '').split('::').last})>"
+            "#<#{self.class.name} type_id=#{type_id} (#{(wire.class.name || '').split('::').last})>"
+          end
+
+          private
+
+          def init_lazy(source, offset)
+            @wire = nil
+            @offset = offset
+            @suffix = EMPTY_SUFFIX
+            @wire_source = source
+            self
           end
         end
       end

data/lib/emf/model/emr/wire_values.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Emf
+  module Model
+    module Emr
+      # `WireAdapter#values`: the record's field values as plain frozen Ruby
+      # objects, without making BinData field objects. See
+      # Emf::Emr::Binary::ValueView for the shape.
+      module WireValues
+        # The field values the record holds now, or nil when its wire class
+        # has no value view (variable-layout records such as ExtTextOut,
+        # strings, bitmaps and Raw): use `wire` for those.
+        #
+        # A field of the wire not made yet is still the record's bytes, so
+        # the values are unpacked from them (one String#unpack; kept and
+        # returned again while no field has been made). A field made through
+        # `wire` may have been edited, so it is read from the wire and the
+        # rest from the bytes. An edit through `wire` is always reflected.
+        # Equal on the Ruby and native backends.
+        def values
+          view = Emf::Emr::Binary::ValueView.for_class(@wire ? @wire.class : @wire_source.wire_class)
+          return unless view
+
+          data, base, untouched = byte_source
+          if data
+            found = untouched ? (@values ||= view.from_bytes(data, base)) : view.from_mixed(data, base, @wire)
+            return found if found
+          end
+          view.from_wire(wire)
+        end
+
+        private
+
+        # [data, offset, untouched] of the bytes the record is filled from.
+        def byte_source
+          return @wire_source.value_source unless @wire
+
+          @wire.lazy_source if @wire.respond_to?(:lazy_source)
+        end
+      end
+    end
+  end
+end

data/lib/emf/model/emr.rb

@@ -4,6 +4,7 @@ module Emf
   module Model
     module Emr
       autoload :Header, "emf/model/emr/header"
+      autoload :WireValues, "emf/model/emr/wire_values"
       autoload :Records, "emf/model/emr/records"
     end
   end

data/lib/emf/model/geometry/color.rb

@@ -4,6 +4,20 @@ module Emf
   module Model
     module Geometry
       class Color
+        # One instantiated ColorRef and its field slots, built on first use.
+        module WireTemplate
+          module_function
+
+          def get
+            @get ||= begin
+              sample = Binary::Types::ColorRef.new
+              sample.field_names.each { |name| sample.public_send(name) }
+              [sample, Emf::Emr::Binary::WireCopy.slots(sample)].freeze
+            end
+          end
+        end
+        private_constant :WireTemplate
+
         def initialize(red:, green:, blue:, alpha: 255)
           @red = coerce(red)
           @green = coerce(green)
@@ -17,8 +31,12 @@ module Emf
           new(red: wire.red, green: wire.green, blue: wire.blue, alpha: wire.reserved.zero? ? 255 : wire.reserved)
         end
 
+        # Same ColorRef as `ColorRef.new(red:, green:, blue:, reserved:)`,
+        # built from a copy of one instantiated ColorRef instead of BinData's
+        # lazy construction (the record builders call this once per color).
         def to_wire
-          Binary::Types::ColorRef.new(red: red, green: green, blue: blue, reserved: alpha)
+          template, slots = WireTemplate.get
+          Emf::Emr::Binary::WireCopy.build(template, slots, { red: red, green: green, blue: blue, reserved: alpha })
         end
 
         def to_hex

data/lib/emf/model/metafile.rb

@@ -5,16 +5,25 @@ module Emf
     class Metafile
       include Enumerable
 
-      def initialize(format:, header:, records:, errors: [], emf_plus: nil, trailing: "")
+      def initialize(format:, header:, records:, errors: [], emf_plus: nil, trailing: "", emf_plus_source: nil, diagnostics: [])
         @format = format
         @header = header
         @records = records.freeze
         @errors = errors.freeze
+        @diagnostics = diagnostics.dup.freeze
         @emf_plus = emf_plus
         @trailing = trailing.freeze
+        @emf_plus_source = emf_plus_source
       end
 
-      attr_reader :format, :header, :records, :errors, :emf_plus, :trailing
+      attr_reader :format, :header, :records, :errors, :emf_plus, :trailing, :diagnostics
+
+      # Return a new view while retaining backend-specific lazy sources.
+      def with_diagnostics(diagnostics)
+        copy = dup
+        copy.instance_variable_set(:@diagnostics, diagnostics.dup.freeze)
+        copy
+      end
 
       def each(&block)
         return to_enum unless block
@@ -22,6 +31,17 @@ module Emf
         @records.each(&block)
       end
 
+      # Typed EMF+ view; nil unless this is an EMF+ metafile. Memoised because
+      # the metafile is immutable; `reload: true` rebuilds it from the current comment bytes.
+      # A backend may supply `emf_plus_source` (called with the metafile and `reload`);
+      # a nil result falls back to the Ruby stream.
+      def emf_plus_stream(reload: false)
+        return unless format == :emf_plus
+
+        @emf_plus_stream = nil if reload
+        @emf_plus_stream ||= @emf_plus_source&.call(self, reload) || Emf::EmfPlus::Stream.from_metafile(self)
+      end
+
       def errors?
         !@errors.empty?
       end

data/lib/emf/model/wmf/bitmap_records.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+module Emf
+  module Model
+    module Wmf
+      module Records
+        # Typed bitmap interior (Emf::Wmf::BitmapImage.of); raw `bitmap` stays authoritative.
+        module TypedImage
+          def typed_image = Emf::Wmf::BitmapImage.of(self)
+        end
+
+        class BitBlt < Record
+          include TypedImage
+
+          def initialize(raster_operation:, source_y:, source_x:, height:, width:, destination_y:, destination_x:, bitmap: nil,
+                         reserved: 0, suffix: "".b, offset: nil, type_id: 0x0922)
+            super(type_id: type_id, offset: offset)
+            @raster_operation = raster_operation
+            @source_y = source_y
+            @source_x = source_x
+            @height = height
+            @width = width
+            @destination_y = destination_y
+            @destination_x = destination_x
+            @bitmap = bitmap
+            @reserved = reserved
+            @suffix = suffix
+          end
+
+          attr_accessor :raster_operation, :source_y, :source_x, :height, :width, :destination_y, :destination_x, :bitmap, :reserved,
+                        :suffix
+        end
+
+        class DibBitBlt < Record
+          include TypedImage
+
+          def initialize(raster_operation:, source_y:, source_x:, height:, width:, destination_y:, destination_x:, bitmap: nil,
+                         reserved: 0, suffix: "".b, offset: nil, type_id: 0x0940)
+            super(type_id: type_id, offset: offset)
+            @raster_operation = raster_operation
+            @source_y = source_y
+            @source_x = source_x
+            @height = height
+            @width = width
+            @destination_y = destination_y
+            @destination_x = destination_x
+            @bitmap = bitmap
+            @reserved = reserved
+            @suffix = suffix
+          end
+
+          attr_accessor :raster_operation, :source_y, :source_x, :height, :width, :destination_y, :destination_x, :bitmap, :reserved,
+                        :suffix
+        end
+
+        class StretchBlt < Record
+          include TypedImage
+
+          def initialize(raster_operation:, source_height:, source_width:, source_y:, source_x:, destination_height:,
+                         destination_width:, destination_y:, destination_x:, bitmap: nil, reserved: 0, suffix: "".b, offset: nil,
+                         type_id: 0x0B23)
+            super(type_id: type_id, offset: offset)
+            @raster_operation = raster_operation
+            @source_height = source_height
+            @source_width = source_width
+            @source_y = source_y
+            @source_x = source_x
+            @destination_height = destination_height
+            @destination_width = destination_width
+            @destination_y = destination_y
+            @destination_x = destination_x
+            @bitmap = bitmap
+            @reserved = reserved
+            @suffix = suffix
+          end
+
+          attr_accessor :raster_operation, :source_height, :source_width, :source_y, :source_x, :destination_height, :destination_width,
+                        :destination_y, :destination_x, :bitmap, :reserved, :suffix
+        end
+
+        class DibStretchBlt < Record
+          include TypedImage
+
+          def initialize(raster_operation:, source_height:, source_width:, source_y:, source_x:, destination_height:,
+                         destination_width:, destination_y:, destination_x:, bitmap: nil, reserved: 0, suffix: "".b, offset: nil,
+                         type_id: 0x0B41)
+            super(type_id: type_id, offset: offset)
+            @raster_operation = raster_operation
+            @source_height = source_height
+            @source_width = source_width
+            @source_y = source_y
+            @source_x = source_x
+            @destination_height = destination_height
+            @destination_width = destination_width
+            @destination_y = destination_y
+            @destination_x = destination_x
+            @bitmap = bitmap
+            @reserved = reserved
+            @suffix = suffix
+          end
+
+          attr_accessor :raster_operation, :source_height, :source_width, :source_y, :source_x, :destination_height, :destination_width,
+                        :destination_y, :destination_x, :bitmap, :reserved, :suffix
+        end
+
+        class SetDibToDev < Record
+          include TypedImage
+
+          def initialize(color_usage:, scan_count:, start_scan:, source_y:, source_x:, height:, width:, destination_y:,
+                         destination_x:, bitmap:, suffix: "".b, offset: nil, type_id: 0x0D33)
+            super(type_id: type_id, offset: offset)
+            @color_usage = color_usage
+            @scan_count = scan_count
+            @start_scan = start_scan
+            @source_y = source_y
+            @source_x = source_x
+            @height = height
+            @width = width
+            @destination_y = destination_y
+            @destination_x = destination_x
+            @bitmap = bitmap
+            @suffix = suffix
+          end
+
+          attr_accessor :color_usage, :scan_count, :start_scan, :source_y, :source_x, :height, :width, :destination_y, :destination_x,
+                        :bitmap, :suffix
+        end
+
+        class StretchDib < Record
+          include TypedImage
+
+          def initialize(raster_operation:, color_usage:, source_height:, source_width:, source_y:, source_x:, destination_height:,
+                         destination_width:, destination_y:, destination_x:, bitmap:, suffix: "".b, offset: nil, type_id: 0x0F43)
+            super(type_id: type_id, offset: offset)
+            @raster_operation = raster_operation
+            @color_usage = color_usage
+            @source_height = source_height
+            @source_width = source_width
+            @source_y = source_y
+            @source_x = source_x
+            @destination_height = destination_height
+            @destination_width = destination_width
+            @destination_y = destination_y
+            @destination_x = destination_x
+            @bitmap = bitmap
+            @suffix = suffix
+          end
+
+          attr_accessor :raster_operation, :color_usage, :source_height, :source_width, :source_y, :source_x, :destination_height,
+                        :destination_width, :destination_y, :destination_x, :bitmap, :suffix
+        end
+      end
+    end
+  end
+end

data/lib/emf/model/wmf/brush_records.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Emf
+  module Model
+    module Wmf
+      module Records
+        class CreatePatternBrush < Record
+          def initialize(bitmap_type:, width:, height:, width_bytes:, planes:, bits_pixel:, bits:, reserved:, pattern:,
+                         offset: nil, suffix: "".b, type_id: 0x01F9)
+            super(type_id: type_id, offset: offset)
+            @bitmap_type = bitmap_type
+            @width = width
+            @height = height
+            @width_bytes = width_bytes
+            @planes = planes
+            @bits_pixel = bits_pixel
+            @bits = bits
+            @reserved = reserved
+            @pattern = pattern
+            @suffix = suffix
+          end
+
+          attr_accessor :bitmap_type, :width, :height, :width_bytes, :planes, :bits_pixel, :bits, :reserved, :pattern, :suffix
+        end
+
+        class DibCreatePatternBrush < Record
+          def initialize(style:, color_usage:, target:, offset: nil, type_id: 0x0142)
+            super(type_id: type_id, offset: offset)
+            @style = style
+            @color_usage = color_usage
+            @target = target
+          end
+
+          attr_accessor :style, :color_usage, :target
+
+          # BS_PATTERN (style 3) ignores the stored color usage and always uses RGB colors.
+          def effective_color_usage = style == 3 ? 0 : color_usage
+
+          # Packed DIB view of the raw target (Emf::Wmf::Dib::Image), or nil if unsupported.
+          def target_dib = Emf::Wmf::Dib.parse(target, effective_color_usage)
+        end
+      end
+    end
+  end
+end

data/lib/emf/model/wmf/dc_escape_records.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Emf
+  module Model
+    module Wmf
+      module Records
+        class SaveDc < StateRecord
+          WIRE_FIELDS = [].freeze
+          WIRE_TYPES = [].freeze
+          WIRE_FORMAT = ""
+          PAYLOAD_BYTES = 0
+
+          def initialize(offset: nil, suffix: "".b, type_id: 0x001E)
+            super
+          end
+        end
+
+        class RestoreDc < StateRecord
+          WIRE_FIELDS = %i[saved_dc].freeze
+          WIRE_TYPES = %i[int16].freeze
+          WIRE_FORMAT = "s<"
+          PAYLOAD_BYTES = 2
+
+          def initialize(saved_dc:, offset: nil, suffix: "".b, type_id: 0x0127)
+            super(type_id: type_id, offset: offset, suffix: suffix)
+            @saved_dc = saved_dc
+          end
+
+          attr_accessor :saved_dc
+        end
+
+        # Reserved record: every body byte belongs to the preserved suffix.
+        class SetRelAbs < StateRecord
+          WIRE_FIELDS = [].freeze
+          WIRE_TYPES = [].freeze
+          WIRE_FORMAT = ""
+          PAYLOAD_BYTES = 0
+
+          def initialize(offset: nil, suffix: "".b, type_id: 0x0105)
+            super
+          end
+        end
+
+        # Escape data stays inert, including recognized driver subfunctions.
+        class Escape < Record
+          def initialize(escape_function:, data:, padding: nil, offset: nil, suffix: "".b, type_id: 0x0626)
+            super(type_id: type_id, offset: offset)
+            @escape_function = escape_function
+            @data = data
+            @padding = padding
+            @suffix = suffix
+          end
+
+          attr_accessor :escape_function, :data, :padding, :suffix
+
+          # Read-only typed views; each returns nil when the subtype or layout does not match.
+          def typed_payload = Emf::Wmf::EscapeViews.typed_payload(self)
+          def typed_counted_payload = Emf::Wmf::EscapeViews.typed_counted_payload(self)
+          def typed_special_passthrough2_payload = Emf::Wmf::EscapeViews.typed_special_passthrough2_payload(self)
+
+          # Validated 0x000F segment; raises Emf::Wmf::EmbeddedEmf::Invalid with a reason.
+          def embedded_emf_segment = Emf::Wmf::EmbeddedEmf.segment(self)
+        end
+      end
+    end
+  end
+end

data/lib/emf/model/wmf/font_record.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Emf
+  module Model
+    module Wmf
+      module Records
+        class CreateFontIndirect < ObjectRecord
+          SIGNED_FIELDS = %i[height width escapement orientation weight].freeze
+          BYTE_FIELDS = %i[italic underline strike_out char_set out_precision clip_precision quality pitch_and_family].freeze
+          WIRE_FIELDS = (SIGNED_FIELDS + BYTE_FIELDS + [:face_name]).freeze
+          WIRE_FORMAT = "s<5C8a32"
+          PAYLOAD_BYTES = 50
+
+          def initialize(height:, width:, escapement:, orientation:, weight:, italic:, underline:, strike_out:,
+                         char_set:, out_precision:, clip_precision:, quality:, pitch_and_family:, face_name:,
+                         offset: nil, type_id: 0x02FB, suffix: "")
+            super(type_id: type_id, offset: offset)
+            @height = height
+            @width = width
+            @escapement = escapement
+            @orientation = orientation
+            @weight = weight
+            @italic = italic
+            @underline = underline
+            @strike_out = strike_out
+            @char_set = char_set
+            @out_precision = out_precision
+            @clip_precision = clip_precision
+            @quality = quality
+            @pitch_and_family = pitch_and_family
+            @face_name = face_name
+            @suffix = suffix
+          end
+
+          attr_accessor(*WIRE_FIELDS, :suffix)
+        end
+      end
+    end
+  end
+end