hexapdf 0.34.1 → 0.35.0

data/lib/hexapdf/font/type1_wrapper.rb

@@ -48,8 +48,8 @@ module HexaPDF
       # Represents a single glyph of the wrapped font.
       class Glyph
 
-        # The associated font object.
-        attr_reader :font
+        # The associated Type1Wrapper object.
+        attr_reader :font_wrapper
 
         # The name of the glyph.
         attr_reader :name
@@ -59,35 +59,35 @@ module HexaPDF
         attr_reader :str
 
         # Creates a new Glyph object.
-        def initialize(font, name, str)
-          @font = font
+        def initialize(font_wrapper, name, str)
+          @font_wrapper = font_wrapper
           @name = name
           @str = str
         end
 
         # Returns the glyph's minimum x coordinate.
         def x_min
-          @font.metrics.character_metrics[name].bbox[0]
+          @font_wrapper.wrapped_font.metrics.character_metrics[name].bbox[0]
         end
 
         # Returns the glyph's maximum x coordinate.
         def x_max
-          @font.metrics.character_metrics[name].bbox[2]
+          @font_wrapper.wrapped_font.metrics.character_metrics[name].bbox[2]
         end
 
         # Returns the glyph's minimum y coordinate.
         def y_min
-          @font.metrics.character_metrics[name].bbox[1]
+          @font_wrapper.wrapped_font.metrics.character_metrics[name].bbox[1]
         end
 
         # Returns the glyph's maximum y coordinate.
         def y_max
-          @font.metrics.character_metrics[name].bbox[3]
+          @font_wrapper.wrapped_font.metrics.character_metrics[name].bbox[3]
         end
 
         # Returns the width of the glyph.
         def width
-          @width ||= @font.width(name)
+          @width ||= @font_wrapper.wrapped_font.width(name)
         end
 
         # Returns +true+ if the word spacing parameter needs to be applied for the glyph.
@@ -95,9 +95,15 @@ module HexaPDF
           @name == :space
         end
 
+        # Returns +true+ since this is a valid glyph.
+        def valid?
+          true
+        end
+
         #:nodoc:
         def inspect
-          "#<#{self.class.name} font=#{@font.full_name.inspect} id=#{name.inspect} #{str.inspect}>"
+          "#<#{self.class.name} font=#{@font_wrapper.wrapped_font.full_name.inspect} " \
+            "id=#{name.inspect} #{str.inspect}>"
         end
 
       end
@@ -154,13 +160,23 @@ module HexaPDF
         1
       end
 
+      # Returns +true+ if the font contains bold glyphs.
+      def bold?
+        @wrapped_font.weight_class > 500
+      end
+
+      # Returns +true+ if the font contains glyphs with an incline (italic or slant).
+      def italic?
+        @wrapped_font.italic_angle.to_i != 0
+      end
+
       # Returns a Glyph object for the given glyph name.
       def glyph(name)
         @name_to_glyph[name] ||=
           begin
             str = Encoding::GlyphList.name_to_unicode(name, **@zapf_dingbats_opt)
             if @wrapped_font.metrics.character_metrics.key?(name)
-              Glyph.new(@wrapped_font, name, str)
+              Glyph.new(self, name, str)
             else
               @pdf_object.document.config['font.on_missing_glyph'].call(str, self)
             end
@@ -178,27 +194,35 @@ module HexaPDF
           raise HexaPDF::Error, "Glyph named #{name.inspect} not found in " \
             "font '#{@wrapped_font.full_name}'"
         end
-        Glyph.new(@wrapped_font, name, string)
+        Glyph.new(self, name, string)
       end
 
       # Returns an array of glyph objects representing the characters in the UTF-8 encoded string.
       #
+      # See #decode_codepoint for details.
+      def decode_utf8(str)
+        str.codepoints.map! {|c| @codepoint_to_glyph[c] || decode_codepoint(c) }
+      end
+
+      # Returns a glyph object for the given Unicode codepoint.
+      #
       # If a Unicode codepoint is not available as glyph object, it is tried to map the codepoint
       # using the font's internal encoding. This is useful, for example, for the ZapfDingbats font
       # to use ASCII characters for accessing the glyphs.
