emf 0.1.2 → 0.2.0

data/lib/emf/emf_plus/records/set_ts_graphics.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "emf/binary/float32_le"
+require "emf/emf_plus/records/primitives/palette"
+
+module Emf
+  module EmfPlus
+    module Records
+      # EmfPlusSetTSGraphics (2.3.8.2). Flags bit T says an EmfPlusPalette
+      # follows the fixed part, bit V that it holds only basic VGA colours.
+      # `palette` is the raw palette bytes so any record re-encodes exactly;
+      # `decoded_palette` reads them as an EmfPlusPalette, or is nil when T is
+      # clear or the bytes are not exactly one palette.
+      class SetTSGraphics < Base
+        TYPE = 0x4039
+        PALETTE_FLAG = 0x0001
+        VGA_PALETTE_FLAG = 0x0002
+        FIXED_SIZE = 36
+
+        class SetTSGraphicsBody < Body
+          endian :little
+          mandatory_parameter :data_size
+          mandatory_parameter :flags
+          uint8 :anti_alias_mode
+          uint8 :text_render_hint
+          uint8 :compositing_mode
+          uint8 :compositing_quality
+          int16 :render_origin_x
+          int16 :render_origin_y
+          uint16 :text_contrast
+          uint8 :filter_type
+          uint8 :pixel_offset
+          array :world_to_device, type: :float32_le, initial_length: 6
+          string :palette, read_length: -> { flags.anybits?(PALETTE_FLAG) ? data_size - FIXED_SIZE : 0 }
+        end
+        BODY = SetTSGraphicsBody
+
+        def flag_fields = { palette: PALETTE_FLAG, vga_palette: VGA_PALETTE_FLAG }
+
+        def palette? = flags.anybits?(PALETTE_FLAG)
+        def vga_palette? = flags.anybits?(VGA_PALETTE_FLAG)
+        def anti_alias_mode = body.anti_alias_mode.to_i
+        def text_render_hint = body.text_render_hint.to_i
+        def compositing_mode = body.compositing_mode.to_i
+        def compositing_quality = body.compositing_quality.to_i
+        def render_origin_x = body.render_origin_x.to_i
+        def render_origin_y = body.render_origin_y.to_i
+        def text_contrast = body.text_contrast.to_i
+        def filter_type = body.filter_type.to_i
+        def pixel_offset = body.pixel_offset.to_i
+        def world_to_device = body.world_to_device.to_a
+        def palette = body.palette.to_s
+        alias palette_bytes palette
+
+        def decoded_palette
+          return unless palette?
+
+          decoded = Primitives::Palette.read(palette)
+          decoded if decoded.num_bytes == palette.bytesize
+        rescue IOError
+          nil
+        end
+
+        # Besides the base edits, `with(decoded_palette: {...})` takes a Hash of
+        # EmfPlusPalette fields: it sets T and replaces the palette bytes.
+        # PaletteCount defaults to the number of entries given.
+        private
+
+        def edited_flags(edits)
+          super(edits.key?(:decoded_palette) ? edits.merge(palette: true) : edits)
+        end
+
+        def edited_body(new_flags, edits)
+          return super unless edits.key?(:decoded_palette)
+
+          super(new_flags, edits.except(:decoded_palette)).tap do |fresh|
+            fresh.palette = palette_bytes_for(edits[:decoded_palette])
+          end
+        end
+
+        def palette_bytes_for(fields)
+          count = fields.fetch(:palette_count) { Array(fields[:palette_entries]).size }
+          Primitives::Palette.new(fields.merge(palette_count: count)).to_binary_s
+        end
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/records/set_world_transform.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "emf/emf_plus/records/primitives/transform_matrix"
+
+module Emf
+  module EmfPlus
+    module Records
+      # EmfPlusSetWorldTransform (2.3.9.6): replaces the world transform; Flags are unused.
+      class SetWorldTransform < Base
+        TYPE = 0x402A
+
+        class SetWorldTransformBody < Body
+          endian :little
+          transform_matrix :matrix
+        end
+        BODY = SetWorldTransformBody
+
+        def matrix = body.matrix
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/records/shape_flags.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Emf
+  module EmfPlus
+    module Records
+      # Record Flags bits shared by the drawing and fill records (2.3.4). The
+      # low byte is an object-table index whose meaning is per record.
+      module ShapeFlags
+        COMPRESSED_FLAG = 0x4000
+        RELATIVE_FLAG = 0x0800
+        OBJECT_ID_MASK = 0x00FF
+
+        def flag_fields
+          super.merge(compressed: COMPRESSED_FLAG, relative: RELATIVE_FLAG, emf_object_id: OBJECT_ID_MASK)
+        end
+
+        def compressed? = flags.anybits?(COMPRESSED_FLAG)
+        def relative? = flags.anybits?(RELATIVE_FLAG)
+        def emf_object_id = flags & OBJECT_ID_MASK
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/records/translate_world_transform.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "emf/binary/float32_le"
+
+module Emf
+  module EmfPlus
+    module Records
+      # EmfPlusTranslateWorldTransform (2.3.9.7): translation by dx, dy.
+      class TranslateWorldTransform < Base
+        include PostMultiplyFlag
+
+        TYPE = 0x402D
+
+        class TranslateWorldTransformBody < Body
+          endian :little
+          float32_le :dx
+          float32_le :dy
+        end
+        BODY = TranslateWorldTransformBody
+
+        def dx = body.dx
+        def dy = body.dy
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/records/unknown.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Emf
+  module EmfPlus
+    module Records
+      # A record type without a typed class; the frame is kept as is.
+      class Unknown
+        attr_reader :frame
+
+        def initialize(frame)
+          @frame = frame
+        end
+
+        def type = frame.type
+        def flags = frame.flags
+        def to_binary = frame.to_binary
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/records.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Emf
+  module EmfPlus
+    # Typed views over framed EMF+ records. Types without a class decode to
+    # Records::Unknown, which keeps the frame so nothing is dropped.
+    module Records
+      autoload :Primitives, "emf/emf_plus/records/primitives"
+      autoload :Base, "emf/emf_plus/records/base"
+      autoload :Body, "emf/emf_plus/records/body"
+      autoload :Unknown, "emf/emf_plus/records/unknown"
+      autoload :Header, "emf/emf_plus/records/header"
+      autoload :EndOfFile, "emf/emf_plus/records/end_of_file"
+      autoload :Comment, "emf/emf_plus/records/comment"
+      autoload :GetDC, "emf/emf_plus/records/get_dc"
+      autoload :Object, "emf/emf_plus/records/object"
+
+      # Flag mixins shared by several record families.
+      autoload :ShapeFlags, "emf/emf_plus/records/shape_flags"
+      autoload :FillBrush, "emf/emf_plus/records/fill_brush"
+      autoload :CombineModeFlags, "emf/emf_plus/records/clip_transform_flags"
+      autoload :PostMultiplyFlag, "emf/emf_plus/records/clip_transform_flags"
+
+      # Drawing and fill
+      autoload :Clear, "emf/emf_plus/records/clear"
+      autoload :DrawRects, "emf/emf_plus/records/draw_rects"
+      autoload :DrawLines, "emf/emf_plus/records/draw_lines"
+      autoload :DrawEllipse, "emf/emf_plus/records/draw_ellipse"
+      autoload :DrawPie, "emf/emf_plus/records/draw_pie"
+      autoload :DrawArc, "emf/emf_plus/records/draw_arc"
+      autoload :DrawPath, "emf/emf_plus/records/draw_path"
+      autoload :DrawClosedCurve, "emf/emf_plus/records/draw_closed_curve"
+      autoload :DrawCurve, "emf/emf_plus/records/draw_curve"
+      autoload :DrawBeziers, "emf/emf_plus/records/draw_beziers"
+      autoload :FillRects, "emf/emf_plus/records/fill_rects"
+      autoload :FillPolygon, "emf/emf_plus/records/fill_polygon"
+      autoload :FillEllipse, "emf/emf_plus/records/fill_ellipse"
+      autoload :FillPie, "emf/emf_plus/records/fill_pie"
+      autoload :FillRegion, "emf/emf_plus/records/fill_region"
+      autoload :FillPath, "emf/emf_plus/records/fill_path"
+      autoload :FillClosedCurve, "emf/emf_plus/records/fill_closed_curve"
+
+      # State
+      autoload :SetRenderingOrigin, "emf/emf_plus/records/set_rendering_origin"
+      autoload :SetAntiAliasMode, "emf/emf_plus/records/set_anti_alias_mode"
+      autoload :SetTextRenderingHint, "emf/emf_plus/records/set_text_rendering_hint"
+      autoload :SetTextContrast, "emf/emf_plus/records/set_text_contrast"
+      autoload :SetInterpolationMode, "emf/emf_plus/records/set_interpolation_mode"
+      autoload :SetPixelOffsetMode, "emf/emf_plus/records/set_pixel_offset_mode"
+      autoload :SetCompositingMode, "emf/emf_plus/records/set_compositing_mode"
+      autoload :SetCompositingQuality, "emf/emf_plus/records/set_compositing_quality"
+      autoload :Save, "emf/emf_plus/records/save"
+      autoload :Restore, "emf/emf_plus/records/restore"
+      autoload :BeginContainer, "emf/emf_plus/records/begin_container"
+      autoload :BeginContainerNoParams, "emf/emf_plus/records/begin_container_no_params"
+      autoload :EndContainer, "emf/emf_plus/records/end_container"
+      autoload :SetTSGraphics, "emf/emf_plus/records/set_ts_graphics"
+
+      # Clipping and transform
+      autoload :ResetClip, "emf/emf_plus/records/reset_clip"
+      autoload :OffsetClip, "emf/emf_plus/records/offset_clip"
+      autoload :SetClipRect, "emf/emf_plus/records/set_clip_rect"
+      autoload :SetClipPath, "emf/emf_plus/records/set_clip_path"
+      autoload :SetClipRegion, "emf/emf_plus/records/set_clip_region"
+      autoload :SetTSClip, "emf/emf_plus/records/set_ts_clip"
+      autoload :SetWorldTransform, "emf/emf_plus/records/set_world_transform"
+      autoload :ResetWorldTransform, "emf/emf_plus/records/reset_world_transform"
+      autoload :MultiplyWorldTransform, "emf/emf_plus/records/multiply_world_transform"
+      autoload :TranslateWorldTransform, "emf/emf_plus/records/translate_world_transform"
+      autoload :ScaleWorldTransform, "emf/emf_plus/records/scale_world_transform"
+      autoload :RotateWorldTransform, "emf/emf_plus/records/rotate_world_transform"
+      autoload :SetPageTransform, "emf/emf_plus/records/set_page_transform"
+
+      # Text and image
+      autoload :DrawString, "emf/emf_plus/records/draw_string"
+      autoload :DrawDriverString, "emf/emf_plus/records/draw_driver_string"
+      autoload :DrawImage, "emf/emf_plus/records/draw_image"
+      autoload :DrawImagePoints, "emf/emf_plus/records/draw_image_points"
+      autoload :SerializableObject, "emf/emf_plus/records/serializable_object"
+
+      module_function
+
+      def registry
+        @registry ||= [
+          Header, EndOfFile, Comment, GetDC, Object,
+          Clear, DrawRects, DrawLines, DrawEllipse, DrawPie, DrawArc, DrawPath, DrawClosedCurve, DrawCurve, DrawBeziers,
+          FillRects, FillPolygon, FillEllipse, FillPie, FillRegion, FillPath, FillClosedCurve,
+          SetRenderingOrigin, SetAntiAliasMode, SetTextRenderingHint, SetTextContrast, SetInterpolationMode,
+          SetPixelOffsetMode, SetCompositingMode, SetCompositingQuality, Save, Restore, BeginContainer,
+          BeginContainerNoParams, EndContainer, SetTSGraphics,
+          ResetClip, OffsetClip, SetClipRect, SetClipPath, SetClipRegion, SetTSClip,
+          SetWorldTransform, ResetWorldTransform, MultiplyWorldTransform, TranslateWorldTransform,
+          ScaleWorldTransform, RotateWorldTransform, SetPageTransform,
+          DrawString, DrawDriverString, DrawImage, DrawImagePoints, SerializableObject
+        ].to_h { |klass| [klass::TYPE, klass] }.freeze
+      end
+
+      def decode(frame)
+        registry.fetch(frame.type, Unknown).new(frame)
+      end
+
+      def decode_all(frames)
+        frames.map { |frame| decode(frame) }
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/serializer.rb

