emf 0.1.2 → 0.2.0

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

@@ -7,9 +7,136 @@ module Emf
   module Emr
     module Binary
       module Records
-        # Stub: preserves full body bytes. Full layout lands with TODO 10.
+        # Exposes option-dependent text buffers without changing the wire layout.
         class PolyTextOutA < Emf::Emr::Binary::Record
           rest :body
+
+          def c_strings
+            checked_body(32).byteslice(28, 4).unpack1("V")
+          end
+
+          def bounds
+            checked_body(16).byteslice(0, 16).b
+          end
+
+          def bounds=(value)
+            replace_body_bytes(0, 16, value)
+          end
+
+          def text_bytes(index)
+            read_span(text_span(index))
+          end
+
+          def set_text_bytes(index, value)
+            replace_body_bytes(*text_span(index), value)
+          end
+
+          def dx_bytes(index)
+            span = dx_span(index)
+            read_span(span) if span
+          end
+
+          def set_dx_bytes(index, value)
+            span = dx_span(index)
+            raise ArgumentError, "text entry has no spacing buffer" unless span
+
+            replace_body_bytes(*span, value)
+          end
+
+          def entry_bounds(index)
+            span = entry_bounds_span(index)
+            read_span(span) if span
+          end
+
+          def set_entry_bounds(index, value)
+            span = entry_bounds_span(index)
+            raise ArgumentError, "text entry has no bounds rectangle" unless span
+
+            replace_body_bytes(*span, value)
+          end
+
+          private
+
+          def checked_body(required)
+            bytes = body.to_s
+            raise ArgumentError, "truncated poly text output body" if bytes.bytesize < required
+
+            bytes
+          end
+
+          def entry_location(index)
+            bytes = checked_body(32)
+            count = bytes.byteslice(28, 4).unpack1("V")
+            raise ArgumentError, "invalid text entry index" unless index.is_a?(Integer) && index >= 0 && index < count
+            raise ArgumentError, "truncated text entry table" if count > (bytes.bytesize - 32) / 24
+
+            offset = 32
+            selected = nil
+            count.times do |position|
+              raise ArgumentError, "truncated text entry table" if bytes.bytesize - offset < 24
+
+              options = bytes.byteslice(offset + 16, 4).unpack1("V")
+              length = options.nobits?(0x100) ? 40 : 24
+              raise ArgumentError, "truncated text entry table" if bytes.bytesize - offset < length
+
+              selected = offset if position == index
+              offset += length
+            end
+            [bytes, selected, offset]
+          end
+
+          def text_span(index)
+            bytes, offset, table_end = entry_location(index)
+            count, pointer = bytes.byteslice(offset + 8, 8).unpack("V2")
+            buffer_span(bytes, pointer, count, table_end, 1)
+          end
+
+          def dx_span(index)
+            bytes, offset, table_end = entry_location(index)
+            count = bytes.byteslice(offset + 8, 4).unpack1("V")
+            options = bytes.byteslice(offset + 16, 4).unpack1("V")
+            pointer_at = options.nobits?(0x100) ? 36 : 20
+            pointer = bytes.byteslice(offset + pointer_at, 4).unpack1("V")
+            return nil if pointer.zero?
+
+            width = options.nobits?(0x2000) ? 4 : 8
+            buffer_span(bytes, pointer, count * width, table_end, 4)
+          end
+
+          def entry_bounds_span(index)
+            bytes, offset, = entry_location(index)
+            options = bytes.byteslice(offset + 16, 4).unpack1("V")
+            [offset + 20, 16] if options.nobits?(0x100)
+          end
+
+          def buffer_span(bytes, pointer, length, table_end, alignment)
+            return [0, 0] if length.zero?
+
+            raise ArgumentError, "misaligned text entry buffer" unless (pointer % alignment).zero?
+
+            offset = pointer - 8
+            if offset < table_end || offset > bytes.bytesize || length > bytes.bytesize - offset
+              raise ArgumentError, "invalid text entry buffer span"
+            end
+
+            [offset, length]
+          end
+
+          def read_span(span)
+            offset, length = span
+            body.to_s.byteslice(offset, length).b
+          end
+
+          def replace_body_bytes(offset, length, value)
+            bytes = checked_body(offset + length)
+            unless value.is_a?(String) && value.bytesize == length
+              raise ArgumentError, "poly 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/poly_textout_w.rb

