emf 0.1.2 → 0.2.0

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

@@ -7,9 +7,46 @@ module Emf
   module Emr
     module Binary
       module Records
-        # Stub: preserves full body bytes. Full layout lands with TODO 10.
+        # Universal font identifiers retain their original byte representation.
         class ForceUfiMapping < Emf::Emr::Binary::Record
           rest :body
+
+          [[:ufi_checksum, 0], [:ufi_index, 4]].each do |name, offset|
+            define_method(name) { ufi_body.byteslice(offset, 4).unpack1("V") }
+            define_method("#{name}=") do |value|
+              ufi_body
+              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(offset, 4, [value].pack("V"))
+            end
+          end
+
+          def ufi_bytes
+            ufi_body.byteslice(0, 8).b
+          end
+
+          def ufi_bytes=(value)
+            replace_ufi_bytes(0, 8, value)
+          end
+
+          private
+
+          def ufi_body
+            bytes = body.to_s
+            raise ArgumentError, "truncated universal font identifier" if bytes.bytesize < 8
+
+            bytes
+          end
+
+          def replace_ufi_bytes(offset, length, value)
+            bytes = ufi_body
+            raise ArgumentError, "UFI value must be a String of #{length} bytes" unless value.is_a?(String) && value.bytesize == length
+
+            replacement = bytes.b
+            replacement[offset, length] = value.b
+            self.body = replacement
+          end
         end
       end
     end

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

@@ -1,14 +1,24 @@
 # frozen_string_literal: true
 
 require "bindata"
-require "emf/emr/binary/record"
+require "emf/emr/binary/variable_buffers"
+require "emf/emr/binary/with_bounds"
+require "emf/emr/binary/region_data"
 
 module Emf
   module Emr
     module Binary
       module Records
-        class FrameRgn < Emf::Emr::Binary::Record
+        class FrameRgn < Emf::Emr::Binary::WithBounds
+          include Emf::Emr::Binary::VariableBuffers
+
+          fixed_layout 40
+          variable_buffer :region_bytes, offset: 40, length: :cb_rgn_data
+
+          uint32 :cb_rgn_data
           uint32 :ih_brush
+          size_l :szl_stroke
+          region_data :rgn_data, byte_length: :cb_rgn_data
           rest :body
         end
       end

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

@@ -7,9 +7,69 @@ module Emf
   module Emr
     module Binary
       module Records
-        # Stub: preserves full body bytes. Full layout lands with TODO 10.
+        # EMR_GLSBOUNDEDRECORD (MS-EMF 2.3.5.23).
         class GlsBoundedRecord < Emf::Emr::Binary::Record
           rest :body
+
+          def bounds
+            gls_body.byteslice(0, 16).b
+          end
+
+          def bounds=(value)
+            write_gls_bytes(0, 16, value)
+          end
+
+          def cb_data
+            gls_body.byteslice(16, 4).unpack1("V")
+          end
+
+          def data_bytes
+            read_gls_data
+          end
+
+          def data_bytes=(value)
+            write_gls_data(value)
+          end
+
+          private
+
+          def gls_body
+            bytes = body.to_s
+            raise ArgumentError, "truncated bounded GLS record prefix" if bytes.bytesize < 20
+
+            bytes
+          end
+
+          def read_gls_data
+            bytes = gls_body
+            length = bytes.byteslice(16, 4).unpack1("V")
+            raise ArgumentError, "truncated bounded GLS record data" if 20 + length > bytes.bytesize
+
+            bytes.byteslice(20, length).b
+          end
+
+          def write_gls_data(value)
+            read_gls_data
+            length = cb_data
+            unless value.is_a?(String) && value.bytesize == length
+              raise ArgumentError, "bounded GLS data must be a String of #{length} bytes"
+            end
+
+            bytes = body.to_s.b
+            bytes[20, length] = value.b
+            self.body = bytes
+          end
+
+          def write_gls_bytes(offset, length, value)
+            gls_body
+            unless value.is_a?(String) && value.bytesize == length
+              raise ArgumentError, "bounded GLS 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/gls_record.rb

@@ -7,9 +7,50 @@ module Emf
   module Emr
     module Binary
       module Records
-        # Stub: preserves full body bytes. Full layout lands with TODO 10.
+        # EMR_GLSRECORD (MS-EMF 2.3.5.24).
         class GlsRecord < Emf::Emr::Binary::Record
           rest :body
