hexapdf 0.46.0 → 1.0.0

data/lib/hexapdf/font/true_type_wrapper.rb

@@ -57,6 +57,10 @@ module HexaPDF
     class TrueTypeWrapper
 
       # Represents a single glyph of the wrapped font.
+      #
+      # Since some characters/strings may be mapped to the same glyph id by the font's builtin cmap
+      # table, it is possible that different Glyph instances with the same #id but different #str
+      # exist.
       class Glyph
 
         # The associated TrueTypeWrapper object.
@@ -152,6 +156,7 @@ module HexaPDF
         @id_to_glyph = {}
         @codepoint_to_glyph = {}
         @encoded_glyphs = {}
+        @last_char_code = 0
       end
 
       # Returns the type of the font, i.e. :TrueType.
@@ -179,14 +184,15 @@ module HexaPDF
         !@subsetter.nil?
       end
 
-      # Returns a Glyph object for the given glyph ID.
+      # Returns a Glyph object for the given glyph ID and +str+ pair.
       #
-      # The optional argument +str+ should be the string representation of the glyph. Only use it if
-      # it is known,
+      # The optional argument +str+ should be the string representation of the glyph. It is possible
+      # that multiple strings map to the same glyph (e.g. hyphen and soft-hyphen could be
+      # represented by the same glyph).
       #
       # Note: Although this method is public, it should normally not be used by application code!
       def glyph(id, str = nil)
-        @id_to_glyph[id] ||=
+        @id_to_glyph[[id, str]] ||=
           if id >= 0 && id < @wrapped_font[:maxp].num_glyphs
             Glyph.new(self, id, str || (+'' << (@cmap.gid_to_code(id) || 0xFFFD)))
           else
@@ -228,14 +234,12 @@ module HexaPDF
 
       # Encodes the glyph and returns the code string.
       def encode(glyph)
-        (@encoded_glyphs[glyph.id] ||=
+        (@encoded_glyphs[glyph] ||=
           begin
             raise HexaPDF::MissingGlyphError.new(glyph) if glyph.kind_of?(InvalidGlyph)
-            if @subsetter
-              [[@subsetter.use_glyph(glyph.id)].pack('n'), glyph]
-            else
-              [[glyph.id].pack('n'), glyph]
-            end
+            @subsetter.use_glyph(glyph.id) if @subsetter
+            @last_char_code += 1
+            [[@last_char_code].pack('n'), @last_char_code]
           end)[0]
       end
 
@@ -286,7 +290,7 @@ module HexaPDF
                                                  Supplement: 0},
                                  CIDToGIDMap: :Identity})
         dict = document.add({Type: :Font, Subtype: :Type0, BaseFont: cid_font[:BaseFont],
-                             Encoding: :'Identity-H', DescendantFonts: [cid_font]})
+                             DescendantFonts: [cid_font]})
         dict.font_wrapper = self
 
         document.register_listener(:complete_objects) do
@@ -294,6 +298,7 @@ module HexaPDF
           embed_font(dict, document)
           complete_width_information(dict)
           create_to_unicode_cmap(dict, document)
+          add_encoding_information_cmap(dict, document)
         end
 
         dict
@@ -306,7 +311,7 @@ module HexaPDF
         return unless @subsetter
 
         tag = +''
-        data = @encoded_glyphs.each_with_object(''.b) {|(id, v), s| s << id.to_s << v[0] }
+        data = @encoded_glyphs.each_with_object(''.b) {|(g, v), s| s << g.id.to_s << v[0] }
         hash = Digest::MD5.hexdigest(data << @wrapped_font.font_name).to_i(16)
         while hash != 0 && tag.length < 6
           hash, mod = hash.divmod(UPPERCASE_LETTERS.length)
@@ -336,8 +341,8 @@ module HexaPDF
       # Adds the /DW and /W fields to the CIDFont dictionary.
       def complete_width_information(dict)
         default_width = glyph(3, " ").width.to_i
-        widths = @encoded_glyphs.reject {|_, v| v[1].width == default_width }.map do |id, v|
-          [(@subsetter ? @subsetter.subset_glyph_id(id) : id), v[1].width]
+        widths = @encoded_glyphs.reject {|g, _| g.width == default_width }.map do |g, _|
+          [(@subsetter ? @subsetter.subset_glyph_id(g.id) : g.id), g.width]
         end.sort!
         dict[:DescendantFonts].first.set_widths(widths, default_width: default_width)
       end
