hexapdf 0.39.1 → 0.41.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 07f7fd9468ec9c36993f4b1f2189704d65c1c73f7fa1ea30d44f6cb0a67fa92c
-  data.tar.gz: 1cad88a48910fd65a9dae7a90dcfe6ac34ef5ba9f69172a18bd52052fb10b99c
+  metadata.gz: ae86345e0f2ed2dd27c9c58c550e7eaffb4d7c5d3ba388afb04318ee20491313
+  data.tar.gz: cfd9f8575ce9f4324c594c2617cc7e1bcf1d735276ac92a275f26acf74566bc9
 SHA512:
-  metadata.gz: eeee46c22616abbca812ef441100e33534384db831aadf04df9b9382920aa58105be04046a76a9da76951c1d0bc39126e4ef33c43fa3401077c34604ff414acc
-  data.tar.gz: 1cd42546ff96980f6fbfeaae450a7f8657350ce3b23692b508b87718028e68fe50acd9ca8b744bc755f9b79029ecd41f5cb1cedc046209336594c3fba5a1807b
+  metadata.gz: d36715922fbbf5a93eeb5512ed0abf7ec78fbd099c49131500bd9f7db75c39248bb2bac12ad7e3df5c4a8a449351f63e0d83e0ed635f9a025e4bf25fdbe9f0e1
+  data.tar.gz: fc7a89694614826c8d151b7dab2c3f45ec335fc94efff873065c3dc68c845a691311b91b42c3b791eb71be80e1f8fd623838eb0cf1b94d0d1b758441df1b1a7a

data/CHANGELOG.md

@@ -1,3 +1,62 @@
+## 0.41.0 - 2024-05-05
+
+### Added
+
+* Font loader [HexaPDF::FontLoader::VariantFromName] to ease specifying font
+  variants
+* [HexaPDF::Type::AcroForm::JavaScriptActions] module to contain all JavaScript
+  actions that HexaPDF can handle
+* Support for the `AFSimple_Calculate` Javascript method
+* Support for Simplified Field Notation for defining Javascript calculations
+* Configuration option 'encryption.on_decryption_error' to allow custom
+  decryption error handling
+* CLI option `--fill-read-only-fields` to `hexapdf form` to specify whether
+  filling in read only fields is allowed
+* [HexaPDF::Type::AcroForm::Field#form_field] to getting the field irrespective
+  of whether the object is already a field or a widget
+* [HexaPDF::Type::AcroForm::TextField#set_format_action] for setting a
+  JavaScript action that formats the field's value
+* [HexaPDF::Type::AcroForm::TextField#set_calculate_action] for setting a
+  JavaScript action that calculates the field's value
+* [HexaPDF::Type::AcroForm#recalculate_fields] for recalculating fields
+
+### Changed
+
+* CLI command `hexapdf form` to show more information in verbose mode
+* CLI command 'hexapdf form' to show the field flags "read only" and "required"
+* [HexaPDF::Type::AcroForm::AppearanceGenerator] to remove the hidden flag from
+  widgets
+
+### Fixed
+
+* [HexaPDF::FontLoader::FromConfiguration] to accept arbitrary keyword arguments
+* [HexaPDF::Font::CMap::Parser] to avoid instantiating invalid UTF-16BE chars
+* [HexaPDF::Type::AcroForm::AppearanceGenerator] to work for files where check
+  boxes don't have appearance subdictionaries
+* [HexaPDF::Type::AcroForm::TextField#field_value=] to call the config option
+  'acro_form.on_invalid_value' when passing a non-String argument (except `nil`)
+* [HexaPDF::Type::AcroForm::JavaScriptActions#apply_af_number_format] to
+  correctly convert strings using commas or points into numbers
+* [HexaPDF::Type::AcroForm::AppearanceGenerator] to use the field instead of the
+  widget object as the source for JavaScript format actions
+* CLI command `hexapdf form --generate-template` to output fields without values
+* `AFNumber_Format` JavaScript parsing to work without trailing semicolon
+
+
+## 0.40.0 - 2024-03-23
+
+### Changed
+
+* **Breaking change**: Style property 'text_overflow' is now called 'overflow'
+
+### Fixed
+
+* [HexaPDF::Layout::ListBox] to hide marker in case of splitting list items with
+  multiple boxes
+* [HexaPDF::Layout::ListBox] to create independent marker boxes for all markers
+* [HexaPDF::Layout::ListBox] to correctly respect a set height
+
+
 ## 0.39.1 - 2024-03-20
 
 ### Fixed

data/examples/019-acro_form.rb

@@ -6,9 +6,6 @@
 # This example show-cases how to create the various form field types and their
 # possible standard appearances.
 #
-# Note the 'number format' text field which uses a JavaScript function for
-# formatting a number.
-#
 # Usage:
 # : `ruby acro_form.rb`
 #
@@ -52,46 +49,38 @@ tx = form.create_text_field("Single Line", font_size: 16)
 widget = tx.create_widget(page, Rect: [200, 445, 500, 465])
 tx.field_value = "A sample test string!"
 
-canvas.text("Number format", at: [70, 420])
-tx = form.create_text_field("Number format", font_size: 16)
-widget = tx.create_widget(page, Rect: [200, 415, 500, 435])
-widget[:AA] = {
-  F: {S: :JavaScript, JS: 'AFNumber_Format(2, 2, 0, 0, "EUR ", true);'},
-}
-tx.field_value = "123456,789"
-
-canvas.text("Multiline", at: [70, 390])
+canvas.text("Multiline", at: [70, 420])
 tx = form.create_multiline_text_field("Multiline", font_size: 0, align: :right)
-widget = tx.create_widget(page, Rect: [200, 325, 500, 405])
+widget = tx.create_widget(page, Rect: [200, 355, 500, 435])
 widget.border_style(color: 0, width: 1)
 tx.field_value = "A sample test string! " * 30 + "\nNew line\n\nAnother line"
 
-canvas.text("Password", at: [70, 300])
+canvas.text("Password", at: [70, 330])
 tx = form.create_password_field("Password", font_size: 16)
-widget = tx.create_widget(page, Rect: [200, 295, 500, 315])
+widget = tx.create_widget(page, Rect: [200, 325, 500, 345])
 
-canvas.text("File select", at: [70, 270])
+canvas.text("File select", at: [70, 300])
 tx = form.create_file_select_field("File Select", font_size: 16)
-widget = tx.create_widget(page, Rect: [200, 265, 500, 285])
+widget = tx.create_widget(page, Rect: [200, 295, 500, 315])
 tx.field_value = "path/to/file.pdf"
 
-canvas.text("Comb", at: [70, 240])
+canvas.text("Comb", at: [70, 270])
 tx = form.create_comb_text_field("Comb field", max_chars: 10, font_size: 16, align: :center)
-widget = tx.create_widget(page, Rect: [200, 220, 500, 255])
+widget = tx.create_widget(page, Rect: [200, 250, 500, 285])
 widget.border_style(color: [30, 128, 0], width: 1)
 tx.field_value = 'Hello'
 
-canvas.text("Combo Box", at: [50, 170])
+canvas.text("Combo Box", at: [50, 200])
 cb = form.create_combo_box("Combo Box", font_size: 12, editable: true,
                            option_items: ['Value 1', 'Another value', 'Choose me!'])
-widget = cb.create_widget(page, Rect: [200, 150, 500, 185])
+widget = cb.create_widget(page, Rect: [200, 180, 500, 215])
 widget.border_style(width: 1)
 cb.field_value = 'Another value'
 
-canvas.text("List Box", at: [50, 120])
+canvas.text("List Box", at: [50, 150])
 lb = form.create_list_box("List Box", font_size: 15, align: :center, multi_select: true,
                          option_items: 1.upto(7).map {|i| "Value #{i}" })
-widget = lb.create_widget(page, Rect: [200, 50, 500, 135])
+widget = lb.create_widget(page, Rect: [200, 80, 500, 165])
 widget.border_style(width: 1)
 lb.list_box_top_index = 1
 lb.field_value = ['Value 6', 'Value 2']

data/examples/027-composer_optional_content.rb

@@ -28,7 +28,7 @@ HexaPDF::Composer.create('composer_optional_content.pdf') do |composer|
   a3m = composer.document.optional_content.create_ocmd([a3, all], policy: :any_on)
 
   composer.text('The Great Ruby Quiz', text_align: :center, margin: [0, 0, 24],
-                font: ['Helvetica', variant: :bold], font_size: 24)
+                font: 'Helvetica bold', font_size: 24)
 
   composer.list(marker_type: :decimal, item_spacing: 32, style: :question) do |listing|
     listing.multiple do |item|

data/examples/030-pdfa.rb

@@ -30,18 +30,18 @@ HexaPDF::Composer.create('pdfa.pdf') do |composer|
   composer.style(:base, font: 'Lato', font_size: 10, line_spacing: 1.3)
   composer.style(:top, font_size: 8)
   composer.style(:top_box, padding: [100, 0, 0], margin: [0, 0, 10], border: {width: [0, 0, 1]})
-  composer.style(:header, font: ['Lato', variant: :bold], font_size: 20, margin: [50, 0, 20])
+  composer.style(:header, font: 'Lato bold', font_size: 20, margin: [50, 0, 20])
   composer.style(:line_items, border: {width: 1, color: "eee"}, margin: [20, 0])
   composer.style(:line_item_cell, font_size: 8)
   composer.style(:footer, border: {width: [1, 0, 0], color: "darkgrey"},
                  padding: [5, 0, 0], valign: :bottom)
-  composer.style(:footer_heading, font: ['Lato', variant: :bold],
+  composer.style(:footer_heading, font: 'Lato bold',
                  font_size: 8, padding: [0, 0, 8])
   composer.style(:footer_text,  font_size: 8, fill_color: "darkgrey")
 
   # Top part
   composer.box(:container, style: :top_box) do |container|
-    container.formatted_text([{text: company[:name], font: ['Lato', variant: :bold]},
+    container.formatted_text([{text: company[:name], font: 'Lato bold'},
                               " - " + company[:address].join(' - ')], style: :top)
   end
   composer.text("Mega Client\nSmall Lane 5\n67890 Noonestown", mask_mode: :box)
@@ -50,7 +50,7 @@ HexaPDF::Composer.create('pdfa.pdf') do |composer|
            ["Service date:", "2024-02-01"]]
   composer.table(cells, column_widths: [150, 80], style: {align: :right}) do |args|
     args[] = {cell: {border: {width: 0}, padding: 2}, text_align: :right}
-    args[0..-1, 0] = {font: ['Lato', variant: :bold]}
+    args[0..-1, 0] = {font: 'Lato bold'}
   end
 
   # Middle part
@@ -65,9 +65,9 @@ HexaPDF::Composer.create('pdfa.pdf') do |composer|
   cells << [nil, nil, nil, "€ #{250 * max * (max + 1) / 2},00"]
   composer.table(cells, column_widths: [250, 80], style: :line_items) do |args|
     args[] = {cell: {border: {width: 0}, padding: 8}, style: :line_item_cell}
-    args[0] = {cell: {background_color: "eee"}, font: ["Lato", variant: :bold]}
+    args[0] = {cell: {background_color: "eee"}, font: "Lato bold"}
     args[-1] = {cell: {background_color: "eee", border: {width: [2, 0, 0]}},
-                font: ["Lato", variant: :bold]}
+                font: "Lato bold"}
     args[0..-1, 1..-1] = {text_align: :right}
   end
 

data/examples/031-acro_form_java_script.rb

@@ -0,0 +1,101 @@
+# # PDF Forms - JavaScript Actions
+#
+# Interactive PDF forms can contain JavaScript to enhance the form. For example,
+# it is possible to use JavaScript to format numbers or to calculate a field
+# value based on the value of other fields.
+#
+# While HexaPDF doesn't support all kinds of JavaScript actions, it supports
+# select field format actions as well as the two most common calculate actions.
+#
+# Usage:
+# : `ruby acro_form.rb`
+#
+
+require 'hexapdf'
+
+doc = HexaPDF::Document.new
+page = doc.pages.add
+canvas = page.canvas
+
+canvas.font("Helvetica", size: 36)
+canvas.text("AcroForm JavaScript Actions ", at: [50, 750])
+form = doc.acro_form(create: true)
+
+canvas.font_size(16)
+
+canvas.text("Value format actions", at: [50, 650])
+
+canvas.text("Number format", at: [70, 620])
+tx = form.create_text_field("Number_Format", font_size: 16)
+tx.set_format_action(:number, decimals: 2, separator_style: :comma)
+widget = tx.create_widget(page, Rect: [200, 615, 500, 635])
+tx.field_value = "1234567.898"
+
+canvas.text("Calculate actions", at: [50, 570])
+
+canvas.text("Source fields", at: [70, 540])
+canvas.text("a:", at: [200, 540])
+tx = form.create_text_field("a", font_size: 16)
+tx.set_format_action(:number, decimals: 2)
+widget = tx.create_widget(page, Rect: [220, 535, 280, 555])
+tx.field_value = "10,50"
+canvas.text("b:", at: [310, 540])
+tx = form.create_text_field("b", font_size: 16)
+tx.set_format_action(:number, decimals: 2)
+widget = tx.create_widget(page, Rect: [330, 535, 390, 555])
+tx.field_value = "20,60"
+canvas.text("c:", at: [420, 540])
+tx = form.create_text_field("c", font_size: 16)
+tx.set_format_action(:number, decimals: 2)
+widget = tx.create_widget(page, Rect: [440, 535, 500, 555])
+tx.field_value = "30,70"
+
+canvas.text("Predefined", at: [70, 510])
+canvas.text("Sum", at: [90, 480])
+tx = form.create_text_field("sum", font_size: 16)
+tx.set_format_action(:number, decimals: 2)
+tx.set_calculate_action(:sum, fields: ['a', 'b', 'c'])
+tx.flag(:read_only)
+widget = tx.create_widget(page, Rect: [310, 475, 500, 495])
+canvas.text("Average", at: [90, 450])
+tx = form.create_text_field("average", font_size: 16)
+tx.set_format_action(:number, decimals: 2)
+tx.set_calculate_action(:average, fields: ['a', 'b', 'c'])
+tx.flag(:read_only)
+widget = tx.create_widget(page, Rect: [310, 445, 500, 465])
+canvas.text("Product", at: [90, 420])
+tx = form.create_text_field("product", font_size: 16)
+tx.set_format_action(:number, decimals: 2)
+tx.set_calculate_action(:product, fields: ['a', 'b', 'c'])
+tx.flag(:read_only)
+widget = tx.create_widget(page, Rect: [310, 415, 500, 435])
+canvas.text("Minimum", at: [90, 390])
+tx = form.create_text_field("min", font_size: 16)
+tx.set_format_action(:number, decimals: 2)
+tx.set_calculate_action(:min, fields: ['a', 'b', 'c'])
+tx.flag(:read_only)
+widget = tx.create_widget(page, Rect: [310, 385, 500, 405])
+canvas.text("Maximum", at: [90, 360])
+tx = form.create_text_field("max", font_size: 16)
+tx.set_format_action(:number, decimals: 2)
+tx.set_calculate_action(:max, fields: ['a', 'b', 'c'])
+tx.flag(:read_only)
+widget = tx.create_widget(page, Rect: [310, 355, 500, 375])
+
+canvas.text("Simplified Field Notation", at: [70, 330])
+canvas.text("a + b + c", at: [90, 300])
+tx = form.create_text_field("sfn1", font_size: 16)
+tx.set_format_action(:number, decimals: 2)
+tx.set_calculate_action(:sfn, fields: "a + b + c")
+tx.flag(:read_only)
+widget = tx.create_widget(page, Rect: [310, 295, 500, 315])
+canvas.text("(a + b)*(c - a) / b + 3.14", at: [90, 270])
+tx = form.create_text_field("sfn2", font_size: 16)
+tx.set_format_action(:number, decimals: 2)
+tx.set_calculate_action(:sfn, fields: "(a + b)*(c - a) / b + 3.14")
+tx.flag(:read_only)
+widget = tx.create_widget(page, Rect: [310, 265, 500, 285])
+
+form.recalculate_fields
+
+doc.write('acro_form_java_script.pdf', optimize: true)

data/lib/hexapdf/cli/command.rb

@@ -134,6 +134,17 @@ module HexaPDF
               false
             end
           end
+        hash[:config]['encryption.on_decryption_error'] =
+          if command_parser.strict
+            proc { true }
+          else
+            proc do |obj, msg|
+              if command_parser.verbosity_info?
+                $stderr.puts "Ignored decryption problem for object (#{ob.oid},#{obj.gen}): #{msg}"
+              end
+              false
+            end
+          end
         hash
       end
 

data/lib/hexapdf/cli/form.rb

@@ -76,6 +76,10 @@ module HexaPDF
         options.on('--flatten', 'Flatten the form fields') do
           @flatten = true
         end
+        options.on("--[no-]fill-read-only-fields", "Allow filling in fields that are " \
+                   "marked as read only. Default: false") do |read_only|
+          @fill_read_only_fields = read_only
+        end
         options.on("--[no-]viewer-override", "Let the PDF viewer override the visual " \
                    "appearance. Default: use setting from input PDF") do |need_appearances|
           @need_appearances = need_appearances
@@ -90,6 +94,7 @@ module HexaPDF
         @flatten = false
         @generate_template = false
         @template = nil
+        @fill_read_only_fields = false
         @need_appearances = nil
         @incremental = true
       end
@@ -115,6 +120,7 @@ module HexaPDF
               else
                 fill_form(doc)
               end
+              doc.acro_form.recalculate_fields
             end
             if @flatten && !doc.acro_form.flatten.empty?
               $stderr.puts "Warning: Not all form fields could be flattened"
@@ -126,8 +132,12 @@ module HexaPDF
             each_field(doc) do |_, _, field, _|
               next if unsupported_fields.include?(field.concrete_field_type)
               name = field.full_field_name.gsub(':', "\\:")
-              Array(field.field_value).each do |val|
-                puts "#{name}: #{val.to_s.gsub(/(\r|\r\n|\n)/, '\1  ')}"
+              if field.field_value
+                Array(field.field_value).each do |val|
+                  puts "#{name}: #{val.to_s.gsub(/(\r|\r\n|\n)/, '\1  ')}"
+                end
+              else
+                puts "#{name}: "
               end
             end
           else
@@ -141,7 +151,7 @@ module HexaPDF
       # Lists all terminal form fields.
       def list_form_fields(doc)
         current_page_index = -1
-        each_field(doc) do |_page, page_index, field, widget|
+        each_field(doc, with_seen: true) do |_page, page_index, field, widget|
           if current_page_index != page_index
             puts "Page #{page_index + 1}"
             current_page_index = page_index
@@ -151,6 +161,7 @@ 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})"
           field_value = if !field.field_value || concrete_field_type != :signature_field
                           field.field_value.inspect
@@ -161,9 +172,10 @@ module HexaPDF
                           temp
                         end
 
-          puts "  #{field_name}"
+          flags = field_flags(field)
+          puts "  #{field_name}" << (flags.empty? ? '' : " (#{flags.join(', ')})")
           if command_parser.verbosity_info?
-            printf("    └─ %-22s | %-20s\n", nice_field_type, position)
+            printf("    └─ %-22s | %-20s\n", nice_field_type, "#{size} #{position}")
           end
           puts "    └─ #{field_value}"
           if command_parser.verbosity_info?
@@ -172,6 +184,10 @@ module HexaPDF
             elsif concrete_field_type == :radio_button || concrete_field_type == :check_box
               puts "    └─ Options: #{([:Off] + field.allowed_values).map(&:to_s).join(', ')}"
             end
+            puts "    └─ Widget OID: #{widget.oid},#{widget.gen}"
+            if field != widget
+              puts "    └─ Field OID:  #{field.oid},#{field.gen}"
+            end
           end
         end
       end
@@ -180,6 +196,7 @@ module HexaPDF
       def fill_form(doc)
         current_page_index = -1
         each_field(doc) do |_page, page_index, field, _widget|
+          next if field.flagged?(:read_only) && !@fill_read_only_fields
           if current_page_index != page_index
             puts "Page #{page_index + 1}"
             current_page_index = page_index
@@ -189,7 +206,8 @@ module HexaPDF
             (field.alternate_field_name ? " (#{field.alternate_field_name})" : '')
           concrete_field_type = field.concrete_field_type
 
-          puts "  #{field_name}"
+          flags = field_flags(field)
+          puts "  #{field_name}" << (flags.empty? ? '' : " (#{flags.join(', ')})")
           puts "    └─ Current value: #{field.field_value.inspect}"
 
           if field.field_type == :Ch
@@ -221,6 +239,11 @@ module HexaPDF
         data.each do |name, value|
           field = form.field_by_name(name)
           raise Error, "Field '#{name}' not found in input PDF" unless field
+          if field.flagged?(:read_only) && !@fill_read_only_fields
+            puts "Ignoring field '#{name}' because it is read only and --fill-read-only-fields " \
+              "is no set"
+            next
+          end
           apply_field_value(field, value)
         end
       end
@@ -275,8 +298,8 @@ module HexaPDF
       end
 
       # Iterates over all non-push button fields in page order. If a field appears on multiple
-      # pages, it is only yielded on the first page.
-      def each_field(doc) # :yields: page, page_index, field
+      # pages, it is only yielded on the first page if +with_seen+ is +false.
+      def each_field(doc, with_seen: false) # :yields: page, page_index, field
         seen = {}
 
         doc.pages.each_with_index do |page, page_index|
@@ -284,7 +307,7 @@ module HexaPDF
             next unless annotation[:Subtype] == :Widget
             field = annotation.form_field
             next if field.concrete_field_type == :push_button
-            unless seen[field.full_field_name]
+            if with_seen || !seen[field.full_field_name]
               yield(page, page_index, field, annotation)
               seen[field.full_field_name] = true
             end
@@ -292,6 +315,12 @@ module HexaPDF
         end
       end
 
+      # Returns an array with the flags "read only" and "required" if they are set.
+      def field_flags(field)
+        [field.flagged?(:read_only) ? "read only" : nil,
+         field.flagged?(:required) ? "required" : nil].compact
+      end
+
     end
 
   end

data/lib/hexapdf/cli/info.rb

@@ -192,6 +192,10 @@ module HexaPDF
             puts "WARNING: Parse error at position #{pos}: #{msg}"
             false
           end
+          options[:config]['encryption.on_decryption_error'] = lambda do |obj, msg|
+            puts "WARNING: Decryption problem for object (#{obj.oid},#{obj.gen}): #{msg}"
+            false
+          end
           options
         else
           super

data/lib/hexapdf/configuration.rb

@@ -255,6 +255,12 @@ module HexaPDF
   #    PDF defines a standard security handler that is implemented
   #    (HexaPDF::Encryption::StandardSecurityHandler) and assigned the :Standard name.
   #
+  # encryption.on_decryption_error::
+  #    Callback hook when HexaPDF encounters a decryption error that can potentially be ignored.
+  #
+  #    The value needs to be an object that responds to \#call(obj, message) and returns +true+ if
+  #    an error should be raised.
+  #
   # encryption.sub_filter_map::
   #    A mapping from a PDF name (a Symbol) to a security handler class (see
   #    HexaPDF::Encryption::SecurityHandler). If the value is a String, it should contain the name
@@ -488,6 +494,9 @@ module HexaPDF
                       'encryption.filter_map' => {
                         Standard: 'HexaPDF::Encryption::StandardSecurityHandler',
                       },
+                      'encryption.on_decryption_error' => proc do |_obj, _error|
+                        false
+                      end,
                       'encryption.sub_filter_map' => {},
                       'filter.map' => {
                         ASCIIHexDecode: 'HexaPDF::Filter::ASCIIHexDecode',
@@ -523,6 +532,7 @@ module HexaPDF
                         'HexaPDF::FontLoader::Standard14',
                         'HexaPDF::FontLoader::FromConfiguration',
                         'HexaPDF::FontLoader::FromFile',
+                        'HexaPDF::FontLoader::VariantFromName',
                       ],
                       'graphic_object.arc.max_curves' => 6,
                       'graphic_object.map' => {

data/lib/hexapdf/content/canvas.rb

@@ -2245,6 +2245,8 @@ module HexaPDF
       #   canvas.text("Times at size 10", at: [10, 150])
       #   canvas.font("Times", variant: :bold_italic, size: 15)
       #   canvas.text("Times bold+italic at size 15", at: [10, 100])
+      #   canvas.font("Times bold")
+      #   canvas.text("Times bold using the variant-from-name method", at: [10, 50])
       #
       # See: PDF2.0 s9.2.2, #font_size, #text
       def font(name = nil, size: nil, **options)

data/lib/hexapdf/document/layout.rb

@@ -92,6 +92,13 @@ module HexaPDF
     #
     #     style.font = ['Helvetica', variant: :bold]
     #
+    #   Helvetica in bold could also be set the conventional way:
+    #
+    #     style.font = 'Helvetica bold'
+    #
+    #   However, using an array it is also possible to specify other options when setting a font,
+    #   like the :subset option.
+    #
     class Layout
 
       # This class is used when a box can contain child boxes and the creation of such boxes should
@@ -539,7 +546,7 @@ module HexaPDF
       #     # assign the predefined style :cell_text to all texts
       #     args[] = {style: :cell_text}
       #     # row 0 has a grey background and bold text
-      #     args[0] = {font: ['Helvetica', variant: :bold], cell: {background_color: 'eee'}}
+      #     args[0] = {font: 'Helvetica bold', cell: {background_color: 'eee'}}
       #     # text in last column is right aligned
       #     args[0..-1, -1] = {text_align: :right}
       #   end

data/lib/hexapdf/encryption/aes.rb

@@ -112,11 +112,15 @@ module HexaPDF
         # It is assumed that the initialization vector is included in the first BLOCK_SIZE bytes
         # of the data. After the decryption the PKCS#5 padding is removed.
         #
+        # If a problem is encountered, an error message is yielded. If no block is given or if the
+        # supplied block returns +true+, an error is raised.
+        #
         # See: PDF2.0 s7.6.3
-        def decrypt(key, data)
+        def decrypt(key, data) # :yields: error_message
           return data if data.empty? # Handle invalid files with empty strings
           if data.length % BLOCK_SIZE != 0 || data.length < BLOCK_SIZE
-            raise HexaPDF::EncryptionError, "Invalid data for decryption, need 32 + 16*n bytes"
+            msg = "Invalid data for decryption, need 32 + 16*n bytes"
+            (!block_given? || yield(msg)) && raise(HexaPDF::EncryptionError, msg)
           end
           iv = data.slice!(0, BLOCK_SIZE)
           # Handle invalid files with missing padding
@@ -126,8 +130,9 @@ module HexaPDF
         # Returns a Fiber object that decrypts the data from the given source fiber with the
         # +key+.
         #
-        # Padding and the initialization vector are handled like in #decrypt.
-        def decryption_fiber(key, source)
+        # Padding, the initialization vector and an optionally given block are handled like in
+        # #decrypt.
+        def decryption_fiber(key, source) # :yields: error_message
           Fiber.new do
             data = ''.b
             while data.length < BLOCK_SIZE && source.alive? && (new_data = source.resume)
@@ -145,8 +150,10 @@ module HexaPDF
             end
 
             if data.length % BLOCK_SIZE != 0
-              raise HexaPDF::EncryptionError, "Invalid data for decryption, need 32 + 16*n bytes"
-            elsif data.empty?
+              msg = "Invalid data for decryption, need 32 + 16*n bytes"
+              (!block_given? || yield(msg)) && raise(HexaPDF::EncryptionError, msg)
+            end
+            if data.empty?
               data # Handle invalid files with missing padding
             else
               unpad(algorithm.process(data))

data/lib/hexapdf/encryption/security_handler.rb

@@ -153,17 +153,18 @@ module HexaPDF
 
         # Creates a new encrypted stream data object by utilizing the given stream data object +obj+
         # as template. The arguments +key+ and +algorithm+ are used for decrypting purposes.
-        def initialize(obj, key, algorithm)
+        def initialize(obj, key, algorithm, &error_block)
           obj.instance_variables.each {|v| instance_variable_set(v, obj.instance_variable_get(v)) }
           @key = key
           @algorithm = algorithm
+          @error_block = error_block
         end
 
         alias undecrypted_fiber fiber
 
         # Returns a fiber like HexaPDF::StreamData#fiber, but one wrapped in a decrypting fiber.
         def fiber(*args)
-          @algorithm.decryption_fiber(@key, super(*args))
+          @algorithm.decryption_fiber(@key, super(*args), &@error_block)
         end
 
       end
@@ -268,17 +269,18 @@ module HexaPDF
       def decrypt(obj)
         return obj if @is_encrypt_dict[obj] || obj.type == :XRef
 
+        error_proc = proc {|msg| document.config['encryption.on_decryption_error'].call(obj, msg) }
         key = object_key(obj.oid, obj.gen, string_algorithm)
         each_string_in_object(obj.value) do |str|
           next if str.empty? || (obj.type == :Sig && obj[:Contents].equal?(str))
-          str.replace(string_algorithm.decrypt(key, str))
+          str.replace(string_algorithm.decrypt(key, str, &error_proc))
         end
 
         if obj.kind_of?(HexaPDF::Stream) && obj.raw_stream.filter[0] != :Crypt
           unless string_algorithm == stream_algorithm
             key = object_key(obj.oid, obj.gen, stream_algorithm)
           end
-          obj.data.stream = EncryptedStreamData.new(obj.raw_stream, key, stream_algorithm)
+          obj.data.stream = EncryptedStreamData.new(obj.raw_stream, key, stream_algorithm, &error_proc)
         end
 
         obj

data/lib/hexapdf/font/cmap/parser.rb

@@ -163,11 +163,7 @@ module HexaPDF
             dest = tokenizer.next_object
 
             if dest.kind_of?(String)
-              codepoint = dest.force_encoding(::Encoding::UTF_16BE).ord
-              code1.upto(code2) do |code|
-                cmap.add_unicode_mapping(code, +'' << codepoint)
-                codepoint += 1
-              end
+              cmap.add_unicode_range_mapping(code1, code2, dest.unpack("n*"))
             elsif dest.kind_of?(Array)
               code1.upto(code2) do |code|
                 str = dest[code - code1].encode!(::Encoding::UTF_8, ::Encoding::UTF_16BE)