idml 0.10.9 → 0.10.11

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

@@ -27,6 +27,13 @@ module Idml
         DEFAULT_SIZE = 12.0
         RUBY_SIZE_FACTOR = 0.5
 
+        # Vertical-writing wing (MECE split; shares this class's
+        # constants, layout_frame, and font resolution).
+        extend VerticalEmit
+
+        # No-metrics fallback path (MECE split; rough output).
+        extend SimpleText
+
         def self.render(canvas, context)
           frame = context.item
           return unless frame.parent_story
@@ -221,231 +228,6 @@ module Idml
 
         # True when the story's StoryPreference declares vertical
         # writing (StoryOrientation="Vertical").
-        def self.vertical_story?(story)
-          story.inner&.story_preference&.story_orientation == "Vertical"
-        end
-        private_class_method :vertical_story?
-
-        # Vertical writing path (StoryOrientation="Vertical", CJK):
-        # paragraphs flow as upright glyph columns advancing
-        # right-to-left; each run starts a fresh column (run-mixing
-        # within a column is not modeled). Runs whose columns would
-        # cross the frame's left inset overflow to the next frame in
-        # the chain. Paragraph spacing, rules, and decorations are
-        # not applied in vertical mode.
-        def self.vertical_render(canvas, state, context, box, font)
-          layout_frame = layout_frame(context.item, box)
-          left_limit = layout_frame.x + (layout_frame.inset_left || 0)
-          resume_vertical_paragraph(state)
-          next_column = state.column_offset || 0
-          pending = 0
-
-          state.paragraphs.each do |paragraph|
-            remaining_runs, next_column = vertical_paragraph(
-              canvas, paragraph, context, layout_frame, font,
-              left_limit, next_column
-            )
-            if remaining_runs.empty?
-              pending += 1
-            else
-              state.current_paragraph = paragraph
-              state.runs_remaining = remaining_runs
-              state.column_offset = next_column
-              break
-            end
-          end
-
-          state.paragraphs = state.paragraphs[pending..]
-        end
-        private_class_method :vertical_render
-
-        # Folds a chain-resumed paragraph (runs_remaining) back to
-        # the head of the paragraph list so the vertical path sees a
-        # uniform sequence. The consumed column offset persists in
-        # the state so the next frame continues right where this
-        # frame's columns ended.
-        def self.resume_vertical_paragraph(state)
-          return unless state.current_paragraph
-
-          state.current_paragraph.runs = state.runs_remaining
-          state.paragraphs.unshift(state.current_paragraph)
-          state.current_paragraph = nil
-          state.runs_remaining = []
-        end
-        private_class_method :resume_vertical_paragraph
-
-        # Renders one paragraph's runs as vertical columns starting
-        # at `start_column`. Returns [runs that did not fit (empty
-        # when all placed), the next unused column index].
-        def self.vertical_paragraph(canvas, paragraph, context,
-                                    layout_frame, font, left_limit,
-                                    start_column)
-          next_column = start_column
-          paragraph.runs.each_with_index do |run, index|
-            size = run.point_size || DEFAULT_SIZE
-            leading = TextEngine::VerticalLayout.leading_for(
-              paragraph.auto_leading, size
-            )
-            glyphs = TextEngine::Shaper.shape(text: run.text, font: font,
-                                              size: size)
-            grouped = tatechuyoko_group(run, glyphs, layout_frame,
-                                        leading, size, next_column)
-            positioned, next_column = grouped ||
-              TextEngine::VerticalTextLayout.layout(
-                glyphs: glyphs, frame: layout_frame, leading: leading,
-                size: size, start_column: next_column
-              )
-            unless vertical_fits?(layout_frame, leading, next_column,
-                                  left_limit)
-              return [paragraph.runs[index..], start_column]
-            end
-
-            emit_vertical_run(canvas, positioned, grouped, run, context,
-                              size)
-            emit_vertical_ruby(canvas, run, positioned, layout_frame,
-                               size, context)
-          end
-          [[], next_column]
-        end
-        private_class_method :vertical_paragraph
-
-        # A tate-chu-yoko group for runs that declare it (and whose
-        # glyphs fit horizontally in a column slot); nil otherwise.
-        def self.tatechuyoko_group(run, glyphs, layout_frame, leading,
-                                   size, start_column)
-          return nil unless run.tatechuyoko
-
-          TextEngine::VerticalTextLayout.tatechuyoko_group(
-            glyphs: glyphs, frame: layout_frame, leading: leading,
-            size: size, start_column: start_column
-          )
-        end
-        private_class_method :tatechuyoko_group
-
-        # Emits a vertical run's glyphs: rotated/normal vertical
-        # handling for stacked columns, plain upright emission for
-        # tate-chu-yoko groups.
-        def self.emit_vertical_run(canvas, positioned, grouped, run,
-                                   context, size)
-          if grouped
-            positioned.each do |glyph|
-              emit_upright_glyph(canvas, glyph, run, context, size)
-            end
-          else
-            emit_vertical_stack(canvas, positioned, run, context, size)
-          end
-        end
-        private_class_method :emit_vertical_run
-
-        # Vertical-stack emission: CJK glyphs stand upright per
-        # glyph; consecutive non-CJK glyphs rotate as ONE group
-        # (the whole Latin word sideways, as InDesign does). The
-        # group's string renders as a single text op inside one
-        # rotated graphics state — the font's advances land each
-        # glyph exactly where per-glyph rotation placed it. A group
-        # never spans columns (x reset) and shares the run's
-        # styling, so one text op is lossless.
-        def self.emit_vertical_stack(canvas, positioned, run, context,
-                                     size)
-          segment = []
-          positioned.each do |glyph|
-            if TextEngine::CjkLayout.cjk?(glyph.codepoint)
-              flush_vertical_segment(canvas, segment, run, context, size)
-              emit_upright_glyph(canvas, glyph, run, context, size)
-            else
-              if !segment.empty? && segment.last.x != glyph.x
-                flush_vertical_segment(canvas, segment, run, context, size)
-              end
-              segment << glyph
-            end
-          end
-          flush_vertical_segment(canvas, segment, run, context, size)
-        end
-        private_class_method :emit_vertical_stack
-
-        def self.flush_vertical_segment(canvas, segment, run, context,
-                                        size)
-          return if segment.empty?
-
-          text = segment.map { |g| [g.codepoint].pack("U") }.join
-          first = segment.first
-          canvas.save_graphics_state do
-            # 90° clockwise: exact matrix (rotate would emit
-            # cos/sin float noise like 6.1e-17).
-            canvas.concat(0, -1, 1, 0, first.x, first.y)
-            text_kwargs = CharacterStyle.text_kwargs(
-              run,
-              {
-                at: [0, 0],
-                font: font_for_run(run, context),
-                size: size,
-              },
-            )
-            canvas.text(text, **text_kwargs)
-          end
-        end
-        private_class_method :flush_vertical_segment
-
-        def self.emit_upright_glyph(canvas, positioned, run, context,
-                                    size)
-          text = [positioned.codepoint].pack("U")
-          text_kwargs = CharacterStyle.text_kwargs(
-            run,
-            {
-              at: [positioned.x, positioned.y],
-              font: font_for_run(run, context),
-              size: size,
-            },
-          )
-          canvas.text(text, **text_kwargs)
-        end
-        private_class_method :emit_upright_glyph
-
-        def self.vertical_fits?(layout_frame, leading, columns, left_limit)
-          right = layout_frame.x + layout_frame.width -
-            (layout_frame.inset_right || 0)
-          (right - (columns * leading)) >= left_limit
-        end
-        private_class_method :vertical_fits?
-
-        # Emits the run's ruby alongside its vertical glyphs:
-        # stacked top-to-bottom beside the column — right side by
-        # default, left for Below* RubyPosition values (the
-        # horizontal above/below convention mirrored under
-        # rotation).
-        def self.emit_vertical_ruby(canvas, run, positioned, frame,
-                                    base_size, context)
-          ruby_text = run.ruby_string
-          return if ruby_text.nil? || ruby_text.empty?
-
-          ruby_size = run.ruby_font_size ||
-            (base_size * RUBY_SIZE_FACTOR)
-          x = ruby_vertical_x(positioned.first, run, base_size)
-          y = frame.y + frame.height - (frame.inset_top || 0)
-          ruby_text.each_codepoint do |codepoint|
-            text_kwargs = CharacterStyle.text_kwargs(
-              run,
-              {
-                at: [x, y - ruby_size],
-                font: font_for_run(run, context),
-                size: ruby_size,
-              },
-            )
-            canvas.text([codepoint].pack("U"), **text_kwargs)
-            y -= ruby_size
-          end
-        end
-        private_class_method :emit_vertical_ruby
-
-        def self.ruby_vertical_x(positioned, run, base_size)
-          offset = base_size * 0.9
-          if run.ruby_position.to_s.include?("Below")
-            positioned.x - offset
-          else
-            positioned.x + offset
-          end
-        end
-        private_class_method :ruby_vertical_x
 
         def self.chain_head?(frame)
           frame.previous_text_frame.nil? || frame.previous_text_frame == "n"