@@ -346,9 +351,10 @@ module HexaPDF
       # correctly.
       def create_to_unicode_cmap(dict, document)
         stream = HexaPDF::StreamData.new do
-          mapping = @encoded_glyphs.keys.map! do |id|
+          mapping = @encoded_glyphs.map do |glyph, (_, char_code)|
             # Using 0xFFFD as mentioned in Adobe #5411, last line before section 1.5
-            [(@subsetter ? @subsetter.subset_glyph_id(id) : id), @cmap.gid_to_code(id) || 0xFFFD]
+            # TODO: glyph.str assumed to consist of single char, No support for multiple chars
+            [char_code, glyph.str.ord || 0xFFFD]
           end.sort_by!(&:first)
           HexaPDF::Font::CMap.create_to_unicode_cmap(mapping)
         end
@@ -357,6 +363,25 @@ module HexaPDF
         dict[:ToUnicode] = stream_obj
       end
 
+      # Adds the /Encoding entry to the +dict+.
+      #
+      # This can either be the identity mapping or, if some Unicode codepoints are mapped to the
+      # same glyph, a custom CMap.
+      def add_encoding_information_cmap(dict, document)
+        mapping = @encoded_glyphs.map do |glyph, (_, char_code)|
+          # Using 0xFFFD as mentioned in Adobe #5411, last line before section 1.5
+          [char_code, (@subsetter ? @subsetter.subset_glyph_id(glyph.id) : glyph.id)]
+        end.sort_by!(&:first)
+        if mapping.all? {|char_code, cid| char_code == cid }
+          dict[:Encoding] = :'Identity-H'
+        else
+          stream = HexaPDF::StreamData.new { HexaPDF::Font::CMap.create_cid_cmap(mapping) }
+          stream_obj = document.add({}, stream: stream)
+          stream_obj.set_filter(:FlateDecode)
+          dict[:Encoding] = stream_obj
+        end
+      end
+
     end
 
   end

data/lib/hexapdf/importer.rb

@@ -141,7 +141,7 @@ module HexaPDF
         internal_import(wrapper.source.object(object), wrapper)
       when HexaPDF::Object
         wrapper.source ||= object.document
-        if !@allow_all && (object.type == :Catalog || object.type == :Pages)
+        if object.null? || (!@allow_all && (object.type == :Catalog || object.type == :Pages))
           @mapper[object.data] = nil
         elsif (mapped_object = @mapper[object.data]&.__getobj__) && !mapped_object.null?
           mapped_object

data/lib/hexapdf/layout/table_box.rb

@@ -382,7 +382,14 @@ module HexaPDF
         def fit_rows(start_row, available_height, column_info, frame)
           height = available_height
           last_fitted_row_index = -1
+          row_heights = {}
+          zero_height_rows = {}
+          row_spans = []
+
           @cells[start_row..-1].each.with_index(start_row) do |columns, row_index|
+            # 1. Fit all columns of the row and record the max height of all non-row-span cells. If
+            #    a row has zero height (usually because it only has row-span cells), record that
+            #    information. Additionally store all cells with row-spans.
             row_fit = true
             row_height = 0
             columns.each_with_index do |cell, col_index|
@@ -396,27 +403,67 @@ module HexaPDF
                 row_fit = false
                 break
               end
-              cell.left = column_info[cell.column].first
-              cell.top = height - available_height
-              row_height = cell.preferred_height if row_height < cell.preferred_height
+              if row_height < cell.preferred_height && cell.row_span == 1
+                row_height = cell.preferred_height
+              end
+              row_spans << cell if cell.row_span > 1
             end
 
-            if row_fit
-              seen = {}
-              columns.each do |cell|
-                next if seen[cell]
-                cell.update_height(cell.row == row_index ? row_height : cell.height + row_height)
-                seen[cell] = true
-              end
+            zero_height_rows[row_index] = true if row_height == 0
 
+            if row_fit
+              # 2. If all cells of the row fit, we subtract the recorded row height of the
+              #    non-row-span cells from the available height for the next pass.
               last_fitted_row_index = row_index
+              row_heights[row_index] = row_height
               available_height -= row_height
