gamba 2.0.0

data/lib/gamba/document/bounding_box.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+module Prawn
+  class Document
+    def bounding_box(point, *arguments, &block)
+      init_bounding_box(block) do |parent_box|
+        @bounding_box = BoundingBox.new(self, parent_box, map_to_absolute(point), *arguments)
+      end
+    end
+
+    def canvas(&block)
+      init_bounding_box(block, hold_position: true) do
+        _left, _bottom, page_width, page_height = page.dimensions
+        @bounding_box = BoundingBox.new(self, nil, [0, page_height], width: page_width, height: page_height)
+      end
+    end
+
+    private
+
+    def init_bounding_box(user_block, options = {})
+      raise ArgumentError, "bounding boxes require a block to be drawn within the box" unless user_block
+
+      parent_box = @bounding_box
+      original_y = y
+      yield parent_box
+      self.y = @bounding_box.absolute_top
+      user_block.call
+      self.y = original_y if y == @bounding_box.absolute_top
+      self.y = @bounding_box.absolute_bottom unless options[:hold_position] || @bounding_box.stretchy?
+      created_box = @bounding_box
+      @bounding_box = parent_box
+      created_box
+    end
+
+    # A rectangle the document draws into, positioned from its top left corner; without a height, it stretches
+    # down to wherever the cursor ends.
+    class BoundingBox
+      class NoReferenceBounds < StandardError
+        def initialize(message = "Can't find reference bounds: my parent is unset")
+          super
+        end
+      end
+
+      attr_reader :document, :parent, :total_left_padding, :total_right_padding, :width
+
+      def initialize(document, parent, point, options = {})
+        raise ArgumentError, "BoundingBox needs the :width option to be set" unless options[:width]
+
+        @document = document
+        @parent = parent
+        @x, @y = point
+        @width = options[:width]
+        @height = options[:height]
+        @total_left_padding = 0
+        @total_right_padding = 0
+        @stretched_height = nil
+      end
+
+      def anchor
+        [@x, @y - height]
+      end
+
+      def indent(left_padding, right_padding = 0)
+        add_left_padding(left_padding)
+        add_right_padding(right_padding)
+        yield
+      ensure
+        @document.bounds.subtract_left_padding(left_padding)
+        @document.bounds.subtract_right_padding(right_padding)
+      end
+
+      def add_left_padding(left_padding)
+        @total_left_padding += left_padding
+        @x += left_padding
+        @width -= left_padding
+      end
+
+      def subtract_left_padding(left_padding)
+        @total_left_padding -= left_padding
+        @x -= left_padding
+        @width += left_padding
+      end
+
+      def add_right_padding(right_padding)
+        @total_right_padding += right_padding
+        @width -= right_padding
+      end
+
+      def subtract_right_padding(right_padding)
+        @total_right_padding -= right_padding
+        @width += right_padding
+      end
+
+      def left
+        0
+      end
+
+      def right
+        @width
+      end
+
+      def top
+        height
+      end
+
+      def bottom
+        0
+      end
+
+      def top_left
+        [left, top]
+      end
+
+      def top_right
+        [right, top]
+      end
+
+      def bottom_right
+        [right, bottom]
+      end
+
+      def bottom_left
+        [left, bottom]
+      end
+
+      def absolute_left
+        @x
+      end
+
+      def absolute_right
+        @x + width
+      end
+
+      def absolute_top
+        @y
+      end
+
+      def absolute_bottom
+        @y - height
+      end
+
+      def absolute_top_left
+        [absolute_left, absolute_top]
+      end
+
+      def absolute_top_right
+        [absolute_right, absolute_top]
+      end
+
+      def absolute_bottom_left
+        [absolute_left, absolute_bottom]
+      end
+
+      def absolute_bottom_right
+        [absolute_right, absolute_bottom]
+      end
+
+      def height
+        return @height if @height
+
+        @stretched_height = [absolute_top - @document.y, Float(@stretched_height || 0.0)].max
+      end
+      alias_method :update_height, :height
+
+      def left_side
+        absolute_left
+      end
+
+      def right_side
+        absolute_right
+      end
+
+      def move_past_bottom
+        if @document.page_number == @document.page_count
+          @document.start_new_page
+        else
+          @document.__send__(:flow_onto_page, @document.page_number + 1)
+        end
+      end
+
+      def stretchy?
+        !@height
+      end
+
+      def reference_bounds
+        return self unless stretchy?
+        raise NoReferenceBounds unless @parent
+
+        @parent.reference_bounds
+      end
+    end
+  end
+end