@@ -502,8 +284,10 @@ module Idml
             (layout_frame.inset_top || 0)
           bottom_limit = TextEngine::VerticalLayout.bottom_limit(layout_frame)
           footnotes = []
-          cursor_y = vertical_justify_top(top_y, bottom_limit, state, context)
-          cursor_y -= first_baseline_offset(context, state, font)
+          cursor_y = FrameMetrics.vertical_justify_top(top_y, bottom_limit,
+                                                       state, context)
+          cursor_y -= FrameMetrics.first_baseline_offset(context, state,
+                                                         font)
           char_cursor = state.char_cursor
 
           if state.current_paragraph
@@ -544,7 +328,9 @@ module Idml
           top_y = col_frame.y + col_frame.height - (col_frame.inset_top || 0)
           bottom_limit = TextEngine::VerticalLayout.bottom_limit(col_frame)
           footnotes = []
-          cursor_y = top_y - first_baseline_offset(context, state, font)
+          cursor_y = top_y - FrameMetrics.first_baseline_offset(
+            context, state, font
+          )
           char_cursor = state.char_cursor
 
           if state.current_paragraph
@@ -607,160 +393,6 @@ module Idml
         private_class_method :build_column_frames
 
         # Computes the starting cursor_y for vertical justification.
-        # IDML's TextFramePreference.VerticalJustification can be:
-        # - TopAlign (default): start at frame top, no offset
-        # - CenterAlign: center the content block vertically
-        # - BottomAlign: align content to the frame bottom
-        # - JustifyAlign: distribute extra space between paragraphs
-        #   (deferred — falls back to TopAlign behavior)
-        #
-        # Content height is estimated by walking paragraphs and
-        # summing leading × lines + space_before/after. Without
-        # shaping/wrapping we can't know exact line count, so we
-        # approximate by treating each run as one line.
-        def self.vertical_justify_top(top_y, bottom_limit, state, context)
-          justification = text_frame_vertical_justification(context)
-          return top_y unless %w[CenterAlign BottomAlign].include?(justification)
-
-          content_height = estimate_content_height(state)
-          available = top_y - bottom_limit
-          slack = [available - content_height, 0].max
-          return top_y if slack.zero?
-
-          case justification
-          when "CenterAlign" then top_y - (slack / 2)
-          when "BottomAlign" then top_y - slack
-          else top_y
-          end
-        end
-        private_class_method :vertical_justify_top
-
-        # FirstBaselineOffset: how far below the frame's top inset
-        # the first line's baseline sits. The layout's default is
-        # leading-based; AscentOffset shifts by (ascent − leading)
-        # and FixedHeight by (MinimumFirstBaselineOffset − leading).
-        # CapHeight uses the font's cap-height metric (leading
-        # fallback when the font reports none); XHeight approximates
-        # as 70% of cap height; EmboxHeight uses the em box (the
-        # first paragraph's point size). Returns the extra shift to
-        # subtract from the cursor.
-        FIRST_BASELINE_MODES = %w[
-          AscentOffset FixedHeight CapHeight XHeight EmboxHeight
-        ].freeze
-
-        def self.first_baseline_offset(context, state, font)
-          pref = context.item&.text_frame_preference&.first
-          mode = pref&.first_baseline_offset
-          return 0.0 unless FIRST_BASELINE_MODES.include?(mode)
-
-          baseline_target(pref, mode, state, font) -
-            first_paragraph_leading(state)
-        end
-        private_class_method :first_baseline_offset
-
-        # Distance from the top inset to the first baseline under
-        # the given mode.
-        # pdfrb 0.7.1 never fills the cap_height metric, so
-        # CapHeight / XHeight fall back to standard font
-        # proportions (cap ≈ 0.72 em, x ≈ 0.52 em — Arial and
-        # Helvetica both sit within 1% of these).
-        CAP_HEIGHT_RATIO = 0.72
-        X_HEIGHT_RATIO = 0.52
-
-        def self.baseline_target(pref, mode, state, font)
-          leading = first_paragraph_leading(state)
-          case mode
-          when "AscentOffset"
-            ratio_scaled(font.ascent, font) * leading
-          when "CapHeight"
-            cap_ratio(font) * leading
-          when "XHeight"
-            X_HEIGHT_RATIO * leading
-          when "EmboxHeight"
-            first_paragraph_size(state)
-          else
-            pref.minimum_first_baseline_offset || leading
-          end
-        end
-        private_class_method :baseline_target
-
-        def self.cap_ratio(font)
-          cap = font.cap_height
-          return CAP_HEIGHT_RATIO unless cap
-
-          ratio_scaled(cap, font)
-        end
-        private_class_method :cap_ratio
-
-        def self.ratio_scaled(metric, font)
-          upem = font.units_per_em
-          return 1.0 if upem.zero?
-
-          metric / upem
-        end
-        private_class_method :ratio_scaled
-
-        def self.first_paragraph_size(state)
-          paragraph = state.current_paragraph || state.paragraphs.first
-          first_run = paragraph&.runs&.first
-          first_run&.point_size || DEFAULT_SIZE
-        end
-        private_class_method :first_paragraph_size
-
-        def self.first_paragraph_leading(state)
-          paragraph = state.current_paragraph || state.paragraphs.first
-          unless paragraph
-            return DEFAULT_SIZE *
-                TextEngine::VerticalLayout::DEFAULT_LEADING_FACTOR
-          end
-
-          size = paragraph.runs.first&.point_size || DEFAULT_SIZE
-          TextEngine::VerticalLayout.leading_for(paragraph.auto_leading,
-                                                 size)
-        end
-        private_class_method :first_paragraph_leading
-
-        def self.text_frame_vertical_justification(context)
-          pref = context.item&.text_frame_preference&.first
-          pref&.vertical_justification
-        end
-        private_class_method :text_frame_vertical_justification
-
-        # Estimates total renderable content height for vertical
-        # justification. Walks paragraphs and runs, summing leading
-        # per run plus paragraph space_before/after. Approximation:
-        # treats each run as one line (wrap may produce more lines,
-        # which would over-estimate slack; acceptable for
-        # justification since we'd rather under-offset than overflow).
-        def self.estimate_content_height(state)
-          paragraphs = paragraphs_for_estimate(state)
-          return 0 if paragraphs.empty?
-
-          paragraphs.sum do |paragraph|
-            paragraph_height(paragraph)
-          end
-        end
-        private_class_method :estimate_content_height
-
-        def self.paragraphs_for_estimate(state)
-          result = []
-          result << state.current_paragraph if state.current_paragraph
-          result + state.paragraphs
-        end
-        private_class_method :paragraphs_for_estimate
-
-        def self.paragraph_height(paragraph)
-          size = paragraph.runs.first&.point_size || DEFAULT_SIZE
-          leading = leading_for(paragraph, size)
-          line_count = [paragraph.runs.length, 1].max
-          (leading * line_count) + space_before_after(paragraph)
-        end
-        private_class_method :paragraph_height
-
-        def self.space_before_after(paragraph)
-          (paragraph.space_before || 0) + (paragraph.space_after || 0)
-        end
-        private_class_method :space_before_after
 
         def self.resume_paragraph(canvas, state, context, layout_frame, font,
                                   cursor_y, bottom_limit, char_cursor,
@@ -789,9 +421,9 @@ module Idml
             break if cursor_y < bottom_limit
 
             next_paragraph = state.paragraphs[index + 1]
-            break if paragraph_deferred?(paragraph, next_paragraph,
-                                         layout_frame, font, cursor_y,
-                                         bottom_limit, pending.positive?)
+            break if KeepPolicy.paragraph_deferred?(paragraph, next_paragraph,
+                                                    layout_frame, font, cursor_y,
+                                                    bottom_limit, pending.positive?)
 
             remaining_runs, cursor_y, char_cursor = render_runs_for_paragraph(
               canvas, paragraph, paragraph.runs, context,
@@ -1185,130 +817,6 @@ module Idml
         end
         private_class_method :mojikumi_aki_overrides
 
-        # True when the paragraph should move wholly to the next
-        # frame: a StartParagraph forced break, or KeepAllLines-
-        # Together with insufficient remaining space (never for the
-        # frame's first paragraph, so progress is always made).
-        def self.paragraph_deferred?(paragraph, next_paragraph,
-                                     layout_frame, font, cursor_y,
-                                     bottom_limit, placed_any)
-          return true if paragraph_break?(paragraph) && placed_any
-          return false unless placed_any
-          return true if keep_with_next_break?(paragraph, next_paragraph,
-                                               layout_frame, font,
-                                               cursor_y, bottom_limit)
-
-          keep_all_lines_break?(paragraph, layout_frame, font,
-                                cursor_y, bottom_limit) ||
-            keep_windows_break?(paragraph, layout_frame, font,
-                                cursor_y, bottom_limit)
-        end
-        private_class_method :paragraph_deferred?
-
-        # KeepAllLinesTogether: defer when the paragraph cannot
-        # fully fit the remaining space.
-        def self.keep_all_lines_break?(paragraph, layout_frame, font,
-                                       cursor_y, bottom_limit)
-          return false unless paragraph.keep_all_lines_together
-
-          wrap_width = TextEngine::VerticalLayout.wrap_width(
-            layout_frame, paragraph.right_indent || 0
-          )
-          height = TextEngine::Measurement.paragraph_height(
-            paragraph, font, wrap_width
-          )
-          (cursor_y - height) < bottom_limit
-        end
-        private_class_method :keep_all_lines_break?
-
-        # Partial keep windows, approximated by measured line
-        # counts: KeepFirstLines defers when fewer than N lines
-        # fit; KeepLastLines defers when the overflow tail for the
-        # next frame would strand fewer than N lines.
-        def self.keep_windows_break?(paragraph, layout_frame, font,
-                                     cursor_y, bottom_limit)
-          return false unless paragraph.keep_first_lines ||
-            paragraph.keep_last_lines
-
-          wrap_width = TextEngine::VerticalLayout.wrap_width(
-            layout_frame, paragraph.right_indent || 0
-          )
-          height = TextEngine::Measurement.paragraph_height(
-            paragraph, font, wrap_width
-          )
-          return false if (cursor_y - height) >= bottom_limit
-
-          leading = first_paragraph_leading_for(paragraph)
-          lines_fit = [((cursor_y - bottom_limit) / leading).floor, 0].max
-          first_window_break?(paragraph, lines_fit) ||
-            last_window_break?(paragraph, lines_fit, height, leading)
-        end
-        private_class_method :keep_windows_break?
-
-        def self.first_window_break?(paragraph, lines_fit)
-          paragraph.keep_first_lines &&
-            lines_fit < paragraph.keep_first_lines
-        end
-        private_class_method :first_window_break?
-
-        def self.last_window_break?(paragraph, lines_fit, height, leading)
-          return false unless paragraph.keep_last_lines
-
-          total_lines = [(height / leading).ceil, 1].max
-          lines_fit.positive? &&
-            (total_lines - lines_fit) < paragraph.keep_last_lines
-        end
-        private_class_method :last_window_break?
-
-        def self.first_paragraph_leading_for(paragraph)
-          size = paragraph.runs.first&.point_size || DEFAULT_SIZE
-          TextEngine::VerticalLayout.leading_for(paragraph.auto_leading,
-                                                 size)
-        end
-        private_class_method :first_paragraph_leading_for
-
-        # KeepWithNext: this paragraph defers when the next
-        # paragraph is forced to the next frame, or when the next
-        # paragraph's first line would not fit after this one.
-        def self.keep_with_next_break?(paragraph, next_paragraph,
-                                       layout_frame, font, cursor_y,
-                                       bottom_limit)
-          return false unless keepable_pair?(paragraph, next_paragraph)
-          return true if paragraph_break?(next_paragraph)
-
-          wrap_width = TextEngine::VerticalLayout.wrap_width(
-            layout_frame, paragraph.right_indent || 0
-          )
-          height = TextEngine::Measurement.paragraph_height(
-            paragraph, font, wrap_width
-          )
-          (cursor_y - height - follower_leading(next_paragraph)) <
-            bottom_limit
-        end
-        private_class_method :keep_with_next_break?
-
-        def self.keepable_pair?(paragraph, next_paragraph)
-          !paragraph.keep_with_next.nil? && !next_paragraph.nil?
-        end
-        private_class_method :keepable_pair?
-
-        def self.follower_leading(next_paragraph)
-          size = next_paragraph.runs.first&.point_size || DEFAULT_SIZE
-          TextEngine::VerticalLayout.leading_for(
-            next_paragraph.auto_leading, size
-          )
-        end
-        private_class_method :follower_leading
-
-        # True when the paragraph requests a forced break to the
-        # next frame/column (StartParagraph). All break flavors act
-        # at frame/column granularity.
-        def self.paragraph_break?(paragraph)
-          %w[NextPage NextColumn NextFrame NextOddPage NextEvenPage]
-            .include?(paragraph.start_paragraph)
-        end
-        private_class_method :paragraph_break?
-
         # Justifies the run's lines; only the final line of the
         # paragraph's final run stays ragged under full
         # justification.
@@ -1446,74 +954,6 @@ module Idml
           line.glyphs.map { |g| [g.codepoint].pack("U") }.join
         end
         private_class_method :line_text
-
-        # Fallback when no metrics are available: emit all runs as
-        # one `text_rich` block, letting pdfrb measure advance widths.
-        # Chain threading is best-effort here — the simple path
-        # doesn't wrap, so the first frame's render typically emits
-        # all content and clears the chain state.
-        def self.simple_render(canvas, state, context, box)
-          runs = collect_runs(state)
-          return if runs.empty?
-
-          runs_for = build_rich_runs(runs, context)
-          first_size = runs.first.point_size || DEFAULT_SIZE
-          canvas.text_rich(
-            runs_for,
-            at: [box[:x], box[:y] + box[:height] - first_size],
-          )
-          emit_simple_footnotes(canvas, runs, context, box)
-          state.paragraphs = []
-          state.current_paragraph = nil
-          state.runs_remaining = []
-        end
-        private_class_method :simple_render
-
-        # Footnote text for the rough (no-metrics) path: one line
-        # per footnote paragraph, stacked upward from the frame's
-        # bottom edge below a hairline separator. Paragraphs are
-        # already marker-prefixed at extraction.
-        def self.emit_simple_footnotes(canvas, runs, context, box)
-          paragraphs = runs.flat_map(&:footnote_paragraphs).compact
-          return if paragraphs.empty?
-
-          size = paragraphs.first.runs.first&.point_size || DEFAULT_SIZE
-          block_top = box[:y] + (paragraphs.length * size)
-          canvas.line_width = 0.5
-          canvas.stroke_color([:gray, 0.0])
-          canvas.move_to(box[:x], block_top + (size * 0.3))
-          canvas.line_to(box[:x] + (box[:width] * 0.25), block_top + (size * 0.3))
-          canvas.stroke
-
-          paragraphs.reverse_each.with_index do |paragraph, index|
-            canvas.text_rich(
-              build_rich_runs(paragraph.runs, context),
-              at: [box[:x], box[:y] + ((index + 1) * size)],
-            )
-          end
-        end
-        private_class_method :emit_simple_footnotes
-
-        def self.collect_runs(state)
-          runs = state.runs_remaining || []
-          if state.current_paragraph
-            runs + state.current_paragraph.runs
-          else
-            runs + state.paragraphs.flat_map(&:runs)
-          end
-        end
-        private_class_method :collect_runs
-
-        def self.build_rich_runs(runs, context)
-          runs.map do |run|
-            {
-              text: run.text,
-              font: font_for_run(run, context),
-              size: run.point_size || DEFAULT_SIZE,
-            }
-          end
-        end
-        private_class_method :build_rich_runs
       end
     end
   end