+
+              # 3. We look at all row-span cells that end at the current row index. If the row-span
+              #    cell is larger than the sum of the row heights, we proportionally enlarge the
+              #    stored height of each spanned row and subtract the difference from the available
+              #    height for the next pass. If the row span contains initially zero-height rows,
+              #    only those rows are enlarged. Row-span cells themselves are not updated at this
+              #    point!
+              row_spans.each do |cell|
+                upper_row_index = cell.row + cell.row_span - 1
+                next unless upper_row_index == row_index
+
+                rows = cell.row.upto(upper_row_index)
+                row_span_height = rows.sum {|ri| row_heights[ri] }
+                if row_span_height < cell.preferred_height
+                  zero_height_rows_in_span = rows.select {|ri| zero_height_rows[ri] }
+                  rows = zero_height_rows_in_span if zero_height_rows_in_span.size > 0
+                  adjustment = (cell.preferred_height - row_span_height) / rows.size.to_f
+                  rows.each {|ri| row_heights[ri] += adjustment }
+                  available_height -= cell.preferred_height - row_span_height
+                end
+              end
             else
               last_fitted_row_index = columns.min_by(&:row).row - 1 if height != available_height
               break
             end
           end
 
+          if last_fitted_row_index >= 0
+            # 4. Once all possible rows have been fitted and the heights of the rows are fixed, the
+            #    final height and top-left corner of each cell needs to be set.
+            running_height = 0
+            @cells[start_row..last_fitted_row_index].each.with_index(start_row) do |columns, row_index|
+              columns.each_with_index do |cell, col_index|
+                next if cell.row != row_index || cell.column != col_index
+                cell.left = column_info[cell.column].first
+                cell.top = running_height
+                if cell.row_span == 1
+                  cell.update_height(row_heights[row_index])
+                else
+                  new_height = cell.row.upto(cell.row + cell.row_span - 1).sum {|ri| row_heights[ri] }
+                  cell.update_height(new_height)
+                end
+              end
+              running_height += row_heights[row_index]
+            end
+          end
+
           [height - available_height, last_fitted_row_index < start_row ? -1 : last_fitted_row_index]
         end
 

data/lib/hexapdf/layout/text_fragment.rb

@@ -235,6 +235,7 @@ module HexaPDF
           end
         end
 
+        in_text_object = (canvas.graphics_object == :text)
         canvas.begin_text
         tlm = canvas.graphics_state.tlm
         tx = x - tlm.e
@@ -248,7 +249,7 @@ module HexaPDF
         elsif ty.abs < PRECISION
           canvas.move_text_cursor(offset: [tx, 0], absolute: false)
         else
-          canvas.move_text_cursor(offset: [x, y])
+          canvas.move_text_cursor(offset: [x, y], absolute: in_text_object)
         end
         canvas.show_glyphs_only(items)
 

data/lib/hexapdf/object.rb

@@ -372,7 +372,7 @@ module HexaPDF
 
     # Computes the hash value based on the object and generation numbers.
     def hash
-      oid.hash ^ gen.hash
+      [oid, gen].hash
     end
 
     def inspect #:nodoc:

data/lib/hexapdf/parser.rb

@@ -184,7 +184,7 @@ module HexaPDF
         length = if object[:Length].kind_of?(Integer)
                    object[:Length]
                  elsif object[:Length].kind_of?(Reference)
-                   @document.deref(object[:Length]).value
+                   @document.deref(object[:Length])&.value || 0
                  else
                    0
                  end

data/lib/hexapdf/reference.rb

@@ -87,7 +87,7 @@ module HexaPDF
 
     # Computes the hash value based on the object and generation numbers.
     def hash
-      oid.hash ^ gen.hash
+      [oid, gen].hash
     end
 
     # Returns the object identifier as "oid,gen".

data/lib/hexapdf/task/merge_acro_form.rb

