hexapdf 0.40.0 → 0.41.0

data/lib/hexapdf/font/cmap.rb

@@ -100,8 +100,10 @@ module HexaPDF
       # The writing mode of the CMap: 0 for horizontal, 1 for vertical writing.
       attr_accessor :wmode
 
-      attr_reader :codespace_ranges, :cid_mapping, :cid_range_mappings, :unicode_mapping # :nodoc:
-      protected :codespace_ranges, :cid_mapping, :cid_range_mappings, :unicode_mapping
+      attr_reader :codespace_ranges, :cid_mapping, :cid_range_mappings, :unicode_mapping,
+                  :unicode_range_mappings # :nodoc:
+      protected :codespace_ranges, :cid_mapping, :cid_range_mappings, :unicode_mapping,
+                :unicode_range_mappings
 
       # Creates a new CMap object.
       def initialize
@@ -109,6 +111,7 @@ module HexaPDF
         @cid_mapping = {}
         @cid_range_mappings = []
         @unicode_mapping = {}
+        @unicode_range_mappings = []
       end
 
       # Add all mappings from the given CMap to this CMap.
@@ -117,6 +120,7 @@ module HexaPDF
         @cid_mapping.merge!(cmap.cid_mapping)
         @cid_range_mappings.concat(cmap.cid_range_mappings)
         @unicode_mapping.merge!(cmap.unicode_mapping)
+        @unicode_range_mappings.concat(cmap.unicode_range_mappings)
       end
 
       # Add a codespace range using an array of ranges for the individual bytes.
@@ -193,10 +197,25 @@ module HexaPDF
         @unicode_mapping[code] = string
       end
 
+      # Adds a mapping from a range of character codes to strings starting with the given 16-bit
+      # integer values (representing the raw UTF-16BE characters).
+      def add_unicode_range_mapping(start_code, end_code, start_values)
+        @unicode_range_mappings << [start_code..end_code, start_values]
+      end
+
       # Returns the Unicode string in UTF-8 encoding for the given character code, or +nil+ if no
       # mapping was found.
       def to_unicode(code)
-        unicode_mapping[code]
+        @unicode_mapping.fetch(code) do
+          @unicode_range_mappings.reverse_each do |range, start_values|
+            if range.cover?(code)
+              str = start_values[0..-2].append(start_values[-1] + code - range.first).
+                pack('n*').encode(::Encoding::UTF_8, ::Encoding::UTF_16BE)
+              return @unicode_mapping[code] = str
+            end
+          end
+          nil
+        end
       end
 
     end

data/lib/hexapdf/font_loader/from_configuration.rb

@@ -62,7 +62,7 @@ module HexaPDF
       #     Specifies whether the font should be subset if possible.
       #
       # This method uses the FromFile font loader behind the scenes.
-      def self.call(document, name, variant: :none, subset: true)
+      def self.call(document, name, variant: :none, subset: true, **)
         file = document.config['font.map'].dig(name, variant)
         return nil if file.nil?
 

data/lib/hexapdf/font_loader/variant_from_name.rb

@@ -0,0 +1,72 @@
+# -*- 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/font/true_type_wrapper'
+require 'hexapdf/font_loader/from_file'
+
+module HexaPDF
+  module FontLoader
+
+    # This module translates font names like 'Helvetica bold' into the arguments 'Helvetica' and
+    # {variant: :bold}.
+    #
+    # This eases the usage of font names where specifying a font variant is not straight-forward.
+    # The actual loading of the font is deferred to Document::Fonts#add.
+    #
+    # Note that this should be the last entry in the list of font loaders to ensure correct
+    # operation.
+    module VariantFromName
+
+      # Returns a font wrapper for the given font by splitting the font name into the font name part
+      # and variant selector part. If the the resulting font cannot be resolved, +nil+ is returned.
+      #
+      # A font name should have the form 'Fontname selector' where selector can be 'bold', 'italic'
+      # or 'bold_italic', for example 'Helvetica bold'.
+      #
+      # Note that a supplied :variant keyword argument is ignored!
+      def self.call(document, name, recursive_invocation: false, **options)
+        return if recursive_invocation
+        name, variant = name.split(/ (?=(?:bold|italic|bold_italic)\z)/, 2)
+        return if variant.nil?
+
+        options[:variant] = variant.to_sym
+        document.fonts.add(name, **options, recursive_invocation: true) rescue nil
+      end
+
+    end
+
+  end
+end

data/lib/hexapdf/font_loader.rb

@@ -88,6 +88,7 @@ module HexaPDF
     autoload(:Standard14, 'hexapdf/font_loader/standard14')
     autoload(:FromConfiguration, 'hexapdf/font_loader/from_configuration')
     autoload(:FromFile, 'hexapdf/font_loader/from_file')
+    autoload(:VariantFromName, 'hexapdf/font_loader/variant_from_name')
 
   end
 

data/lib/hexapdf/layout/style.rb

