idml 0.8.2 → 0.8.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 27df11baaefb3de6bfc6198404a9b3ad10b54b53de8a44cbe58658afdfdf4d4b
-  data.tar.gz: 4274cf4d1869bab1457da1427d8ba96d27cf64ced0140174923b7492ee283dd8
+  metadata.gz: a20e81d5d762e6dfcb5c374d342210ac6132a96604d83ee305dfa1c64e64e535
+  data.tar.gz: e6da886fc60f952b2e9f39f512027b953958c19e14cadf3200dc9952e4c3fa96
 SHA512:
-  metadata.gz: '02936232be8a99effaf2f417d765281700c8f6b89004bab18e462d29d8b60b12259a715780fd0c2c1b68d41e5f82cd087b2933753551c72f3235d5cfbe3e3640'
-  data.tar.gz: e92764f18f109a4ae66dabb4ebfcb3a991cd2926c22e7836de42e99d7c1b45e931cd0aa4f22678193564fb82bdbf24eeccd593405a1ada0322cda7f5ce54f32d
+  metadata.gz: f8a51af44eaa9c43cba3bbdc9f332b1fa94f34f3eb08cb32ce01b957ceff14d6903f03a2d458884a538ef6f6e56d224868427abc46f1303d8f04d82324d9aa5b
+  data.tar.gz: 68e81d0fc87751c37015ea4a3b905a65c7863145bc074714e3241a02e4f951294703b3a3b4eef8d46601d896b95ddc40d3d267f9e54ee71483b2ba9bccbb742a

data/TODO.pdf/107-image-rendering-unification.md

@@ -1,6 +1,19 @@
 # TODO PDF 107: Image rendering unification via PageItemRenderer
 
-## Status: OPEN — gap identified in 2026-08-08 audit
+## Status: DONE for z-order — ImageCollector now tags each ref with
+`parent_self` (the containing page item's Self). SpreadRenderer
+groups refs by parent and renders each item's images when that item
+is reached in the each_page_item loop (instead of all upfront as a
+background layer). Images now respect z-order relative to other
+page items.
+
+Intra-item ordering (fill behind image, stroke on top) remains
+approximate: the image renders BEFORE the item's fill/stroke dispatch.
+For the common case (image inside unfilled rectangle with stroke)
+this produces correct output — image behind stroke. For filled
+rectangles containing images (rare), the fill would cover the image.
+Full intra-item ordering would require integrating image rendering
+into RectangleRenderer between fill and stroke.
 
 ## Problem
 

data/TODO.pdf/113-multi-column-text-frames.md

@@ -1,6 +1,10 @@
 # TODO PDF 113: Multi-column text frames (TextColumnCount, TextColumnGutter)
 
-## Status: OPEN — gap identified in 2026-08-10 audit
+## Status: DONE — engine_render detects TextColumnCount > 1 and
+splits the frame into N column-specific Frame structs. Text flows
+column 1 → column 2 → ... → chain to next frame via StoryChainController.
+Each column acts as a mini-frame with the same height/insets but a
+narrower width. TextColumnGutter honored as the gap between columns.
 
 ## Problem
 

data/lib/idml/render/image_collector.rb

@@ -56,11 +56,13 @@ module Idml
 
         load_new(image, parent, uri)
       end
+      private :register
 
       def reuse(name, image, parent)
         { name: name, placement: placement_for(image, parent),
-          clip_box: clip_box_for(parent) }
+          clip_box: clip_box_for(parent), parent_self: parent.self_attr }
       end
+      private :reuse
 
       def load_new(image, parent, uri)
         path = Image.resolve_path(uri, base_dir: @base_dir)
@@ -73,8 +75,9 @@ module Idml
         name = @writer.add_image(data: data)
         @writer.register_image_name(uri, name)
         { name: name, placement: placement_for(image, parent, dims[1]),
-          clip_box: clip_box_for(parent) }
+          clip_box: clip_box_for(parent), parent_self: parent.self_attr }
       end
+      private :load_new
 
       def clip_box_for(parent)
         return nil unless parent.geometric_bounds

data/lib/idml/render/renderers/text_frame_renderer.rb

@@ -158,7 +158,22 @@ module Idml
         # next frame in the chain.
         def self.engine_render(canvas, state, context, box, font)
           layout_frame = layout_frame(context.item, box)
-          top_y = box[:y] + box[:height] - (layout_frame.inset_top || 0)
+          col_count = text_column_count(context)
+
+          if col_count && col_count > 1
+            engine_render_multi_column(canvas, state, context, layout_frame,
+                                       font, col_count)
+          else
+            engine_render_single_column(canvas, state, context, layout_frame,
+                                        font)
+          end
+        end
+        private_class_method :engine_render
+
+        def self.engine_render_single_column(canvas, state, context,
+                                              layout_frame, font)
+          top_y = layout_frame.y + layout_frame.height -
+            (layout_frame.inset_top || 0)
           bottom_limit = TextEngine::VerticalLayout.bottom_limit(layout_frame)
           cursor_y = vertical_justify_top(top_y, bottom_limit, state, context)
           char_cursor = state.char_cursor
@@ -174,7 +189,87 @@ module Idml
           consume_paragraphs(canvas, state, context, layout_frame, font,
                              cursor_y, bottom_limit, char_cursor)
         end