@@ -0,0 +1,164 @@
+# -*- encoding: utf-8; frozen_string_literal: true -*-
+#
+#--
+# This file is part of HexaPDF.
+#
+# HexaPDF - A Versatile PDF Creation and Manipulation Library For Ruby
+# Copyright (C) 2014-2024 Thomas Leitner
+#
+# HexaPDF is free software: you can redistribute it and/or modify it
+# under the terms of the GNU Affero General Public License version 3 as
+# published by the Free Software Foundation with the addition of the
+# following permission added to Section 15 as permitted in Section 7(a):
+# FOR ANY PART OF THE COVERED WORK IN WHICH THE COPYRIGHT IS OWNED BY
+# THOMAS LEITNER, THOMAS LEITNER DISCLAIMS THE WARRANTY OF NON
+# INFRINGEMENT OF THIRD PARTY RIGHTS.
+#
+# HexaPDF is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public
+# License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with HexaPDF. If not, see <http://www.gnu.org/licenses/>.
+#
+# The interactive user interfaces in modified source and object code
+# versions of HexaPDF must display Appropriate Legal Notices, as required
+# under Section 5 of the GNU Affero General Public License version 3.
+#
+# In accordance with Section 7(b) of the GNU Affero General Public
+# License, a covered work must retain the producer line in every PDF that
+# is created or manipulated using HexaPDF.
+#
+# If the GNU Affero General Public License doesn't fit your need,
+# commercial licenses are available at <https://gettalong.at/hexapdf/>.
+#++
+
+require 'hexapdf/serializer'
+
+module HexaPDF
+  module Task
+
+    # Task for merging an AcroForm from one PDF into another.
+    #
+    # It takes care of
+    #
+    # * adding the fields to the main Type::AcroForm::Form dictionary,
+    # * adjusting the field names so that they are unique,
+    # * and merging the properties of the main AcroForm dictionary itself and adjusting field
+    #   information appropriately.
+    #
+    # Note that the pages with the fields need to be imported already.
+    #
+    # The steps for using this task are:
+    #
+    # 1. Import the pages into the target document and add all imported pages to an array
+    # 2. Call this task using the created array of pages.
+    #
+    # Example:
+    #
+    #   pages = doc.pages.map {|page| target.pages.add(target.import(page)) }
+    #   target.task(:merge_acro_form, source: doc, pages: pages)
+    module MergeAcroForm
+
+      # Performs the necessary steps to merge the AcroForm fields from the +source+ into the target
+      # document +doc+.
+      #
+      # +source+::
+      #     Specifies the source PDF document the information from which should be merged into the
+      #     target document.
+      #
+      # +pages+::
+      #     An array of pages that were imported from +source+ and contain the widgets of the fields
+      #     that should be merged.
+      def self.call(doc, source:, pages:)
+        return unless source.acro_form
+
+        acro_form = doc.acro_form(create: true)
+
+        # Determine a unique name for root field and create root field
+        import_name = 'merged_' +
+                      (acro_form.root_fields.select {|field| field[:T] =~ /\Amerged_\d+\z/ }.
+                        map {|field| field[:T][/\d+/].to_i }.sort.last || 0).succ.to_s
+        root_field = doc.add({T: import_name, Kids: []})
+        acro_form.root_fields << root_field
+
+        # Merge the main AcroForm dictionary
+        font_name_mapping = merge_form_dictionary(acro_form, source.acro_form, root_field)
+        font_name_re = font_name_mapping.keys.map {|name| Regexp.escape(name) }.join('|')
+        root_field[:DA] && root_field[:DA].sub!(font_name_re, font_name_mapping)
+
+        # Process all field widgets of the given pages
+        process_calculate_actions = false
+        signature_field_seen = false
+        pages.each do |page|
+          page.each_annotation do |widget|
+            next unless widget[:Subtype] == :Widget
+            field = widget.form_field
+
+            # Correct the font name in the default appearance string
+            widget[:DA] && widget[:DA].sub!(font_name_re, font_name_mapping)
+            field[:DA] && field[:DA].sub!(font_name_re, font_name_mapping)
+
+            process_calculate_actions = true if field[:AA]&.[](:C)
+            signature_field_seen = true if field.field_type == :Sig
+
+            # Add to the root field
+            field = field[:Parent] while field[:Parent]
+            if field != root_field
+              field[:Parent] = root_field
+              root_field[:Kids] << field
+            end
+          end
+        end
+
+        # Update calculation JavaScript actions with changed field names
+        fix_calculate_actions(acro_form, source.acro_form, import_name) if process_calculate_actions
+
+        # Update signature flags if necessary
+        if signature_field_seen && source.acro_form.signature_flag?(:signatures_exist)
+          acro_form.signature_flag(:signatures_exist)
+        end
+      end
+
+      # Merges the AcroForm +source_form+ into the +target_form+ and returns a mapping of old font
+      # names to new ones.
+      def self.merge_form_dictionary(target_form, source_form, root_field)
+        target_resources = target_form.default_resources
+        font_name_mapping = {}
+        serializer = HexaPDF::Serializer.new
+
+        source_form.default_resources[:Font].each do |font_name, value|
+          new_name = target_resources.add_font(target_form.document.import(value))
+          font_name_mapping[serializer.serialize(font_name)] = serializer.serialize(new_name)
+        end
+
+        root_field[:DA] = target_form.document.import(source_form[:DA])
+        root_field[:Q] = target_form.document.import(source_form[:Q])
+
+        font_name_mapping
+      end
+
+      # Fixes the calculate actions listed in the /CO entry of the main AcroForm dictionary to use
+      # the new names of the fields.
+      def self.fix_calculate_actions(acro_form, source_form, import_name)
+        if source_form[:CO]
+          acro_form[:CO] ||= []
+          acro_form[:CO].value.concat(acro_form.document.import(source_form[:CO]).value)
+          acro_form[:CO].each do |field|
+            next unless (action = field[:AA]&.[](:C))
+            action[:JS].gsub!(/"(.*?)"/) do |match|
+              if source_form.field_by_name($1)
+                "\"#{import_name}.#{$1}\""
+              else
+                match
+              end
+            end
+          end
+        end
+      end
+
+    end
+
+  end
+end

