hexapdf 0.32.2 → 0.34.0

data/lib/hexapdf/layout/frame.rb

@@ -106,8 +106,8 @@ module HexaPDF
         # The available height in the frame for this particular box.
         attr_accessor :available_height
 
-        # The rectangle (a Geom2D::Polygon object) that will be removed from the frame when drawing
-        # the box.
+        # The rectangle (a Geom2D::Rectangle object) that will be removed from the frame when
+        # drawing the box.
         attr_accessor :mask
 
         # Initialize the result object for the given box.
@@ -133,12 +133,18 @@ module HexaPDF
         # The configuration option "debug" can be used to add visual debug output with respect to
         # box placement.
         def draw(canvas)
-          if canvas.context.document.config['debug']
-            canvas.save_graphics_state do
-              canvas.fill_color("green").stroke_color("darkgreen").
-                opacity(fill_alpha: 0.1, stroke_alpha: 0.2).
-                draw(:geom2d, object: mask, path_only: true).fill_stroke
+          doc = canvas.context.document
+          if doc.config['debug']
+            name = "#{box.class} (#{x.to_i},#{y.to_i}-#{box.width.to_i}x#{box.height.to_i})"
+            ocg = doc.optional_content.ocg(name)
+            canvas.optional_content(ocg) do
+              canvas.save_graphics_state do
+                canvas.fill_color("green").stroke_color("darkgreen").
+                  opacity(fill_alpha: 0.1, stroke_alpha: 0.2).
+                  draw(:geom2d, object: mask, path_only: true).fill_stroke
+              end
             end
+            doc.optional_content.default_configuration.add_ocg_to_ui(ocg, path: 'Debug')
           end
           box.draw(canvas, x, y)
         end
@@ -157,7 +163,8 @@ module HexaPDF
       # The height of the frame.
       attr_reader :height
 
-      # The shape of the frame, a Geom2D::PolygonSet consisting of rectilinear polygons.
+      # The shape of the frame, either a Geom2D::Rectangle in the simple case or a
+      # Geom2D::PolygonSet consisting of rectilinear polygons in the more complex case.
       attr_reader :shape
 
       # The x-coordinate where the next box will be placed.
@@ -181,15 +188,19 @@ module HexaPDF
       # Also see the note in the #x documentation for further information.
       attr_reader :available_height
 
+      # The context object (a HexaPDF::Type::Page or HexaPDF::Type::Form) for which this frame
+      # should be used.
+      attr_reader :context
+
       # Creates a new Frame object for the given rectangular area.
-      def initialize(left, bottom, width, height, shape: nil)
+      def initialize(left, bottom, width, height, shape: nil, context: nil)
         @left = left
         @bottom = bottom
         @width = width
         @height = height
-        @shape = shape || Geom2D::PolygonSet.new(
-          [create_rectangle(left, bottom, left + width, bottom + height)]
-        )
+        @shape = shape || create_rectangle(left, bottom, left + width, bottom + height)
+        @context = context
+
         @x = left
         @y = bottom + height
         @available_width = width
@@ -199,6 +210,12 @@ module HexaPDF
         @region_selection = :max_height
       end
 
+      # Returns the HexaPDF::Document instance (through #context) that is associated with this Frame
+      # object or +nil+ if no context object has been set.
+      def document
+        @context&.document
+      end
+
       # Fits the given box into the current region of available space and returns a FitResult
       # object.
       #
@@ -319,8 +336,16 @@ module HexaPDF
       def find_next_region
         case @region_selection
         when :max_width
-          find_max_width_region
-          @region_selection = :max_height
+          if @shape.kind_of?(Geom2D::Rectangle)
+            @x = @shape.x
+            @y = @shape.y + @shape.height
+            @available_width = @shape.width
+            @available_height = @shape.height
+            @region_selection = :trim_shape
+          else
+            find_max_width_region
+            @region_selection = :max_height
+          end
         when :max_height
           x, y, aw, ah = @x, @y, @available_width, @available_height
           find_max_height_region
@@ -338,7 +363,17 @@ module HexaPDF
 
       # Removes the given *rectilinear* polygon from the frame's shape.
       def remove_area(polygon)