@@ -7,9 +7,136 @@ module Emf
   module Emr
     module Binary
       module Records
-        # Stub: preserves full body bytes. Full layout lands with TODO 10.
+        # Exposes option-dependent text buffers without changing the wire layout.
         class PolyTextOutW < Emf::Emr::Binary::Record
           rest :body
+
+          def c_strings
+            checked_body(32).byteslice(28, 4).unpack1("V")
+          end
+
+          def bounds
+            checked_body(16).byteslice(0, 16).b
+          end
+
+          def bounds=(value)
+            replace_body_bytes(0, 16, value)
+          end
+
+          def text_bytes(index)
+            read_span(text_span(index))
+          end
+
+          def set_text_bytes(index, value)
+            replace_body_bytes(*text_span(index), value)
+          end
+
+          def dx_bytes(index)
+            span = dx_span(index)
+            read_span(span) if span
+          end
+
+          def set_dx_bytes(index, value)
+            span = dx_span(index)
+            raise ArgumentError, "text entry has no spacing buffer" unless span
+
+            replace_body_bytes(*span, value)
+          end
+
+          def entry_bounds(index)
+            span = entry_bounds_span(index)
+            read_span(span) if span
+          end
+
+          def set_entry_bounds(index, value)
+            span = entry_bounds_span(index)
+            raise ArgumentError, "text entry has no bounds rectangle" unless span
+
+            replace_body_bytes(*span, value)
+          end
+
+          private
+
+          def checked_body(required)
+            bytes = body.to_s
+            raise ArgumentError, "truncated poly text output body" if bytes.bytesize < required
+
+            bytes
+          end
+
+          def entry_location(index)
+            bytes = checked_body(32)
+            count = bytes.byteslice(28, 4).unpack1("V")
+            raise ArgumentError, "invalid text entry index" unless index.is_a?(Integer) && index >= 0 && index < count
+            raise ArgumentError, "truncated text entry table" if count > (bytes.bytesize - 32) / 24
+
+            offset = 32
+            selected = nil
+            count.times do |position|
+              raise ArgumentError, "truncated text entry table" if bytes.bytesize - offset < 24
+
+              options = bytes.byteslice(offset + 16, 4).unpack1("V")
+              length = options.nobits?(0x100) ? 40 : 24
+              raise ArgumentError, "truncated text entry table" if bytes.bytesize - offset < length
+
+              selected = offset if position == index
+              offset += length
+            end
+            [bytes, selected, offset]
+          end
+
+          def text_span(index)
+            bytes, offset, table_end = entry_location(index)
+            count, pointer = bytes.byteslice(offset + 8, 8).unpack("V2")
+            buffer_span(bytes, pointer, count * 2, table_end, 2)
+          end
+
+          def dx_span(index)
+            bytes, offset, table_end = entry_location(index)
+            count = bytes.byteslice(offset + 8, 4).unpack1("V")
+            options = bytes.byteslice(offset + 16, 4).unpack1("V")
+            pointer_at = options.nobits?(0x100) ? 36 : 20
+            pointer = bytes.byteslice(offset + pointer_at, 4).unpack1("V")
+            return nil if pointer.zero?
+
+            width = options.nobits?(0x2000) ? 4 : 8
+            buffer_span(bytes, pointer, count * width, table_end, 4)
+          end
+
+          def entry_bounds_span(index)
+            bytes, offset, = entry_location(index)
+            options = bytes.byteslice(offset + 16, 4).unpack1("V")
+            [offset + 20, 16] if options.nobits?(0x100)
+          end
+
+          def buffer_span(bytes, pointer, length, table_end, alignment)
+            return [0, 0] if length.zero?
+
+            raise ArgumentError, "misaligned text entry buffer" unless (pointer % alignment).zero?
+
+            offset = pointer - 8
+            if offset < table_end || offset > bytes.bytesize || length > bytes.bytesize - offset
+              raise ArgumentError, "invalid text entry buffer span"
+            end
+
+            [offset, length]
+          end
+
+          def read_span(span)
+            offset, length = span
+            body.to_s.byteslice(offset, length).b
+          end
+
+          def replace_body_bytes(offset, length, value)
+            bytes = checked_body(offset + length)
+            unless value.is_a?(String) && value.bytesize == length
+              raise ArgumentError, "poly 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/raw.rb

