emf 0.1.2 → 0.2.0

data/lib/emf/emr/binary/records/set_icm_profile_w.rb

@@ -1,15 +1,85 @@
 # frozen_string_literal: true
 
 require "bindata"
+require "emf/emr/binary/variable_buffers"
 require "emf/emr/binary/record"
 
 module Emf
   module Emr
     module Binary
       module Records
-        # Stub: preserves full body bytes. Full layout lands with TODO 10.
+        # MS-EMF 2.3.11.16: name and profile lengths are byte counts.
         class SetIcmProfileW < Emf::Emr::Binary::Record
+          include Emf::Emr::Binary::VariableBuffers
+
+          fixed_layout 20
+          variable_buffer :icm_name_bytes, offset: 20, length: -> { u32_at(12) }
+          variable_buffer :icm_profile_bytes, offset: -> { 20 + u32_at(12) }, length: -> { u32_at(16) }
+
+          # Byte counts and opaque spans retain the original body layout.
           rest :body
+
+          def dw_flags
+            profile_prefix.unpack1("V")
+          end
+
+          def dw_flags=(value)
+            raise ArgumentError, "color profile flags must be an Integer" unless value.is_a?(Integer)
+            raise RangeError, "color profile flags must fit an unsigned 32-bit integer" unless (0..0xFFFFFFFF).cover?(value)
+
+            write_profile_bytes(0, 4, [value].pack("V"))
+          end
+
+          def cb_name
+            profile_prefix.byteslice(4, 4).unpack1("V")
+          end
+
+          def cb_data
+            profile_prefix.byteslice(8, 4).unpack1("V")
+          end
+
+          def name_bytes
+            read_profile_bytes(12, cb_name)
+          end
+
+          def name_bytes=(value)
+            write_profile_bytes(12, cb_name, value)
+          end
+
+          def profile_bytes
+            read_profile_bytes(12 + cb_name, cb_data)
+          end
+
+          def profile_bytes=(value)
+            write_profile_bytes(12 + cb_name, cb_data, value)
+          end
+
+          private
+
+          def profile_prefix
+            bytes = body.to_s
+            raise ArgumentError, "truncated color profile prefix" if bytes.bytesize < 12
+
+            bytes
+          end
+
+          def read_profile_bytes(offset, length)
+            bytes = profile_prefix
+            raise ArgumentError, "truncated color profile span" if offset + length > bytes.bytesize
+
+            bytes.byteslice(offset, length).b
+          end
+
+          def write_profile_bytes(offset, length, value)
+            read_profile_bytes(offset, length)
+            unless value.is_a?(String) && value.bytesize == length
+              raise ArgumentError, "color profile value must be a String of #{length} bytes"
+            end
+
+            bytes = body.to_s.b
+            bytes[offset, length] = value.b
+            self.body = bytes
+          end
         end
       end
     end

data/lib/emf/emr/binary/records/set_linked_ufis.rb

@@ -7,9 +7,57 @@ module Emf
   module Emr
     module Binary
       module Records
-        # Stub: preserves full body bytes. Full layout lands with TODO 10.
+        # Linked identifiers preserve the declared count and ignored reserved bytes.
         class SetLinkedUfis < Emf::Emr::Binary::Record
           rest :body
+
+          def u_num_linked_ufi
+            bytes = body.to_s
+            raise ArgumentError, "truncated linked UFI count" if bytes.bytesize < 4
+
+            bytes.unpack1("V")
+          end
+
+          [[:ufi_checksum, 0], [:ufi_index, 4]].each do |name, offset|
+            define_method(name) do |index|
+              position = ufi_position(index)
+              body.to_s.byteslice(position + offset, 4).unpack1("V")
+            end
+
+            define_method("set_#{name}") do |index, value|
+              position = ufi_position(index)
+              raise ArgumentError, "UFI value must be an Integer" unless value.is_a?(Integer)
+              raise RangeError, "UFI value must fit an unsigned 32-bit integer" unless (0..0xFFFFFFFF).cover?(value)
+
+              replace_ufi_bytes(position + offset, 4, [value].pack("V"))
+            end
+          end
+
+          def ufi_bytes(index)
+            body.to_s.byteslice(ufi_position(index), 8).b
+          end
+
+          def set_ufi_bytes(index, value)
+            replace_ufi_bytes(ufi_position(index), 8, value)
+          end
+
+          private
+
+          def ufi_position(index)
+            count = u_num_linked_ufi
+            raise ArgumentError, "truncated linked UFI array or reserved bytes" if 12 + (count * 8) > body.to_s.bytesize
+            raise ArgumentError, "UFI index must identify a declared entry" unless index.is_a?(Integer) && index >= 0 && index < count
+
+            4 + (index * 8)
+          end
+
+          def replace_ufi_bytes(offset, length, value)
+            raise ArgumentError, "UFI value must be a String of #{length} bytes" unless value.is_a?(String) && value.bytesize == length
+
+            replacement = body.to_s.b
+            replacement[offset, length] = value.b
+            self.body = replacement
+          end
         end
       end
     end

