hexapdf 1.3.0 → 1.4.0

data/lib/hexapdf/layout/style.rb

@@ -150,14 +150,15 @@ module HexaPDF
         end
 
         # :call-seq:
-        #   quad.set(value)
-        #   quad.set(array)
-        #   quad.set(quad)
+        #   quad.set(value)     -> quad
+        #   quad.set(array)     -> quad
+        #   quad.set(hash)      -> quad
+        #   quad.set(quad)      -> quad
         #
-        # Sets all values of the quad.
+        # Sets all values of the quad and returns it.
         #
-        # * If a single value is provided that is neither a Quad nor an array, it is handled as if
-        #   an array with one value was given.
+        # * If a single value is provided that is neither a Quad nor an array nor a hash, it is
+        #   handled as if an array with one value was given.
         #
         # * If a Quad is provided, its values are used.
         #
@@ -170,6 +171,9 @@ module HexaPDF
         #     third value.
         #   * Four or more values: Top is set to the first, right to the second, bottom to the third
         #     and left to the fourth value.
+        #
+        # * If a hash is provided, the keys +:top+, +:bottom+, +:left+ and +:right+ are used to set
+        #   the respective value. All unspecified keys that have not been set before are set to 0.
         def set(obj)
           case obj
           when Quad
@@ -182,9 +186,15 @@ module HexaPDF
             @bottom = obj[2] || obj[0]
             @left = obj[3] || obj[1] || obj[0]
             @right = obj[1] || obj[0]
+          when Hash
+            @top = obj[:top] || @top || 0
+            @bottom = obj[:bottom] || @bottom || 0
+            @left = obj[:left] || @left || 0
+            @right = obj[:right] || @right || 0
           else
             @top = @bottom = @left = @right = obj
           end
+          self
         end
 
         # Returns +true+ if the quad effectively contains only one value.
@@ -398,6 +408,9 @@ module HexaPDF
       # bottom-left corner of the box during the drawing operations.
       class Layers
 
+        # The array holding all raw layer definitions.
+        attr_reader :layers
+
         # Creates a new Layers object popuplated with the given +layers+.
         def initialize(layers = nil)
           @layers = []