data/lib/hexapdf/task/optimize.rb

@@ -214,13 +214,13 @@ module HexaPDF
         end
       end
 
-      # Deletes field entries of the object that are optional and currently set to their default
-      # value.
+      # Deletes field entries (except for /Type) of the object that are optional and currently set
+      # to their default value.
       def self.delete_fields_with_defaults(obj)
         return unless obj.kind_of?(HexaPDF::Dictionary) && !obj.null?
         obj.each do |name, value|
-          if (field = obj.class.field(name)) && !field.required? && field.default? &&
-              value == field.default
+          if name != :Type && (field = obj.class.field(name)) && !field.required? &&
+             field.default? && value == field.default
             obj.delete(name)
           end
         end

data/lib/hexapdf/task.rb

@@ -65,6 +65,7 @@ module HexaPDF
     autoload(:Optimize, 'hexapdf/task/optimize')
     autoload(:Dereference, 'hexapdf/task/dereference')
     autoload(:PDFA, 'hexapdf/task/pdfa')
+    autoload(:MergeAcroForm, 'hexapdf/task/merge_acro_form')
 
   end
 

data/lib/hexapdf/tokenizer.rb

@@ -144,6 +144,8 @@ module HexaPDF
       elsif byte == 93 # ]
         @ss.pos += 1
         TOKEN_ARRAY_END
+      elsif byte == 41 # )
+        raise HexaPDF::MalformedPDFError.new("Delimiter ')' found at invalid position", pos: pos)
       elsif byte == 123 || byte == 125 # { }
         Token.new(@ss.get_byte)
       elsif byte == 37 # %

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

@@ -134,11 +134,12 @@ module HexaPDF
           if !normal_appearance.kind_of?(HexaPDF::Dictionary) || normal_appearance.kind_of?(HexaPDF::Stream)
             (@widget[:AP] ||= {})[:N] = {Off: nil}
             normal_appearance = @widget[:AP][:N]
-            normal_appearance[@field[:V] == :Off ? :Yes : @field[:V]] = nil
+            normal_appearance[@field.field_value&.to_sym || :Yes] = nil
           end
           on_name = (normal_appearance.value.keys - [:Off]).first
           unless on_name
-            raise HexaPDF::Error, "Widget of button field doesn't define name for on state"
+            on_name = @field.field_value&.to_sym || :Yes
+            normal_appearance[on_name] = nil
           end
 
           @widget[:AS] = (@field[:V] == on_name ? on_name : :Off)
@@ -226,8 +227,11 @@ module HexaPDF
 
           form = (@widget[:AP] ||= {})[:N] ||= @document.add({Type: :XObject, Subtype: :Form})
           # Wrap existing object in Form class in case the PDF writer didn't include the /Subtype
