emf 0.1.2 → 0.2.0

data/lib/emf/emf_plus/objects/font.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "emf/binary/float32_le"
+require "emf/emf_plus/records/primitives/graphics_version"
+
+module Emf
+  module EmfPlus
+    module Objects
+      # EmfPlusFont (2.2.1.3).
+      class Font < Typed
+        FIXED_SIZE = 24
+        LENGTH_OFFSET = 20
+
+        # Anonymous until assigned so BinData does not register it as :font_body,
+        # a name the EMR record field resolves by symbol.
+        FontBody = Class.new(Records::Body) do
+          endian :little
+          graphics_version :version
+          float32_le :em_size
+          uint32 :size_unit
+          int32 :font_style_flags
+          uint32 :reserved
+          uint32 :char_count
+          string :family_name, read_length: -> { char_count * 2 }
+        end
+        BODY = FontBody
+
+        def em_size = body.em_size
+        def size_unit = body.size_unit
+        def style_flags = body.font_style_flags
+
+        def family_name
+          body.family_name.to_s.dup.force_encoding(Encoding::UTF_16LE).encode(Encoding::UTF_8, invalid: :replace, undef: :replace)
+        end
+
+        private
+
+        def check_bounds(data, logical)
+          return if data.bytesize < FIXED_SIZE
+
+          length = data.byteslice(LENGTH_OFFSET, 4).unpack1("V")
+          require_room(data, logical, FIXED_SIZE + (length * 2), "FamilyName of #{length} characters")
+        end
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/objects/image.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "emf/emf_plus/records/primitives/graphics_version"
+require "emf/emf_plus/records/primitives/bitmap"
+require "emf/emf_plus/records/primitives/metafile"
+
+module Emf
+  module EmfPlus
+    module Objects
+      # EmfPlusImage (2.2.1.4). ImageDataType 1 carries an EmfPlusBitmap, 2 an
+      # EmfPlusMetafile; any other value keeps its bytes in unrecognized_data.
+      class Image < Typed
+        BITMAP = 1
+        METAFILE = 2
+        TYPE_OFFSET = 4
+        BITMAP_TYPE_END = 28
+        PIXEL_FORMAT_OFFSET = 20
+        BITMAP_TYPE_OFFSET = 24
+        PALETTE_COUNT_OFFSET = 32
+        PALETTE_ENTRIES_OFFSET = 36
+        METAFILE_SIZE_OFFSET = 12
+        METAFILE_DATA_OFFSET = 16
+
+        class ImageBody < Records::Body
+          endian :little
+          graphics_version :version
+          uint32 :image_type
+          bitmap :bitmap, onlyif: -> { image_type == BITMAP }
+          metafile :metafile, onlyif: -> { image_type == METAFILE }
+          rest :unrecognized_data, onlyif: -> { ![BITMAP, METAFILE].include?(image_type) }
+        end
+        BODY = ImageBody
+
+        def image_type = body.image_type
+        def bitmap = (body.bitmap if image_type == BITMAP)
+        def metafile = (body.metafile if image_type == METAFILE)
+
+        private
+
+        def check_bounds(data, logical)
+          return if data.bytesize < 8
+
+          case data.byteslice(TYPE_OFFSET, 4).unpack1("V")
+          when BITMAP then check_palette(data, logical)
+          when METAFILE then check_metafile(data, logical)
+          end
+        end
+
+        def check_palette(data, logical)
+          return if data.bytesize < PALETTE_ENTRIES_OFFSET
+
+          pixel_format, bitmap_type = data.byteslice(PIXEL_FORMAT_OFFSET, 8).unpack("VV")
+          return unless bitmap_type.zero? && pixel_format.anybits?(Records::Primitives::Bitmap::INDEXED_FLAG)
+
+          count = data.byteslice(PALETTE_COUNT_OFFSET, 4).unpack1("V")
+          require_room(data, logical, PALETTE_ENTRIES_OFFSET + (count * 4), "Palette of #{count} entries")
+        end
+
+        def check_metafile(data, logical)
+          return if data.bytesize < METAFILE_DATA_OFFSET
+
+          size = data.byteslice(METAFILE_SIZE_OFFSET, 4).unpack1("V")
+          require_room(data, logical, METAFILE_DATA_OFFSET + size, "MetafileData of #{size} bytes")
+        end
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/objects/image_attributes.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "emf/emf_plus/records/primitives/graphics_version"
+require "emf/emf_plus/records/primitives/argb"
+
+module Emf
+  module EmfPlus
+    module Objects
+      # EmfPlusImageAttributes (2.2.1.5).
+      class ImageAttributes < Typed
+        class ImageAttributesBody < Records::Body
+          endian :little
+          graphics_version :version
+          uint32 :reserved1
+          uint32 :wrap_mode
+          argb :clamp_color
+          int32 :object_clamp
+          uint32 :reserved2
+        end
+        BODY = ImageAttributesBody
+
+        def wrap_mode = body.wrap_mode
+        def clamp_color = body.clamp_color
+        def object_clamp = body.object_clamp
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/objects/opaque.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Emf
+  module EmfPlus
+    module Objects
+      # ObjectData of a type that has no typed body yet.
+      class Opaque
+        attr_reader :object_type, :data
+
+        def initialize(logical)
+          @object_type = logical.object_type
+          @data = logical.data
+        end
+
+        def to_binary = data
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/objects/parts.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "bindata"
+
+module Emf
+  module EmfPlus
+    module Objects
+      # Building blocks for objects whose layout depends on flags: a Cursor
+      # walks the data once and collects ordered parts that a Body re-encodes.
+      module Parts
+        class Malformed < StandardError; end
+
+        # What a nested object needs from the logical object it is cut from.
+        Slice = Struct.new(:object_type, :data, :offset)
+
+        # A typed object embedded in another one; it keeps its own padding.
+        Nested = Struct.new(:object) do
+          def num_bytes = object.to_binary.bytesize
+          def to_binary_s = object.to_binary
+        end
+
+        # A 4-byte length followed by that many bytes, of which `inner` reads
+        # a prefix; the rest is kept so the bytes round-trip.
+        Sized = Struct.new(:byte_length, :inner, :extra) do
+          def num_bytes = 4 + inner.num_bytes + extra.bytesize
+          def to_binary_s = [byte_length].pack("V") + inner.to_binary_s + extra
+        end
+
+        # Ordered parts; strings are raw bytes.
+        class Body
+          attr_reader :parts
+
+          def initialize(parts) = @parts = parts
+
+          def version = parts.fetch(:header).version
+
+          def num_bytes = parts.each_value.sum { |part| part.is_a?(String) ? part.bytesize : part.num_bytes }
+
+          def to_binary_s = parts.each_value.map { |part| part.is_a?(String) ? part : part.to_binary_s }.join.b
+        end
+
+        # Reads parts front to back. Every count and length is checked against
+        # the bytes left before anything is allocated.
+        class Cursor
+          attr_reader :parts
+
+          def initialize(data)
+            @data = data
+            @pos = 0
+            @parts = {}
+          end
+
+          def take(name, klass)
+            record = klass.new
+            raise Malformed, "#{name} needs #{record.num_bytes} bytes, #{remaining} left" if record.num_bytes > remaining
+
+            @parts[name] = record.read(@data.byteslice(@pos..))
+            @pos += record.num_bytes
+          end
+
+          # A BinData record that starts with a 4-byte count of `item_size` elements.
+          def take_counted(name, klass, item_size)
+            count = peek_uint32(name, "count")
+            needed = 4 + (count * item_size)
+            raise Malformed, "#{name} of #{count} entries needs #{needed} bytes, #{remaining} left" if needed > remaining
+
+            @parts[name] = klass.read(@data.byteslice(@pos..))
+            @pos += @parts[name].num_bytes
+          end
+
+          # The block builds the inner part from the length-delimited bytes.
+          def take_sized(name)
+            length = peek_uint32(name, "length")
+            raise Malformed, "#{name} length #{length} exceeds the #{remaining - 4} bytes left" if length > remaining - 4
+
+            body = @data.byteslice(@pos + 4, length)
+            inner = yield(body)
+            @parts[name] = Sized.new(length, inner, body.byteslice(inner.num_bytes..))
+            @pos += 4 + length
+          end
+
+          def take_rest(name)
+            rest = @data.byteslice(@pos..)
+            @parts[name] = rest.freeze unless rest.empty?
+            @pos += rest.bytesize
+          end
+
+          def rest = @data.byteslice(@pos..)
+
+          def remaining = @data.bytesize - @pos
+
+          private
+
+          def peek_uint32(name, what)
+            raise Malformed, "#{name} #{what} needs 4 bytes, #{remaining} left" if remaining < 4
+
+            @data.byteslice(@pos, 4).unpack1("V")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/objects/path.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "emf/emf_plus/records/primitives/path"
+
+module Emf
+  module EmfPlus
+    module Objects
+      # EmfPlusPath object (2.2.1.6); AlignmentPadding stays in `trailing`.
+      class Path < Typed
+        BODY = Records::Primitives::Path
+
+        def point_count = body.point_count
+        def flags = body.flags
+        def relative? = body.relative?
+        def compressed? = body.compressed?
+        def points = body.points.points.map { |p| [p.x, p.y] }
+        def point_types = body.point_types
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/objects/pen.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require "emf/binary/float32_le"
+require "emf/emf_plus/records/primitives/graphics_version"
+require "emf/emf_plus/records/primitives/transform_matrix"
+
+module Emf
+  module EmfPlus
+    module Objects
+      # EmfPlusPen (2.2.1.7): Version, Type, PenData (2.2.2.33) with the
+      # optional data its flags select (2.2.2.34), then an EmfPlusBrush.
+      # The brush reads to the end of the object, so alignment padding is in
+      # the brush's `trailing`.
+      class Pen < Typed
+        DATA_TRANSFORM = 0x001
+        DATA_START_CAP = 0x002
+        DATA_END_CAP = 0x004
+        DATA_JOIN = 0x008
+        DATA_MITER_LIMIT = 0x010
+        DATA_LINE_STYLE = 0x020
+        DATA_DASHED_LINE_CAP = 0x040
+        DATA_DASH_OFFSET = 0x080
+        DATA_DASHED_LINE = 0x100
+        DATA_NON_CENTER = 0x200
+        DATA_COMPOUND_LINE = 0x400
+        DATA_CUSTOM_START_CAP = 0x800
+        DATA_CUSTOM_END_CAP = 0x1000
+
+        P = Records::Primitives
+        private_constant :P
+
+        class PenHeader < Records::Body
+          endian :little
+          graphics_version :version
+          uint32 :pen_type
+          uint32 :pen_data_flags
+          uint32 :pen_unit
+          float32_le :pen_width
+        end
+
+        # EmfPlusDashedLineData (2.2.2.16).
+        class DashedLineData < Records::Body
+          endian :little
+          uint32 :dashed_line_data_size
+          array :dashed_line_data, type: :float32_le, initial_length: :dashed_line_data_size
+        end
+
+        # EmfPlusCompoundLineData (2.2.2.9).
+        class CompoundLineData < Records::Body
+          endian :little
+          uint32 :compound_line_data_size
+          array :compound_line_data, type: :float32_le, initial_length: :compound_line_data_size
+        end
+
+        # Optional scalars in spec order: flag, part name, BinData type.
+        SCALARS = [
+          [DATA_START_CAP, :start_cap, BinData::Int32le],
+          [DATA_END_CAP, :end_cap, BinData::Int32le],
+          [DATA_JOIN, :join, BinData::Int32le],
+          [DATA_MITER_LIMIT, :miter_limit, Emf::Binary::Float32Le],
+          [DATA_LINE_STYLE, :line_style, BinData::Int32le],
+          [DATA_DASHED_LINE_CAP, :dashed_line_cap, BinData::Int32le],
+          [DATA_DASH_OFFSET, :dash_offset, Emf::Binary::Float32Le]
+        ].freeze
+        private_constant :SCALARS
+
+        # Walks the data once, reading each piece the flags select.
+        class Reader
+          def initialize(data, logical)
+            @cursor = Parts::Cursor.new(data)
+            @logical = logical
+          end
+
+          def read
+            @cursor.take(:header, PenHeader)
+            read_optional(@cursor.parts.fetch(:header).pen_data_flags)
+            @cursor.parts[:brush] = Parts::Nested.new(Brush.new(slice(BRUSH, @cursor.rest)))
+            Parts::Body.new(@cursor.parts)
+          end
+
+          private
+
+          def read_optional(flags)
+            @cursor.take(:transform, P::TransformMatrix) if flags.anybits?(DATA_TRANSFORM)
+            SCALARS.each { |flag, name, type| @cursor.take(name, type) if flags.anybits?(flag) }
+            @cursor.take_counted(:dashed_line, DashedLineData, 4) if flags.anybits?(DATA_DASHED_LINE)
+            @cursor.take(:pen_alignment, BinData::Int32le) if flags.anybits?(DATA_NON_CENTER)
+            @cursor.take_counted(:compound_line, CompoundLineData, 4) if flags.anybits?(DATA_COMPOUND_LINE)
+            read_custom_cap(:custom_start_cap) if flags.anybits?(DATA_CUSTOM_START_CAP)
+            read_custom_cap(:custom_end_cap) if flags.anybits?(DATA_CUSTOM_END_CAP)
+          end
+
+          def read_custom_cap(name)
+            @cursor.take_sized(name) { |bytes| Parts::Nested.new(CustomLineCap.new(slice(CUSTOM_LINE_CAP, bytes))) }
+          end
+
+          def slice(object_type, bytes) = Parts::Slice.new(object_type, bytes, @logical.offset)
+        end
+
+        def pen_type = header.pen_type
+        def pen_data_flags = header.pen_data_flags
+        def pen_unit = header.pen_unit
+        def pen_width = header.pen_width
+        def transform = body.parts[:transform]
+        def start_cap = scalar(:start_cap)
+        def end_cap = scalar(:end_cap)
+        def join = scalar(:join)
+        def miter_limit = scalar(:miter_limit)
+        def line_style = scalar(:line_style)
+        def dashed_line_cap = scalar(:dashed_line_cap)
+        def dash_offset = scalar(:dash_offset)
+        def pen_alignment = scalar(:pen_alignment)
+        def dashed_line = body.parts[:dashed_line]&.dashed_line_data&.to_a
+        def compound_line = body.parts[:compound_line]&.compound_line_data&.to_a
+        def custom_start_cap = body.parts[:custom_start_cap]&.inner&.object
+        def custom_end_cap = body.parts[:custom_end_cap]&.inner&.object
+        def brush = body.parts.fetch(:brush).object
+
+        private
+
+        def header = body.parts.fetch(:header)
+        def scalar(name) = body.parts[name]&.value
+
+        def read_body(data, logical)
+          Reader.new(data, logical).read
+        rescue IOError, BinData::ValidityError, Parts::Malformed => e
+          fail_parse(logical, e.message)
+        end
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/objects/region.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "stringio"
+require "emf/emf_plus/records/primitives/byte_reader"
+require "emf/emf_plus/records/primitives/graphics_version"
+require "emf/emf_plus/records/primitives/region_node"
+
+module Emf
+  module EmfPlus
+    module Objects
+      # EmfPlusRegion object (2.2.1.8). The RegionNode array of the spec is a
+      # preorder binary tree, so one root node holds all RegionNodeCount + 1
+      # nodes; bytes after the root stay in `trailing`.
+      class Region < Typed
+        class RegionBody
+          include Records::Primitives::ByteReader
+
+          attr_reader :version, :region_node_count, :root
+
+          def read(source)
+            io = StringIO.new(source)
+            @version = Records::Primitives::GraphicsVersion.new.read(io)
+            @region_node_count = take(io, 4, "RegionNodeCount").unpack1("V")
+            @root = Records::Primitives::RegionNode.new.read(io)
+            @size = io.pos
+            self
+          end
+
+          def num_bytes = @size
+          def to_binary_s = version.to_binary_s + [region_node_count].pack("V") + root.to_binary_s
+        end
+        BODY = RegionBody
+
+        def node_count = body.region_node_count
+        def root = body.root
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/objects/string_format.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "emf/binary/float32_le"
+require "emf/emf_plus/records/primitives/graphics_version"
+require "emf/emf_plus/records/primitives/language_identifier"
+require "emf/emf_plus/records/primitives/string_format_data"
+
+module Emf
+  module EmfPlus
+    module Objects
+      # EmfPlusStringFormat (2.2.1.9).
+      class StringFormat < Typed
+        FIXED_SIZE = 60
+        COUNTS_OFFSET = 52
+
+        class StringFormatBody < Records::Body
+          endian :little
+          graphics_version :version
+          uint32 :string_format_flags
+          language_identifier :language
+          uint32 :string_alignment
+          uint32 :line_align
+          uint32 :digit_substitution
+          language_identifier :digit_language
+          float32_le :first_tab_offset
+          int32 :hotkey_prefix
+          float32_le :leading_margin
+          float32_le :trailing_margin
+          float32_le :tracking
+          uint32 :trimming
+          int32 :tab_stop_count
+          int32 :range_count
+          string_format_data :string_format_data, tab_stop_count: -> { tab_stop_count },
+                                                  range_count: -> { range_count }
+        end
+        BODY = StringFormatBody
+
+        def flags = body.string_format_flags
+        def tab_stops = body.string_format_data.tab_stops.to_a
+        def char_ranges = body.string_format_data.char_ranges.map { |r| [r.first_position, r.range_length] }
+
+        private
+
+        def check_bounds(data, logical)
+          return if data.bytesize < FIXED_SIZE
+
+          tab_stops, ranges = data.byteslice(COUNTS_OFFSET, 8).unpack("l<l<")
+          fail_parse(logical, "negative count (TabStopCount #{tab_stops}, RangeCount #{ranges})") if tab_stops.negative? || ranges.negative?
+          require_room(data, logical, FIXED_SIZE + (tab_stops * 4) + (ranges * 8),
+                       "StringFormatData of #{tab_stops} tab stops and #{ranges} ranges")
+        end
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/objects/typed.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "bindata"
+
+module Emf
+  module EmfPlus
+    module Objects
+      # A graphics object read through a BinData class (BODY in the subclass).
+      # Bytes after the body (alignment padding) stay in `trailing`, so an
+      # unedited object re-encodes to its ObjectData.
+      class Typed
+        attr_reader :object_type, :body, :trailing
+
+        def initialize(logical)
+          @object_type = logical.object_type
+          data = logical.data
+          check_bounds(data, logical)
+          @body = read_body(data, logical)
+          @trailing = data.byteslice(@body.num_bytes..).freeze
+        end
+
+        def to_binary = body.to_binary_s + trailing
+
+        def version = body.version.raw
+
+        private
+
+        def check_bounds(_data, _logical); end
+
+        def read_body(data, logical)
+          self.class::BODY.new.read(data)
+        rescue IOError, BinData::ValidityError => e
+          fail_parse(logical, e.message)
+        end
+
+        def fail_parse(logical, message)
+          name = self.class.name.split("::").last
+          raise ParseError.new(offset: logical.offset, record_code: Records::Object::TYPE,
+                               message: "malformed #{name} object at offset #{logical.offset}: #{message}")
+        end
+
+        def require_room(data, logical, needed, what)
+          return if needed <= data.bytesize
+
+          fail_parse(logical, "#{what} needs #{needed} bytes, object holds #{data.bytesize}")
+        end
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/objects.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Emf
+  module EmfPlus
+    # Typed bodies for the ObjectData carried by EmfPlusObject records.
+    # Object types without a class keep their bytes in Objects::Opaque.
+    module Objects
+      autoload :Opaque, "emf/emf_plus/objects/opaque"
+      autoload :Typed, "emf/emf_plus/objects/typed"
+      autoload :Font, "emf/emf_plus/objects/font"
+      autoload :StringFormat, "emf/emf_plus/objects/string_format"
+      autoload :ImageAttributes, "emf/emf_plus/objects/image_attributes"
+      autoload :Brush, "emf/emf_plus/objects/brush"
+      autoload :Path, "emf/emf_plus/objects/path"
+      autoload :Region, "emf/emf_plus/objects/region"
+      autoload :Image, "emf/emf_plus/objects/image"
+      autoload :Parts, "emf/emf_plus/objects/parts"
+      autoload :Pen, "emf/emf_plus/objects/pen"
+      autoload :CustomLineCap, "emf/emf_plus/objects/custom_line_cap"
+
+      BRUSH = 1
+      PEN = 2
+      PATH = 3
+      REGION = 4
+      IMAGE = 5
+      FONT = 6
+      STRING_FORMAT = 7
+      IMAGE_ATTRIBUTES = 8
+      CUSTOM_LINE_CAP = 9
+      TYPED = {
+        BRUSH => :Brush, PEN => :Pen, PATH => :Path, REGION => :Region, IMAGE => :Image,
+        FONT => :Font, STRING_FORMAT => :StringFormat, IMAGE_ATTRIBUTES => :ImageAttributes,
+        CUSTOM_LINE_CAP => :CustomLineCap
+      }.freeze
+      private_constant :TYPED
+
+      module_function
+
+      # `logical` is an ObjectChain::LogicalObject.
+      def decode(logical)
+        name = TYPED[logical.object_type]
+        name ? const_get(name).new(logical) : Opaque.new(logical)
+      end
+    end
+  end
+end