hexapdf 1.2.0 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 041330c9846091186ddeecd7900a7919bb96da26b3513b047f03c87888efedcd
-  data.tar.gz: ff89d47f1eeac1d2dda4982224403318528401918ccfe7f1bb775d05d8f0e6f3
+  metadata.gz: 82d0430964f9f4c6925af5bb076a2e641908c3a4cb6796acc64dbe1303bc3407
+  data.tar.gz: 689a86b637a86331ca203d7d7ac90a9fb3c50c275f07b21d8109013faa509f07
 SHA512:
-  metadata.gz: 508fa118a26d5825f9ae2a105cdf4717b02901fd3095c49cf5855caae7648bf60b9cea414bb6670dd3bd0c82f99b076a8df7ffb79efa60990003468d7f3a9db9
-  data.tar.gz: 613323b8b2a93a01e31ec9e35664e6dc2939b210bbe7d7c055cb861eac6cd530978b14256a55a8e51f2e3804be06808440d5816c73e808df4af3f111f325b9c9
+  metadata.gz: 4cfe8038379e5dc7f3bebeb38b44525676b934cb2b2355ac7575fa7a4466a6c4ec9ab9e0a80a184aebab32b2aa87e06dff735c10915abebe11541ada95d8129c
+  data.tar.gz: 62562b4bae557ad3dac03cb51913a8d1d6796d6cad9ce0626bc901cc15afeb301e42d061c345a1ebcb30e09a018dbe4b7c26fc4c567423c262f67607d04b95c9

data/CHANGELOG.md