data/lib/emf/emr/binary/records/set_miter_limit.rb

@@ -8,7 +8,7 @@ module Emf
     module Binary
       module Records
         class SetMiterLimit < Emf::Emr::Binary::Record
-          float :miter_limit
+          float32_le :miter_limit
         end
       end
     end

data/lib/emf/emr/binary/records/set_palette_entries.rb

@@ -2,14 +2,32 @@
 
 require "bindata"
 require "emf/emr/binary/record"
+require "emf/emr/binary/palette_body"
+require "emf/emr/binary/palette_entry"
 
 module Emf
   module Emr
     module Binary
       module Records
-        # Stub: preserves full body bytes. Full layout lands with TODO 10.
         class SetPaletteEntries < Emf::Emr::Binary::Record
-          rest :body
+          uint32 :ih_pal
+          uint32 :start
+          uint32 :entry_count
+          array :palette_entries, type: :emr_palette_entry, initial_length: :entry_count
+          rest :trailing
+
+          def body
+            PaletteBody.new(self, to_binary_s.byteslice(8..))
+          end
+
+          def body=(value)
+            bytes = value.to_s
+            count = bytes.byteslice(8, 4)&.unpack1("V")
+            raise ArgumentError, "invalid palette body entry count" unless count && bytes.bytesize >= 12 + (count * 4)
+
+            replacement = self.class.read(to_binary_s.byteslice(0, 8) + bytes)
+            assign(replacement.snapshot)
+          end
         end
       end
     end

data/lib/emf/emr/binary/records/set_text_justification.rb

@@ -2,14 +2,20 @@
 
 require "bindata"
 require "emf/emr/binary/record"
+require "emf/emr/binary/state_record_body"
 
 module Emf
   module Emr
     module Binary
       module Records
-        # Stub: preserves full body bytes. Full layout lands with TODO 10.
         class SetTextJustification < Emf::Emr::Binary::Record
-          rest :body
+          include StateRecordBody
+
+          BODY_SIZE = 8
+
+          int32 :n_break_extra
+          int32 :n_break_count
+          rest :trailing
         end
       end
     end

data/lib/emf/emr/binary/records/small_text_out.rb

@@ -10,17 +10,68 @@ module Emf
         # EMRSMALLTEXTOUT (MS-EMF 2.3.5.37).
         # Layout: emr, Dest, cChars, fuOptions, iGraphicsMode, exScale (float),
         # eyScale (float), [optional RECTL], TextString (1 or 2 bytes per char).
-        # The body bytes (after the fixed header) are deferred to the visitor
-        # for parsing because the layout depends on fuOptions.
+        # Option-dependent bounds and text are exposed as raw bytes while the
+        # body retains the original wire layout and any trailing bytes.
         class SmallTextOut < Emf::Emr::Binary::Record
           int32 :x_dest
           int32 :y_dest
           uint32 :c_chars
           uint32 :fu_options
           uint32 :i_graphics_mode
-          float :ex_scale
-          float :ey_scale
+          float32_le :ex_scale
+          float32_le :ey_scale
           rest :body
+
+          def bounds
+            return nil if no_rectangle?
+
+            available_body(16).byteslice(0, 16).b
+          end
+
+          def bounds=(value)
+            raise ArgumentError, "small text output has no bounds rectangle" if no_rectangle?
+
+            write_body_bytes(0, 16, value)
+          end
+
+          def text_bytes
+            offset, length = text_region
+            available_body(offset + length).byteslice(offset, length).b
+          end
+
+          def text_bytes=(value)
+            offset, length = text_region
+            write_body_bytes(offset, length, value)
+          end
+
+          private
+
+          def no_rectangle?
+            fu_options.to_i.anybits?(0x100)
+          end
+
+          def text_region
+            width = fu_options.to_i.nobits?(0x200) ? 2 : 1
+            [no_rectangle? ? 0 : 16, c_chars.to_i * width]
+          end
+
+          def available_body(required_length)
+            bytes = body.to_s
+            raise ArgumentError, "truncated small text output body" if bytes.bytesize < required_length
+
+            bytes
+          end
+
+          def write_body_bytes(offset, length, value)
+            bytes = available_body(offset + length)
+            unless value.is_a?(String) && value.bytesize == length
+              raise ArgumentError, "small text output value must be a String of #{length} bytes"
+            end
+
+            replacement = bytes.b
+            replacement[offset, length] = value.b
+            self.body = replacement
+          end
         end
       end
     end