-          # key; we can do this since we know this has to be a Form object
-          form = @document.wrap(form, type: :XObject, subtype: :Form) unless form[:Subtype] == :Form
+          # key or the type of the object is wrong; we can do this since we know this has to be a
+          # Form object
+          unless form.type == :XObject && form[:Subtype] == :Form
+            form = @document.wrap(form, type: :XObject, subtype: :Form)
+          end
           form.value.replace({Type: :XObject, Subtype: :Form, BBox: [0, 0, width, height],
                               Matrix: matrix, Resources: HexaPDF::Object.deep_copy(default_resources)})
           form.contents = ''

data/lib/hexapdf/type/acro_form/form.rb

@@ -81,6 +81,7 @@ module HexaPDF
         define_field :CO,              type: PDFArray, version: '1.3'
         define_field :DR,              type: :XXResources
         define_field :DA,              type: String
+        define_field :Q,               type: Integer
         define_field :XFA,             type: [Stream, PDFArray], version: '1.5'
 
         bit_field(:signature_flags, {signatures_exist: 0, append_only: 1},
@@ -182,24 +183,18 @@ module HexaPDF
         # The optional keyword arguments allow setting often used properties of the field:
         #
         # +font+::
-        #     The font that should be used for the text of the field. If +font_size+, +font_options+
-        #     or +font_color+ is specified but +font+ isn't, the font Helvetica is used.
-        #
-        #     If no font is set on the text field, the default font properties of the AcroForm form
-        #     are used. Note that field specific or form specific font properties have to be set.
-        #     Otherwise there will be an error when trying to generate a visual representation of
-        #     the field value.
+        #     The font that should be used for the text of the field. If not specified, it
+        #     defaults to Helvetica.
         #
         # +font_options+::
-        #     A hash with font options like :variant that should be used.
+        #     A hash with font options like :variant that should be used. If not specified, it
+        #     defaults to the empty hash.
         #
         # +font_size+::
-        #     The font size that should be used. If +font+, +font_options+ or +font_color+ is
-        #     specified but +font_size+ isn't, font size defaults to 0 (= auto-sizing).
+        #     The font size that should be used. If not specified, it defaults to 0 (= auto-sizing).
         #
         # +font_color+::
-        #     The font color that should be used. If +font+, +font_options+ or +font_size+ is
-        #     specified but +font_color+ isn't, font color defaults to 0 (i.e. black).
+        #     The font color that should be used. If not specified, it defaults to 0 (i.e. black).
         #
         # +align+::
         #     The alignment of the text, either :left, :center or :right.
@@ -440,8 +435,7 @@ module HexaPDF
 
         # Returns the dictionary containing the default resources for form field appearance streams.
         def default_resources
-          self[:DR] ||= document.wrap({ProcSet: [:PDF, :Text, :ImageB, :ImageC, :ImageI]},
-                                      type: :XXResources)
+          self[:DR] ||= document.wrap({}, type: :XXResources)
         end
 
         # Sets the global default appearance string using the provided values or the default values
@@ -527,7 +521,7 @@ module HexaPDF
             field = Field.wrap(document, field)
             next unless field && (calculation_action = field[:AA]&.[](:C))
             result = JavaScriptActions.calculate(self, calculation_action)
-            field.form_field.field_value = result if result
+            field.field_value = result if result
           end
         end
 
@@ -561,13 +555,11 @@ module HexaPDF
         # Applies the given variable field properties to the field.
         def apply_variable_text_properties(field, font: nil, font_options: nil, font_size: nil,
                                            font_color: nil, align: nil)
-          if font || font_options || font_size || font_color
-            field.set_default_appearance_string(font: font || 'Helvetica',
-                                                font_options: font_options || {},
-                                                font_size: font_size || 0,
-                                                font_color: font_color || 0)
-          end
-          field.text_alignment(align) if align
+          field.set_default_appearance_string(font: font || 'Helvetica',
+                                              font_options: font_options || {},
+                                              font_size: font_size || 0,
+                                              font_color: font_color || 0)
+          field.text_alignment(align || :left)
         end
 
         def perform_validation # :nodoc:
@@ -625,8 +617,6 @@ module HexaPDF
             if font_name && !(self[:DR][:Font] && self[:DR][:Font][font_name])
               yield("The font specified in /DA is not in the /DR resource dictionary")
             end
-          else
-            set_default_appearance_string
           end
 
           create_appearances if document.config['acro_form.create_appearances']