+
+          def cb_data
+            gls_body(4).byteslice(0, 4).unpack1("V")
+          end
+
+          def data_bytes
+            read_gls_data(4)
+          end
+
+          def data_bytes=(value)
+            write_gls_data(4, value)
+          end
+
+          private
+
+          def gls_body(prefix_length)
+            bytes = body.to_s
+            raise ArgumentError, "truncated GLS record prefix" if bytes.bytesize < prefix_length
+
+            bytes
+          end
+
+          def read_gls_data(prefix_length)
+            bytes = gls_body(prefix_length)
+            length = bytes.byteslice(0, 4).unpack1("V")
+            raise ArgumentError, "truncated GLS record data" if prefix_length + length > bytes.bytesize
+
+            bytes.byteslice(prefix_length, length).b
+          end
+
+          def write_gls_data(prefix_length, value)
+            read_gls_data(prefix_length)
+            length = cb_data
+            unless value.is_a?(String) && value.bytesize == length
+              raise ArgumentError, "GLS record data must be a String of #{length} bytes"
+            end
+
+            bytes = body.to_s.b
+            bytes[prefix_length, length] = value.b
+            self.body = bytes
+          end
         end
       end
     end

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "bindata"
+require "emf/emr/binary/variable_buffers"
 require "emf/emr/binary/with_bounds"
 
 module Emf
@@ -8,6 +9,12 @@ module Emf
     module Binary
       module Records
         class GradientFill < Emf::Emr::Binary::WithBounds
+          include Emf::Emr::Binary::VariableBuffers
+
+          fixed_layout 36
+          variable_buffer :vertex_bytes, offset: 36, length: -> { n_ver * 16 }
+          variable_buffer :mesh_bytes, offset: -> { 36 + (n_ver * 16) }, length: -> { n_tri * (ul_mode == 2 ? 12 : 8) }
+
           uint32 :n_ver
           uint32 :n_tri
           uint32 :ul_mode

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

@@ -1,14 +1,22 @@
 # frozen_string_literal: true
 
 require "bindata"
-require "emf/emr/binary/record"
+require "emf/emr/binary/variable_buffers"
+require "emf/emr/binary/with_bounds"
+require "emf/emr/binary/region_data"
 
 module Emf
   module Emr
     module Binary
       module Records
-        class InvertRgn < Emf::Emr::Binary::Record
-          uint32 :ih_brush
+        class InvertRgn < Emf::Emr::Binary::WithBounds
+          include Emf::Emr::Binary::VariableBuffers
+
+          fixed_layout 28
+          variable_buffer :region_bytes, offset: 28, length: :cb_rgn_data
+
+          uint32 :cb_rgn_data
+          region_data :rgn_data, byte_length: :cb_rgn_data
           rest :body
         end
       end

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

@@ -1,15 +1,81 @@
 # 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 128 bytes including the EMR header; the bitmap
+        # pointers are read from body without declaring fields.
         class MaskBlt < Emf::Emr::Binary::WithBounds
+          include Emf::Emr::Binary::VariableBuffers
+
+          fixed_layout 128
+          variable_buffer :bmi_bytes, offset: :off_bmi_src, length: :cb_bmi_src
+          variable_buffer :bits_bytes, offset: :off_bits_src, length: :cb_bits_src
+          variable_buffer :mask_bmi_bytes, offset: :off_bmi_mask, length: :cb_bmi_mask
+          variable_buffer :mask_bits_bytes, offset: :off_bits_mask, length: :cb_bits_mask
+
           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 off_bmi_mask
+            pointers(88)[0]
+          end
+
+          def cb_bmi_mask
+            pointers(88)[1]
+          end
+
+          def off_bits_mask
+            pointers(88)[2]
+          end
+
+          def cb_bits_mask
+            pointers(88)[3]
+          end
+
+          def dib_header_view
+            DibHeader.view(off_bmi_src, cb_bmi_src, 128, after_fixed,
+                           bits_offset: off_bits_src, bits_size: cb_bits_src)
+          end
+
+          def mask_dib_header_view
+            DibHeader.view(off_bmi_mask, cb_bmi_mask, 128, after_fixed,
+                           bits_offset: off_bits_mask, bits_size: cb_bits_mask)
+          end
+
+          private
+
+          def after_fixed
+            body.to_s.byteslice(104..).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/named_escape.rb

@@ -7,9 +7,86 @@ module Emf
   module Emr
     module Binary
       module Records