data/lib/gamba/document/column_box.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Prawn
+  class Document
+    def column_box(*arguments, &block)
+      init_column_box(block) do |parent_box|
+        map_to_absolute!(arguments[0])
+        @bounding_box = ColumnBox.new(self, parent_box, *arguments)
+      end
+    end
+
+    private
+
+    def init_column_box(user_block, options = {})
+      parent_box = @bounding_box
+      yield parent_box
+      self.y = @bounding_box.absolute_top
+      user_block.call
+      self.y = @bounding_box.absolute_bottom unless options[:hold_position]
+      @bounding_box = parent_box
+    end
+
+    # A bounding box whose text flows down one column, then the next, then onto a new page.
+    class ColumnBox < BoundingBox
+      DEFAULT_COLUMN_COUNT = 3
+
+      def initialize(document, parent, point, options = {})
+        super
+        @columns = options[:columns] || DEFAULT_COLUMN_COUNT
+        @spacer = options[:spacer] || @document.font_size
+        @current_column = 0
+        @reflow_margins = options[:reflow_margins]
+      end
+
+      def bare_column_width
+        (@width - (@spacer * (@columns - 1))) / @columns
+      end
+
+      def width
+        bare_column_width - (@total_left_padding + @total_right_padding)
+      end
+
+      def width_of_column
+        bare_column_width + @spacer
+      end
+
+      def left_side
+        absolute_left + (width_of_column * @current_column)
+      end
+
+      def left
+        width_of_column * @current_column
+      end
+
+      def right_side
+        absolute_right - (width_of_column * (@columns - (1 + @current_column)))
+      end
+
+      def right
+        left + width
+      end
+
+      def move_past_bottom
+        @current_column = (@current_column + 1) % @columns
+        @document.y = @y
+        return unless @current_column.zero?
+
+        @y = @parent.absolute_top if @reflow_margins
+        @document.start_new_page
+      end
+
+      def add_left_padding(left_padding)
+        @total_left_padding += left_padding
+        @x += left_padding
+      end
+
+      def subtract_left_padding(left_padding)
+        @total_left_padding -= left_padding
+        @x -= left_padding
+      end
+
+      def add_right_padding(right_padding)
+        @total_right_padding += right_padding
+      end
+
+      def subtract_right_padding(right_padding)
+        @total_right_padding -= right_padding
+      end
+    end
+  end
+end

data/lib/gamba/document/internals.rb