@@ -614,7 +614,7 @@ module HexaPDF
       # The font to be used, must be set to a valid font wrapper object before it can be used.
       #
       # HexaPDF::Composer handles this property specially in that it resolves a set string or array
-      # to a font wrapper object before doing else with the style object.
+      # to a font wrapper object before doing anything else with the style object.
       #
       # This is the only style property without a default value!
       #
@@ -624,11 +624,12 @@ module HexaPDF
       #
       #   #>pdf-composer100
       #   composer.text("Helvetica", font: composer.document.fonts.add("Helvetica"))
-      #   composer.text("Courier", font: "Courier") # works only with composer
+      #   composer.text("Courier", font: "Courier")
       #
       #   helvetica_bold = composer.document.fonts.add("Helvetica", variant: :bold)
       #   composer.text("Helvetica Bold", font: helvetica_bold)
-      #   composer.text("Courier Bold", font: ["Courier", variant: :bold]) # only composer
+      #   composer.text("Courier Bold", font: "Courier bold")
+      #   composer.text("Courier Bold also", font: ["Courier", variant: :bold])
 
       ##
       # :method: font_size
@@ -1413,7 +1414,7 @@ module HexaPDF
       #   #>pdf-composer100
       #   composer.text("This is some longer text that does appear in two lines.")
       #   composer.text("This is some longer text that does not appear in two lines.",