@@ -12,6 +12,9 @@ module Emf
           uint32 :i_type
           uint32 :n_size
           rest :payload
+
+          # Not a Record, so it has no built fast path: just its bytes.
+          def append_built_to?(_out) = false
         end
       end
     end

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

@@ -8,6 +8,7 @@ module Emf
     module Binary
       module Records
         class RealizePalette < Emf::Emr::Binary::Record
+          rest :trailing
         end
       end
     end

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

@@ -10,7 +10,7 @@ module Emf
         # EMR_RECTANGLE: emr + rclBox per MS-EMF 2.3.5.
         # No rclBounds.
         class Rectangle < Emf::Emr::Binary::Record
-  rectl :rcl_box
+          rectl :rcl_box
         end
       end
     end

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

@@ -2,14 +2,28 @@
 
 require "bindata"
 require "emf/emr/binary/record"
+require "emf/emr/binary/palette_body"
 
 module Emf
   module Emr
     module Binary
       module Records
-        # Stub: preserves full body bytes. Full layout lands with TODO 10.
         class ResizePalette < Emf::Emr::Binary::Record
-          rest :body
+          uint32 :ih_pal
+          uint32 :entry_count
+          rest :trailing
+
+          def body
+            PaletteBody.new(self, to_binary_s.byteslice(8..))
+          end
+
+          def body=(value)
+            bytes = value.to_s
+            raise ArgumentError, "invalid palette body length" if bytes.bytesize < 8
+
+            replacement = self.class.read(to_binary_s.byteslice(0, 8) + bytes)
+            assign(replacement.snapshot)
+          end
         end
       end
     end

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

@@ -10,8 +10,8 @@ module Emf
         # EMR_ROUNDRECT: emr + rclBox per MS-EMF 2.3.5.
         # No rclBounds.
         class RoundRect < Emf::Emr::Binary::Record
-  rectl :rcl_box
-  size_l :szl_corner
+          rectl :rcl_box
+          size_l :szl_corner
         end
       end
     end

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

@@ -9,6 +9,7 @@ module Emf
       module Records
         class SelectPalette < Emf::Emr::Binary::Record
           uint32 :ih_pal
