hexapdf 0.17.0 → 0.18.0

data/examples/019-acro_form.rb

@@ -0,0 +1,88 @@
+# # PDF Forms
+#
+# PDF files can be used for interactive forms, containing various types of form
+# fields. HexaPDF supports the creation and processing of these forms.
+#
+# This example show-cases how to create the various form field types and their
+# possible standard appearances.
+#
+# 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("Form Example", at: [50, 750])
+form = doc.acro_form(create: true)
+
+canvas.font_size(16)
+canvas.text("Check boxes", at: [50, 650])
+[:check, :circle, :cross, :diamond, :square, :star].each_with_index do |symbol, index|
+  cb = form.create_check_box("Checkbox #{index}")
+  widget = cb.create_widget(page, Rect: [200 + 50 * index, 640, 240 + 50 * index, 680])
+  widget.background_color(1 - 0.05 * index)
+  widget.marker_style(style: symbol, color: [0.166 * index, 0, 1 - 0.166 * index],
+                      size: 7 * index)
+  cb.field_value = true
+end
+
+canvas.text("Radio buttons", at: [50, 550])
+rb = form.create_radio_button("Radio")
+[:check, :circle, :cross, :diamond, :square, :star].each_with_index do |symbol, index|
+  widget = rb.create_widget(page, value: :"button#{index}",
+                            Rect: [200 + 50 * index, 540, 240 + 50 * index, 580])
+  widget.background_color(1 - 0.05 * index)
+  widget.marker_style(style: symbol, color: [0.166 * index, 0, 1 - 0.166 * index],
+                      size: 7 * index)
+end
+rb.field_value = :button0
+
+canvas.text("Text fields", at: [50, 450])
+
+canvas.text("Single line", at: [70, 420])
+tx = form.create_text_field("Single Line", font_size: 16)
+widget = tx.create_widget(page, Rect: [200, 415, 500, 435])
+tx.field_value = "A sample test string!"
+
+canvas.text("Multiline", at: [70, 390])
+tx = form.create_multiline_text_field("Multiline", font_size: 0, align: :right)
+widget = tx.create_widget(page, Rect: [200, 325, 500, 405])
+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])
+tx = form.create_password_field("Password", font_size: 16)
+widget = tx.create_widget(page, Rect: [200, 295, 500, 315])
+
+canvas.text("File select", at: [70, 270])
+tx = form.create_file_select_field("File Select", font_size: 16)
+widget = tx.create_widget(page, Rect: [200, 265, 500, 285])
+tx.field_value = "path/to/file.pdf"
+
+canvas.text("Comb", at: [70, 240])
+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.border_style(color: [30, 128, 0], width: 1)
+tx.field_value = 'Hello'
+
+canvas.text("Combo Box", at: [50, 170])
+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.border_style(width: 1)
+cb.field_value = 'Another value'
+
+canvas.text("List Box", at: [50, 120])
+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.border_style(width: 1)
+lb.list_box_top_index = 1
+lb.field_value = ['Value 6', 'Value 2']
+
+doc.write('acro_form.pdf', optimize: true)

data/lib/hexapdf/configuration.rb

@@ -203,6 +203,12 @@ module HexaPDF
   #
   #    In nearly all cases this option should not be changed from its default setting!
   #
+  # document.on_invalid_string::
+  #    A callable object that takes the invalid UTF-16BE encoded string and returns a valid UTF-8
+  #    encoded string.
+  #
+  #    The default is to remove all invalid characters.
+  #
   # encryption.aes::
   #    The class that should be used for AES encryption. If the value is a String, it should
   #    contain the name of a constant to such a class.
@@ -380,6 +386,9 @@ module HexaPDF
                       end,
                       'acro_form.text_field.default_width' => 100,
                       'document.auto_decrypt' => true,