-      #                 height: 15, text_overflow: :truncate)
+      #                 height: 15, overflow: :truncate)
 
       [
         [:font, "raise HexaPDF::Error, 'No font set'"],

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

@@ -39,6 +39,7 @@ require 'hexapdf/error'
 require 'hexapdf/layout/style'
 require 'hexapdf/layout/text_fragment'
 require 'hexapdf/layout/text_layouter'
+require 'hexapdf/type/acro_form/java_script_actions'
 
 module HexaPDF
   module Type
@@ -129,14 +130,20 @@ module HexaPDF
         #   widget.background_color(1)
         #   widget.marker_style(style: :circle, size: 0, color: 0)
         def create_check_box_appearances
-          appearance_keys = @widget.appearance_dict&.normal_appearance&.value&.keys || []
-          on_name = (appearance_keys - [:Off]).first
+          normal_appearance = @widget.appearance_dict&.normal_appearance
+          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
+          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"
           end
 
           @widget[:AS] = (@field[:V] == on_name ? on_name : :Off)
           @widget.flag(:print)
+          @widget.unflag(:hidden)
 
           border_style = @widget.border_style
           marker_style = @widget.marker_style
@@ -206,6 +213,7 @@ module HexaPDF
 
           @widget[:AS] = :N
           @widget.flag(:print)
+          @widget.unflag(:hidden)
           rect = @widget[:Rect]
           rect.width = @document.config['acro_form.text_field.default_width'] if rect.width == 0
           if rect.height == 0
@@ -358,7 +366,7 @@ module HexaPDF
 
         # Draws a single line of text inside the widget's rectangle.
         def draw_single_line_text(canvas, width, height, style, padding)
-          value, text_color = apply_javascript_formatting(@field.field_value)
+          value, text_color = JavaScriptActions.apply_format(@field.field_value, @field[:AA]&.[](:F))
           style.fill_color = text_color if text_color
           calculate_and_apply_font_size(value, style, width, height, padding)
           line = HexaPDF::Layout::Line.new(@document.layout.text_fragments(value, style: style))
@@ -500,79 +508,6 @@ module HexaPDF
           style.clear_cache
         end
 
-        # Handles Javascript formatting routines for single-line text fields.
-        #
-        # Returns [value, nil_or_text_color] where value is the new, potentially adjusted field
-        # value and the second argument is either +nil+ or the color that should be used for the
-        # text value.
-        def apply_javascript_formatting(value)
-          format_action = @widget[:AA]&.[](:F)
-          return [value, nil] unless format_action && format_action[:S] == :JavaScript
-          if (match = AF_NUMBER_FORMAT_RE.match(format_action[:JS]))
-            apply_af_number_format(value, match)
-          else
-            [value, nil]
-          end
-        end
-
-        # Regular expression for matching the AFNumber_Format Javascript method.
-        AF_NUMBER_FORMAT_RE = /
-          \AAFNumber_Format\(
-            \s*(?<ndec>\d+)\s*,
-            \s*(?<sep_style>[0-3])\s*,
-            \s*(?<neg_style>[0-3])\s*,
-            \s*0\s*,
-            \s*(?<currency_string>".*?")\s*,
-            \s*(?<prepend>false|true)\s*
-          \);\z
-        /x
-
-        # Implements the Javascript AFNumber_Format method.
-        #
-        # See:
-        # - https://experienceleague.adobe.com/docs/experience-manager-learn/assets/FormsAPIReference.pdf
-        # - https://opensource.adobe.com/dc-acrobat-sdk-docs/library/jsapiref/JS_API_AcroJS.html#printf
-        def apply_af_number_format(value, match)
-          value = value.to_f
-          format = "%.#{match[:ndec]}f"
-          text_color = 'black'
-
-          currency_string = JSON.parse(match[:currency_string])
-          format = (match[:prepend] == 'true' ? currency_string + format : format + currency_string)
-
-          if value < 0
-            value = value.abs
-            case match[:neg_style]
-            when '0' # MinusBlack
-              format = "-#{format}"
-            when '1' # Red
-              text_color = 'red'
-            when '2' # ParensBlack
-              format = "(#{format})"
-            when '3' # ParensRed
-              format = "(#{format})"
-              text_color = 'red'
-            end
-          end
-
-          result = sprintf(format, value)
-
-          # sep_style: 0=12,345.67, 1=12345.67, 2=12.345,67, 3=12345,67
-          before_decimal_point, after_decimal_point = result.split('.')
-          if match[:sep_style] == '0' || match[:sep_style] == '2'
-            separator = (match[:sep_style] == '0' ? ',' : '.')
-            before_decimal_point.gsub!(/\B(?=(\d\d\d)+(?:[^\d]|\z))/, separator)
-          end
-          result = if after_decimal_point
-                     decimal_point = (match[:sep_style] =~ /[01]/ ? '.' : ',')
-                     "#{before_decimal_point}#{decimal_point}#{after_decimal_point}"
-                   else
-                     before_decimal_point
-                   end
-
-          [result, text_color]
-        end
-
       end
 
     end

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

@@ -155,6 +155,12 @@ module HexaPDF
           field.value[name].nil? ? nil : field[name]
         end
 
+        # Wraps the given +field+ object inside the correct field class and returns the wrapped
+        # object.
+        def self.wrap(document, field)
+          document.wrap(field, type: :XXAcroFormField, subtype: inherited_value(field, :FT))
+        end
+
         # Form fields must always be indirect objects.
         def must_be_indirect?
           true
@@ -236,6 +242,14 @@ module HexaPDF
           kids.nil? || kids.empty? || kids.none? {|kid| kid.key?(:T) }
         end
 
+        # Returns self.
+        #
+        # This method is only here to make it easier to get the form field when the object may
+        # either be a form field or a field widget.
+        def form_field
+          self
+        end
+
         # Returns +true+ if the field contains an embedded widget.
         def embedded_widget?
           key?(:Subtype)

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

@@ -99,11 +99,11 @@ module HexaPDF
           document.pages.each do |page|
             page.each_annotation do |annot|
               if !annot.key?(:Parent) && annot.key?(:FT)
-                result << document.wrap(annot, type: :XXAcroFormField, subtype: annot[:FT])
+                result << Field.wrap(document, annot)
               elsif annot.key?(:Parent)
                 field = annot[:Parent]
                 field = field[:Parent] while field[:Parent]
-                result << document.wrap(field, type: :XXAcroFormField)
+                result << Field.wrap(document, field)
               end
             end
           end
@@ -129,8 +129,7 @@ module HexaPDF
             array.each_with_index do |field, index|
               next if field.nil?
               unless field.respond_to?(:type) && field.type == :XXAcroFormField
-                array[index] = field = document.wrap(field, type: :XXAcroFormField,
-                                                     subtype: Field.inherited_value(field, :FT))
+                array[index] = field = Field.wrap(document, field)
               end
               if field.terminal_field?
                 yield(field)
@@ -153,8 +152,7 @@ module HexaPDF
           name.split('.').each do |part|
             field = nil
             fields&.each do |f|
-              f = document.wrap(f, type: :XXAcroFormField,
-                                subtype: Field.inherited_value(f, :FT))
+              f = Field.wrap(document, f)
               next unless f[:T] == part
               field = f
               fields = field[:Kids] unless field.terminal_field?
@@ -420,6 +418,26 @@ module HexaPDF
           not_flattened
         end
 
+        # Recalculates all form fields that have a calculate action applied (which are all fields
+        # listed in the /CO entry).
+        #
+        # If HexaPDF doesn't support a calculation method or an error occurs during calculation, the
+        # field value is not updated.
+        #
+        # Note that calculations are *not* done automatically when a form field's value changes
+        # since it would lead to possibly many calls to this actions. So first fill in all field
+        # values and then call this method.
+        #
+        # See: JavaScriptActions
+        def recalculate_fields
+          self[:CO]&.each do |field|
+            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
+          end
+        end
+
         private
 
         # Creates a new field with the full name +name+ and the field type +type+.
@@ -468,8 +486,7 @@ module HexaPDF
               end
               next false unless field.key?(:T) # Skip widgets
 
-              field = document.wrap(field, type: :XXAcroFormField,
-                                    subtype: Field.inherited_value(field, :FT))
+              field = Field.wrap(document, field)
               reject = false
               if field[:Parent] != parent
                 yield("Parent entry of field (#{field.oid},#{field.gen}) invalid", true)