@@ -5,8 +5,15 @@ module Emf
     module Serializer
       module_function
 
-      def call(_metafile)
-        raise SerializeError, "EMF+ serializer not yet implemented — see TODO.impl/15-public-api.md"
+      def call(frames)
+        frames.map(&:to_binary).join.b
+      end
+
+      # Re-serializes frames per originating comment: { record index => payload
+      # bytes (without the "EMF+" identifier) }, ready to write back into the
+      # matching EMR_COMMENT.
+      def by_comment(frames)
+        frames.group_by(&:comment_index).transform_values { |group| call(group) }
       end
     end
   end

data/lib/emf/emf_plus/stream/conformance.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Emf
+  module EmfPlus
+    class Stream
+      # Reports records MS-EMFPLUS 2.1.1.1 does not allow in a conformant file.
+      # Only reports: the records stay Records::Unknown with their bytes intact.
+      # `kind` is :reserved_type, :stroke_fill_path, :unknown_type or
+      # :header_not_after_emf_header.
+      module Conformance
+        Diagnostic = Struct.new(:kind, :comment_index, :offset, :record_type, :message, keyword_init: true) do
+          def initialize(**)
+            super
+            freeze
+          end
+        end
+
+        RESERVED = (0x4005..0x4007)
+        STROKE_FILL_PATH = 0x4037
+        DEFINED = (0x4001..0x403A)
+
+        module_function
+
+        HEADER_PLACEMENT = "EmfPlusHeader record MUST be embedded in an EMR_COMMENT_EMFPLUS record, " \
+                           "which MUST be the record immediately following the EMF header (MS-EMFPLUS 2.3.3.3)"
+
+        def check(handles, segments)
+          (type_diagnostics(handles, segments) + header_diagnostics(handles, segments)).freeze
+        end
+
+        def type_diagnostics(handles, segments)
+          handles.filter_map do |handle|
+            next unless handle.record.is_a?(Records::Unknown)
+
+            kind, message = classify(handle.record.type)
+            next unless kind
+
+            Diagnostic.new(kind: kind, comment_index: segments[handle.segment_index].record_index,
+                           offset: handle.offset, record_type: handle.record.type, message: message)
+          end
+        end
+
+        # Only the first header is placed: the text does not forbid further
+        # headers, and corpus files carry a second one in a later comment.
+        def header_diagnostics(handles, segments)
+          handle = handles.find { |candidate| candidate.record.is_a?(Records::Header) }
+          comment_index = handle && segments[handle.segment_index].record_index
+          return [] if handle.nil? || comment_index.zero?
+
+          [Diagnostic.new(kind: :header_not_after_emf_header, comment_index: comment_index, offset: handle.offset,
+                          record_type: handle.record.type, message: HEADER_PLACEMENT)]
+        end
+
+        def classify(type)
+          if RESERVED.cover?(type)
+            [:reserved_type, format("reserved EMF+ record type 0x%04X MUST NOT be used", type)]
+          elsif type == STROKE_FILL_PATH
+            [:stroke_fill_path, "EmfPlusStrokeFillPath (0x4037) has no record layout"]
+          elsif !DEFINED.cover?(type)
+            [:unknown_type, format("EMF+ record type 0x%04X is outside 0x4001-0x403A", type)]
+          end
+        end
+
+        private_class_method :type_diagnostics, :header_diagnostics, :classify
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/stream/editor.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Emf
+  module EmfPlus
+    class Stream
+      # Collects record replacements for Stream#edit.
+      class Editor
+        attr_reader :stream
+
+        def initialize(stream)
+          @stream = stream
+        end
+
+        def replace(handle, record)
+          @stream = @stream.with_record(handle, record)
+          self
+        end
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/stream/emf_gap.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Emf
+  module EmfPlus
+    class Stream
+      # The EMF records (indices into Metafile#records) lying between two
+      # EMF+-bearing comments, or before the first / after the last one.
+      class EmfGap
+        attr_reader :range
+
+        def initialize(range)
+          @range = range
+          freeze
+        end
+
+        def gap? = true
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/stream/link_index.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Emf
+  module EmfPlus
+    class Stream
+      # The Links view of a stream's records: GetDC spans, effect links by draw
+      # handle and link diagnostics.
+      class LinkIndex
+        # A record handle seen through the framed-record interface Links reads.
+        Frame = Struct.new(:handle, :comment_index) do
+          def type = handle.record.type
+          def flags = handle.record.flags
+          def offset = handle.offset
+        end
+        private_constant :Frame
+
+        attr_reader :dc_spans, :errors
+
+        def initialize(source, handles, segments)
+          frames = handles.map { |handle| Frame.new(handle, segments[handle.segment_index].record_index) }
+          links, @errors = Links.effect_links(frames)
+          @effects = links.to_h { |link| [link.draw.handle.stream_index, link.effect.handle] }.freeze
+          @dc_spans = Links.get_dc_spans(source, frames).freeze
+        end
+
+        def effect_for(handle) = @effects[handle.stream_index]
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/stream/rebuild.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Emf
+  module EmfPlus
+    class Stream
+      # Builds the edited Metafile: dirty segments' comments are rewritten, every
+      # other record is reused, and the header size follows the byte change.
+      class Rebuild
+        def initialize(source, dirty_segments)
+          @source = source
+          @dirty_segments = dirty_segments
+        end
+
+        def call
+          records = @source.records.dup
+          delta = @dirty_segments.sum { |segment| rewrite_comment(records, segment) }
+          Model::Metafile.new(format: @source.format, header: resized_header(delta), records: records,
+                              errors: @source.errors, emf_plus: emf_plus_of(records), trailing: @source.trailing)
+        end
+
+        private
+
+        # Replaces the segment's comment in `records`; returns the change in bytes.
+        def rewrite_comment(records, segment)
+          original = @source.records[segment.record_index]
+          wire = segment.comment_wire(original.wire)
+          records[segment.record_index] = Model::Emr::Records::WireAdapter.new(wire: wire, offset: original.offset)
+          wire.n_size - original.wire.n_size
+        end
+
+        def resized_header(delta)
+          return @source.header if delta.zero?
+
+          wire = @source.header.to_wire
+          wire.n_bytes = @source.header.n_bytes + delta
+          Model::Emr::Header.from_wire(wire)
+        end
+
+        def emf_plus_of(records)
+          records.filter_map do |record|
+            Emf::Emr::Parser.extract_emf_plus(record.wire) if record.wire.is_a?(Emf::Emr::Binary::Records::Comment)
+          end.join.b
+        end
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/stream/record_handle.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Emf
+  module EmfPlus
+    class Stream
+      # A typed EMF+ record with its position: the segment it lives in, its byte
+      # offset inside that segment's payload and its index among all records.
+      # `comment_offset` is the file offset of the containing EMR_COMMENT, or nil
+      # when the source record has none (a rebuilt or hand-made metafile).
+      class RecordHandle
+        attr_reader :record, :segment_index, :offset, :stream_index, :comment_offset
+
+        def initialize(record:, segment_index:, offset:, stream_index:, comment_offset: nil)
+          @record = record
+          @segment_index = segment_index
+          @offset = offset
+          @stream_index = stream_index
+          @comment_offset = comment_offset
+          freeze
+        end
+
+        def gap? = false
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/stream/segment.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Emf
+  module EmfPlus
+    class Stream
+      # The EMF+ payload of one EMR_COMMENT. `record_index` locates the comment
+      # in Metafile#records and `payload_range` the payload inside its wire
+      # data (after the "EMF+" identifier). Bytes the framer could not read
+      # (`unframed`) and bytes after cb_data (`tail`) are kept verbatim.
+      class Segment
+        IDENTIFIER = "EMF+".b.freeze
+
+        attr_reader :record_index, :payload_range, :records, :unframed, :tail
+
+        # Returns nil unless the comment carries an EMF+ payload.
+        def self.from_comment(record_index, wire, errors)
+          data = wire.data.b
+          return unless wire.cb_data >= IDENTIFIER.bytesize && data.start_with?(IDENTIFIER)
+
+          length = [wire.cb_data, data.bytesize].min - IDENTIFIER.bytesize
+          payload = data.byteslice(IDENTIFIER.bytesize, length)
+          frames = Parser.call(payload, errors: errors, comment_index: record_index)
+          framed = frames.sum(&:size)
+          payload_end = IDENTIFIER.bytesize + length
+          new(record_index: record_index, payload_range: IDENTIFIER.bytesize...payload_end, records: decode(frames, errors),
+              unframed: payload.byteslice(framed..), tail: data.byteslice(payload_end..))
+        end
+
+        def self.decode(frames, errors)
+          frames.map do |frame|
+            Records.decode(frame)
+          rescue ParseError => e
+            errors << e
+            Records::Unknown.new(frame)
+          end
+        end
+
+        def initialize(record_index:, payload_range:, records:, unframed:, tail:, dirty: false)
+          @record_index = record_index
+          @payload_range = payload_range
+          @records = records.freeze
+          @unframed = unframed.freeze
+          @tail = tail.freeze
+          @dirty = dirty
+          freeze
+        end
+
+        def dirty? = @dirty
+
+        def payload
+          records.map(&:to_binary).join.b + unframed
+        end
+
+        def replace(position, record)
+          swapped = records.dup.tap { |list| list[position] = record }
+          self.class.new(record_index: record_index, payload_range: payload_range, records: swapped,
+                         unframed: unframed, tail: tail, dirty: true)
+        end
+
+        # The EMR_COMMENT wire for this segment with cb_data and nSize recomputed.
+        def comment_wire(original)
+          data = IDENTIFIER + payload + tail
+          padded = data + ("\0" * (-data.bytesize % 4))
+          Emf::Emr::Binary::Records::Comment.new(i_type: original.i_type, n_size: 12 + padded.bytesize,
+                                                 cb_data: IDENTIFIER.bytesize + payload.bytesize, data: padded)
+        end
+      end
+    end
+  end
+end