-        @shape = Geom2D::Algorithms::PolygonOperation.run(@shape, polygon, :difference)
+        @shape = if @shape.kind_of?(Geom2D::Rectangle) && polygon.kind_of?(Geom2D::Rectangle) &&
+                     float_equal(@shape.x, polygon.x) && float_equal(@shape.width, polygon.width) &&
+                     float_equal(@shape.y + @shape.height, polygon.y + polygon.height)
+                   if float_equal(@shape.height, polygon.height)
+                     Geom2D::PolygonSet()
+                   else
+                     Geom2D::Rectangle(@shape.x, @shape.y, @shape.width, @shape.height - polygon.height)
+                   end
+                 else
+                   Geom2D::Algorithms::PolygonOperation.run(@shape, polygon, :difference)
+                 end
         @region_selection = :max_width
         find_next_region
       end
@@ -369,8 +404,7 @@ module HexaPDF
       # Creates a Geom2D::Polygon object representing the rectangle with the bottom left corner
       # (blx, bly) and the top right corner (trx, try).
       def create_rectangle(blx, bly, trx, try)
-        Geom2D::Polygon(Geom2D::Point(blx, bly), Geom2D::Point(trx, bly),
-                        Geom2D::Point(trx, try), Geom2D::Point(blx, try))
+        Geom2D::Rectangle(blx, bly, trx - blx, try - bly)
       end
 
       # Finds the region with the maximum width.
@@ -404,7 +438,8 @@ module HexaPDF
 
       # Trims the frame's shape so that the next starting point is different.
       def trim_shape
-        return unless (segments = find_starting_point)
+        @x = @y = @available_width = @available_height = 0
+        return if @shape.kind_of?(Geom2D::Rectangle) || !(segments = find_starting_point)
 
         # Just use the second top-most segment
         # TODO: not the optimal solution!

data/lib/hexapdf/layout/image_box.rb

@@ -74,6 +74,11 @@ module HexaPDF
         @image = image
       end
 
+      # Returns +false+ since the image is always drawn if it fits.
+      def empty?
+        false
+      end
+
       # Fits the image into the available space, taking the initially set width and height into
       # account (see the class description for details).
       def fit(available_width, available_height, _frame)

data/lib/hexapdf/layout/inline_box.rb

@@ -47,9 +47,10 @@ module HexaPDF
     # beforehand! This means the box *must* have at least its width set. The height may either also
     # be set or determined during fitting.
     #
-    # Fitting of the wrapped box is done immediately after creating a InlineBox instance. For this,
-    # a frame is used that has the width of the wrapped box and its height, or if not set, a
-    # practically infinite height. In the latter case the height *must* be set during fitting.
+    # Fitting of the wrapped box via #fit_wrapped_box needs to be done before accessing any other
+    # method that uses the wrapped box. For fitting, a frame is used that has the width of the
+    # wrapped box and its height, or if not set, a practically infinite height. In the latter case
+    # the height *must* be set during fitting.
     class InlineBox
 
       # Creates an InlineBox that wraps a basic Box. All arguments (except +valign+) and the block
@@ -73,14 +74,14 @@ module HexaPDF
       # The +valign+ argument can be used to specify the vertical alignment of the box relative to
       # other items in the Line.
       def initialize(box, valign: :baseline)
+        raise HexaPDF::Error, "Width of box not set" if box.width == 0
         @box = box
         @valign = valign
-        @fit_result = Frame.new(0, 0, box.width, box.height == 0 ? 100_000 : box.height).fit(box)
-        if !@fit_result.success?
-          raise HexaPDF::Error, "Box for inline use could not be fit"
-        elsif box.height > 99_000
-          raise HexaPDF::Error, "Box for inline use has no valid height set after fitting"
-        end
+      end
+
+      # Returns the style of the wrapped box.
+      def style
+        box.style
       end
 
       # Returns +true+ if this inline box is just a placeholder without drawing operations.
@@ -125,6 +126,17 @@ module HexaPDF
         height
       end
 
+      # Fits the wrapped box, using the given context (see Frame#context).
+      def fit_wrapped_box(context)
+        @fit_result = Frame.new(0, 0, box.width, box.height == 0 ? 100_000 : box.height,
+                                context: context).fit(box)
+        if !@fit_result.success?
+          raise HexaPDF::Error, "Box for inline use could not be fit"
+        elsif box.height > 99_000
+          raise HexaPDF::Error, "Box for inline use has no valid height set after fitting"
+        end
+      end
+
     end
 
   end

data/lib/hexapdf/layout/list_box.rb

@@ -60,6 +60,9 @@ module HexaPDF
     #    arguments are ignored.
     class ListBox < Box
 
+      # Stores the information when fitting an item of the list box.
+      ItemResult = Struct.new(:box_fitter, :height, :marker, :marker_pos_x)
+
       # The child boxes of this ListBox. They need to be finalized before #fit is called.
       attr_reader :children
 