data/lib/emf/emr/binary/records/stretch_blt.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
 require "bindata"
+require "emf/emr/binary/variable_buffers"
 require "emf/emr/binary/with_bounds"
+require "emf/emr/binary/dib_header"
 
 module Emf
   module Emr
@@ -16,6 +18,12 @@ module Emf
         # a fixed-size :bytes buffer (NOT :rest, which would consume the
         # whole tail).
         class StretchBlt < Emf::Emr::Binary::WithBounds
+          include Emf::Emr::Binary::VariableBuffers
+
+          fixed_layout 108
+          variable_buffer :bmi_bytes, offset: :off_bmi_src, length: :cb_bmi_src
+          variable_buffer :bits_bytes, offset: :off_bits_src, length: :cb_bits_src
+
           int32le :x_dest
           int32le :y_dest
           int32le :cx_dest
@@ -32,6 +40,12 @@ module Emf
           int32le :cx_src
           int32le :cy_src
           rest :body
+
+          # Read-only; computed from the current fields on each call.
+          def dib_header_view
+            DibHeader.view(off_bmi_src, cb_bmi_src, 108, body,
+                           bits_offset: off_bits_src, bits_size: cb_bits_src)
+          end
         end
       end
     end

data/lib/emf/emr/binary/records/stretch_dibits.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
 require "bindata"
+require "emf/emr/binary/variable_buffers"
 require "emf/emr/binary/with_bounds"
+require "emf/emr/binary/dib_header"
 
 module Emf
   module Emr
@@ -20,6 +22,12 @@ module Emf
         #   cxDest, cyDest (int32)
         #   [trailing BITMAPINFO + pixel array]
         class StretchDIBits < Emf::Emr::Binary::WithBounds
+          include Emf::Emr::Binary::VariableBuffers
+
+          fixed_layout 80
+          variable_buffer :bmi_bytes, offset: :off_bmi_src, length: :cb_bmi_src
+          variable_buffer :bits_bytes, offset: :off_bits_src, length: :cb_bits_src
+
           int32 :x_dest
           int32 :y_dest
           int32 :x_src
@@ -35,6 +43,12 @@ module Emf
           int32 :cx_dest
           int32 :cy_dest
           rest :trailing
+
+          # Read-only; computed from the current fields on each call.
+          def dib_header_view
+            DibHeader.view(off_bmi_src, cb_bmi_src, 80, trailing,
+                           bits_offset: off_bits_src, bits_size: cb_bits_src)
+          end
         end
       end
     end

data/lib/emf/emr/binary/records/transparent_blt.rb

@@ -1,15 +1,58 @@
 # frozen_string_literal: true
 
 require "bindata"
+require "emf/emr/binary/variable_buffers"
 require "emf/emr/binary/with_bounds"
+require "emf/emr/binary/dib_header"
 
 module Emf
   module Emr
     module Binary
       module Records
         # Stub: leading fields per MS-EMF, body captures remaining bytes.
+        # The fixed part is 108 bytes including the EMR header; the bitmap
+        # pointers are read from body without declaring fields.
         class TransparentBlt < Emf::Emr::Binary::WithBounds
+          include Emf::Emr::Binary::VariableBuffers
+
+          fixed_layout 108
+          variable_buffer :bmi_bytes, offset: :off_bmi_src, length: :cb_bmi_src
+          variable_buffer :bits_bytes, offset: :off_bits_src, length: :cb_bits_src
+
           rest :body
+
+          # Read-only accessors computed from body on each call; body starts at
+          # record offset 24, so a record offset maps to (offset - 24) in body.
+          def off_bmi_src
+            pointers(60)[0]
+          end
+
+          def cb_bmi_src
+            pointers(60)[1]
+          end
+
+          def off_bits_src
+            pointers(60)[2]
+          end
+
+          def cb_bits_src
+            pointers(60)[3]
+          end
+
+          def dib_header_view
+            DibHeader.view(off_bmi_src, cb_bmi_src, 108, after_fixed,
+                           bits_offset: off_bits_src, bits_size: cb_bits_src)
+          end
+
+          private
+
+          def after_fixed
+            body.to_s.byteslice(84..).to_s
+          end
+
+          def pointers(offset)
+            body.to_s.byteslice(offset, 16).to_s.unpack("V4").map(&:to_i)
+          end
         end
       end
     end

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

@@ -12,6 +12,7 @@ module Emf
         autoload :Raw, "emf/emr/binary/records/raw"
         autoload :Eof, "emf/emr/binary/records/eof"
         autoload :SetTextColor, "emf/emr/binary/records/set_text_color"
+        autoload :SetColorAdjustment, "emf/emr/binary/records/set_color_adjustment"
         autoload :SetBkColor, "emf/emr/binary/records/set_bk_color"
         autoload :SetBkMode, "emf/emr/binary/records/set_bk_mode"
         autoload :SetMapMode, "emf/emr/binary/records/set_map_mode"
@@ -99,7 +100,7 @@ module Emf
         autoload :StretchBlt, "emf/emr/binary/records/stretch_blt"
         autoload :MaskBlt, "emf/emr/binary/records/mask_blt"
         autoload :PlgBlt, "emf/emr/binary/records/plg_blt"
-        autoload :SetDIBitsToDevice, "emf/emr/binary/records/set_dibits_to_device"
+        autoload :SetDibitsToDevice, "emf/emr/binary/records/set_dibits_to_device"
         autoload :AlphaBlend, "emf/emr/binary/records/alpha_blend"
         autoload :TransparentBlt, "emf/emr/binary/records/transparent_blt"
         autoload :SetLayout, "emf/emr/binary/records/set_layout"
@@ -218,7 +219,7 @@ module Emf
           Binary::TypeCodes::STRETCHBLT => :StretchBlt,
           Binary::TypeCodes::MASKBLT => :MaskBlt,
           Binary::TypeCodes::PLGBLT => :PlgBlt,
-          Binary::TypeCodes::SETDIBITSTODEVICE => :SetDIBitsToDevice,
+          Binary::TypeCodes::SETDIBITSTODEVICE => :SetDibitsToDevice,
           Binary::TypeCodes::ALPHABLEND => :AlphaBlend,
           Binary::TypeCodes::SETLAYOUT => :SetLayout,
           Binary::TypeCodes::TRANSPARENTBLT => :TransparentBlt,
@@ -239,6 +240,7 @@ module Emf
           Binary::TypeCodes::CREATECOLORSPACEW => :CreateColorspaceW,
           Binary::TypeCodes::CREATECOLORSPACE => :CreateColorspace,
           Binary::TypeCodes::SETCOLORSPACE => :SetColorspace,
+          Binary::TypeCodes::SETCOLORADJUSTMENT => :SetColorAdjustment,
           Binary::TypeCodes::DELETECOLORSPACE => :DeleteColorspace,
           Binary::TypeCodes::GLSRECORD => :GlsRecord,
           Binary::TypeCodes::GLSBOUNDEDRECORD => :GlsBoundedRecord,

data/lib/emf/emr/binary/region_data.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "bindata"
+require "emf/binary/types"
+
+module Emf
+  module Emr
+    module Binary
+      # MS-EMF 2.2.24: a 32-byte header followed by RectL objects.
+      class RegionData < BinData::Record
+        mandatory_parameter :byte_length
+        endian :little
+        uint32 :header_size, initial_value: 32
+        uint32 :region_type
+        uint32 :count_rects
+        uint32 :rgn_size
+        rectl :bounds
+        array :rectangles, type: :rectl, initial_length: :bounded_rectangle_count
+        string :trailing, read_length: -> { [eval_parameter(:byte_length) - 32 - (count_rects * 16), 0].max }
+
+        def bounded_rectangle_count
+          length = eval_parameter(:byte_length)
+          count = count_rects.to_i
+          raise BinData::ValidityError, "region rectangles exceed declared region data length" if length < 32 || count * 16 > length - 32
+
+          count
+        end
+      end
+    end
+  end
+end
+
+BinData::RegisteredClasses.register("region_data", Emf::Emr::Binary::RegionData)

data/lib/emf/emr/binary/state_record_body.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Emf
+  module Emr
+    module Binary
+      module StateRecordBody
+        class Body < String
+          def initialize(record, bytes)
+            @record = record
+            super(bytes)
+          end
+
+          def assign(bytes)
+            @record.body = bytes
+            replace(@record.body)
+          end
+        end
+
+        def body
+          Body.new(self, to_binary_s.byteslice(8..))
+        end
+
+        def body=(value)
+          bytes = value.to_s
+          raise ArgumentError, "invalid state record body length" if bytes.bytesize < self.class::BODY_SIZE
+
+          replacement = self.class.read(to_binary_s.byteslice(0, 8) + bytes)
+          assign(replacement.snapshot)
+        end
+      end
+    end
+  end
+end