-      def decode_utf8(str)
-        str.codepoints.map! do |c|
-          @codepoint_to_glyph[c] ||=
-            begin
-              name = Encoding::GlyphList.unicode_to_name(+'' << c, **@zapf_dingbats_opt)
-              if @wrapped_font.metrics.character_set == 'Special' &&
-                  (name == :'.notdef' || !@wrapped_font.metrics.character_metrics.key?(name))
-                name = @encoding.name(c)
-              end
-              name = +"u" << c.to_s(16).rjust(6, '0') if name == :'.notdef'
-              glyph(name)
+      #
+      # The configuration option 'font.on_missing_glyph' is invoked if no glyph for a given
+      # codepoint is available.
+      def decode_codepoint(codepoint)
+        @codepoint_to_glyph[codepoint] ||=
+          begin
+            name = Encoding::GlyphList.unicode_to_name(+'' << codepoint, **@zapf_dingbats_opt)
+            if @wrapped_font.metrics.character_set == 'Special' &&
+                (name == :'.notdef' || !@wrapped_font.metrics.character_metrics.key?(name))
+              name = @encoding.name(codepoint)
             end
-        end
+            name = +"u" << codepoint.to_s(16).rjust(6, '0') if name == :'.notdef'
+            glyph(name)
+          end
       end
 
       # Encodes the glyph and returns the code string.

data/lib/hexapdf/layout/box.rb

@@ -71,7 +71,7 @@ module HexaPDF
     #        If the subclass supports the value :flow of the 'position' style property, this method
     #        needs to be overridden to return +true+.
     #
-    # #split:: This method splits the content so that the available space is used as good as
+    # #split:: This method splits the content so that the current region is used as good as
     #          possible. The default implementation should be fine for most use-cases, so only
     #          #split_content needs to be implemented. The method #create_split_box should be used
     #          for getting a basic cloned box.
@@ -186,26 +186,29 @@ module HexaPDF
 
       # Fits the box into the Frame and returns +true+ if fitting was successful.
       #
-      # The default implementation uses the whole available space for width and height if they were
-      # initially set to 0. Otherwise the specified dimensions are used.
+      # The arguments +available_width+ and +available_height+ are the width and height of the
+      # current region of the frame. The frame itself is provided as third argument.
+      #
+      # The default implementation uses the available width and height for the box width and height
+      # if they were initially set to 0. Otherwise the specified dimensions are used.
       def fit(available_width, available_height, _frame)
         @width = (@initial_width > 0 ? @initial_width : available_width)
         @height = (@initial_height > 0 ? @initial_height : available_height)
         @fit_successful = (@width <= available_width && @height <= available_height)
       end
 
-      # Tries to split the box into two, the first of which needs to fit into the available space,
-      # and returns the parts as array.
+      # Tries to split the box into two, the first of which needs to fit into the current region of
+      # the frame, and returns the parts as array.
       #
       # If the first item in the result array is not +nil+, it needs to be this box and it means
       # that even when #fit fails, a part of the box may still fit. Note that #fit should not be
       # called before #draw on the first box since it is already fitted. If not even a part of this
-      # box fits into the available space, +nil+ should be returned as the first array element.
+      # box fits into the current region, +nil+ should be returned as the first array element.
       #
       # Possible return values:
       #
-      # [self]:: The box fully fits into the available space.
-      # [nil, self]:: The box can't be split or no part of the box fits into the available space.
+      # [self]:: The box fully fits into the current region.
+      # [nil, self]:: The box can't be split or no part of the box fits into the current region.
       # [self, new_box]:: A part of the box fits and a new box is returned for the rest.
       #
       # This default implementation provides the basic functionality based on the #fit result that

data/lib/hexapdf/layout/column_box.rb

@@ -138,12 +138,14 @@ module HexaPDF
         super && (!@box_fitter || @box_fitter.fit_results.empty?)
       end
 
-      # Fits the column box into the available space.
+      # Fits the column box into the current region of the frame.
       #
       # If the style property 'position' is set to :flow, the columns might not be rectangles but
       # arbitrary (sets of) polygons since the +frame+s shape is taken into account.
       def fit(available_width, available_height, frame)
-        initial_fit_successful = (@equal_height ? nil : false)
+        return false if @initial_height > available_height || @initial_width > available_width
+
+        initial_fit_successful = (@equal_height && @columns.size > 1 ? nil : false)
         tries = 0
         @width = if style.position == :flow
                    (@initial_width > 0 ? @initial_width : frame.width) - reserved_width
@@ -205,7 +207,7 @@ module HexaPDF
         end
 
         @width = columns[-1].sum + reserved_width
-        @height = @box_fitter.content_heights.max + reserved_height
+        @height = (@initial_height > 0 ? @initial_height : @box_fitter.content_heights.max + reserved_height)
         @draw_pos_x = frame.x + reserved_width_left
         @draw_pos_y = frame.y - @height + reserved_height_bottom
 

data/lib/hexapdf/layout/frame.rb