@@ -177,6 +180,11 @@ module HexaPDF
         true
       end
 
+      # Returns +true+ if no box was fitted into the list box.
+      def empty?
+        super && (!@results || @results.all? {|result| result.box_fitter.fit_results.empty? })
+      end
+
       # Fits the list box into the available space.
       def fit(available_width, available_height, frame)
         @width = if @initial_width > 0
@@ -205,9 +213,10 @@ module HexaPDF
         end
 
         @results = []
-        @results_item_marker_x = []
 
-        @children.each do |child|
+        @children.each_with_index do |child, index|
+          item_result = ItemResult.new
+
           shape = Geom2D::Polygon([left, top - height],
                                   [left + width, top - height],
                                   [left + width, top],
@@ -217,24 +226,36 @@ module HexaPDF
             remove_indent_from_frame_shape(shape) unless shape.polygons.empty?
           end
 
-          item_frame = Frame.new(item_frame_left, top - height, item_frame_width, height, shape: shape)
-          @results_item_marker_x << item_frame.x - content_indentation
+          item_frame = Frame.new(item_frame_left, top - height, item_frame_width, height,
+                                 shape: shape, context: frame.context)
+
+          if index != 0 || !split_box? || @split_box == :show_first_marker
+            box = item_marker_box(frame.document, index)
+            break unless box.fit(content_indentation, height, nil)
+            item_result.marker = box
+            item_result.marker_pos_x = item_frame.x - content_indentation
+            item_result.height = box.height
+          end
 
           box_fitter = BoxFitter.new([item_frame])
           Array(child).each {|box| box_fitter.fit(box) }
-          @results << box_fitter
+          item_result.box_fitter = box_fitter
+          item_result.height = [item_result.height.to_i, box_fitter.content_heights[0]].max
+          @results << item_result
 
-          top -= box_fitter.content_heights[0] + item_spacing
-          height -= box_fitter.content_heights[0] + item_spacing
+          top -= item_result.height + item_spacing
+          height -= item_result.height + item_spacing
 
           break if !box_fitter.fit_successful? || height <= 0
         end
 
-        @height = @results.sum {|box_fitter| box_fitter.content_heights[0] } +
+        @height = @results.sum {|item_result| item_result.height } +
           (@results.count - 1) * item_spacing +
           reserved_height
 
-        @fit_successful = @results.all?(&:fit_successful?) && @results.size == @children.size
+        @draw_pos_x = frame.x + reserved_width_left
+        @draw_pos_y = frame.y - @height + reserved_height_bottom
+        @fit_successful = @results.all? {|r| r.box_fitter.fit_successful? } && @results.size == @children.size
       end
 
       private
@@ -285,7 +306,7 @@ module HexaPDF
 
       # Splits the content of the list box. This method is called from Box#split.
       def split_content(_available_width, _available_height, _frame)
-        remaining_boxes = @results[-1].remaining_boxes
+        remaining_boxes = @results[-1].box_fitter.remaining_boxes
         first_is_split_box = remaining_boxes.first&.split_box?
         children = (remaining_boxes.empty? ? [] : [remaining_boxes]) + @children[@results.size..-1]
 
@@ -294,7 +315,6 @@ module HexaPDF
         box.instance_variable_set(:@start_number,
                                   @start_number + @results.size + (first_is_split_box ? -1 : 0))
         box.instance_variable_set(:@results, [])
-        box.instance_variable_set(:@results_item_marker_x, [])
 
         [self, box]
       end
@@ -308,20 +328,22 @@ module HexaPDF
         fragment = case @item_type
                    when :disc
                      TextFragment.create("•", font: document.fonts.add("Times"),
-                                         font_size: style.font_size)
+                                         font_size: style.font_size, fill_color: style.fill_color)
                    when :circle
                      TextFragment.create("❍", font: document.fonts.add("ZapfDingbats"),
                                          font_size: style.font_size / 2.0,
+                                         fill_color: style.fill_color,
                                          text_rise: -style.font_size / 1.8)
                    when :square
                      TextFragment.create("■", font: document.fonts.add("ZapfDingbats"),
                                          font_size: style.font_size / 2.0,
+                                         fill_color: style.fill_color,
                                          text_rise: -style.font_size / 1.8)
                    when :decimal
                      text = (@start_number + index).to_s << "."
                      decimal_style = {
                        font: (style.font? ? style.font : document.fonts.add("Times")),
-                       font_size: style.font_size || 10,
+                       font_size: style.font_size || 10, fill_color: style.fill_color
                      }
                      TextFragment.create(text, decimal_style)
                    else