@@ -1527,10 +1540,10 @@ module HexaPDF
         [:text_rendering_mode, "Content::TextRenderingMode::FILL",
          {setter: "Content::TextRenderingMode.normalize(value)"}],
         [:subscript, false,
-         {setter: "value; superscript(false) if superscript",
+         {setter: "value; superscript(false) if value && superscript? && superscript",
           valid_values: [true, false]}],
         [:superscript, false,
-         {setter: "value; subscript(false) if subscript",
+         {setter: "value; subscript(false) if value && subscript? && subscript",
           valid_values: [true, false]}],
         [:underline, false, {valid_values: [true, false]}],
         [:strikeout, false, {valid_values: [true, false]}],
@@ -1557,8 +1570,10 @@ module HexaPDF
         [:fill_horizontal, nil],
         [:background_color, nil],
         [:background_alpha, 1],
-        [:padding, "Quad.new(0)", {setter: "Quad.new(value)"}],
-        [:margin, "Quad.new(0)", {setter: "Quad.new(value)"}],
+        [:padding, "Quad.new(0)",
+         {setter: "value.kind_of?(Hash) && @name ? @name.set(value) : Quad.new(value)"}],
+        [:margin, "Quad.new(0)",
+         {setter: "value.kind_of?(Hash) && @name ? @name.set(value) : Quad.new(value)"}],
         [:border, "Border.new", {setter: "Border.new(**value)"}],
         [:overlays, "Layers.new", {setter: "Layers.new(value)"}],
         [:underlays, "Layers.new", {setter: "Layers.new(value)"}],
@@ -1641,9 +1656,9 @@ module HexaPDF
 
       # The calculated text rise, taking superscript and subscript into account.
       def calculated_text_rise
-        if superscript
+        if superscript? && superscript
           text_rise + font_size * 0.33
-        elsif subscript
+        elsif subscript? && subscript
           text_rise - font_size * 0.20
         else
           text_rise
@@ -1652,7 +1667,7 @@ module HexaPDF
 
       # The calculated font size, taking superscript and subscript into account.
       def calculated_font_size
-        (superscript || subscript ? 0.583 : 1) * font_size
+        ((superscript? && superscript) || (subscript? && subscript) ? 0.583 : 1) * font_size
       end
 
       # Returns the correct offset from the baseline for the underline.

data/lib/hexapdf/layout/table_box.rb

@@ -126,6 +126,15 @@ module HexaPDF
     #           [layout.text('E'), layout.text('F')]]
     #  composer.column(height: 90) {|col| col.table(cells, header: header, footer: footer) }
     #
+    # While the width of a cell is determined by the #column_widths array, the height is
+    # automatically determined during fitting of the content. However, it is also possible to use a
+    # fixed height (only if the actual content is smaller or equal than it):
+    #
+    #  #>pdf-composer
+    #  cells = [[{content: layout.text('A'), height: 5}, layout.text('B')],
+    #           [{content: layout.text('C'), height: 40}, layout.text('D')]]
+    #  composer.table(cells)
+    #
     # The cells can be styled using a callable object for more complex styling:
     #
     #  #>pdf-composer
@@ -191,13 +200,14 @@ module HexaPDF
         attr_accessor :children
 
         # Creates a new Cell instance.
-        def initialize(row:, column:, children: nil, row_span: nil, col_span: nil, **kwargs)
+        def initialize(row:, column:, children: nil, min_height: nil, row_span: nil, col_span: nil, **kwargs)
           super(**kwargs, width: 0, height: 0)
           @children = children
           @row = row
           @column = column
           @row_span = row_span || 1
           @col_span = col_span || 1
+          @min_height = min_height
           style.border.width.set(1) unless style.border?
           style.border.draw_on_bounds = true
           style.padding.set(5) unless style.padding?
@@ -257,6 +267,11 @@ module HexaPDF
             @fit_results = []
             fit_result.success!
           end
+
+          if @min_height && @height < @min_height
+            @height = @preferred_height = @min_height
+            fit_result.failure! if available_height < @height
+          end
         end
 
         # Draws the content of the cell.
@@ -298,6 +313,8 @@ module HexaPDF
       #
       #   +:col_span+:: An integer specifying the number of columsn this cell should span.
       #
+      #   +:min_height+:: A number specifying the minimum height of the table cell.
+      #
       #   +:properties+:: A hash of properties (see Box#properties) to be set on the cell itself.
       #
       #   All other key-value pairs are taken to be cell styling information (like
@@ -513,11 +530,12 @@ module HexaPDF
                 children = content.delete(:content)
                 row_span = content.delete(:row_span)
                 col_span = content.delete(:col_span)
+                min_height = content.delete(:min_height)
                 properties = content.delete(:properties)
                 style = content
               end
               cell = Cell.new(children: children, row: row_index, column: col_index,
-                              row_span: row_span, col_span: col_span)
+                              row_span: row_span, col_span: col_span, min_height: min_height)
               cell_style_block&.call(cell)
               cell.style.update(**style) if style
               cell.properties.update(properties) if properties

data/lib/hexapdf/type/annotations/appearance_generator.rb

@@ -75,6 +75,8 @@ module HexaPDF
           when :Line then create_line_appearance
           when :Square then create_square_circle_appearance(:square)
           when :Circle then create_square_circle_appearance(:circle)
+          when :Polygon then create_polygon_polyline_appearance(:polygon)
+          when :PolyLine then create_polygon_polyline_appearance(:polyline)
           else
             raise HexaPDF::Error, "Appearance regeneration for #{@annot[:Subtype]} not yet supported"
           end
@@ -143,18 +145,8 @@ module HexaPDF
           # the caption when calculating the bounding box.
           #
           # The result could still be improved by tailoring to the specific line ending style.
-          calculate_le_padding = lambda do |le_style|
-            case le_style
-            when :square, :circle, :diamond, :slash, :open_arrow, :closed_arrow
-              3 * style.width
-            when :ropen_arrow, :rclosed_arrow
-              10 * style.width
-            else
-              0
-            end
-          end
-          dstart = calculate_le_padding.call(line_ending_style.start_style)
-          dend = calculate_le_padding.call(line_ending_style.end_style)
+          dstart = calculate_line_ending_padding(line_ending_style.start_style, style.width)
+          dend = calculate_line_ending_padding(line_ending_style.end_style, style.width)
           if captioned
             cap_ulx = x0 + cos_angle * cap_x - sin_angle * cap_y
             cap_uly = y0 + sin_angle * cap_x + cos_angle * cap_y
@@ -299,6 +291,90 @@ module HexaPDF
           end
         end
 
+        # Creates the appropriate appearance for a polygon or polyline annotation depending on the
+        # given +type+ (which can either be +:polygon+ or +:polyline+).
+        #
+        # The cloudy border effect is not supported.
+        #
+        # See: HexaPDF::Type::Annotations::Polygon, HexaPDF::Type::Annotations::Polyline
+        def create_polygon_polyline_appearance(type)
+          # Prepare the annotation
+          form = (@annot[:AP] ||= {})[:N] ||=
+            @document.add({Type: :XObject, Subtype: :Form, BBox: [0, 0, 0, 0]})
+          form.contents = ""
+          @annot.flag(:print)
+          @annot.unflag(:hidden)
+
+          # Get all needed values from the annotation
+          vertices = @annot.vertices
+          border_style = @annot.border_style
+          line_ending_style = @annot.line_ending_style
+          opacity = @annot.opacity
+          interior_color = @annot.interior_color
+
+          # Calculate the annotation's rectangle as well as the form bounding box
+          padding_start = calculate_line_ending_padding(line_ending_style.start_style, border_style.width)
+          padding_end = calculate_line_ending_padding(line_ending_style.end_style, border_style.width)
+          x_coords, y_coords = vertices.partition.with_index {|_, index| index.even? }
+          min_x, max_x = (x_coords + [x_coords[0] + padding_start, x_coords[0] - padding_start,
+                                      x_coords[-1] + padding_end, x_coords[-1] - padding_end]).minmax
+          min_y, max_y = (y_coords + [y_coords[0] + padding_start, y_coords[0] - padding_start,
+                                      y_coords[-1] + padding_end, y_coords[-1] - padding_end]).minmax
+
+          padding = 4 * border_style.width
+          rect = [min_x - padding, min_y - padding, max_x + padding, max_y + padding]
+          @annot[:Rect] = rect
+          form[:BBox] = rect.dup
+
+          return if vertices.length < 4
+
+          # Set the appropriate graphics state
+          canvas = form.canvas(translate: false)
+          canvas.opacity(**opacity.to_h)
+          canvas.stroke_color(border_style.color) if border_style.color
+          canvas.fill_color(interior_color) if interior_color
+          canvas.line_width(border_style.width)
+          canvas.line_dash_pattern(border_style.style) if border_style.style.kind_of?(Array)
+
+          stroke_op = (border_style.color ? :stroke : :end_path)
+          fill_op = (border_style.color && interior_color ? :fill_stroke :
+                       (border_style.color ? :stroke : (interior_color ? :fill : :end_path)))
+
+          # Draw the polygon/polyline
+          canvas.send(type, *vertices)
+          canvas.send(type == :polygon ? fill_op : stroke_op)
+
+          return unless type == :polyline
+
+          # Draw line endings
+          angle_start = Math.atan2(y_coords[1] - y_coords[0], x_coords[1] - x_coords[0])
+          angle_end = Math.atan2(y_coords[-2] - y_coords[-1], x_coords[-2] - x_coords[-1])
+          if line_ending_style.start_style != :none
+            do_fill = draw_line_ending(canvas, line_ending_style.start_style,
+                                       x_coords[0], y_coords[0], border_style.width, angle_start)
+            canvas.send(do_fill ? fill_op : stroke_op)
+          end
+          if line_ending_style.end_style != :none
+            do_fill = draw_line_ending(canvas, line_ending_style.end_style,
+                                       x_coords[-1], y_coords[-1], border_style.width, angle_end)
+            canvas.send(do_fill ? fill_op : stroke_op)
+          end
+
+        end
+
+        # Calculates the padding needed around the line endings based on the line ending +style+ and
+        # the +border_width+.
+        def calculate_line_ending_padding(style, border_width)
+          case style
+          when :square, :circle, :diamond, :slash, :open_arrow, :closed_arrow
+            3 * border_width
+          when :ropen_arrow, :rclosed_arrow
+            10 * border_width
+          else
+            0
+          end
+        end
+
         # Draws the line ending style +type+ at the position (+x+, +y+) and returns +true+ if the
         # shape needs to be filled.
         #
@@ -319,11 +395,13 @@ module HexaPDF
             canvas.polygon(x + lw3, y, x, y + lw3, x - lw3, y, x, y - lw3)
             true
           when :open_arrow, :closed_arrow, :ropen_arrow, :rclosed_arrow
-            arrow_cos = Math.cos(Math::PI / 6 + angle)
-            arrow_sin = Math.sin(Math::PI / 6 + angle)
+            arrow_cos_up = Math.cos(angle + Math::PI / 6)
+            arrow_sin_up = Math.sin(angle + Math::PI / 6)
+            arrow_cos_down = Math.cos(angle - Math::PI / 6)
+            arrow_sin_down = Math.sin(angle - Math::PI / 6)
             dir = (type == :ropen_arrow || type == :rclosed_arrow ? -1 : 1)
-            canvas.polyline(x + dir * arrow_cos * 3 * lw3, y + arrow_sin * 3 * lw3, x, y,
-                            x + dir * arrow_cos * 3 * lw3, y - arrow_sin * 3 * lw3)
+            canvas.polyline(x + dir * arrow_cos_up * 3 * lw3, y + arrow_sin_up * 3 * lw3, x, y,
+                            x + dir * arrow_cos_down * 3 * lw3, y + arrow_sin_down * 3 * lw3)
             if type == :closed_arrow || type == :rclosed_arrow
               canvas.close_subpath
               true

data/lib/hexapdf/type/annotations/interior_color.rb

@@ -61,7 +61,7 @@ module HexaPDF
         #           the allowed arguments.
         #
         #           If the special value +:transparent+ is used when setting the color, no color is
-        #           used for filling the line endings.
+        #           used for filling.
         def interior_color(*color)
           if color.empty?
             color = self[:IC]

data/lib/hexapdf/type/annotations/line.rb

@@ -71,6 +71,7 @@ module HexaPDF
 
         include BorderStyling
         include InteriorColor
+        include LineEndingStyling
 
         define_field :Subtype, type: Symbol, required: true, default: :Line
         define_field :L,       type: PDFArray, required: true
@@ -116,163 +117,6 @@ module HexaPDF
           end
         end
 
-        # Maps HexaPDF names to PDF names.
-        LINE_ENDING_STYLE_MAP = { # :nodoc:
-          Square: :Square, square: :Square,
-          Circle: :Circle, circle: :Circle,
-          Diamond: :Diamond, diamond: :Diamond,
-          OpenArrow: :OpenArrow, open_arrow: :OpenArrow,
-          ClosedArrow: :ClosedArrow, closed_arrow: :ClosedArrow,
-          None: :None, none: :None,
-          Butt: :Butt, butt: :Butt,
-          ROpenArrow: :ROpenArrow, ropen_arrow: :ROpenArrow,
-          RClosedArrow: :RClosedArrow, rclosed_arrow: :RClosedArrow,
-          Slash: :Slash, slash: :Slash,
-        }.freeze
-        LINE_ENDING_STYLE_REVERSE_MAP = LINE_ENDING_STYLE_MAP.invert # :nodoc:
-
-
-        # Describes the line ending style for a line annotation, i.e. the +start_style+ and the
-        # +end_style+.
-        #
-        # See Line#line_ending_style for more information.
-        LineEndingStyle = Struct.new(:start_style, :end_style)
-
-        # :call-seq:
-        #   line.line_ending_style                                         => style
-        #   line.line_ending_style(start_style: :none, end_style: :none)   => line
-        #
-        # Returns a LineEndingStyle instance holding the current line ending styles when no argument
-        # is given. Otherwise sets the line ending style of the line and returns self.
-        #
-        # When returning the styles, unknown line ending styles are mapped to :none.
-        #
-        # When setting the line ending style, arguments that are not provided will use the currently
-        # defined value or fall back to the default of +:none+.
-        #
-        # Possible line ending styles (the first one is the HexaPDF name, the second the PDF name):
-        #
-        # :square or :Square::
-        #     A square filled with the annotation's interior colour, if any.
-        #
-        #       #>pdf-small-hide
-        #       doc.annotations.
-        #         create_line(doc.pages[0], start_point: [20, 20], end_point: [80, 60]).
-        #         interior_color("hp-orange").
-        #         line_ending_style(end_style: :square).
-        #         regenerate_appearance
-        #
-        # :circle or :Circle::
-        #     A circle filled with the annotation’s interior colour, if any.
-        #
-        #       #>pdf-small-hide
-        #       doc.annotations.
-        #         create_line(doc.pages[0], start_point: [20, 20], end_point: [80, 60]).
-        #         interior_color("hp-orange").
-        #         line_ending_style(end_style: :circle).
-        #         regenerate_appearance
-        #
-        # :diamond or :Diamond::
-        #     A diamond shape filled with the annotation’s interior colour, if any.
-        #
-        #       #>pdf-small-hide
-        #       doc.annotations.
-        #         create_line(doc.pages[0], start_point: [20, 20], end_point: [80, 60]).
-        #         interior_color("hp-orange").
-        #         line_ending_style(end_style: :diamond).
-        #         regenerate_appearance
-        #
-        # :open_arrow or :OpenArrow::
-        #     Two short lines meeting in an acute angle to form an open arrowhead.
-        #
-        #       #>pdf-small-hide
-        #       doc.annotations.
-        #         create_line(doc.pages[0], start_point: [20, 20], end_point: [80, 60]).
-        #         interior_color("hp-orange").
-        #         line_ending_style(end_style: :open_arrow).
-        #         regenerate_appearance
-        #
-        # :closed_arrow or :ClosedArrow::
-        #     Two short lines meeting in an acute angle as in the +:open_arrow+ style and connected
-        #     by a third line to form a triangular closed arrowhead filled with the annotation’s
-        #     interior colour, if any.
-        #
-        #       #>pdf-small-hide
-        #       doc.annotations.
-        #         create_line(doc.pages[0], start_point: [20, 20], end_point: [80, 60]).
-        #         interior_color("hp-orange").
-        #         line_ending_style(end_style: :closed_arrow).
-        #         regenerate_appearance
-        #
-        # :none or :None::
-        #     No line ending.
-        #
-        #       #>pdf-small-hide
-        #       doc.annotations.
-        #         create_line(doc.pages[0], start_point: [20, 20], end_point: [80, 60]).
-        #         interior_color("hp-orange").
-        #         line_ending_style(end_style: :none).
-        #         regenerate_appearance
-        #
-        # :butt or :Butt::
-        #     A short line at the endpoint perpendicular to the line itself.
-        #
-        #       #>pdf-small-hide
-        #       doc.annotations.
-        #         create_line(doc.pages[0], start_point: [20, 20], end_point: [80, 60]).
-        #         interior_color("hp-orange").
-        #         line_ending_style(end_style: :butt).
-        #         regenerate_appearance
-        #
-        # :ropen_arrow or :ROpenArrow::
-        #     Two short lines in the reverse direction from +:open_arrow+.
-        #
-        #       #>pdf-small-hide
-        #       doc.annotations.
-        #         create_line(doc.pages[0], start_point: [20, 20], end_point: [80, 60]).
-        #         interior_color("hp-orange").
-        #         line_ending_style(end_style: :ropen_arrow).
-        #         regenerate_appearance
-        #
-        # :rclosed_arrow or :RClosedArrow::
-        #     A triangular closed arrowhead in the reverse direction from +:closed_arrow+.
-        #
-        #       #>pdf-small-hide
-        #       doc.annotations.
-        #         create_line(doc.pages[0], start_point: [20, 20], end_point: [80, 60]).
-        #         interior_color("hp-orange").
-        #         line_ending_style(end_style: :rclosed_arrow).
-        #         regenerate_appearance
-        #
-        # :slash or :Slash::
-        #      A short line at the endpoint approximately 30 degrees clockwise from perpendicular to
-        #      the line itself.
-        #
-        #       #>pdf-small-hide
-        #       doc.annotations.
-        #         create_line(doc.pages[0], start_point: [20, 20], end_point: [80, 60]).
-        #         interior_color("hp-orange").
-        #         line_ending_style(end_style: :slash).
-        #         regenerate_appearance
-        def line_ending_style(start_style: :UNSET, end_style: :UNSET)
-          if start_style == :UNSET && end_style == :UNSET
-            le = self[:LE]
-            LineEndingStyle.new(LINE_ENDING_STYLE_REVERSE_MAP.fetch(le[0], :none),
-                                LINE_ENDING_STYLE_REVERSE_MAP.fetch(le[1], :none))
-          else
-            start_style = self[:LE][0] if start_style == :UNSET
-            end_style = self[:LE][1] if end_style == :UNSET
-            start_style = LINE_ENDING_STYLE_MAP.fetch(start_style) do
-              raise ArgumentError, "Invalid line ending style: #{start_style.inspect}"
-            end
-            end_style = LINE_ENDING_STYLE_MAP.fetch(end_style) do
-              raise ArgumentError, "Invalid line ending style: #{end_style.inspect}"
-            end
-            self[:LE] = [start_style, end_style]
-            self
-          end
-        end
-
         # :call-seq:
         #   line.leader_line_length          => leader_line_length
         #   line.leader_line_length(length)  => line