@@ -53,8 +53,8 @@ module HexaPDF
     #   available space. If fitting is successful, the box can be drawn using #draw.
     #
     #   The method #fit is also called for absolutely positioned boxes but since these boxes are not
-    #   subject to the normal constraints, the available space used is the width and height inside
-    #   the frame to the right and top of the bottom-left corner of the box.
+    #   subject to the normal constraints, the provided available width and height are the width and
+    #   height inside the frame to the right and top of the bottom-left corner of the box.
     #
     # * If the box didn't fit, call #find_next_region to determine the next region for placing the
     #   box. If a new region was found, start over with #fit. Otherwise the frame has no more space
@@ -71,9 +71,9 @@ module HexaPDF
     #
     # == Used Box Properties
     #
-    # The style properties "position", "position_hint" and "margin" are taken into account when
-    # fitting, splitting or drawing a box. Note that the margin is ignored if a box's side coincides
-    # with the frame's original boundary.
+    # The style properties 'position', 'align', 'valign', 'margin' and 'mask_mode' are taken into
+    # account when fitting, splitting or drawing a box. Note that the margin is ignored if a box's
+    # side coincides with the frame's original boundary.
     #
     # == Frame Shape
     #
@@ -178,12 +178,12 @@ module HexaPDF
       # Also see the note in the #x documentation for further information.
       attr_reader :y
 
-      # The available width for placing a box.
+      # The available width of the current region for placing a box.
       #
       # Also see the note in the #x documentation for further information.
       attr_reader :available_width
 
-      # The available height for placing a box.
+      # The available height of the current region for placing a box.
       #
       # Also see the note in the #x documentation for further information.
       attr_reader :available_height
@@ -219,19 +219,24 @@ module HexaPDF
       # Fits the given box into the current region of available space and returns a FitResult
       # object.
       #
+      # Fitting a box takes the style properties 'position', 'align', 'valign', 'margin', and
+      # 'mask_mode' into account.
+      #
       # Use the FitResult#success? method to determine whether fitting was successful.
       def fit(box)
         fit_result = FitResult.new(box)
         return fit_result if full?
 
+        margin = box.style.margin if box.style.margin?
+
         position = if box.style.position != :flow || box.supports_position_flow?
                      box.style.position
                    else
                      :default
                    end
 
-        if position == :absolute
-          x, y = box.style.position_hint
+        if position.kind_of?(Array)
+          x, y = box.style.position
 
           aw = width - x
           ah = height - y
@@ -240,23 +245,15 @@ module HexaPDF
 
           x += left
           y += bottom
-          rectangle = if box.style.margin?
-                        margin = box.style.margin
-                        create_rectangle(x - margin.left, y - margin.bottom,
-                                         x + box.width + margin.right, y + box.height + margin.top)
-                      else
-                        create_rectangle(x, y, x + box.width, y + box.height)
-                      end
         else
           aw = available_width
           ah = available_height
 
-          margin_top = margin_right = margin_left = 0
-          if box.style.margin?
-            margin = box.style.margin
+          margin_top = margin_right = margin_left = margin_bottom = 0
+          if margin
             aw -= margin_right = margin.right unless float_equal(@x + aw, @left + @width)
             aw -= margin_left = margin.left unless float_equal(@x, @left)
-            ah -= margin.bottom unless float_equal(@y - ah, @bottom)
+            ah -= margin_bottom = margin.bottom unless float_equal(@y - ah, @bottom)
             ah -= margin_top = margin.top unless float_equal(@y, @bottom + @height)
           end
 
@@ -266,14 +263,9 @@ module HexaPDF
           height = box.height
 
           case position
-          when :flow
-            x = 0
-            y = @y - height
-            rectangle = create_rectangle(left, [bottom, y - (margin&.bottom || 0)].max,
-                                         left + self.width, @y)
-          else
-            x = case box.style.position_hint
-                when nil, :left
+          when :default, :float
+            x = case box.style.align
+                when :left
                   @x + margin_left
                 when :right
                   @x + margin_left + aw - width
@@ -286,19 +278,63 @@ module HexaPDF
                     @x + margin_left + (aw - width) / 2.0
                   end
                 end
-            y = @y - height - margin_top
-            rectangle = if position == :float
-                          create_rectangle([left, x - (margin&.left || 0)].max,
-                                           [bottom, y - (margin&.bottom || 0)].max,
-                                           [left + self.width, x + width + (margin&.right || 0)].min,
-                                           @y)
-                        else
-                          create_rectangle(left, [bottom, y - (margin&.bottom || 0)].max,
-                                           left + self.width, @y)
-                        end
+            y = case box.style.valign
+                when :top
+                  @y - margin_top - height
+                when :bottom
+                  @y - available_height + margin_bottom
+                when :center
+                  max_margin = [margin_top, margin_bottom].max
+                  # If we have enough space left for equal margins, we center perfectly
+                  if available_height - height >= 2 * max_margin
+                    @y - height - (available_height - height) / 2.0
+                  else
+                    @y - margin_top - height - (ah - height) / 2.0
+                  end
+                end
+          when :flow
+            x = 0
+            y = @y - height
+          else
+            raise HexaPDF::Error, "Invalid value '#{position}' for style property position"
           end
         end
 
+        mask_mode = if box.style.mask_mode == :default
+                      case position
+                      when :default, :flow then :fill_frame_horizontal
+                      else :box
+                      end
+                    else
+                      box.style.mask_mode
+                    end
+        rectangle =
+          case mask_mode
+          when :none
+            create_rectangle(x, y, x, y)
+          when :box
+            if margin
+              create_rectangle([left, x - (margin&.left || 0)].max,
+                               [bottom, y - (margin&.bottom || 0)].max,
+                               [left + self.width, x + box.width + (margin&.right || 0)].min,
+                               [bottom + self.height, y + box.height + (margin&.top || 0)].min)
+            else
+              create_rectangle(x, y, x + box.width, y + box.height)
+            end
+          when :fill_horizontal
+            create_rectangle(@x, [bottom, y - (margin&.bottom || 0)].max,
+                             @x + available_width,
+                             [@y, y + box.height + (margin&.top || 0)].min)
+          when :fill_frame_horizontal
+            create_rectangle(left, [bottom, y - (margin&.bottom || 0)].max,
+                             left + self.width, @y)
+          when :fill_vertical
+            create_rectangle([@x, x - (margin&.left || 0)].max, @y - available_height,
+                             [@x + available_width, x + box.width + (margin&.right || 0)].min, @y)
+          when :fill
+            create_rectangle(@x, @y - available_height, @x + available_width, @y)
+          end
+
         fit_result.available_width = aw
         fit_result.available_height = ah
         fit_result.x = x
@@ -326,7 +362,7 @@ module HexaPDF
 
       # Finds the next region for placing boxes. Returns +false+ if no useful region was found.
       #
-      # This method should be called after drawing a box using #draw was not successful. It finds a
+      # This method should be called after fitting or drawing a box was not successful. It finds a
       # different region on each invocation. So if a box doesn't fit into the first region, this
       # method should be called again to find another region and to try again.
       #
@@ -363,6 +399,8 @@ module HexaPDF
 
       # Removes the given *rectilinear* polygon from the frame's shape.
       def remove_area(polygon)
+        return if polygon.kind_of?(Geom2D::Rectangle) && (polygon.width == 0 || polygon.height == 0)
+
         @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)

data/lib/hexapdf/layout/image_box.rb

@@ -56,7 +56,7 @@ module HexaPDF
     #     #>pdf-composer100
     #     composer.image(machu_picchu, width: 100, height: 30)
     #
-    # * If neither has been set, the image is scaled to fit the available space.
+    # * If neither has been set, the image is scaled to fit the current region.
     #
     #     #>pdf-composer100
     #     composer.image(machu_picchu)
@@ -79,8 +79,8 @@ module HexaPDF
         false
       end
 
-      # Fits the image into the available space, taking the initially set width and height into
-      # account (see the class description for details).
+      # Fits the image into the current region of the frame, taking the initially set width and
+      # height into account (see the class description for details).
       def fit(available_width, available_height, _frame)
         image_width = @image.width.to_f
         image_height = @image.height.to_f

data/lib/hexapdf/layout/list_box.rb

@@ -44,9 +44,10 @@ module HexaPDF
 
     # A ListBox arranges its children as unordered or ordered list items.
     #
-    # The indentation of the contents from the left (#content_indentation) as well as the type of
-    # item (#item_type) can be specified. Additionally, it is possible to define the start number
-    # for ordered lists (#start_number) and the amount of spacing between items (#item_spacing).
+    # The indentation of the contents from the left (#content_indentation) as well as the marker
+    # type of the items (#marker_type) can be specified. Additionally, it is possible to define the
+    # start number for ordered lists (#start_number) and the amount of spacing between items
+    # (#item_spacing).
     #
     # If the list box has padding and/or borders specified, they are handled like with any other
     # box. This means they are around all items and their contents and are not used separately for
@@ -75,7 +76,7 @@ module HexaPDF
       #     Draws a filled disc for the items of the unordered list.
       #
       #       #>pdf-composer100
-      #       composer.box(:list, item_type: :disc) do |list|
+      #       composer.box(:list, marker_type: :disc) do |list|
       #         list.lorem_ipsum_box(sentences: 1)
       #       end
       #
@@ -84,7 +85,7 @@ module HexaPDF
       #     Draws an unfilled circle for the items of the unordered list.
       #
       #       #>pdf-composer100
-      #       composer.box(:list, item_type: :circle) do |list|
+      #       composer.box(:list, marker_type: :circle) do |list|
       #         list.lorem_ipsum_box(sentences: 1)
       #       end
       #
@@ -93,7 +94,7 @@ module HexaPDF
       #     Draws a filled square for the items of the unordered list.
       #
       #       #>pdf-composer100
-      #       composer.box(:list, item_type: :square) do |list|
+      #       composer.box(:list, marker_type: :square) do |list|
       #         list.lorem_ipsum_box(sentences: 1)
       #       end
       #
@@ -103,7 +104,7 @@ module HexaPDF
       #     the ordered list.
       #
       #       #>pdf-composer100
-      #       composer.box(:list, item_type: :decimal) do |list|
+      #       composer.box(:list, marker_type: :decimal) do |list|
       #         5.times { list.lorem_ipsum_box(sentences: 1) }
       #       end
       #
@@ -118,19 +119,19 @@ module HexaPDF
       #      image = lambda do |document, box, index|
       #        document.layout.image_box(machu_picchu, height: box.style.font_size)
       #      end
-      #      composer.box(:list, item_type: image) do |list|
+      #      composer.box(:list, marker_type: image) do |list|
       #        2.times { list.lorem_ipsum_box(sentences: 1) }
       #      end
-      attr_reader :item_type
+      attr_reader :marker_type
 
-      # The start number when using an #item_type that represents an ordered list.
+      # The start number when using a #marker_type that represents an ordered list.
       #
       # The default value for this is 1.
       #
       # Example:
       #
       #   #>pdf-composer100
-      #   composer.box(:list, item_type: :decimal, start_number: 3) do |list|
+      #   composer.box(:list, marker_type: :decimal, start_number: 3) do |list|
       #     2.times { list.lorem_ipsum_box(sentences: 1) }
       #   end
       attr_reader :start_number
@@ -162,11 +163,11 @@ module HexaPDF
       attr_reader :item_spacing
 
       # Creates a new ListBox object for the given child boxes in +children+.
-      def initialize(children: [], item_type: :disc, content_indentation: nil, start_number: 1,
+      def initialize(children: [], marker_type: :disc, content_indentation: nil, start_number: 1,
                      item_spacing: 0, **kwargs)
         super(**kwargs)
         @children = children
-        @item_type = item_type
+        @marker_type = marker_type
         @content_indentation = content_indentation || 2 * style.font_size
         @start_number = start_number
         @item_spacing = item_spacing
@@ -185,7 +186,7 @@ module HexaPDF
         super && (!@results || @results.all? {|result| result.box_fitter.fit_results.empty? })
       end
 
-      # Fits the list box into the available space.
+      # Fits the list box into the current region of the frame.
       def fit(available_width, available_height, frame)
         @width = if @initial_width > 0
                    @initial_width
@@ -322,10 +323,10 @@ module HexaPDF
       # Creates a box for the item marker at the given item index, using #item_style to decide on
       # its contents.
       def item_marker_box(document, index)
-        return @item_type.call(document, self, index) if @item_type.kind_of?(Proc)
+        return @marker_type.call(document, self, index) if @marker_type.kind_of?(Proc)
         return @item_marker_box if defined?(@item_marker_box)
 
-        fragment = case @item_type
+        fragment = case @marker_type
                    when :disc
                      TextFragment.create("•", font: document.fonts.add("Times"),
                                          font_size: style.font_size, fill_color: style.fill_color)
@@ -347,10 +348,10 @@ module HexaPDF
                      }
                      TextFragment.create(text, decimal_style)
                    else
-                     raise HexaPDF::Error, "Unknown list item type #{@item_type.inspect}"
+                     raise HexaPDF::Error, "Unknown list marker type #{@marker_type.inspect}"
                    end
-        box = TextBox.new(items: [fragment], style: {align: :right, padding: [0, 5, 0, 0]})
-        @item_marker_box = box unless @item_type == :decimal
+        box = TextBox.new(items: [fragment], style: {text_align: :right, padding: [0, 5, 0, 0]})
+        @item_marker_box = box unless @marker_type == :decimal
         box
       end