@@ -333,16 +355,24 @@ module HexaPDF
       end
 
       # Draws the list items onto the canvas at position [x, y].
-      def draw_content(canvas, _x, _y)
-        @results.each_with_index do |box_fitter, index|
-          if index != 0 || !split_box? || @split_box == :show_first_marker
-            box = item_marker_box(canvas.context.document, index)
-            box.fit(content_indentation, box_fitter.content_heights[0], nil)
-            box.draw(canvas, @results_item_marker_x[index],
-                     box_fitter.frames[0].bottom + box_fitter.frames[0].height - box.height)
+      def draw_content(canvas, x, y)
+        translate = (style.position != :flow && (x != @draw_pos_x || y != @draw_pos_y))
+
+        if translate
+          canvas.save_graphics_state
+          canvas.translate(x - @draw_pos_x, y - @draw_pos_y)
+        end
+
+        @results.each do |item_result|
+          box_fitter = item_result.box_fitter
+          if (marker = item_result.marker)
+            marker.draw(canvas, item_result.marker_pos_x,
+                        box_fitter.frames[0].bottom + box_fitter.frames[0].height - marker.height)
           end
           box_fitter.fit_results.each {|result| result.draw(canvas) }
         end
+
+        canvas.restore_graphics_state if translate
       end
 
     end

data/lib/hexapdf/layout/page_style.rb

@@ -95,8 +95,8 @@ module HexaPDF
       # If this attribute is +nil+ (the default), it means that this style should be used again.
       attr_accessor :next_style
 
-      # Creates a new page style instance for the given page size and orientation. If a block is
-      # given, it is used as template for defining the initial content.
+      # Creates a new page style instance for the given page size, orientation and next style
+      # values. If a block is given, it is used as template for defining the initial content.
       #
       # Example:
       #
@@ -105,12 +105,12 @@ module HexaPDF
       #     style.next_style = :other
       #     canvas.fill_color("fd0") { canvas.circle(100, 100, 50).fill }
       #   end
-      def initialize(page_size: :A4, orientation: :portrait, &block)
+      def initialize(page_size: :A4, orientation: :portrait, next_style: nil, &block)
         @page_size = page_size
         @orientation = orientation
         @template = block
         @frame = nil
-        @next_style = nil
+        @next_style = next_style
       end
 
       # Creates a new page in the given document with this page style and returns it.
@@ -135,7 +135,8 @@ module HexaPDF
         Layout::Frame.new(box.left + margin.left,
                           box.bottom + margin.bottom,
                           box.width - margin.left - margin.right,
-                          box.height - margin.bottom - margin.top)
+                          box.height - margin.bottom - margin.top,
+                          context: page)
       end
 
     end

data/lib/hexapdf/layout/style.rb

@@ -206,11 +206,16 @@ module HexaPDF
         # The styles of each edge. See Quad.
         attr_reader :style
 
+        # Specifies whether the border should be drawn inside the provided rectangle (+false+,
+        # default) or on it (+true+).
+        attr_accessor :draw_on_bounds
+
         # Creates a new border style. All arguments can be set to any value that a Quad can process.
-        def initialize(width: 0, color: 0, style: :solid)
+        def initialize(width: 0, color: 0, style: :solid, draw_on_bounds: false)
           @width = Quad.new(width)
           @color = Quad.new(color)
           @style = Quad.new(style)
+          @draw_on_bounds = draw_on_bounds
         end
 
         # Duplicates a Border object's properties.
@@ -226,10 +231,20 @@ module HexaPDF
           width.simple? && width.top == 0
         end
 
-        # Draws the border onto the canvas, inside the rectangle (x, y, w, h).
+        # Draws the border onto the canvas.
+        #
+        # Depending on #draw_on_bounds the border is drawn inside the rectangle (x, y, w, h) or on
+        # it.
         def draw(canvas, x, y, w, h)
           return if none?
 
+          if draw_on_bounds
+            x -= width.left / 2.0
+            y -= width.bottom / 2.0
+            w += (width.left + width.right) / 2.0
+            h += (width.top + width.bottom) / 2.0
+          end
+
           canvas.save_graphics_state do
             if width.simple? && color.simple? && style.simple?
               draw_simple_border(canvas, x, y, w, h)
@@ -444,17 +459,17 @@ module HexaPDF
       # Style objects using link annotations. Typical use cases would be linking to a (named)
       # destination on a different page or executing a URI action.
       #
-      # See: PDF1.7 s12.5.6.6, Layers, HexaPDF::Type::Annotations::Link
+      # See: PDF2.0 s12.5.6.5, Layers, HexaPDF::Type::Annotations::Link
       class LinkLayer
 
         # Creates a new LinkLayer object.
         #
-        # The following arguments are allowed (note that only *one* of +dest+, +uri+ or +file+ may
-        # be specified):
+        # The following arguments are allowed (note that only *one* of +dest+, +uri+, +file+ or
+        # +action+ may be specified):
         #
         # +dest+::
         #   The destination array or a name of a named destination for in-document links. If neither
-        #   +dest+ nor +uri+ nor +file+ is specified, it is assumed that the box has a custom
+        #   +dest+, +uri+, +file+ nor +action+ is specified, it is assumed that the box has a custom
         #   property named 'link' which is used for the destination.
         #
         # +uri+::
@@ -465,6 +480,9 @@ module HexaPDF
         #   should be launched. Can either be a string or a Filespec object. Also see:
         #   HexaPDF::Type::FileSpecification.
         #
+        # +action+::
+        #   The PDF action that should be executed.
+        #
         # +border+::
         #   If set to +true+, a standard border is used. Also accepts an array that adheres to the
         #   rules for annotation borders.
@@ -477,15 +495,17 @@ module HexaPDF
         #   LinkLayer.new(dest: [page, :XYZ, nil, nil, nil], border: true)
         #   LinkLayer.new(uri: "https://my.example.com/path", border: [5 5 2])
         #   LinkLayer.new     # use 'link' custom box property for dest
-        def initialize(dest: nil, uri: nil, file: nil, border: false, border_color: nil)
-          if dest && (uri || file) || uri && file
-            raise ArgumentError, "Only one of dest, uri and file is allowed"
+        def initialize(dest: nil, uri: nil, file: nil, action: nil, border: false, border_color: nil)
+          if dest && (uri || file || action) || uri && (file || action) || file && action
+            raise ArgumentError, "Only one of dest, uri, file or action is allowed"
           end
           @dest = dest
           @action = if uri
                       {S: :URI, URI: uri}
                     elsif file
                       {S: :Launch, F: file, NewWindow: true}
+                    elsif action
+                      action
                     end
           @border = case border
                     when false then [0, 0, 0]
@@ -1030,6 +1050,40 @@ module HexaPDF
       #                 line_spacing: 1.5, last_line_gap: true)
       #   composer.text("There is spacing above this line due to last_line_gap.")
 
+      ##
+      # :method: fill_horizontal
+      # :call-seq:
+      #   fill_horizontal(factor = nil)
+      #
+      # If set to a positive number, it specifies that the content of the text item should be
+      # repeated and appropriate spacing applied so that the remaining space of the line is
+      # completely filled.
+      #
+      # If there are multiple text items with this property set for a single line, the remaining
+      # space is split between those items using the set +factors+. For example, if item A has a
+      # factor of 1 and item B a factor of 2, the remaining space will be split so that item
+      # B will receive twice the space of A.
+      #
+      # Notes:
+      #
+      # * This property _must not_ be applied to inline boxes, it only works for text items.
+      # * If the filling should be done with spaces, the non-breaking space character \u{00a0} has
+      #   to be used.
+      #
+      # Examples:
+      #
+      #   #>pdf-composer100
+      #   composer.formatted_text(["Left", {text: "\u{00a0}", fill_horizontal: 1},
+      #                            "Right"])
+      #   composer.formatted_text(["Typical table of contents entry",
+      #                            {text: ".", fill_horizontal: 1}, "34"])
+      #   composer.formatted_text(["Factor 1", {text: "\u{00a0}", fill_horizontal: 1},
+      #                            "Factor 3", {text: "\u{00a0}", fill_horizontal: 3}, "End"])
+      #   overlays = [proc {|c, b| c.line(0, b.height / 2.0, b.width, b.height / 2.0).stroke}]
+      #   composer.formatted_text([{text: "\u{00a0}", fill_horizontal: 1, overlays: overlays},
+      #                            'Centered',
+      #                            {text: "\u{00a0}", fill_horizontal: 1, overlays: overlays}])
+
       ##
       # :method: background_color
       # :call-seq:
@@ -1278,6 +1332,7 @@ module HexaPDF
            "{type: value, value: extra_arg} : value))",
           extra_args: ", extra_arg = nil"}],
         [:last_line_gap, false, {valid_values: [true, false]}],
+        [:fill_horizontal, nil],
         [:background_color, nil],
         [:background_alpha, 1],
         [:padding, "Quad.new(0)", {setter: "Quad.new(value)"}],