@@ -1,3 +1,93 @@
+## 1.4.0 - 2025-08-03
+
+### Added
+
+* [HexaPDF::Type::Annotations::Polygon] for polygon annotations as well as
+  [HexaPDF::Document::Annotations#create_polygon]
+* [HexaPDF::Type::Annotations::Polyline] for polyline annotations as well as
+  [HexaPDF::Document::Annotations#create_polyline]
+* [HexaPDF::Layout::ContainerBox#splitable] for specifying whether the container
+  box may be split
+* [HexaPDF::Layout::Style::Layers#layers] for retrieving the list of defined
+  layers
+* [HexaPDF::Document::Layout#resolve_font] for resolving the font style property
+* [HexaPDF::Type::Measure] for representing the measure dictionary
+* [HexaPDF::Layout::Box::FitResult#failure!] for setting the result status to
+  failure
+
+### Changed
+
+* **Breaking change**: Extracted `#line_ending_style` and associated data class
+  from [HexaPDF::Type::Annotations::Line] into
+  [HexaPDF::Type::Annotations::LineEndingStyling]
+* [HexaPDF::Layout::TableBox] implementation to allow setting the minimum height
+  of a table cell
+* [HexaPDF::Layout::Style::Quad#set] to allow setting a subset of values using a
+  hash
+* CLI command `hp form` to show the names of radio button widgets
+* CLI command `hp form` to show position and size of widgets in easier to
+  understand form
+* Default signing handler to not set /DigestMethod entry on signature reference
+  dictionary anymore
+
+### Fixed
+
+* Parsing and writing the /ModDate and /CreationDate trailer info fields in case
+  of string values when using the XMP metadata handler
+* [HexaPDF::Layout::Style] to not accidentally set subscript or superscript
+  values
+* [HexaPDF::DictionaryFields::DateConverter] to handle invalid dates with two
+  trailing apostrophes
+* [HexaPDF::Document::Layout::CellArgumentCollector#retrieve_arguments_for] to
+  not change the stored data
+* Encryption when using AES with 256bits and an owner password
+
+
+## 1.3.0 - 2025-04-23
+
+### Added
+
+* [HexaPDF::Type::Annotations::Square] for rectangle annotations as well as
+  [HexaPDF::Document::Annotations#create_rectangle]
+* [HexaPDF::Type::Annotations::Circle] for ellipse annotations as well as
+  [HexaPDF::Document::Annotations#create_ellipse]
+* Basic appearance generation for push button fields
+* [HexaPDF::Type::Annotation::BorderEffect] type class
+* [HexaPDF::Type::Annotations::BorderEffect] module that provides convenience
+  access to the border effect dictionary
+* [HexaPDF::Document::Layout#style?] and [HexaPDF::Composer#style?] for checking
+  whether a given style (name) exists
+* [HexaPDF::Layout::Style#each_property] for iterating over all set properties
+* [HexaPDF::Layout::Style#merge] for merging another style instance
+* [HexaPDF::Layout::Style#box_options] for specifying box initialization options
+* [HexaPDF::Layout::Style#font_bold] and [HexaPDF::Layout::Style#font_italic]
+  for setting bold and/or italic variants independently of the font name
+* [HexaPDF::PDFArray#map!] for mapping elements in-place
+* [HexaPDF::PDFArray#compact!] for removing `nil` elements
+
+### Changed
+
+* **Breaking change**: [HexaPDF::Type::Annotations::Widget::MarkerStyle::new]
+  got a new positional argument
+* [HexaPDF::Type::Annotations::Widget#marker_style] to allow setting and
+  retrieving the font for push buttons
+* Extracted `#interior_color` from [HexaPDF::Type::Annotations::Line] into
+  [HexaPDF::Type::Annotations::InteriorColor]
+* CLI command `hexapdf inspect` to support decoding Form XObject streams
+* [HexaPDF::Layout::Style#line_spacing] to accept a `LineSpacing` object when
+  setting the value
+
+### Fixed
+
+* Text extraction with macOS Preview due a bug in Preview
+* [HexaPDF::PDFArray#reject!] to work according to documented method signature
+* [HexaPDF::Type::AcroForm::Field#create_widget] to ensure the proper type
+  class is stored in the document in case an embedded widget is extracted
+* [HexaPDF::Type::AcroForm::Form] validation to ensure that all field objects in
+  the field hierarchy are using a field type class
+* [HexaPDF::Type::AcroForm::Form] validation to delete merged fields
+
+
 ## 1.2.0 - 2025-02-10
 
 ### Added

data/README.md

@@ -82,7 +82,7 @@ canvas.text("Hello World!", at: [20, 400])
 doc.write("hello-world.pdf")
 ~~~
 
-For detailed information have a look at the [HexaPDF website][website] where you will the API
+For detailed information have a look at the [HexaPDF website][website] where you will find the API
 documentation, example code and more.
 
 It is recommend to use the HTML API documentation provided by the HexaPDF website as it is enhanced

data/lib/hexapdf/cli/form.rb

@@ -161,8 +161,8 @@ module HexaPDF
             (field.alternate_field_name ? " (#{field.alternate_field_name})" : '')
           concrete_field_type = field.concrete_field_type
           nice_field_type = concrete_field_type.to_s.split('_').map(&:capitalize).join(' ')
-          size = "(#{widget[:Rect].width.round(3)}x#{widget[:Rect].height.round(3)})"
-          position = "(#{widget[:Rect].left}, #{widget[:Rect].bottom})"
+          size = "#{widget[:Rect].width.round(3)}x#{widget[:Rect].height.round(3)}"
+          position = "x=#{widget[:Rect].left}, y=#{widget[:Rect].bottom}"
           field_value = if !field.field_value || concrete_field_type != :signature_field
                           field.field_value.inspect
                         else
@@ -172,10 +172,15 @@ module HexaPDF
                           temp
                         end
 
+          if concrete_field_type == :radio_button
+            rb_name = ((widget.appearance_dict&.normal_appearance&.value&.keys || []) - [:Off]).first
+            rb_name = " (#{rb_name.inspect})"
+          end
+
           flags = field_flags(field)
-          puts "  #{field_name}" << (flags.empty? ? '' : " (#{flags.join(', ')})")
+          puts "  #{field_name}#{rb_name}" << (flags.empty? ? '' : " (#{flags.join(', ')})")
           if command_parser.verbosity_info?
-            printf("    └─ %-22s | %-20s\n", nice_field_type, "#{size} #{position}")
+            printf("    └─ %-22s | %-20s\n", nice_field_type, "#{position}, #{size} ")
           end
           puts "    └─ #{field_value}"
           if command_parser.verbosity_info?

data/lib/hexapdf/cli/inspect.rb

@@ -188,12 +188,20 @@ module HexaPDF
                   end
             serialize(obj.value, recursive: true) if obj
 
-          when 's', 'stream', 'raw', 'raw-stream'
+          when 's', 'stream', 'raw', 'raw-stream', 'sd'
             if (obj = pdf_object_from_string_reference(data.shift) rescue $stderr.puts($!.message)) &&
                 obj.kind_of?(HexaPDF::Stream)
-              source = (command.start_with?('raw') ? obj.stream_source : obj.stream_decoder)
-              while source.alive? && (stream_data = source.resume)
-                $stdout.write(stream_data)
+              if command == 'sd'
+                if obj.respond_to?(:process_contents)
+                  obj.process_contents(ContentProcessor.new)
+                else
+                  $stderr.puts("Error: The object is not a Form XObject or page")
+                end
+              else
+                source = (command.start_with?('raw') ? obj.stream_source : obj.stream_decoder)
+                while source.alive? && (stream_data = source.resume)
+                  $stdout.write(stream_data)
+                end
               end
             elsif command_parser.verbosity_info?
               $stderr.puts("Note: Object has no stream data")
@@ -427,6 +435,7 @@ module HexaPDF
         ["OID[,GEN] | o[bject] OID[,GEN]", "Print object"],
         ["r[ecursive] OID[,GEN]", "Print object recursively"],
         ["s[tream] OID[,GEN]", "Print filtered stream"],
+        ["sd OID[,GEN]", "Print the decoded stream of a Form XObject or page"],
         ["raw[-stream] OID[,GEN]", "Print raw stream"],
         ["rev[ision] [NUMBER]", "Print or extract revision"],
         ["x[ref] OID[,GEN]", "Print the cross-reference entry"],

data/lib/hexapdf/composer.rb

@@ -261,6 +261,20 @@ module HexaPDF
       @document.layout.style(name, base: base, **properties)
     end
 
+    # Returns +true+ if a style with the given +name+ exists, else +false+.
+    #
+    # See HexaPDF::Document::Layout#style for details; this method is just a thin wrapper around
+    # that method.
+    #
+    # Example:
+    #
+    #   composer.style(:header, font: 'Helvetica')
+    #   composer.style?(:header)     # => true
+    #   composer.style?(:paragraph)  # => false
+    def style?(name)
+      @document.layout.style?(name)
+    end
+
     # :call-seq:
     #    composer.styles              -> styles
     #    composer.styles(**mapping)   -> styles

data/lib/hexapdf/configuration.rb

@@ -374,6 +374,11 @@ module HexaPDF
   #    The default implementation returns an object of class HexaPDF::Font::InvalidGlyph which, when
   #    not removed before encoding, will raise a HexaPDF::MissingGlyphError.
   #
+  #    Note: The 'font.on_invalid_glyph' configuration option does something similar but is used
+  #    later and only by the layout engine. If this callback hook returns an invalid glyph instance,
+  #    the 'font.on_invalid_glyph' callback hook is invoked when using the layout engine and it can
+  #    return a substitute glyph in any font.
+  #
   #    If a replacement glyph should be displayed instead of an error, the following provides a good
   #    starting implementation:
   #
@@ -709,6 +714,7 @@ module HexaPDF
                         XXAcroFormField: 'HexaPDF::Type::AcroForm::Field',
                         XXAppearanceDictionary: 'HexaPDF::Type::Annotation::AppearanceDictionary',
                         Border: 'HexaPDF::Type::Annotation::Border',
+                        XXBorderEffect: 'HexaPDF::Type::Annotation::BorderEffect',
                         SigFieldLock: 'HexaPDF::Type::AcroForm::SignatureField::LockDictionary',
                         SV: 'HexaPDF::Type::AcroForm::SignatureField::SeedValueDictionary',
                         SVCert: 'HexaPDF::Type::AcroForm::SignatureField::CertificateSeedValueDictionary',
@@ -747,6 +753,7 @@ module HexaPDF
                         Namespace: 'HexaPDF::Type::Namespace',
                         MCR: 'HexaPDF::Type::MarkedContentReference',
                         OBJR: 'HexaPDF::Type::ObjectReference',
+                        Measure: 'HexaPDF::Type::Measure',
                       },
                       'object.subtype_map' => {
                         nil => {
@@ -766,6 +773,10 @@ module HexaPDF
                           Link: 'HexaPDF::Type::Annotations::Link',
                           Widget: 'HexaPDF::Type::Annotations::Widget',
                           Line: 'HexaPDF::Type::Annotations::Line',
+                          Square: 'HexaPDF::Type::Annotations::Square',
+                          Circle: 'HexaPDF::Type::Annotations::Circle',
+                          Polygon: 'HexaPDF::Type::Annotations::Polygon',
+                          PolyLine: 'HexaPDF::Type::Annotations::Polyline',
                           XML: 'HexaPDF::Type::Metadata',
                           GTS_PDFX: 'HexaPDF::Type::OutputIntent',
                           GTS_PDFA1: 'HexaPDF::Type::OutputIntent',
@@ -795,6 +806,10 @@ module HexaPDF
                           Link: 'HexaPDF::Type::Annotations::Link',
                           Widget: 'HexaPDF::Type::Annotations::Widget',
                           Line: 'HexaPDF::Type::Annotations::Line',
+                          Square: 'HexaPDF::Type::Annotations::Square',
+                          Circle: 'HexaPDF::Type::Annotations::Circle',
+                          Polygon: 'HexaPDF::Type::Annotations::Polygon',
+                          PolyLine: 'HexaPDF::Type::Annotations::Polyline',
                         },
                         XXAcroFormField: {
                           Tx: 'HexaPDF::Type::AcroForm::TextField',

data/lib/hexapdf/dictionary_fields.rb

@@ -313,7 +313,7 @@ module HexaPDF
         [String, Time, Date, DateTime]
       end
 
-      DATE_RE = /\AD:(\d{4})(\d\d)?(\d\d)?(\d\d)?(\d\d)?(\d\d)?([Z+-])?(?:(\d+)(?:'|'(\d+)'?|\z)?)?\z/n # :nodoc:
+      DATE_RE = /\AD:(\d{4})(\d\d)?(\d\d)?(\d\d)?(\d\d)?(\d\d)?([Z+-])?(?:(\d+)(?:'|'(\d+)'?'?|\z)?)?\z/n # :nodoc:
 
       # Checks if the given object is a string and converts into a Time object if possible.
       # Otherwise returns +nil+.

data/lib/hexapdf/digital_signature/signing/default_handler.rb

@@ -297,8 +297,7 @@ module HexaPDF
               raise HexaPDF::Error, "Can set DocMDP access permissions only on first signature"
             end
             params = doc.add({Type: :TransformParams, V: :'1.2', P: doc_mdp_permissions})
-            sigref = doc.add({Type: :SigRef, TransformMethod: :DocMDP, DigestMethod: :SHA256,
-                              TransformParams: params})
+            sigref = doc.add({Type: :SigRef, TransformMethod: :DocMDP, TransformParams: params})
             signature[:Reference] = [sigref]
             (doc.catalog[:Perms] ||= {})[:DocMDP] = signature
           end

data/lib/hexapdf/document/annotations.rb

@@ -69,12 +69,12 @@ module HexaPDF
       # +create_type+ method.
       #
       # The +options+ are passed on the specific annotation creation method.
-      def create(type, page, **options)
+      def create(type, page, *args, **options)
         method_name = "create_#{type}"
         unless respond_to?(method_name)
           raise ArgumentError, "Invalid type specified"
         end
-        send("create_#{type}", page, **options)
+        send("create_#{type}", page, *args, **options)
       end
 
       # :call-seq:
@@ -100,6 +100,111 @@ module HexaPDF
           border_style(color: 0, width: 1)
       end
 
+      # :call-seq:
+      #   annotations.create_rectangle(page, x, y, width, height)  -> annotation
+      #
+      # Creates a rectangle (called "square" in the PDF specification) annotation with the
+      # lower-left corner at (+x+, +y+) and the given +width+ and +height+.
+      #
+      # The rectangle uses a black stroke color, no interior color and a line width of 1pt by
+      # default. It can be further styled using the convenience methods on the returned annotation
+      # object.
+      #
+      # Example:
+      #
+      #   #>pdf-small
+      #   doc.annotations.create_rectangle(doc.pages[0], 20, 20, 20, 60).
+      #     regenerate_appearance
+      #
+      #   doc.annotations.create_rectangle(doc.pages[0], 60, 20, 20, 60).
+      #     border_style(color: "hp-blue", width: 2).
+      #     interior_color("hp-orange").
+      #     regenerate_appearance
+      #
+      # See: Type::Annotations::Square
+      def create_rectangle(page, x, y, w, h)
+        annot = create_and_add_to_page(:Square, page)
+        annot[:Rect] = [x, y, x + w, y + h]
+        annot.border_style(color: 0, width: 1)
+        annot
+      end
+
+      # :call-seq:
+      #   annotations.create_ellipse(page, cx, cy, a:, b:)  -> annotation
+      #
+      # Creates an ellipse (called "circle" in the PDF specification) annotation with the center
+      # point at (+cx+, +cy+), the semi-major axis +a+ and the semi-minor axis +b+.
+      #
+      # The ellipse uses a black stroke color, no interior color and a line width of 1pt by
+      # default. It can be further styled using the convenience methods on the returned annotation
+      # object.
+      #
+      # Example:
+      #
+      #   #>pdf-small
+      #   doc.annotations.create_ellipse(doc.pages[0], 30, 50, a: 15, b: 20).
+      #     regenerate_appearance
+      #
+      #   doc.annotations.create_ellipse(doc.pages[0], 70, 50, a: 15, b: 20).
+      #     border_style(color: "hp-blue", width: 2).
+      #     interior_color("hp-orange").
+      #     regenerate_appearance
+      #
+      # See: Type::Annotations::Circle
+      def create_ellipse(page, x, y, a:, b:)
+        annot = create_and_add_to_page(:Circle, page)
+        annot[:Rect] = [x - a, y - b, x + a, y + b]
+        annot.border_style(color: 0, width: 1)
+        annot
+      end
+
+      # :call-seq:
+      #   annotations.create_polyline(page, *points)  -> annotation
+      #
+      # Creates a polyline annotation for the given +points+ (alternating horizontal and vertical
+      # coordinates) on the given page and returns it.
+      #
+      # The polyline uses a black color and a width of 1pt. It can be further styled using the
+      # convenience methods on the returned annotation object.
+      #
+      # Example:
+      #
+      #   #>pdf-small
+      #   doc.annotations.create_polyline(doc.pages[0], 20, 20, 30, 70, 80, 60, 40, 30).
+      #     border_style(color: "hp-blue", width: 2, style: [3, 1]).
+      #     regenerate_appearance
+      #
+      # See: Type::Annotations::Polyline
+      def create_polyline(page, *points)
+        create_and_add_to_page(:PolyLine, page).
+          vertices(*points).
+          border_style(color: 0, width: 1)
+      end
+
+      # :call-seq:
+      #   annotations.create_polygon(page, *points)  -> annotation
+      #
+      # Creates a polygon annotation for the given +points+ (alternating horizontal and vertical
+      # coordinates) on the given page and returns it.
+      #
+      # The polygon uses a black color and a width of 1pt for the border and no interior color. It
+      # can be further styled using the convenience methods on the returned annotation object.
+      #
+      # Example:
+      #
+      #   #>pdf-small
+      #   doc.annotations.create_polygon(doc.pages[0], 20, 20, 30, 70, 80, 60, 40, 30).
+      #     border_style(color: "hp-blue", width: 2, style: [3, 1]).
+      #     interior_color("hp-orange").
+      #     regenerate_appearance
+      #
+      # See: Type::Annotations::Polygon
+      def create_polygon(page, *points)
+        create_and_add_to_page(:Polygon, page).
+          vertices(*points).
+          border_style(color: 0, width: 1)
+      end
+
       private
 
       # Returns the root of the destinations name tree.

data/lib/hexapdf/document/layout.rb

@@ -92,13 +92,23 @@ module HexaPDF
     #
     #     style.font = ['Helvetica', variant: :bold]
     #
-    #   Helvetica in bold could also be set the conventional way:
+    #   Helvetica in bold could also be set in the following ways:
     #
     #     style.font = 'Helvetica bold'
+    #     # or
+    #     style.font_bold = true
+    #     style.font = 'Helvetica'
+    #
+    #   The font_bold and font_italic style properties are always taken into account. For example,
+    #   if the font is set to 'Helvetica italic' and font_bold to +true+, the actual font would be
+    #   the bold _and_ italic Helvetica font.
     #
     #   However, using an array it is also possible to specify other options when setting a font,
     #   like the :subset option.
     #
+    # * It is possible to resolve the font of a style object manually by using the #resolve_font
+    #   method.
+    #
     class Layout
 
       # This class is used when a box can contain child boxes and the creation of such boxes should
@@ -218,6 +228,77 @@ module HexaPDF
         style
       end
 
+      # Returns +true+ if a style with the given +name+ exists, else +false+.
+      #
+      # Example:
+      #
+      #   layout.style(:header, font: 'Helvetica')
+      #   layout.style?(:header)     # => true
+      #   layout.style?(:paragraph)  # => false
+      #
+      # See: #style
+      def style?(name)
+        @styles.key?(name)
+      end
+
+      FONT_BOLD_VARIANT_MAPPER = { #:nodoc:
+        nil => {true => :bold, false: :none},
+        none: {true => :bold, false: :none},
+        bold: {true => :bold, false: :none},
+        italic: {true => :bold_italic, false: :italic},
+        bold_italic: {true => :bold_italic, false: :italic},
+      }
+
+      FONT_ITALIC_VARIANT_MAPPER = { #:nodoc:
+        nil => {true => :italic, false: :none},
+        none: {true => :italic, false: :none},
+        italic: {true => :italic, false: :none},
+        bold: {true => :bold_italic, false: :bold},
+        bold_italic: {true => :bold_italic, false: :bold},
+      }
+
+      # Resolves the font object for the given +style+ and applies the result to it.
+      #
+      # The Layout::Style#font property is the only one without a default value but is needed for
+      # many operations. This method ensures that the +style+ has a valid font object for the font
+      # property by resolving the font name.
+      #
+      # The font object is resolved in the following way:
+      #
+      # * If the font property is not set, the font value of the :base style is used and if that is
+      #   also not set, the 'font.default' configuration value is used.
+      #
+      # * Afterwards, if the font property is a valid font object, nothing needs to be done.
+      #
+      # * Otherwise, if the font property is a single font name or a [font name, options hash]
+      #   array, it is resolved to a font object, also taking the font_bold and font_italic style
+      #   properties into account.
+      #
+      # Example:
+      #
+      #   style = layout.style(:header, font: 'Helvetica')
+      #   style.font                   # => 'Helvetica'
+      #   layout.resolve_font(style)
+      #   style.font                   # => #<HexaPDF::Font::Type1Wrapper>
+      #
+      # See: The "Box Styles" section in Layout for more details.
+      def resolve_font(style)
+        unless style.font?
+          style.font(@styles[:base].font? && @styles[:base].font || @document.config['font.default'])
+        end
+        unless style.font.respond_to?(:pdf_object)
+          name, options = *style.font
+          options ||= {}
+          if style.font_bold?
+            options[:variant] = FONT_BOLD_VARIANT_MAPPER.dig(options[:variant], style.font_bold)
+          end
+          if style.font_italic?
+            options[:variant] = FONT_ITALIC_VARIANT_MAPPER.dig(options[:variant], style.font_italic)
+          end
+          style.font(@document.fonts.add(name, **options))
+        end
+      end
+
       # :call-seq:
       #    layout.styles            -> styles
       #    layout.styles(**mapping)   -> styles
@@ -286,8 +367,9 @@ module HexaPDF
             box_options[:children] = ChildrenCollector.collect(self, &block)
           end
         end
+        style = retrieve_style(style)
         box_class_for_name(name).new(width: width, height: height,
-                                     style: retrieve_style(style), **box_options, &box_block)
+                                     style: style, **style.box_options, **box_options, &box_block)
       end
 
       # Creates an array of HexaPDF::Layout::TextFragment objects for the given +text+.
@@ -354,7 +436,7 @@ module HexaPDF
         box_style = (box_style ? retrieve_style(box_style) : style)
         box_class_for_name(:text).new(items: text_fragments(text, style: style),
                                       width: width, height: height, properties: properties,
-                                      style: box_style)
+                                      style: box_style, **box_style.box_options)
       end
       alias text text_box
 
@@ -457,7 +539,8 @@ module HexaPDF
           end
         end
         box_class_for_name(:text).new(items: data, width: width, height: height,
-                                      properties: properties, style: box_style)
+                                      properties: properties, style: box_style,
+                                      **box_style.box_options)
       end
       alias formatted_text formatted_text_box
 
@@ -479,7 +562,7 @@ module HexaPDF
         style = retrieve_style(style, style_properties)
         image = file.kind_of?(HexaPDF::Stream) ? file : @document.images.add(file)
         box_class_for_name(:image).new(image: image, width: width, height: height,
-                                       properties: properties, style: style)
+                                       properties: properties, style: style, **style.box_options)
       end
       alias image image_box
 
@@ -533,9 +616,10 @@ module HexaPDF
           @argument_infos.each_with_object({}) do |arg_info, result|
             next unless arg_info.rows.include?(row) && arg_info.cols.include?(col)
             if arg_info.args[:cell]
-              arg_info.args[:cell] = (result[:cell] || {}).merge(arg_info.args[:cell])
+              result.update(arg_info.args, cell: (result[:cell] || {}).merge(arg_info.args[:cell]))
+            else
+              result.update(arg_info.args)
             end
-            result.update(arg_info.args)
           end
         end
 
@@ -608,7 +692,8 @@ module HexaPDF
         end
         box_class_for_name(:table).new(cells: cells, column_widths: column_widths, header: header,
                                        footer: footer, cell_style: cell_style, width: width,
-                                       height: height, properties: properties, style: style)
+                                       height: height, properties: properties, style: style,
+                                       **style.box_options)
       end
       alias table table_box
 
@@ -685,13 +770,7 @@ module HexaPDF
         end
         style = HexaPDF::Layout::Style.create(@styles[style] || style || @styles[:base])
         style = style.dup.update(**properties) unless properties.nil? || properties.empty?
-        unless style.font?
-          style.font(@styles[:base].font? && @styles[:base].font || @document.config['font.default'])
-        end
-        unless style.font.respond_to?(:pdf_object)
-          name, options = *style.font
-          style.font(@document.fonts.add(name, **(options || {})))
-        end
+        resolve_font(style)
         style
       end
 

data/lib/hexapdf/document/metadata.rb

@@ -430,8 +430,12 @@ module HexaPDF
         @metadata[ns_dc]['creator'] = info_dict[:Author] if info_dict.key?(:Author)
         @metadata[ns_dc]['description'] = info_dict[:Subject] if info_dict.key?(:Subject)
         @metadata[ns_xmp]['CreatorTool'] = info_dict[:Creator] if info_dict.key?(:Creator)
-        @metadata[ns_xmp]['CreateDate'] = info_dict[:CreationDate] if info_dict.key?(:CreationDate)
-        @metadata[ns_xmp]['ModifyDate'] = info_dict[:ModDate] if info_dict.key?(:ModDate)
+        if info_dict.key?(:CreationDate) && !info_dict[:CreationDate].kind_of?(String)
+          @metadata[ns_xmp]['CreateDate'] = info_dict[:CreationDate]
+        end
+        if info_dict.key?(:ModDate) && !info_dict[:ModDate].kind_of?(String)
+          @metadata[ns_xmp]['ModifyDate'] = info_dict[:ModDate] if info_dict.key?(:ModDate)
+        end
         @metadata[ns_pdf]['Keywords'] = info_dict[:Keywords] if info_dict.key?(:Keywords)
         @metadata[ns_pdf]['Producer'] = info_dict[:Producer] if info_dict.key?(:Producer)
         if info_dict.key?(:Trapped) && info_dict[:Trapped] != :Unknown
@@ -528,7 +532,10 @@ module HexaPDF
       # Formats the given date-time object (Time, Date, or DateTime) to be a valid XMP date-time
       # value.
       def xmp_date(date)
-        date.strftime("%Y-%m-%dT%H:%M:%S%:z")
+        case date
+        when Time, Date, DateTime then date.strftime("%Y-%m-%dT%H:%M:%S%:z")
+        else ''
+        end
       end
 
     end

data/lib/hexapdf/document.rb

@@ -743,6 +743,15 @@ module HexaPDF
     # Before the document is written, it is validated using #validate and an error is raised if the
     # document is not valid. However, this step can be skipped if needed.
     #
+    # The method dispatches two messages:
+    #
+    # :complete_objects::
+    #   This message is dispatched before anything is done and should be used to finalize objects.
+    #
+    # :before_write::
+    #   This message is dispatched directly before the document gets serialized and allows, for
+    #   example, overriding automatic HexaPDF changes (e.g. forcefully setting a document version).
+    #
     # Options:
     #
     # incremental::

data/lib/hexapdf/encryption/standard_security_handler.rb

@@ -325,8 +325,13 @@ module HexaPDF
         options.user_password = prepare_password(options.user_password)
         options.owner_password = prepare_password(options.owner_password)
 
-        dict[:O] = compute_o_field(options.owner_password, options.user_password)
-        dict[:U] = compute_u_field(options.user_password)
+        if dict[:R] <= 4
+          dict[:O] = compute_o_field(options.owner_password, options.user_password)
+          dict[:U] = compute_u_field(options.user_password)
+        else
+          dict[:U] = compute_u_field(options.user_password)
+          dict[:O] = compute_o_field(options.owner_password, options.user_password)
+        end
 
         if dict[:R] <= 4
           encryption_key = compute_user_encryption_key(options.user_password)

data/lib/hexapdf/error.rb

@@ -94,9 +94,17 @@ module HexaPDF
     end
 
     def message # :nodoc:
-      "No glyph for #{glyph.str.inspect} in font '#{glyph.font_wrapper.wrapped_font.full_name}' " \
-        "found. \n\n" \
-        "Use the configuration option 'font.on_missing_glyph' to customize missing glyph handling."
+      str = "No glyph for #{glyph.str.inspect} in font '#{glyph.font_wrapper.wrapped_font.full_name}' " \
+            "found. \n\n"
+      str << if glyph.font_wrapper.font_type == :Type1
+               "The used Type1 font only contains a very limited number of glyphs. TrueType " \
+               "fonts usually provide a much wider array of glyphs. Use the configuration option " \
+               "'font.map' to register appropriate font files. Also have a look at the " \
+               "'font.default' and 'font.fallback' options. "
+             else
+               "Maybe register another #{glyph.font_wrapper.font_type} font that contains the " \
+               "needed glyph and use it as fallback via the configuration option 'font.fallback'."
+             end
     end
 
   end