-        private_class_method :engine_render
+        private_class_method :engine_render_single_column
+
+        # Renders text across N columns within a single frame. Text
+        # flows column 1 → column 2 → ... → chain to next frame. Each
+        # column acts as a mini-frame with the same height but a
+        # narrower width. The chain state threads across columns
+        # transparently.
+        def self.engine_render_multi_column(canvas, state, context,
+                                             layout_frame, font, col_count)
+          gutter = text_column_gutter(context) || 0
+          col_frames = build_column_frames(layout_frame, col_count, gutter)
+
+          col_frames.each do |col_frame|
+            break if state_empty?(state)
+
+            render_column(canvas, state, context, col_frame, font)
+          end
+        end
+        private_class_method :engine_render_multi_column
+
+        def self.render_column(canvas, state, context, col_frame, font)
+          top_y = col_frame.y + col_frame.height - (col_frame.inset_top || 0)
+          bottom_limit = TextEngine::VerticalLayout.bottom_limit(col_frame)
+          cursor_y = top_y
+          char_cursor = state.char_cursor
+
+          if state.current_paragraph
+            cursor_y, char_cursor = resume_paragraph(
+              canvas, state, context, col_frame, font,
+              cursor_y, bottom_limit, char_cursor
+            )
+            return if state.current_paragraph
+          end
+
+          consume_paragraphs(canvas, state, context, col_frame, font,
+                             cursor_y, bottom_limit, char_cursor)
+        end
+        private_class_method :render_column
+
+        def self.state_empty?(state)
+          state.paragraphs.empty? && state.current_paragraph.nil?
+        end
+        private_class_method :state_empty?
+
+        def self.text_column_count(context)
+          pref = context.item&.text_frame_preference&.first
+          pref&.text_column_count
+        end
+        private_class_method :text_column_count
+
+        def self.text_column_gutter(context)
+          pref = context.item&.text_frame_preference&.first
+          pref&.text_column_gutter
+        end
+        private_class_method :text_column_gutter
+
+        # Builds N column-specific Frame structs from the parent
+        # layout frame. Each column has the same y/height/insets but
+        # a different x and width so VerticalLayout's geometry math
+        # produces correct per-column results.
+        def self.build_column_frames(layout_frame, col_count, gutter)
+          inset_left = layout_frame.inset_left || 0
+          inset_right = layout_frame.inset_right || 0
+          content_width = layout_frame.width - inset_left - inset_right
+          col_width = (content_width - ((col_count - 1) * gutter)) / col_count
+
+          Array.new(col_count) do |i|
+            col_left = layout_frame.x + inset_left + (i * (col_width + gutter))
+            TextEngine::Frame.new(
+              x: col_left - inset_left,
+              y: layout_frame.y,
+              width: col_width + inset_left + inset_right,
+              height: layout_frame.height,
+              inset_top: layout_frame.inset_top,
+              inset_bottom: layout_frame.inset_bottom,
+              inset_left: inset_left,
+              inset_right: inset_right,
+            )
+          end
+        end
+        private_class_method :build_column_frames
 
         # Computes the starting cursor_y for vertical justification.
         # IDML's TextFramePreference.VerticalJustification can be:

data/lib/idml/render/spread_renderer.rb

@@ -40,14 +40,15 @@ module Idml
           condition_filter: @condition_filter,
           style_lookup: @style_lookup,
         }
+        images_by_parent = group_images_by_parent(image_refs)
 
         canvas.save_graphics_state do
           render_background(canvas, page_width, page_height)
-          render_images(canvas, image_refs)
-          render_master_items(canvas, spread, context_base)
+          render_master_items(canvas, spread, context_base, images_by_parent)
           spread.each_page_item do |item|
             next unless @layer_filter.visible?(item)
 
+            render_item_images(canvas, images_by_parent, item.self_attr)
             context = RenderContext.new(context_base.merge(item: item))
             PageItemRenderer.render(canvas, context)
           end
@@ -62,13 +63,30 @@ module Idml
         canvas.fill
       end
 
+      # Groups image refs by their parent page item's Self so each
+      # item's images render when that item is reached in z-order
+      # (instead of all upfront as a background layer).
+      def group_images_by_parent(image_refs)
+        image_refs.each_with_object({}) do |ref, hash|
+          parent = ref[:parent_self]
+          next unless parent
+
+          (hash[parent] ||= []) << ref
+        end
+      end
+
+      def render_item_images(canvas, images_by_parent, item_self)
+        refs = images_by_parent[item_self]
+        return unless refs
+
+        render_images(canvas, refs)
+      end
+
       def render_images(canvas, image_refs)
         return if image_refs.empty?
 
         image_refs.each do |ref|
           placement = ref[:placement]
-          placement[:scale_x].abs
-          placement[:scale_y].abs
           canvas.save_graphics_state do
             apply_image_clip(canvas, ref)
             canvas.draw_image_matrix(ref[:name],
@@ -88,11 +106,12 @@ module Idml
         canvas.clip
       end
 
-      def render_master_items(canvas, spread, context_base)
+      def render_master_items(canvas, spread, context_base, images_by_parent)
         return unless @package
 
         resolve_master_spreads(spread).each do |master|
-          render_master_page_items(canvas, master, context_base)
+          render_master_page_items(canvas, master, context_base,
+                                   images_by_parent)
         end
       end
 
@@ -107,11 +126,13 @@ module Idml
         masters
       end
 
-      def render_master_page_items(canvas, master_part, context_base)
+      def render_master_page_items(canvas, master_part, context_base,
+                                   images_by_parent)
         master_part.master_spread.each do |master_so|
           master_so.each_page_item do |item|
             next unless @layer_filter.visible?(item)
 
+            render_item_images(canvas, images_by_parent, item.self_attr)
             context = RenderContext.new(context_base.merge(item: item))
             PageItemRenderer.render(canvas, context)
           end

data/lib/idml/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Idml
-  VERSION = "0.8.2"
+  VERSION = "0.8.4"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: idml
 version: !ruby/object:Gem::Version
-  version: 0.8.2
+  version: 0.8.4
 platform: ruby
 authors:
 - Ribose
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-08-13 00:00:00.000000000 Z
+date: 2026-08-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal