hexapdf 0.40.0 → 0.42.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2dab266d2115bdd9a7c9caf6a7512b56da77c14b8fe080d631d270c89a67e49f
-  data.tar.gz: c05acdf542d3b65e2c763f9aa84e21de4ad4f6800a48a4b4ca6873832089a0e2
+  metadata.gz: dd69db2c04dc802784438f9038c9a6ab32dac0806edca43b6c59406bba9d7ea6
+  data.tar.gz: a51a510a6a98b547b2b11fb07804ca9039a666adf95b52f65db9b070c3ffe9c3
 SHA512:
-  metadata.gz: 0e63528c1c604b06a8f07a53852ebfc2f5172a9aee43320942e4088f8aaf68953acc6f9e6017c4215591a8bb7a428b61fa20bd6e4ea180af39c62058de5b04db
-  data.tar.gz: 8b648570a98fcd5f1688c97ead5c05a0da6918cba49b3905bd70f526a65ddf376618e5d533c6bb04823117fc892839a600d0ba63d006699205e1ef399e0b64f5
+  metadata.gz: 714cba0b758960066498413b545dc7cf2806e1e483f99b017958450bfe29fd12aac1eef40f670d189f7cd7dab5784dd83e7b6f95533b97cf71c883dd9f307485
+  data.tar.gz: c93ceed7393b57fa5c6ca83141a8307b6015a1fa6907886b52c57bf72384d4d23ac8356adede0dabc35578cad5e1cef074f75c94e01e5c9532cadd0a688bbd57

data/CHANGELOG.md

@@ -1,3 +1,74 @@
+## 0.42.0 - 2024-05-12
+
+### Added
+
+* Support for the `AFPercent_Format` JavaScript method
+* Support for the `AFTime_Format` JavaScript method
+* [HexaPDF::Type::AcroForm::Form#fill] for easily filling out form fields
+* CLI command `hexapdf usage` for showing space usage information
+* Support for attaching files via `hexapdf files` CLI command
+* Refinement on [HexaPDF::Utils] to support conversion of Numeric values to
+  points (e.g. `5.mm`, `5.cm`, `5.inch`)
+
+### Changed
+
+* [HexaPDF::Type::AcroForm::ButtonField#field_value=] to always allow using
+  `true` for check boxes
+* CLI commands to prompt whether an existing output file should be overwritten
+
+### Fixed
+
+* [HexaPDF::Type::Resources#font] to always return a correctly wrapped font
+  object
+* [HexaPDF::Type::AcroForm::TextField#field_value=] to actually use the value
+  returned by the call to the config option 'acro_form.on_invalid_value'
+
+
+## 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

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,113 @@
+# # 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("Percent format", at: [70, 590])
+tx = form.create_text_field("Percent_Format", font_size: 16)
+tx.set_format_action(:percent, decimals: 2, separator_style: :comma)
+widget = tx.create_widget(page, Rect: [200, 585, 500, 605])
+tx.field_value = "12,45678"
+
+canvas.text("Time format", at: [70, 560])
+tx = form.create_text_field("Time_Format", font_size: 16)
+tx.set_format_action(:time, format: :hh_mm_ss)
+widget = tx.create_widget(page, Rect: [200, 555, 500, 575])
+tx.field_value = "3:15:20 pm"
+
+canvas.text("Calculate actions", at: [50, 510])
+
+canvas.text("Source fields", at: [70, 480])
+canvas.text("a:", at: [200, 480])
+tx = form.create_text_field("a", font_size: 16)
+tx.set_format_action(:number, decimals: 2)
+widget = tx.create_widget(page, Rect: [220, 475, 280, 495])
+tx.field_value = "10,50"
+canvas.text("b:", at: [310, 480])
+tx = form.create_text_field("b", font_size: 16)
+tx.set_format_action(:number, decimals: 2)
+widget = tx.create_widget(page, Rect: [330, 475, 390, 495])
+tx.field_value = "20,60"
+canvas.text("c:", at: [420, 480])
+tx = form.create_text_field("c", font_size: 16)
+tx.set_format_action(:number, decimals: 2)
+widget = tx.create_widget(page, Rect: [440, 475, 500, 495])
+tx.field_value = "30,70"
+
+canvas.text("Predefined", at: [70, 450])
+canvas.text("Sum", at: [90, 420])
+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, 415, 500, 435])
+canvas.text("Average", at: [90, 390])
+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, 385, 500, 405])
+canvas.text("Product", at: [90, 360])
+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, 355, 500, 375])
+canvas.text("Minimum", at: [90, 330])
+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, 325, 500, 345])
+canvas.text("Maximum", at: [90, 300])
+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, 295, 500, 315])
+
+canvas.text("Simplified Field Notation", at: [70, 270])
+canvas.text("a + b + c", at: [90, 240])
+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, 235, 500, 255])
+canvas.text("(a + b)*(c - a) / b + 3.14", at: [90, 210])
+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, 205, 500, 225])
+
+form.recalculate_fields
+
+doc.write('acro_form_java_script.pdf', optimize: true)

data/lib/hexapdf/cli/command.rb

@@ -53,7 +53,7 @@ module HexaPDF
       module Extensions #:nodoc:
         def help_banner #:nodoc:
           "hexapdf #{HexaPDF::VERSION} - Versatile PDF Manipulation Tool\n" \
-            "Copyright (c) 2014-2023 Thomas Leitner; licensed under the AGPLv3\n\n" \
+            "Copyright (c) 2014-2024 Thomas Leitner; licensed under the AGPLv3\n\n" \
             "#{format(usage, indent: 7)}\n\n"
         end
 
@@ -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
 
@@ -156,12 +167,12 @@ module HexaPDF
         end
       end
 
-      # Checks whether the given output file exists and raises an error if it does and
-      # HexaPDF::CLI#force is not set.
+      # Checks whether the given output file exists and ask whether to overwrite the output file if
+      # it does. If HexaPDF::CLI#force is set, a possibly existing output file is always overwritten.
       def maybe_raise_on_existing_file(filename)
         if !command_parser.force && File.exist?(filename)
-          raise Error, "Output file '#{filename}' already exists, not overwriting. Use --force to " \
-            "force writing"
+          response = read_from_console("Output file '#{filename}' already exists - overwrite? (y/n)")
+          exit(1) unless response =~ /y/i
         end
       end
 
@@ -366,9 +377,9 @@ module HexaPDF
       # console.
       def read_password(prompt = "Password")
         if $stdin.tty?
-          read_from_console(prompt)
+          read_from_console(prompt, noecho: true)
         else
-          ($stdin.gets || read_from_console(prompt)).chomp
+          ($stdin.gets || read_from_console(prompt, noecho: true)).chomp
         end
       end
 
@@ -396,11 +407,14 @@ module HexaPDF
       private
 
       # Displays the given prompt, reads from the console without echo and returns the read string.
-      def read_from_console(prompt)
+      def read_from_console(prompt, noecho: false)
         IO.console.write("#{prompt}: ")
-        str = IO.console.noecho {|io| io.gets.chomp }
-        puts
-        str
+        if noecho
+          IO.console.noecho {|io| io.gets.chomp }
+          puts
+        else
+          IO.console.gets.chomp
+        end
       end
 
     end

data/lib/hexapdf/cli/files.rb

@@ -39,19 +39,29 @@ require 'hexapdf/cli/command'
 module HexaPDF
   module CLI
 
-    # Lists or extracts embedded files from a PDF file.
+    # Lists or extracts embedded files from a PDF file or attaches them.
     #
     # See: HexaPDF::Type::EmbeddedFile
     class Files < Command
 
       def initialize #:nodoc:
         super('files', takes_commands: false)
-        short_desc("List or extract embedded files from a PDF file")
+        short_desc("List and extract embedded files from a PDF or attach files")
         long_desc(<<~EOF)
-          If the option --extract is not given, the available files are listed with their names and
-          indices. The --extract option can then be used to extract one or more files.
+          If neither the option --attach nor the option --extract is given, the available
+          files are listed with their names and indices. The --extract option can then be
+          used to extract one or more files. Or the --attach option can be used to attach
+          files to the PDF.
         EOF
 
+        options.on("--attach FILE", "-a FILE", String,
+                   "The file that should be attached. Can be used multiple times.") do |file|
+          @attach_files << [file, nil]
+        end
+        options.on("--description DESC", "-d DESC", String,
+                   "Adds a description to the last file to be attached.") do |description|
+          @attach_files[-1][1] = description
+        end
         options.on("--extract [a,b,c,...]", "-e [a,b,c,...]", Array,
                    "The indices of the files that should be extracted. Use 0 or no argument to " \
                    "extract all files.") do |indices|
@@ -66,15 +76,24 @@ module HexaPDF
           @password = (pwd == '-' ? read_password : pwd)
         end
 
+        @attach_files = []
         @indices = []
         @password = nil
         @search = false
       end
 
-      def execute(pdf) #:nodoc:
-        with_document(pdf, password: @password) do |doc|
-          if @indices.empty?
+      def execute(pdf, output = nil) #:nodoc:
+        if @indices.empty? && !@attach_files.empty?
+          raise Error, "Missing output file" unless output
+          maybe_raise_on_existing_file(output)
+        end
+        with_document(pdf, password: @password, out_file: output) do |doc|
+          if @indices.empty? && @attach_files.empty?
             list_files(doc)
+          elsif !@indices.empty? && !@attach_files.empty?
+            raise Error, "Use either --attach or --extract but not both"
+          elsif !@attach_files.empty?
+            attach_files(doc)
           else
             extract_files(doc)
           end
@@ -116,6 +135,11 @@ module HexaPDF
         end
       end
 
+      # Attaches the files given on the CLI to the document.
+      def attach_files(doc)
+        @attach_files.each {|file, desc| doc.files.add(file, description: desc) }
+      end
+
       # Iterates over all embedded files.
       def each_file(doc, &block) # :yields: obj, index
         doc.files.each(search: @search).select(&:embedded_file?).each_with_index(&block)

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
@@ -179,7 +195,9 @@ module HexaPDF
       # Fills out the form by interactively asking the user for field values.
       def fill_form(doc)
         current_page_index = -1
+        form = doc.acro_form
         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 +207,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
@@ -206,9 +225,9 @@ module HexaPDF
             print "    └─ New value: "
             value = $stdin.readline.chomp
             next if value.empty?
-            apply_field_value(field, value)
+            form.fill(field.full_field_name => value)
           rescue HexaPDF::Error => e
-            puts "       ⚠  #{e.message}"
+            puts "       ⚠ Error while setting '#{field.full_field_name}': #{e.message}"
             retry
           end
         end
@@ -216,13 +235,20 @@ module HexaPDF
 
       # Fills out the form using the data from the provided template file.
       def fill_form_with_template(doc)
-        data = parse_template
         form = doc.acro_form
-        data.each do |name, value|
+        data = parse_template
+        data.reject! do |name, _value|
           field = form.field_by_name(name)
           raise Error, "Field '#{name}' not found in input PDF" unless field
-          apply_field_value(field, value)
+          if field.flagged?(:read_only) && !@fill_read_only_fields
+            puts "Ignoring field '#{name}' because it is read only and --fill-read-only-fields " \
+              "is not set"
+            true
+          else
+            false
+          end
         end
+        form.fill(data)
       end
 
       # Parses the data from the given template file.
@@ -250,33 +276,9 @@ module HexaPDF
         data
       end
 
-      # Applies the given value to the field.
-      def apply_field_value(field, value)
-        case field.concrete_field_type
-        when :single_line_text_field, :multiline_text_field, :comb_text_field, :file_select_field,
-            :combo_box, :list_box, :editable_combo_box
-          field.field_value = value
-        when :check_box
-          field.field_value = case value
-                              when /y(es)?|t(rue)?/
-                                true
-                              when /n(o)?|f(alse)?/
-                                false
-                              else
-                                value
-                              end
-        when :radio_button
-          field.field_value = value.to_sym
-        else
-          raise Error, "Field type #{field.concrete_field_type} not yet supported"
-        end
-      rescue StandardError
-        raise Error, "Error while setting '#{field.full_field_name}': #{$!.message}"
-      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 +286,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 +294,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