@@ -0,0 +1,264 @@
+# frozen_string_literal: true
+
+module Prawn
+  class Document
+    # The document's objects, pages and graphic state stack: what Prawn splits between PDF::Core's renderer and its
+    # document state.
+    module Internals
+      # A save not yet restored: the state in effect before it (nil on an empty stack, the default one), the
+      # ExtGState its block sets, {name:, reference:}, if any, and whether it was restored since.
+      OpenSave = Struct.new(:previous, :ext_gstate, :restored)
+      DEFAULT_GRAPHIC_STATE = PDF::Core::GraphicState.new.freeze
+      # The settings a block ending on a later page writes back, each with its writer, in the order Prawn writes them
+      # on a new page, then the blend mode.
+      GRAPHIC_SETTING_WRITERS = {fill_paint: :write_fill_paint, stroke_paint: :write_stroke_paint, line_width: :write_line_width,
+                                 cap_style: :write_stroke_cap_style, join_style: :write_stroke_join_style, dash: :write_stroke_dash,
+                                 blend_mode: :write_blend_mode}.freeze
+      # What these writers read from the state.
+      RESUMED_STATE = %i[fill_color fill_pattern stroke_color stroke_pattern line_width cap_style join_style dash blend_mode].freeze
+
+      attr_reader :page, :pages, :pages_reference
+
+      def ref(data)
+        ref!(data).identifier
+      end
+
+      def ref!(data, stream = nil)
+        reference = PDF::Core::Reference.new(@objects.size + 1, data, stream)
+        @objects << reference
+        reference
+      end
+
+      def deref(object)
+        object.is_a?(PDF::Core::Reference) ? object.data : object
+      end
+
+      def add_content(string)
+        open_graphics_state if page.stack.empty?
+        page.content_stream << string << "\n"
+      end
+
+      def names
+        @root.data[:Names] ||= ref!(Type: :Names)
+      end
+
+      def outlines_reference
+        @root.data[:Outlines] ||= ref!(PDF::Core::OutlineRoot.new)
+      end
+
+      def names?
+        @root.data.key?(:Names)
+      end
+
+      def before_render(&block)
+        @before_render_callbacks << block
+      end
+
+      def on_page_create(&block)
+        @on_page_create = block
+      end
+
+      def compression_enabled?
+        @compress
+      end
+
+      def min_version(version)
+        @version = version if version > @version
+      end
+
+      # Like Prawn, reading the state of a page whose stack was emptied opens a new one.
+      def graphic_state
+        open_graphics_state if page.stack.empty?
+        page.stack.last
+      end
+
+      def save_graphics_state(graphic_state = nil)
+        save_transformation_stack
+        previous = graphic_state ? page.stack.last : self.graphic_state
+        open_save = OpenSave.new(previous, nil, false)
+        @unrestored_graphics_states << open_save
+        state = PDF::Core::GraphicState.new(graphic_state || previous)
+        state.save = open_save
+        # A state given, as a dynamic repeater gives the one it was created in, still inherits the page's text state.
+        state.copy_text_state(previous) if graphic_state
+        page.stack.push(state)
+        add_content("q")
+        return unless block_given?
+
+        yield
+        restore_graphics_state
+      end
+
+      # A page break leaves the blocks still open with states saved on an earlier page, which closed them when it
+      # ended: like Prawn, their restore closes the state open on the new page (or one reopened for a block with an
+      # ExtGState), and where none is open it has nothing left to close. Only a restore matching no save at all, on an
+      # empty stack, raises.
+      def restore_graphics_state
+        restore_transformation_stack
+        open_save = @unrestored_graphics_states.pop
+        open_save&.restored = true
+        if page.stack.empty?
+          raise Errors::EmptyGraphicStateStack, "\n You have reached the end of the graphic state stack" unless open_save
+        else
+          add_content("Q")
+          page.stack.pop
+        end
+        return unless open_save && !page.stack.last.equal?(open_save.previous)
+
+        resume_graphic_settings(open_save.previous)
+        resume_text_state
+      end
+
+      def trailer
+        @trailer
+      end
+
+      # What Prawn splits into a renderer and a state is this document itself: code written for Prawn calls both.
+      def renderer
+        self
+      end
+
+      def state
+        self
+      end
+
+      def info
+        @info.data
+      end
+
+      private
+
+      # The states left open on a page by blocks that ended on another one: content drawn there again is drawn outside
+      # them, as it would have been had the blocks ended there, in a base state with the settings in effect before them.
+      def close_restored_graphics_states
+        closed = nil
+        while (state = page.stack.last)&.save&.restored
+          closed = state
+          page.content_stream << "Q\n"
+          page.stack.pop
+        end
+        return unless closed
+
+        graphic_state
+        resume_graphic_settings(closed.save.previous)
+      end
+
+      def open_graphics_state
+        page.stack.push(PDF::Core::GraphicState.new)
+        page.content_stream << "q\n"
+      end
+
+      # The blocks still open saved their states on the page just closed: the page's own state is the outermost one's.
+      # When one sets an ExtGState (opacity, blend mode), the new page reopens them in order, so each block's restore
+      # closes its own state; otherwise the page stays as Prawn writes it.
+      def reopen_ext_gstate_blocks
+        return if @unrestored_graphics_states.empty?
+
+        outermost, *inner = @unrestored_graphics_states
+        graphic_state.save = outermost
+        return if @unrestored_graphics_states.none?(&:ext_gstate)
+
+        write_ext_gstate(outermost.ext_gstate) if outermost.ext_gstate
+        inner.each { reopen_graphics_state(_1) }
+      end
+
+      # Content flowing onto a page that exists, through go_to_page: the page keeps its own state, which holds what it
+      # drew already. When a block still open that began elsewhere sets an ExtGState, each such block gets a state of
+      # its own on top, in order, so only what they add here is drawn in them, and each block's restore closes its own.
+      def reopen_ext_gstate_blocks_on_existing_page
+        return if @unrestored_graphics_states.none?(&:ext_gstate)
+
+        saves_on_page = page.stack.filter_map(&:save)
+        saved_elsewhere = @unrestored_graphics_states.reject { |open_save| saves_on_page.any? { _1.equal?(open_save) } }
+        saved_elsewhere.each { reopen_graphics_state(_1) } if saved_elsewhere.any?(&:ext_gstate)
+      end
+
+      # Content flowing onto a page that exists goes on with the settings in effect, as on a new page. go_to_page alone
+      # keeps the page's own settings, which page numbers and repeaters draw with, as in Prawn.
+      def flow_onto_page(page_number)
+        carried = page.stack.last
+        go_to_page(page_number)
+        resume_graphic_settings(carried)
+      end
+
+      def reopen_graphics_state(open_save)
+        page.stack.push(PDF::Core::GraphicState.new(graphic_state))
+        page.stack.last.save = open_save
+        add_content("q")
+        write_ext_gstate(open_save.ext_gstate) if open_save.ext_gstate
+      end
+
+      def ext_gstate_block(ext_gstate)
+        save_graphics_state
+        @unrestored_graphics_states.last.ext_gstate = ext_gstate
+        write_ext_gstate(ext_gstate)
+        yield
+        restore_graphics_state
+      end
+
+      def write_ext_gstate(ext_gstate)
+        page.ext_gstates[ext_gstate[:name]] = ext_gstate[:reference]
+        add_content("/#{ext_gstate[:name]} gs")
+        graphic_state.blend_mode = (ext_gstate[:name] == "BMNormal") ? nil : ext_gstate if ext_gstate[:reference].data.key?(:BM)
+      end
+
+      def write_blend_mode
+        write_ext_gstate(graphic_state.blend_mode || blend_mode_ext_gstate(:Normal))
+      end
+
+      # A block that saved its state on an earlier page ends on this one, where the state it returns to is the new
+      # page's (the default one once that is closed), not the one in effect before the block: Prawn draws what follows
+      # in black. Write back the settings that differ, as Prawn writes them on a new page.
+      def resume_graphic_settings(previous)
+        previous ||= DEFAULT_GRAPHIC_STATE
+        current = page.stack.last || DEFAULT_GRAPHIC_STATE
+        differing = GRAPHIC_SETTING_WRITERS.reject { |setting, _writer| current.public_send(setting) == previous.public_send(setting) }
+        return if differing.empty?
+
+        state = graphic_state
+        RESUMED_STATE.each { |setting| state.public_send(:"#{setting}=", previous.public_send(setting).dup) }
+        differing.each_value { |writer| send(writer) }
+      end
+
+      def initialize_internals(options)
+        @objects = []
+        @info = ref!({Creator: "Gamba", Producer: "Gamba"}.merge(options[:info] || {}))
+        @root = ref!(Type: :Catalog)
+        @pages_reference = ref!(Type: :Pages, Count: 0, Kids: [])
+        @root.data[:Pages] = @pages_reference
+        @root.data[:ViewerPreferences] = {PrintScaling: :None} if options[:print_scaling] == :none
+        @version = 1.3
+        # One entry per save not yet restored, document-wide.
+        @unrestored_graphics_states = []
+        min_version(1.6) if options[:print_scaling] == :none
+        @pages = []
+        @page = nil
+        @trailer = options.fetch(:trailer, {})
+        @compress = options.fetch(:compress, false)
+        @before_render_callbacks = []
+        @on_page_create = nil
+      end
+
+      def insert_page(page, page_number)
+        pages.insert(page_number, page)
+        pages_reference.data[:Kids].insert(page_number, page.dictionary)
+        pages_reference.data[:Count] += 1
+      end
+
+      def render_document
+        pages.each_with_index do |page, index|
+          go_to_page(index + 1)
+          until page.stack.empty?
+            page.content_stream << "Q\n"
+            page.stack.pop
+          end
+          page.finalize
+        end
+        @before_render_callbacks.each { _1.call(self) }
+        finalize_pdf_a if pdf_a?
+        PDF::Core::Writer.call(objects: @objects, root: @root, info: @info, version: @version, trailer: @trailer, encryption: @encryption,
+          identified: pdf_a?)
+      end
+    end
+  end
+end

data/lib/gamba/document/span.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Prawn
+  class Document
+    # A column of the given width across pages, positioned within the margins, starting at the cursor.
+    def span(width, options = {})
+      Prawn.verify_options([:position], options)
+      original_position = y
+      left_boundary =
+        case options.fetch(:position, :left)
+        when :left then margin_box.absolute_left
+        when :center then margin_box.absolute_left + (margin_box.width / 2.0) - (width / 2.0)
+        when :right then margin_box.absolute_right - width
+        when Numeric then margin_box.absolute_left + options[:position]
+        else raise ArgumentError, "Invalid option for :position"
+        end
+      canvas do
+        bounding_box([left_boundary, margin_box.absolute_top], width:) do
+          self.y = original_position
+          yield
+        end
+      end
+    end
+  end
+end