idml 0.8.1 → 0.8.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 987636748becfcad9dafe0f703801848e6c4e1bffa12a59b7cd0034424b3628a
-  data.tar.gz: bcd103a17bab68ca38a9cd2534aa97f937aa10f560c79283bd5e1efd585be22e
+  metadata.gz: 0672dfcc5cf9d3116f38dd98904f2d2ba10a8373d04814d6fa936f0bffcf93c0
+  data.tar.gz: a3e3d982c061380e4201490366bac05c066bec85829b397378f933a6fea27d27
 SHA512:
-  metadata.gz: d7eb62a48b163312832120f0d475b4b7ced9b1364c457677135026f1e75b84d36d53faa834c7ec36ecd87b4e9daacd727c0f1e75639a87919b98f507c56fde01
-  data.tar.gz: 470a0a62f1855b42369f0a81f099982a89a50f4070ad981a23d66693f6724e3fdf8c04441fb274c702871163e94c96804a27b4d7651ec5eea5de83cd435c791d
+  metadata.gz: fac32a9ec144ccf1970834c0724e1eb33667f140955f2b10fad3168823c55f64826b33ccb5b4aa781ecd53b6478515cac62809603d290706a4c433784b10b266
+  data.tar.gz: ed671dd23f413602e93506584114efb806a294d2970ccd0c17571b786dba9b64323dcfb03411cf8cd0571aaf9696eda7792e4eac8eee4197100797b37eed3c43

data/TODO.pdf/103-drop-caps.md

@@ -1,13 +1,12 @@
 # TODO PDF 103: Drop caps (DropCapLines, DropCapCharacters)
 
-## Status: PARTIAL — `Render::DropCap` helper computes drop-cap
-geometry (font_size = base × lines, width via font_metrics.measure_text,
-height = leading × lines). TextFrameRenderer.emit_drop_cap emits the
-drop cap as an enlarged glyph at the paragraph's top-left when the
-paragraph declares DropCapLines/DropCapCharacters > 0 and is the
-chain's first paragraph.
-
-Wrap-around text is NOT yet implemented — the drop cap renders as an
+## Status: DONE — `Render::DropCap` helper computes drop-cap geometry.
+TextFrameRenderer.emit_drop_cap emits the enlarged glyph, strips the
+drop cap characters from the first run (no double render), and
+applies reduced wrap width for the first `drop_cap_lines` runs so
+text wraps around the drop cap. Approximation: treats each run as
+one line (real per-line tracking would require line-count-aware
+wrapping).
 enlarged glyph; subsequent paragraph text flows normally and may
 overlap the drop cap. Real wrap-around (indent lines 1..M to the
 right of the drop cap) requires per-line wrap-width control in

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/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:
@@ -306,18 +401,44 @@ module Idml
 
           emit_paragraph_top_rule(canvas, paragraph, context, cursor_y,
                                   frame_left, frame_right, first_paragraph)
-          emit_drop_cap(canvas, paragraph, context, frame_left, cursor_y,
-                        first_paragraph)
+          drop_cap = emit_drop_cap(canvas, paragraph, context, frame_left,
+                                   cursor_y, first_paragraph)
+
+          effective_runs = prepare_runs_for_drop_cap(runs, drop_cap)
+          dc_width = drop_cap&.wrap_offset || 0
+          dc_lines = drop_cap&.lines || 0
 
+          rendered, cursor_y, char_cursor = iterate_paragraph_runs(
+            canvas, paragraph, effective_runs, context, layout_frame,
+            font, wrap_width, cursor_y, bottom_limit, char_cursor,
+            first_paragraph, para_attrs, dc_width, dc_lines
+          )
+
+          remaining_runs = effective_runs[rendered..]
+          cursor_y = emit_paragraph_bottom_rule(canvas, paragraph, context,
+                                                cursor_y, frame_left,
+                                                frame_right, para_attrs,
+                                                remaining_runs)
+          [remaining_runs, cursor_y, char_cursor]
+        end
+        private_class_method :render_runs_for_paragraph
+
+        def self.iterate_paragraph_runs(canvas, paragraph, runs, context,
+                                        layout_frame, font, wrap_width,
+                                        cursor_y, bottom_limit, char_cursor,
+                                        first_paragraph, para_attrs,
+                                        dc_width, dc_lines)
           rendered_count = 0
           runs.each do |run|
             break if cursor_y < bottom_limit
 
             space_before = paragraph_space_before(para_attrs, first_paragraph,
                                                   rendered_count)
+            run_wrap = drop_cap_wrap_width(wrap_width, dc_width,
+                                           dc_lines, rendered_count)
             positioned, next_y = layout_run(
               canvas, run, paragraph, context, layout_frame, font,
-              wrap_width, cursor_y, space_before,
+              run_wrap, cursor_y, space_before,
               para_attrs[:first_line_indent], para_attrs[:left_indent],
               char_cursor
             )
@@ -325,15 +446,43 @@ module Idml
             cursor_y = next_y
             rendered_count += 1
           end
+          [rendered_count, cursor_y, char_cursor]
+        end
+        private_class_method :iterate_paragraph_runs
 
-          remaining_runs = runs[rendered_count..]
-          cursor_y = emit_paragraph_bottom_rule(canvas, paragraph, context,
-                                                cursor_y, frame_left,
-                                                frame_right, para_attrs,
-                                                remaining_runs)
-          [remaining_runs, cursor_y, char_cursor]
+        # Strips drop cap characters from the first run so they don't
+        # render twice (once as the enlarged drop cap, once as normal
+        # text). Returns a new run list with the first run's text
+        # adjusted. If stripping empties the first run, removes it.
+        def self.prepare_runs_for_drop_cap(runs, drop_cap)
+          return runs unless drop_cap
+          return runs if runs.empty?
+
+          stripped_count = drop_cap.text.length
+          first = runs.first
+          return runs if first.text.length < stripped_count
+
+          remaining_text = first.text[stripped_count..]
+          return runs.drop(1) if remaining_text.nil? || remaining_text.empty?
+
+          stripped_run = first.dup
+          stripped_run.text = remaining_text
+          [stripped_run] + runs[1..]
         end
-        private_class_method :render_runs_for_paragraph
+        private_class_method :prepare_runs_for_drop_cap
+
+        # Returns reduced wrap width for runs within the drop cap zone
+        # (first `drop_cap_lines` runs). After the zone, returns full
+        # width. Approximation: treats each run as one line. Proper
+        # implementation would track actual line count per run.
+        def self.drop_cap_wrap_width(full_width, drop_cap_width,
+                                      drop_cap_lines, run_index)
+          return full_width if drop_cap_width.zero? || drop_cap_lines.zero?
+          return full_width if run_index >= drop_cap_lines
+
+          full_width - drop_cap_width
+        end
+        private_class_method :drop_cap_wrap_width
 
         # Renders the drop cap for a paragraph (when declared and the
         # first paragraph of the chain). Wrap-around text is not yet

data/lib/idml/version.rb

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

metadata

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