-        # Stub: preserves full body bytes. Full layout lands with TODO 10.
+        # Body-backed byte spans retain the driver's raw name, data and padding.
         class NamedEscape < Emf::Emr::Binary::Record
           rest :body
+
+          def i_escape
+            named_escape_body.byteslice(0, 4).unpack1("V")
+          end
+
+          def i_escape=(value)
+            bytes = named_escape_body
+            raise ArgumentError, "i_escape must be an Integer" unless value.is_a?(Integer)
+            raise RangeError, "i_escape must fit in an unsigned 32-bit field" unless value.between?(0, 0xFFFFFFFF)
+
+            bytes[0, 4] = [value].pack("V")
+            self.body = bytes
+          end
+
+          def cj_driver
+            named_escape_body.byteslice(4, 4).unpack1("V")
+          end
+
+          def cj_in
+            named_escape_body.byteslice(8, 4).unpack1("V")
+          end
+
+          def driver_name_bytes
+            bytes = named_escape_body
+            length = bytes.byteslice(4, 4).unpack1("V")
+            validate_span!(bytes, 12, length, "driver name")
+            bytes.byteslice(12, length).b
+          end
+
+          def driver_name_bytes=(value)
+            bytes = named_escape_body
+            length = bytes.byteslice(4, 4).unpack1("V")
+            validate_span!(bytes, 12, length, "driver name")
+            validate_bytes!(value, length, "driver name")
+            bytes[12, length] = value.b
+            self.body = bytes
+          end
+
+          def data_bytes
+            bytes = named_escape_body
+            driver_length = bytes.byteslice(4, 4).unpack1("V")
+            data_length = bytes.byteslice(8, 4).unpack1("V")
+            data_offset = 12 + driver_length
+            validate_span!(bytes, 12, driver_length, "driver name")
+            validate_span!(bytes, data_offset, data_length, "data")
+            bytes.byteslice(data_offset, data_length).b
+          end
+
+          def data_bytes=(value)
+            bytes = named_escape_body
+            driver_length = bytes.byteslice(4, 4).unpack1("V")
+            data_length = bytes.byteslice(8, 4).unpack1("V")
+            data_offset = 12 + driver_length
+            validate_span!(bytes, 12, driver_length, "driver name")
+            validate_span!(bytes, data_offset, data_length, "data")
+            validate_bytes!(value, data_length, "data")
+            bytes[data_offset, data_length] = value.b
+            self.body = bytes
+          end
+
+          private
+
+          def named_escape_body
+            bytes = body.to_s.b
+            raise ArgumentError, "truncated named escape prefix" if bytes.bytesize < 12
+
+            bytes
+          end
+
+          def validate_span!(bytes, offset, length, name)
+            raise ArgumentError, "truncated named escape #{name}" if length > bytes.bytesize - offset
+          end
+
+          def validate_bytes!(value, length, name)
+            valid = value.is_a?(String) && value.bytesize == length
+            raise ArgumentError, "#{name} must be a String of #{length} bytes" unless valid
+          end
         end
       end
     end

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

@@ -1,14 +1,22 @@
 # frozen_string_literal: true
 
 require "bindata"
-require "emf/emr/binary/record"
+require "emf/emr/binary/variable_buffers"
+require "emf/emr/binary/with_bounds"
+require "emf/emr/binary/region_data"
 
 module Emf
   module Emr
     module Binary
       module Records
-        class PaintRgn < Emf::Emr::Binary::Record
-          uint32 :ih_brush
+        class PaintRgn < Emf::Emr::Binary::WithBounds
+          include Emf::Emr::Binary::VariableBuffers
+
+          fixed_layout 28
+          variable_buffer :region_bytes, offset: 28, length: :cb_rgn_data
+
+          uint32 :cb_rgn_data
+          region_data :rgn_data, byte_length: :cb_rgn_data
           rest :body
         end
       end

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

@@ -7,9 +7,84 @@ module Emf
   module Emr
     module Binary
       module Records
-        # EMR_PIXELFORMAT: header + body. Stub preserves bytes verbatim.
+        # Pixel format fields retain their original fixed-width descriptor bytes.
         class PixelFormat < Emf::Emr::Binary::Record
           rest :body
+
+          [
+            [:pfd_size, 0, "v", 2],
+            [:pfd_version, 2, "v", 2],
+            [:dw_flags, 4, "V", 4],
+            [:i_pixel_type, 8, "C", 1],
+            [:c_color_bits, 9, "C", 1],
+            [:c_red_bits, 10, "C", 1],
+            [:c_red_shift, 11, "C", 1],
+            [:c_green_bits, 12, "C", 1],
+            [:c_green_shift, 13, "C", 1],
+            [:c_blue_bits, 14, "C", 1],
+            [:c_blue_shift, 15, "C", 1],
+            [:c_alpha_bits, 16, "C", 1],
+            [:c_alpha_shift, 17, "C", 1],
+            [:c_accum_bits, 18, "C", 1],
+            [:c_accum_red_bits, 19, "C", 1],
+            [:c_accum_green_bits, 20, "C", 1],
+            [:c_accum_blue_bits, 21, "C", 1],
+            [:c_accum_alpha_bits, 22, "C", 1],
+            [:c_depth_bits, 23, "C", 1],
+            [:c_stencil_bits, 24, "C", 1],
+            [:c_aux_buffers, 25, "C", 1],
+            [:i_layer_type, 26, "C", 1],
+            [:b_reserved, 27, "C", 1],
+            [:dw_layer_mask, 28, "V", 4],
+            [:dw_visible_mask, 32, "V", 4],
+            [:dw_damage_mask, 36, "V", 4]
+          ].each do |name, offset, format, width|
+            define_method(name) do
+              pixel_format_body.byteslice(offset, width).unpack1(format)
+            end
+
+            define_method("#{name}=") do |value|
+              write_pixel_format_value(offset, value, format, width)
+            end
+          end
+
+          def pfd_bytes
+            pixel_format_body.byteslice(0, 40).b
+          end
+
+          def pfd_bytes=(value)
+            replace_pixel_format_bytes(0, 40, value)
+          end
+
+          private
+
+          def pixel_format_body
+            bytes = body.to_s
+            raise ArgumentError, "truncated pixel format descriptor" if bytes.bytesize < 40
+
+            bytes
+          end
+
+          def write_pixel_format_value(offset, value, format, width)
+            pixel_format_body
+            raise ArgumentError, "pixel format value must be an Integer" unless value.is_a?(Integer)
+
+            range = 0...(1 << (width * 8))
+            raise RangeError, "pixel format value must fit its #{width * 8}-bit field" unless range.cover?(value)
+
+            replace_pixel_format_bytes(offset, width, [value].pack(format))
+          end
+
+          def replace_pixel_format_bytes(offset, length, value)
+            bytes = pixel_format_body
+            unless value.is_a?(String) && value.bytesize == length
+              raise ArgumentError, "pixel format 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/plg_blt.rb

@@ -1,15 +1,81 @@
 # 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 140 bytes including the EMR header; the bitmap
+        # pointers are read from body without declaring fields.
         class PlgBlt < Emf::Emr::Binary::WithBounds
+          include Emf::Emr::Binary::VariableBuffers
+
+          fixed_layout 140
+          variable_buffer :bmi_bytes, offset: :off_bmi_src, length: :cb_bmi_src
+          variable_buffer :bits_bytes, offset: :off_bits_src, length: :cb_bits_src
+          variable_buffer :mask_bmi_bytes, offset: :off_bmi_mask, length: :cb_bmi_mask
+          variable_buffer :mask_bits_bytes, offset: :off_bits_mask, length: :cb_bits_mask
+
           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(72)[0]
+          end
+
+          def cb_bmi_src
+            pointers(72)[1]
+          end
+
+          def off_bits_src
+            pointers(72)[2]
+          end
+
+          def cb_bits_src
+            pointers(72)[3]
+          end
+
+          def off_bmi_mask
+            pointers(100)[0]
+          end
+
+          def cb_bmi_mask
+            pointers(100)[1]
+          end
+
+          def off_bits_mask
+            pointers(100)[2]
+          end
+
+          def cb_bits_mask
+            pointers(100)[3]
+          end
+
+          def dib_header_view
+            DibHeader.view(off_bmi_src, cb_bmi_src, 140, after_fixed,
+                           bits_offset: off_bits_src, bits_size: cb_bits_src)
+          end
+
+          def mask_dib_header_view
+            DibHeader.view(off_bmi_mask, cb_bmi_mask, 140, after_fixed,
+                           bits_offset: off_bits_mask, bits_size: cb_bits_mask)
+          end
+
+          private
+
+          def after_fixed
+            body.to_s.byteslice(116..).to_s
+          end
+
+          def pointers(offset)
+            body.to_s.byteslice(offset, 16).to_s.unpack("V4").map(&:to_i)
+          end
         end
       end
     end