+          rest :trailing
         end
       end
     end

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

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require "bindata"
+require "emf/emr/binary/record"
+
+module Emf
+  module Emr
+    module Binary
+      module Records
+        class SetColorAdjustment < Emf::Emr::Binary::Record
+          rest :body
+
+          def adjustment_size
+            read_adjustment_value(0, "v")
+          end
+
+          def adjustment_size=(value)
+            write_adjustment_value(0, value)
+          end
+
+          def values
+            read_adjustment_value(2, "v")
+          end
+
+          def values=(value)
+            write_adjustment_value(2, value)
+          end
+
+          def illuminant_index
+            read_adjustment_value(4, "v")
+          end
+
+          def illuminant_index=(value)
+            write_adjustment_value(4, value)
+          end
+
+          def red_gamma
+            read_adjustment_value(6, "v")
+          end
+
+          def red_gamma=(value)
+            write_adjustment_value(6, value)
+          end
+
+          def green_gamma
+            read_adjustment_value(8, "v")
+          end
+
+          def green_gamma=(value)
+            write_adjustment_value(8, value)
+          end
+
+          def blue_gamma
+            read_adjustment_value(10, "v")
+          end
+
+          def blue_gamma=(value)
+            write_adjustment_value(10, value)
+          end
+
+          def reference_black
+            read_adjustment_value(12, "v")
+          end
+
+          def reference_black=(value)
+            write_adjustment_value(12, value)
+          end
+
+          def reference_white
+            read_adjustment_value(14, "v")
+          end
+
+          def reference_white=(value)
+            write_adjustment_value(14, value)
+          end
+
+          def contrast
+            read_adjustment_value(16, "s<")
+          end
+
+          def contrast=(value)
+            write_adjustment_value(16, value, signed: true)
+          end
+
+          def brightness
+            read_adjustment_value(18, "s<")
+          end
+
+          def brightness=(value)
+            write_adjustment_value(18, value, signed: true)
+          end
+
+          def colorfulness
+            read_adjustment_value(20, "s<")
+          end
+
+          def colorfulness=(value)
+            write_adjustment_value(20, value, signed: true)
+          end
+
+          def red_green_tint
+            read_adjustment_value(22, "s<")
+          end
+
+          def red_green_tint=(value)
+            write_adjustment_value(22, value, signed: true)
+          end
+
+          private
+
+          def adjustment_body
+            bytes = body.to_s
+            raise ArgumentError, "invalid color adjustment body length" if bytes.bytesize < 24
+
+            bytes
+          end
+
+          def read_adjustment_value(offset, format)
+            adjustment_body.byteslice(offset, 2).unpack1(format)
+          end
+
+          def write_adjustment_value(offset, value, signed: false)
+            bytes = adjustment_body.dup
+            raise ArgumentError, "color adjustment value must be an Integer" unless value.is_a?(Integer)
+
+            bounds = signed ? (-32_768..32_767) : (0..65_535)
+            raise RangeError, "color adjustment value must fit its 16-bit integer field" unless bounds.cover?(value)
+
+            bytes[offset, 2] = [value].pack(signed ? "s<" : "v")
+            self.body = bytes
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -7,9 +7,30 @@ module Emf
   module Emr
     module Binary
       module Records
-        # Stub: preserves full body bytes. Full layout lands with TODO 10.
         class SetColorspace < Emf::Emr::Binary::Record
           rest :body
+
+          def ih_cs
+            colorspace_body.byteslice(0, 4).unpack1("V")
+          end
+
+          def ih_cs=(value)
+            bytes = colorspace_body.dup
+            raise ArgumentError, "colorspace handle must be an Integer" unless value.is_a?(Integer)
+            raise RangeError, "colorspace handle must fit an unsigned 32-bit integer" unless (0..0xffffffff).cover?(value)
+
+            bytes[0, 4] = [value].pack("V")
+            self.body = bytes
+          end
+
+          private
+
+          def colorspace_body
+            bytes = body.to_s
+            raise ArgumentError, "invalid colorspace body length" if bytes.bytesize < 4
+
+            bytes
+          end
         end
       end
     end

data/lib/emf/emr/binary/records/set_dibits_to_device.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 76 bytes including the EMR header; the bitmap
+        # pointers are read from body without declaring fields.
         class SetDibitsToDevice < Emf::Emr::Binary::WithBounds
+          include Emf::Emr::Binary::VariableBuffers
+
+          fixed_layout 76
+          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(24)[0]
+          end
+
+          def cb_bmi_src
+            pointers(24)[1]
+          end
+
+          def off_bits_src
+            pointers(24)[2]
+          end
+
+          def cb_bits_src
+            pointers(24)[3]
+          end
+
+          def dib_header_view
+            DibHeader.view(off_bmi_src, cb_bmi_src, 76, after_fixed,
+                           bits_offset: off_bits_src, bits_size: cb_bits_src)
+          end
+
+          private
+
+          def after_fixed
+            body.to_s.byteslice(52..).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/set_icm_profile_a.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.15: name and profile lengths are byte counts.
         class SetIcmProfileA < 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