+                      'document.on_invalid_string' => proc do |str|
+                        str.encode(Encoding::UTF_8, invalid: :replace, replace: '')
+                      end,
                       'encryption.aes' => 'HexaPDF::Encryption::FastAES',
                       'encryption.arc4' => 'HexaPDF::Encryption::FastARC4',
                       'encryption.filter_map' => {

data/lib/hexapdf/content/color_space.rb

@@ -35,7 +35,9 @@
 #++
 
 require 'hexapdf/error'
+require 'hexapdf/content'
 require 'hexapdf/configuration'
+require 'hexapdf/serializer'
 
 module HexaPDF
   module Content
@@ -304,6 +306,23 @@ module HexaPDF
         GlobalConfiguration.constantize('color_space.map', for_components(spec)).new.color(*spec)
       end
 
+      # Serializes the given device color into the form expected by PDF content streams.
+      #
+      # The +type+ argument can either be :stroke to serialize as stroke color operator or :fill as
+      # fill color operator.
+      def self.serialize_device_color(color, type: :fill)
+        operator = case color.color_space.family
+                   when :DeviceRGB then :rg
+                   when :DeviceGray then :g
+                   when :DeviceCMYK then :k
+                   else
+                     raise ArgumentError, "Device color object expected, got #{color.class}"
+                   end
+        operator = operator.upcase if type == :stroke
+        Content::Operator::DEFAULT_OPERATORS[operator].
+          serialize(HexaPDF::Serializer.new, *color.components)
+      end
+
       # Returns a device color object for the given components array without applying value
       # normalization.
       def self.prenormalized_device_color(components)

data/lib/hexapdf/content/graphic_object/arc.rb

@@ -51,8 +51,8 @@ module HexaPDF
       # Examples:
       #
       #   #>pdf-center
-      #   arc = canvas.graphic_object(:arc, a: 100, b: 50).stroke
-      #   arc.draw(canvas).stroke    # or: canvas.draw(arc).stroke
+      #   arc = canvas.graphic_object(:arc, a: 100, b: 50, end_angle: 150)
+      #   canvas.draw(arc).stroke
       #
       # See: ELL - https://spaceroots.org/documents/ellipse/elliptical-arc.pdf
       class Arc

data/lib/hexapdf/content/graphic_object/endpoint_arc.rb

@@ -43,6 +43,15 @@ module HexaPDF
       # This class describes an elliptical arc in endpoint parameterization. It allows one to
       # generate an arc from the current point to a given point, similar to Content::Canvas#line_to.
       #
+      # This graphic object is registered under the :endpoint_arc key for use with the
+      # HexaPDF::Content::Canvas class.
+      #
+      # Examples:
+      #
+      #   #>pdf-center
+      #   arc = canvas.graphic_object(:endpoint_arc, x: 50, y: 20, a: 30, b: 10)
+      #   canvas.move_to(0, 0).draw(arc).stroke
+      #
       # See: GraphicObject::Arc, ARC - https://www.w3.org/TR/SVG/implnote.html#ArcImplementationNotes
       class EndpointArc
 
@@ -58,29 +67,86 @@ module HexaPDF
         end
 
         # x-coordinate of endpoint
+        #
+        # Examples:
+        #
+        #   #>pdf-center
+        #   arc = canvas.graphic_object(:endpoint_arc, x: 50, y: 20, a: 30, b: 20)
+        #   canvas.move_to(0, 0).draw(arc).stroke
+        #   canvas.stroke_color("red").move_to(0, 0).draw(arc, x: -50).stroke
         attr_reader :x
 
         # y-coordinate of endpoint
+        #
+        # Examples:
+        #
+        #   #>pdf-center
+        #   arc = canvas.graphic_object(:endpoint_arc, x: 50, y: 20, a: 30, b: 20)
+        #   canvas.move_to(0, 0).draw(arc).stroke
+        #   canvas.stroke_color("red").move_to(0, 0).draw(arc, y: -20).stroke
         attr_reader :y
 
         # Length of semi-major axis
+        #
+        # Examples:
+        #
+        #   #>pdf-center
+        #   arc = canvas.graphic_object(:endpoint_arc, x: 50, y: 20, a: 30, b: 20)
+        #   canvas.move_to(0, 0).draw(arc).stroke
+        #   canvas.stroke_color("red").move_to(0, 0).draw(arc, a: 40).stroke
         attr_reader :a
 
         # Length of semi-minor axis
+        #
+        # Examples:
+        #
+        #   #>pdf-center
+        #   arc = canvas.graphic_object(:endpoint_arc, x: 50, y: 20, a: 30, b: 20)
+        #   canvas.move_to(0, 0).draw(arc).stroke
+        #   canvas.stroke_color("red").move_to(0, 0).draw(arc, b: 50).stroke
         attr_reader :b
 
         # Inclination in degrees of semi-major axis in respect to x-axis
+        #
+        # Examples:
+        #
+        #   #>pdf-center
+        #   arc = canvas.graphic_object(:endpoint_arc, x: 50, y: 20, a: 30, b: 20)
+        #   canvas.move_to(0, 0).draw(arc).stroke
+        #   canvas.stroke_color("red").move_to(0, 0).draw(arc, inclination: 45).stroke
         attr_reader :inclination
 
         # Large arc choice - if +true+ use the large arc (i.e. the one spanning more than 180
         # degrees), else the small arc
+        #
+        # Examples:
+        #
+        #   #>pdf-center
+        #   arc = canvas.graphic_object(:endpoint_arc, x: 50, y: 20, a: 30, b: 20)
+        #   canvas.move_to(0, 0).draw(arc).stroke
+        #   canvas.stroke_color("red").move_to(0, 0).draw(arc, large_arc: false, clockwise: true).stroke
         attr_reader :large_arc
 
         # Direction of arc - if +true+ in clockwise direction, else in counterclockwise direction
+        #
+        # This is needed, for example, when filling paths using the nonzero winding number rule to achieve
+        # different effects.
+        #
+        # Examples:
+        #
+        #   #>pdf-center
+        #   arc = canvas.graphic_object(:endpoint_arc, x: 50, y: 20, a: 30, b: 20)
+        #   canvas.move_to(0, 0).draw(arc).stroke
+        #   canvas.stroke_color("red").move_to(0, 0).draw(arc, clockwise: true).stroke
         attr_reader :clockwise
 
         # Creates an endpoint arc with default values x=0, y=0, a=0, b=0, inclination=0,
         # large_arc=true, clockwise=false (a line to the origin).
+        #
+        # Examples:
+        #
+        #   #>pdf-center
+        #   canvas.move_to(30, 30).draw(:endpoint_arc).stroke
         def initialize
           @x = @y = 0
           @a = @b = 0
@@ -185,10 +251,10 @@ module HexaPDF
           cy = sin_theta * cxp + cos_theta * cyp + (y1 + y2) / 2.0
 
           # F.6.5.5
-          start_angle = compute_angle_to_x_axis((x1p - cxp) / rx, (y1p - cyp) / ry)
+          start_angle = compute_angle_to_x_axis((x1p - cxp), (y1p - cyp)) % 360
 
           # F.6.5.6 (modified bc we just need the end angle)
-          end_angle = compute_angle_to_x_axis((-x1p - cxp) / rx, (-y1p - cyp) / ry)
+          end_angle = compute_angle_to_x_axis((-x1p - cxp), (-y1p - cyp)) % 360
 
           {cx: cx, cy: cy, a: rx, b: ry, start_angle: start_angle, end_angle: end_angle,
            inclination: @inclination, clockwise: @clockwise}

data/lib/hexapdf/content/graphic_object/geom2d.rb

@@ -57,9 +57,22 @@ module HexaPDF
         attr_accessor :object
 
         # The radius to use when drawing Geom2D::Point objects; defaults to 1
+        #
+        # Examples:
+        #
+        #   #>pdf-center
+        #   canvas.draw(:geom2d, object: ::Geom2D::Point(0, 0))
+        #   canvas.draw(:geom2d, object: ::Geom2D::Point(50, 0), point_radius: 5)
         attr_accessor :point_radius
 
         # Specifies whether only paths should be drawn or if they should be stroked/filled too
+        # (default).
+        #
+        # Examples:
+        #
+        #   #>pdf-center
+        #   canvas.draw(:geom2d, object: ::Geom2D::Segment([0, 0], [0, 50]))
+        #   canvas.draw(:geom2d, object: ::Geom2D::Segment([0, 0], [50, 0]), path_only: true)
         attr_accessor :path_only
 
         # Creates a Geom2D drawing support object.

data/lib/hexapdf/content/graphic_object/solid_arc.rb

@@ -41,20 +41,45 @@ module HexaPDF
       # This graphic object represents a solid elliptical arc, i.e. an arc that has an inner and
       # an outer set of a/b values.
       #
+      # This graphic object is registered under the :solid_arc key for use with the
+      # HexaPDF::Content::Canvas class.
+      #
       # Thus it can be used to create
       #
-      # * an (elliptical) disk (when the inner a/b are zero and the difference between start and
+      # * an (*elliptical*) *disk* (when the inner a/b are zero and the difference between start and
       #   end angles is greater than or equal to 360),
       #
-      # * an (elliptical) sector (when the inner a/b are zero and the difference between start
+      #     #>pdf-center
+      #     canvas.fill_color("red").
+      #       draw(:solid_arc, outer_a: 80, outer_b: 50, end_angle: 360).
+      #       fill_stroke
+      #
+      # * an (*elliptical*) *sector* (when the inner a/b are zero and the difference between start
       #   and end angles is less than 360),
       #
-      # * an (elliptical) annulus (when the inner a/b are nonzero and the difference between
+      #     #>pdf-center
+      #     canvas.fill_color("red").
+      #       draw(:solid_arc, outer_a: 80, outer_b: 50, start_angle: 20, end_angle: 230).
+      #       fill_stroke
+      #
+      # * an (*elliptical*) *annulus* (when the inner a/b are nonzero and the difference between
       #   start and end angles is greater than or equal to 360), and
       #
-      # * an (elliptical) annular sector (when the inner a/b are nonzero and the difference
+      #     #>pdf-center
+      #     canvas.fill_color("red").
+      #       draw(:solid_arc, outer_a: 80, outer_b: 50, inner_a: 70, inner_b: 30,
+      #            end_angle: 360).
+      #       fill_stroke
+      #
+      # * an (*elliptical*) *annular sector* (when the inner a/b are nonzero and the difference
       #   between start and end angles is less than 360)
       #
+      #     #>pdf-center
+      #     canvas.fill_color("red").
+      #       draw(:solid_arc, outer_a: 80, outer_b: 50, inner_a: 70, inner_b: 30,
+      #            start_angle: 20, end_angle: 230).
+      #       fill_stroke
+      #
       # See: Arc
       class SolidArc
 
@@ -66,30 +91,106 @@ module HexaPDF
         end
 
         # x-coordinate of center point
+        #
+        # Examples:
+        #
+        #   #>pdf-center
+        #   solid_arc = canvas.graphic_object(:solid_arc, outer_a: 30, outer_b: 20,
+        #                                     inner_a: 20, inner_b: 10)
+        #   canvas.draw(solid_arc).stroke
+        #   canvas.stroke_color("red").draw(solid_arc, cx: 50).stroke
         attr_reader :cx
 
         # y-coordinate of center point
+        #
+        # Examples:
+        #
+        #   #>pdf-center
+        #   solid_arc = canvas.graphic_object(:solid_arc, outer_a: 30, outer_b: 20,
+        #                                     inner_a: 20, inner_b: 10)
+        #   canvas.draw(solid_arc).stroke
+        #   canvas.stroke_color("red").draw(solid_arc, cy: 50).stroke
         attr_reader :cy
 
-        # Length of inner semi-major axis
+        # Length of inner semi-major axis which (without altering the #inclination) is parallel to
+        # the x-axis
+        #
+        # Examples:
+        #
+        #   #>pdf-center
+        #   solid_arc = canvas.graphic_object(:solid_arc, outer_a: 30, outer_b: 20,
+        #                                     inner_a: 20, inner_b: 10)
+        #   canvas.draw(solid_arc).stroke
+        #   canvas.stroke_color("red").draw(solid_arc, inner_a: 5).stroke
         attr_reader :inner_a
 
-        # Length of inner semi-minor axis
+        # Length of inner semi-minor axis which (without altering the #inclination) is parallel to the
+        # y-axis
+        #
+        # Examples:
+        #
+        #   #>pdf-center
+        #   solid_arc = canvas.graphic_object(:solid_arc, outer_a: 30, outer_b: 20,
+        #                                     inner_a: 20, inner_b: 10)
+        #   canvas.draw(solid_arc).stroke
+        #   canvas.stroke_color("red").draw(solid_arc, inner_b: 20).stroke
         attr_reader :inner_b
 
-        # Length of outer semi-major axis
+        # Length of outer semi-major axis which (without altering the #inclination) is parallel to
+        # the x-axis
+        #
+        # Examples:
+        #
+        #   #>pdf-center
+        #   solid_arc = canvas.graphic_object(:solid_arc, outer_a: 30, outer_b: 20,
+        #                                     inner_a: 20, inner_b: 10)
+        #   canvas.draw(solid_arc).stroke
+        #   canvas.stroke_color("red").draw(solid_arc, outer_a: 45).stroke
         attr_reader :outer_a
 
-        # Length of outer semi-minor axis
+        # Length of outer semi-minor axis which (without altering the #inclination) is parallel to the
+        # y-axis
+        #
+        # Examples:
+        #
+        #   #>pdf-center
+        #   solid_arc = canvas.graphic_object(:solid_arc, outer_a: 30, outer_b: 20,
+        #                                     inner_a: 20, inner_b: 10)
+        #   canvas.draw(solid_arc).stroke
+        #   canvas.stroke_color("red").draw(solid_arc, outer_b: 40).stroke
         attr_reader :outer_b
 
-        # Start angle in degrees
+        # Start angle of the solid arc in degrees
+        #
+        # Examples:
+        #
+        #   #>pdf-center
+        #   solid_arc = canvas.graphic_object(:solid_arc, outer_a: 30, outer_b: 20,
+        #                                     inner_a: 20, inner_b: 10)
+        #   canvas.draw(solid_arc).stroke
+        #   canvas.stroke_color("red").draw(solid_arc, start_angle: 60).stroke
         attr_reader :start_angle
 
-        # End angle in degrees
+        # End angle  of the solid arc in degrees
+        #
+        # Examples:
+        #
+        #   #>pdf-center
+        #   solid_arc = canvas.graphic_object(:solid_arc, outer_a: 30, outer_b: 20,
+        #                                     inner_a: 20, inner_b: 10)
+        #   canvas.draw(solid_arc).stroke
+        #   canvas.stroke_color("red").draw(solid_arc, end_angle: 120).stroke
         attr_reader :end_angle
 
         # Inclination in degrees of semi-major axis in respect to x-axis
+        #
+        # Examples:
+        #
+        #   #>pdf-center
+        #   solid_arc = canvas.graphic_object(:solid_arc, outer_a: 30, outer_b: 20,
+        #                                     inner_a: 20, inner_b: 10)
+        #   canvas.draw(solid_arc).stroke
+        #   canvas.stroke_color("red").draw(solid_arc, inclination: 40).stroke
         attr_reader :inclination
 
         # Creates a solid arc with default values (a unit disk at the origin).

data/lib/hexapdf/dictionary.rb

@@ -318,8 +318,8 @@ module HexaPDF
             value[name] = document.add(obj)
           elsif !field.indirect && obj.kind_of?(HexaPDF::Object) && obj.indirect?
             yield("Field #{name} needs to be a direct object", true)
-            document.delete(obj)
             value[name] = obj.value
+            document.delete(obj)
           end
         end
       end

data/lib/hexapdf/dictionary_fields.rb

@@ -233,11 +233,16 @@ module HexaPDF
 
       # Converts the string into UTF-8 encoding, assuming it is a binary string. Otherwise +nil+ is
       # returned.
-      def self.convert(str, _type, _document)
+      def self.convert(str, _type, document)
         return unless str.kind_of?(String) && str.encoding == Encoding::BINARY
 
         if str.getbyte(0) == 254 && str.getbyte(1) == 255
-          str[2..-1].force_encoding(Encoding::UTF_16BE).encode(Encoding::UTF_8)
+          str = str[2..-1].force_encoding(Encoding::UTF_16BE)
+          if str.valid_encoding?
+            str.encode!(Encoding::UTF_8)
+          else
+            document.configuration['document.on_invalid_string'].call(str)
+          end
         else
           Utils::PDFDocEncoding.convert_to_utf8(str)
         end

data/lib/hexapdf/encryption/security_handler.rb

@@ -213,7 +213,9 @@ module HexaPDF
         end
 
         handler = handler.new(document)
-        document.trailer[:Encrypt] = handler.set_up_decryption(dict, **options)
+        dict = document.trailer[:Encrypt] = handler.set_up_decryption(dict, **options)
+        HexaPDF::Object.make_direct(dict.value)
+        document.revisions.current.update(dict)
         document.revisions.each do |r|
           loader = r.loader
           r.loader = lambda do |xref_entry|

data/lib/hexapdf/object.rb

@@ -141,6 +141,24 @@ module HexaPDF
       end
     end
 
+    # Makes sure that the object itself as well as all nested values are direct objects.
+    #
+    # If an indirect object is found, it is turned into a direct object and the indirect object is
+    # deleted from the document.
+    def self.make_direct(object)
+      if object.kind_of?(HexaPDF::Object) && object.indirect?
+        object_to_delete = object
+        object = object.value
+        object_to_delete.document.delete(object_to_delete)
+      end
+      if object.kind_of?(Hash)
+        object.transform_values! {|val| make_direct(val) }
+      elsif object.kind_of?(Array)
+        object.map! {|val| make_direct(val) }
+      end
+      object
+    end
+
     # The wrapped HexaPDF::PDFData value.
     #
     # This attribute is not part of the public API!

data/lib/hexapdf/parser.rb

@@ -404,6 +404,7 @@ module HexaPDF
     def reconstruct_revision
       return if @in_reconstruct_revision
       @in_reconstruct_revision = true
+      @header_offset = 0
 
       raise unless @document.config['parser.try_xref_reconstruction']
       msg = "#{$!} - trying cross-reference table reconstruction"
@@ -428,8 +429,10 @@ module HexaPDF
           elsif gen.kind_of?(Integer) && tok.kind_of?(Tokenizer::Token) && tok == 'obj'
             xref.add_in_use_entry(token, gen, pos)
             if linearized.nil?
+              pos = @tokenizer.pos
               obj = @tokenizer.next_object rescue nil
               linearized = obj.kind_of?(Hash) && obj.key?(:Linearized)
+              @tokenizer.pos = pos
             end
             @tokenizer.scan_until(/(?:\n|\r\n?)endobj\b/)
           end

data/lib/hexapdf/serializer.rb

@@ -35,6 +35,8 @@
 #++
 
 require 'time'
+require 'hexapdf/object'
+require 'hexapdf/stream'
 require 'hexapdf/tokenizer'
 require 'hexapdf/filter'
 require 'hexapdf/utils/lru_cache'

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

@@ -227,8 +227,8 @@ module HexaPDF
         # Note: Rich text fields are currently not supported!
         def create_text_appearances
           default_resources = @document.acro_form.default_resources
-          font, font_size = retrieve_font_information(default_resources)
-          style = HexaPDF::Layout::Style.new(font: font)
+          font, font_size, font_color = retrieve_font_information(default_resources)
+          style = HexaPDF::Layout::Style.new(font: font, fill_color: font_color)
           border_style = @widget.border_style
           padding = [1, border_style.width].max
 
@@ -482,7 +482,7 @@ module HexaPDF
 
         # Returns the font wrapper and font size to be used for a variable text field.
         def retrieve_font_information(resources)
-          font_name, font_size = @field.parse_default_appearance_string
+          font_name, font_size, font_color = @field.parse_default_appearance_string
           font_object = resources.font(font_name) rescue nil
           font = font_object&.font_wrapper
           unless font
@@ -498,7 +498,7 @@ module HexaPDF
               raise(HexaPDF::Error, "Font #{font_name} of the AcroForm's default resources not usable")
             end
           end
-          [font, font_size]
+          [font, font_size, font_color]
         end
 
         # Calculates the font size for text fields based on the font and font size of the default