hexapdf 0.17.3 → 0.18.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 15efadb34e0a5dc93ec7659d02cb95a19400a38fe7ccffcbc2438fa6e6f51b8f
-  data.tar.gz: 29ddd43180432e648c107ae40c2618415f0ead8bf6e6fcbe46bc1f0557eae271
+  metadata.gz: d95ce1575c017f44b2c0f96e7e5a927b8c4f8c3adf6aa0f3a7dc983c5dfa77a8
+  data.tar.gz: e49a23655e5ce4f4ded50c5ac0c90d7892c41bd526dbdfe72ad85cca4891098b
 SHA512:
-  metadata.gz: 0a3668dd377838665e75b6c8325efbe237e379823deb060acdf5c7be26d799ab4eee65e94a75b50e9ffc27c81693cb0158765402d9d6f4ddbacc3c1b3be531d4
-  data.tar.gz: 759a4a692997d50022f26fd6e5fbf06859a93a00b5d371286a084ffbcb98d3571d72eeb1d3c8d733b4b8917d195c236f7dac3654e4fddae8cb9c2cf7b2f9ab42
+  metadata.gz: 37e3b09a059bb7875c797f50f60642b080f20a081fa2540f74837ac51a8cb9c1aa5b93e6502dd9f242d178f68ea654c0619b2e55d4cb934e36badca4a5057d1c
+  data.tar.gz: cd9fc830b8b4f5387478d7e6c32260672a9332bb2faf3aa7afcb4d71bf7c39481616f7f33d731229a6099e44dac84bbecd651c3618593f6c7ba872b9e958a3cb

data/CHANGELOG.md

@@ -1,3 +1,35 @@
+## 0.18.0 - 2021-11-04
+
+### Added
+
+* [HexaPDF::Content::ColorSpace::serialize_device_color] for serialization of
+  device colors in parts other than the canvas
+* [HexaPDF::Type::AcroForm::VariableTextField::create_appearance_string] for
+  centralized creation of appearance strings
+* [HexaPDF::Object.make_direct] for making objects and all parts of them direct
+  instead of indirect
+
+### Changed
+
+* [HexaPDF::Type::AcroForm::VariableTextField::parse_appearance_string] to also
+  return the font color
+* [HexaPDF::Type::AcroForm::VariableTextField#set_default_appearance_string] to
+  allow specifying the font color
+* [HexaPDF::Type::AcroForm::Form] methods to support new variable text field
+  methods
+* [HexaPDF::Type::AcroForm::AppearanceGenerator] to support the set font color
+  when creating text field appearances
+
+### Fixed
+
+* Writing of existing, encrypted PDF files where parts of the encryption
+  dictionary are indirect objects
+* [HexaPDF::Content::GraphicObject::EndpointArc] to correctly determine the
+  start and end points
+* [HexaPDF::Dictionary#perform_validation] to correctly handle objects that
+  should not be indirect objects
+
+
 ## 0.17.3 - 2021-10-31
 
 ### Fixed

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

@@ -49,8 +49,8 @@ module HexaPDF
       # Examples:
       #
       #   #>pdf-center
-      #   arc = canvas.graphic_object(:endpoint_arc, x: 50, y: 20, a: 30, b: 10).stroke
-      #   arc.move_to(0, 0).draw(canvas).stroke    # or: canvas.draw(arc).stroke
+      #   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
@@ -251,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/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/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/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

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

@@ -157,8 +157,8 @@ 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+ or
-        #     +font_options+ is specified but +font+ isn't, the font Helvetica is used.
+        #     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.
@@ -169,15 +169,20 @@ module HexaPDF
         #     A hash with font options like :variant that should be used.
         #
         # +font_size+::
-        #     The font size that should be used. If +font+ or +font_options+ is specified but
-        #     +font_size+ isn't, font size defaults to 0 (= auto-sizing).
+        #     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).
+        #
+        # +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).
         #
         # +align+::
         #     The alignment of the text, either :left, :center or :right.
-        def create_text_field(name, font: nil, font_options: nil, font_size: nil, align: nil)
+        def create_text_field(name, font: nil, font_options: nil, font_size: nil, font_color: nil,
+                              align: nil)
           create_field(name, :Tx) do |field|
             apply_variable_text_properties(field, font: font, font_options: font_options,
-                                           font_size: font_size, align: align)
+                                           font_size: font_size, font_color: font_color, align: align)
           end
         end
 
@@ -189,11 +194,11 @@ module HexaPDF
         # The optional keyword arguments allow setting often used properties of the field, see
         # #create_text_field for details.
         def create_multiline_text_field(name, font: nil, font_options: nil, font_size: nil,
-                                        align: nil)
+                                        font_color: nil, align: nil)
           create_field(name, :Tx) do |field|
             field.initialize_as_multiline_text_field
             apply_variable_text_properties(field, font: font, font_options: font_options,
-                                           font_size: font_size, align: align)
+                                           font_size: font_size, font_color: font_color, align: align)
           end
         end
 
@@ -208,11 +213,11 @@ module HexaPDF
         # The optional keyword arguments allow setting often used properties of the field, see
         # #create_text_field for details.
         def create_comb_text_field(name, max_chars:, font: nil, font_options: nil, font_size: nil,
-                                   align: nil)
+                                   font_color: nil, align: nil)
           create_field(name, :Tx) do |field|
             field.initialize_as_comb_text_field
             apply_variable_text_properties(field, font: font, font_options: font_options,
-                                           font_size: font_size, align: align)
+                                           font_size: font_size, font_color: font_color, align: align)
             field[:MaxLen] = max_chars
           end
         end
@@ -224,11 +229,12 @@ module HexaPDF
         #
         # The optional keyword arguments allow setting often used properties of the field, see
         # #create_text_field for details.
-        def create_file_select_field(name, font: nil, font_options: nil, font_size: nil, align: nil)
+        def create_file_select_field(name, font: nil, font_options: nil, font_size: nil,
+                                     font_color: nil, align: nil)
           create_field(name, :Tx) do |field|
             field.initialize_as_file_select_field
             apply_variable_text_properties(field, font: font, font_options: font_options,
-                                           font_size: font_size, align: align)
+                                           font_size: font_size, font_color: font_color, align: align)
           end
         end
 
@@ -239,11 +245,12 @@ module HexaPDF
         #
         # The optional keyword arguments allow setting often used properties of the field, see
         # #create_text_field for details.
-        def create_password_field(name, font: nil, font_options: nil, font_size: nil, align: nil)
+        def create_password_field(name, font: nil, font_options: nil, font_size: nil,
+                                  font_color: nil, align: nil)
           create_field(name, :Tx) do |field|
             field.initialize_as_password_field
             apply_variable_text_properties(field, font: font, font_options: font_options,
-                                           font_size: font_size, align: align)
+                                           font_size: font_size, font_color: font_color, align: align)
           end
         end
 
@@ -280,13 +287,13 @@ module HexaPDF
         # +font+, +font_options+, +font_size+ and +align+::
         #     See #create_text_field
         def create_combo_box(name, option_items: nil, editable: nil, font: nil,
-                             font_options: nil, font_size: nil, align: nil)
+                             font_options: nil, font_size: nil, font_color: nil, align: nil)
           create_field(name, :Ch) do |field|
             field.initialize_as_combo_box
             field.option_items = option_items if option_items
             field.flag(:edit) if editable
             apply_variable_text_properties(field, font: font, font_options: font_options,
-                                           font_size: font_size, align: align)
+                                           font_size: font_size, font_color: font_color, align: align)
           end
         end
 
@@ -306,13 +313,13 @@ module HexaPDF
         # +font+, +font_options+, +font_size+ and +align+::
         #     See #create_text_field.
         def create_list_box(name, option_items: nil, multi_select: nil, font: nil,
-                            font_options: nil, font_size: nil, align: nil)
+                            font_options: nil, font_size: nil, font_color: nil, align: nil)
           create_field(name, :Ch) do |field|
             field.initialize_as_list_box
             field.option_items = option_items if option_items
             field.flag(:multi_select) if multi_select
             apply_variable_text_properties(field, font: font, font_options: font_options,
-                                           font_size: font_size, align: align)
+                                           font_size: font_size, font_color: font_color, align: align)
           end
         end
 
@@ -322,13 +329,16 @@ module HexaPDF
                                       type: :XXResources)
         end
 
-        # Sets the global default appearance string using the provided values.
+        # Sets the global default appearance string using the provided values or the default values
+        # which provide a sane default.
         #
-        # The default argument values are a sane default. If +font_size+ is set to 0, the font size
-        # is calculated using the height/width of the field.
-        def set_default_appearance_string(font: 'Helvetica', font_size: 0)
-          name = default_resources.add_font(document.fonts.add(font).pdf_object)
-          self[:DA] = "0 g /#{name} #{font_size} Tf"
+        # See VariableTextField::create_appearance_string for information on the arguments.
+        def set_default_appearance_string(font: 'Helvetica', font_options: {}, font_size: 0,
+                                          font_color: 0)
+          self[:DA] = VariableTextField.create_appearance_string(document, font: font,
+                                                                 font_options: font_options,
+                                                                 font_size: font_size,
+                                                                 font_color: font_color)
         end
 
         # Sets the /NeedAppearances field to +true+.
@@ -420,11 +430,12 @@ 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,
-                                           align: nil)
-          if font || font_options || font_size
+                                           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_size: font_size || 0,
+                                                font_color: font_color || 0)
           end
           field.text_alignment(align) if align
         end
@@ -437,7 +448,7 @@ module HexaPDF
               yield("When the field /DA is present, the field /DR must also be present")
               return
             end
-            font_name, _ = VariableTextField.parse_appearance_string(da)
+            font_name, = VariableTextField.parse_appearance_string(da)
             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

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

@@ -37,7 +37,7 @@
 require 'hexapdf/dictionary'
 require 'hexapdf/stream'
 require 'hexapdf/error'
-require 'hexapdf/content/parser'
+require 'hexapdf/content'
 
 module HexaPDF
   module Type
@@ -61,14 +61,53 @@ module HexaPDF
 
         UNSET_ARG = ::Object.new # :nodoc:
 
-        # Parses the given appearance string. If no block is given, the appearance string is
-        # searched for font name and font size both of which are returend. Otherwise the block is
-        # called with each found content stream operator and has to handle them themselves.
+        # Creates an AcroForm appearance string for the HexaPDF +document+ from the given arguments
+        # and returns it.
+        #
+        # +font+::
+        #     The name of the font.
+        #
+        # +font_options+::
+        #     Additional font options like :variant used when loading the font. See
+        #     HexaPDF::Document::Fonts#add
+        #
+        # +font_size+::
+        #     The font size. If this is set to 0, the font size is calculated using the height/width
+        #     of the field.
+        #
+        # +font_color+::
+        #     The font color. See HexaPDF::Content::ColorSpace.device_color_from_specification for
+        #     allowed values.
+        def self.create_appearance_string(document, font: 'Helvetica', font_options: {},
+                                          font_size: 0, font_color: 0)
+          name = document.acro_form(create: true).default_resources.
+            add_font(document.fonts.add(font, **font_options).pdf_object)
+          font_color = HexaPDF::Content::ColorSpace.device_color_from_specification(font_color)
+          color_string = HexaPDF::Content::ColorSpace.serialize_device_color(font_color)
+          "#{color_string.chomp} /#{name} #{font_size} Tf"
+        end
+
+        # :call-seq:
+        #   VariableTextField.parse_appearance_string(string)  -> [font_name, font_size, font_color]
+        #   VariableTextField.parse_appearance_string(string) {|obj, params| block }   -> nil
+        #
+        # Parses the given appearance string.
+        #
+        # If no block is given, the appearance string is searched for font name, font size and font
+        # color all of which are returned. Otherwise the block is called with each found content
+        # stream operator and has to handle them itself.
         def self.parse_appearance_string(appearance_string, &block) # :yield: obj, params
-          font_params = nil
-          block ||= lambda {|obj, params| font_params = params.dup if obj == :Tf }
+          font_params = [nil, nil, nil]
+          block ||= lambda do |obj, params|
+            case obj
+            when :Tf
+              font_params[0, 2] = params
+            when :rg, :g, :k
+              font_params[2] = HexaPDF::Content::ColorSpace.prenormalized_device_color(params)
+            end
+          end
           HexaPDF::Content::Parser.parse(appearance_string.sub(/\/\//, '/'), &block)
-          font_params
+          block_given? ? nil : font_params
         end
 
         # :call-seq:
@@ -99,21 +138,20 @@ module HexaPDF
           end
         end
 
-        # Sets the default appearance string using the provided values.
-        #
-        # The default argument values are a sane default. If +font_size+ is set to 0, the font size
-        # is calculated using the height/width of the field.
+        # Sets the default appearance string using the provided values or the default values which
+        # provide a sane default.
         #
-        # Use the +font_options+ hash to provide font options like :variant, see
-        # HexaPDF::Document::Fonts#add.
-        def set_default_appearance_string(font: 'Helvetica', font_options: {}, font_size: 0)
-          name = document.acro_form(create: true).default_resources.
-            add_font(document.fonts.add(font, **font_options).pdf_object)
-          self[:DA] = "0 g /#{name} #{font_size} Tf"
+        # See ::create_appearance_string for information on the arguments.
+        def set_default_appearance_string(font: 'Helvetica', font_options: {}, font_size: 0,
+                                          font_color: 0)
+          self[:DA] = self.class.create_appearance_string(document, font: font,
+                                                          font_options: font_options,
+                                                          font_size: font_size,
+                                                          font_color: font_color)
         end
 
         # Parses the default appearance string and returns an array containing [font_name,
-        # font_size].
+        # font_size, font_color].
         #
         # The default appearance string is taken from the field or, if not set, the default
         # appearance string of the form.

data/lib/hexapdf/type/annotations/widget.rb

@@ -268,6 +268,7 @@ module HexaPDF
             style ||= (field.check_box? ? :check : :cicrle)
             size ||= 0
             color = Content::ColorSpace.device_color_from_specification(color || 0)
+            serialized_color = Content::ColorSpace.serialize_device_color(color)
 
             self[:MK] ||= {}
             self[:MK][:CA] = case style
@@ -281,13 +282,6 @@ module HexaPDF
                              else
                                raise ArgumentError, "Unknown value #{style} for argument 'style'"
                              end
-            operator = case color.color_space.family
-                       when :DeviceRGB then :rg
-                       when :DeviceGray then :g
-                       when :DeviceCMYK then :k
-                       end
-            serialized_color = Content::Operator::DEFAULT_OPERATORS[operator].
-              serialize(HexaPDF::Serializer.new, *color.components)
             self[:DA] = "/ZaDb #{size} Tf #{serialized_color}".strip
           else
             style = case self[:MK]&.[](:CA)
@@ -306,16 +300,10 @@ module HexaPDF
                       end
                     end
             size = 0
-            color = [0]
+            color = HexaPDF::Content::ColorSpace.prenormalized_device_color([0])
             if (da = self[:DA] || field[:DA])
-              HexaPDF::Type::AcroForm::VariableTextField.parse_appearance_string(da) do |obj, params|
-                case obj
-                when :rg, :g, :k then color = params.dup
-                when :Tf then size = params[1]
-                end
-              end
+              _, size, color = HexaPDF::Type::AcroForm::VariableTextField.parse_appearance_string(da)
             end
-            color = HexaPDF::Content::ColorSpace.prenormalized_device_color(color)
 
             MarkerStyle.new(style, size, color)
           end

data/lib/hexapdf/version.rb

@@ -37,6 +37,6 @@
 module HexaPDF
 
   # The version of HexaPDF.
-  VERSION = '0.17.3'
+  VERSION = '0.18.0'
 
 end

data/test/hexapdf/content/graphic_object/test_endpoint_arc.rb

@@ -55,21 +55,29 @@ describe HexaPDF::Content::GraphicObject::EndpointArc do
 
     it "draws the arc onto the canvas" do
       {
-        [false, false] => {cx: 100, cy: 50, start_angle: 180, end_angle: 270, clockwise: false},
-        [false, true] => {cx: 50, cy: 25, start_angle: 90, end_angle: 0, clockwise: true},
-        [true, false] => {cx: 50, cy: 25, start_angle: 90, end_angle: 360, clockwise: false},
-        [true, true] => {cx: 100, cy: 50, start_angle: 180, end_angle: -90, clockwise: true},
+        [false, false] => {cx: 100, cy: 50, a: 50, b: 25, start_angle: 180, end_angle: 270, clockwise: false},
+        [false, true] => {cx: 50, cy: 25, a: 50, b: 25, start_angle: 90, end_angle: 0, clockwise: true},
+        [true, false] => {cx: 50, cy: 25, a: 50, b: 25, start_angle: 90, end_angle: 360, clockwise: false},
+        [true, true] => {cx: 0, cy: 0, a: 40, b: 30, start_angle: 60, end_angle: 120},
       }.each do |(large_arc, clockwise), data|
         @page.delete(:Contents)
         canvas = @page.canvas
-        canvas.draw(:arc, a: 50, b: 25, inclination: 0, **data)
+        arc = canvas.graphic_object(:arc, **data)
+        canvas.draw(arc)
         arc_data = @page.contents
 
         canvas.contents.clear
         assert(@page.contents.empty?)
-        canvas.move_to(50.0, 50.0)
-        canvas.draw(:endpoint_arc, x: 100, y: 25, a: 50, b: 25, inclination: 0,
-                    large_arc: large_arc, clockwise: clockwise)
+        canvas.move_to(*arc.start_point)
+        earc = canvas.graphic_object(:endpoint_arc, x: arc.end_point[0], y: arc.end_point[1],
+                                     a: data[:a], b: data[:b], inclination: data[:inclination] || 0,
+                                     large_arc: large_arc, clockwise: clockwise)
+        canvas.draw(earc)
+        narc = canvas.graphic_object(:arc, **earc.send(:compute_arc_values, *arc.start_point))
+        assert_in_delta(arc.start_point[0], narc.start_point[0], 0.0001)
+        assert_in_delta(arc.start_point[1], narc.start_point[1], 0.0001)
+        assert_in_delta(arc.end_point[0], narc.end_point[0], 0.0001)
+        assert_in_delta(arc.end_point[1], narc.end_point[1], 0.0001)
         assert_equal(arc_data, @page.contents)
       end
     end

data/test/hexapdf/content/test_color_space.rb

@@ -99,6 +99,32 @@ describe HexaPDF::Content::ColorSpace do
     end
   end
 
+  describe "self.serialize_device_color" do
+    it "works for device gray colors" do
+      color = @class.device_color_from_specification(0.5)
+      assert_equal("0.5 g\n", @class.serialize_device_color(color))
+      assert_equal("0.5 G\n", @class.serialize_device_color(color, type: :stroke))
+    end
+
+    it "works for device RGB colors" do
+      color = @class.device_color_from_specification("red")
+      assert_equal("1.0 0.0 0.0 rg\n", @class.serialize_device_color(color))
+      assert_equal("1.0 0.0 0.0 RG\n", @class.serialize_device_color(color, type: :stroke))
+    end
+
+    it "works for device CMYK colors" do
+      color = @class.device_color_from_specification([100, 100, 100, 0])
+      assert_equal("1.0 1.0 1.0 0.0 k\n", @class.serialize_device_color(color))
+      assert_equal("1.0 1.0 1.0 0.0 K\n", @class.serialize_device_color(color, type: :stroke))
+    end
+
+    it "fails if no device color is provided" do
+      assert_raises(ArgumentError) do
+        @class.serialize_device_color(@class::Universal.new([]).default_color)
+      end
+    end
+  end
+
   it "returns a device color object for prenormalized color values" do
     assert_equal([5, 6, 7], @class.prenormalized_device_color([5, 6, 7]).components)
   end

data/test/hexapdf/encryption/test_security_handler.rb

@@ -107,9 +107,11 @@ describe HexaPDF::Encryption::SecurityHandler do
       end
 
       it "updates the trailer's /Encrypt entry to be wrapped by an encryption dictionary" do
-        @document.trailer[:Encrypt] = {Filter: :Test, V: 1}
+        @document.trailer[:Encrypt] = {Filter: :Test,
+                                       V: HexaPDF::Object.new(1, oid: 1, document: @document)}
         HexaPDF::Encryption::SecurityHandler.set_up_decryption(@document)
         assert_kind_of(HexaPDF::Encryption::EncryptionDictionary, @document.trailer[:Encrypt])
+        assert_equal({Filter: :Test, V: 1}, @document.trailer[:Encrypt].value)
       end
 
       it "returns the frozen security handler" do

data/test/hexapdf/test_dictionary.rb

@@ -20,6 +20,7 @@ describe HexaPDF::Dictionary do
   end
 
   def delete(_obj)
+    _obj.data.value = nil
   end
 
   def wrap(obj, type:)

data/test/hexapdf/test_object.rb

@@ -45,6 +45,34 @@ describe HexaPDF::Object do
     end
   end
 
+  describe "class.make_direct" do
+    before do
+      @doc = HexaPDF::Document.new
+    end
+
+    it "doesn't touch wrapped direct objects" do
+      obj = HexaPDF::Object.new(5)
+      assert_same(obj, HexaPDF::Object.make_direct(obj))
+    end
+
+    it "works for simple values" do
+      obj = HexaPDF::Object.new(5, oid: 1, document: @doc)
+      assert_same(5, HexaPDF::Object.make_direct(obj))
+    end
+
+    it "works for hashes" do
+      obj = HexaPDF::Dictionary.new({a: 5, b: HexaPDF::Object.new(:a, oid: 3, document: @doc)},
+                                    oid: 1, document: @doc)
+      assert_equal({a: 5, b: :a}, HexaPDF::Object.make_direct(obj))
+    end
+
+    it "works for arrays" do
+      obj = HexaPDF::PDFArray.new([:b, HexaPDF::Object.new(:a, oid: 3, document: @doc)],
+                                    oid: 1, document: @doc)
+      assert_equal([:b, :a], HexaPDF::Object.make_direct(obj))
+    end
+  end
+
   describe "initialize" do
     it "uses a simple value as is" do
       obj = HexaPDF::Object.new(5)

data/test/hexapdf/test_writer.rb

@@ -40,7 +40,7 @@ describe HexaPDF::Writer do
       219
       %%EOF
       3 0 obj
-      <</Producer(HexaPDF version 0.17.3)>>
+      <</Producer(HexaPDF version 0.18.0)>>
       endobj
       xref
       3 1
@@ -72,7 +72,7 @@ describe HexaPDF::Writer do
       141
       %%EOF
       6 0 obj
-      <</Producer(HexaPDF version 0.17.3)>>
+      <</Producer(HexaPDF version 0.18.0)>>
       endobj
       2 0 obj
       <</Length 10>>stream

data/test/hexapdf/type/acro_form/test_appearance_generator.rb

@@ -499,6 +499,7 @@ describe HexaPDF::Type::AcroForm::AppearanceGenerator do
 
       it "creates the /N appearance stream according to the set string" do
         @field.field_value = 'Text'
+        @field.set_default_appearance_string(font_color: "red")
         @generator.create_appearances
         assert_operators(@widget[:AP][:N].stream,
                          [[:begin_marked_content, [:Tx]],
@@ -507,6 +508,7 @@ describe HexaPDF::Type::AcroForm::AppearanceGenerator do
                           [:clip_path_non_zero],
                           [:end_path],
                           [:set_font_and_size, [:F1, 6.641436]],
+                          [:set_device_rgb_non_stroking_color, [1.0, 0.0, 0.0]],
                           [:begin_text],
                           [:set_text_matrix, [1, 0, 0, 1, 2, 3.240724]],
                           [:show_text, ["Text"]],
@@ -556,6 +558,7 @@ describe HexaPDF::Type::AcroForm::AppearanceGenerator do
 
       it "creates the /N appearance stream according to the set string" do
         @field.field_value = "Test\nValue"
+        @field.set_default_appearance_string(font_size: 10, font_color: "red")
         @generator.create_appearances
         assert_operators(@widget[:AP][:N].stream,
                          [[:begin_marked_content, [:Tx]],
@@ -566,6 +569,7 @@ describe HexaPDF::Type::AcroForm::AppearanceGenerator do
                           [:save_graphics_state],
                           [:set_leading, [11.5625]],
                           [:set_font_and_size, [:F1, 10]],
+                          [:set_device_rgb_non_stroking_color, [1.0, 0.0, 0.0]],
                           [:begin_text],
                           [:set_text_matrix, [1, 0, 0, 1, 2, 16.195]],
                           [:show_text, ['Test']],
@@ -653,6 +657,7 @@ describe HexaPDF::Type::AcroForm::AppearanceGenerator do
 
       it "creates the /N appearance stream according to the set string" do
         @field.field_value = 'Text'
+        @field.set_default_appearance_string(font_size: 10, font_color: "red")
         @generator.create_appearances
         assert_operators(@widget[:AP][:N].stream,
                          [[:begin_marked_content, [:Tx]],
@@ -661,6 +666,7 @@ describe HexaPDF::Type::AcroForm::AppearanceGenerator do
                           [:clip_path_non_zero],
                           [:end_path],
                           [:set_font_and_size, [:F1, 10]],
+                          [:set_device_rgb_non_stroking_color, [1.0, 0.0, 0.0]],
                           [:begin_text],
                           [:set_text_matrix, [1, 0, 0, 1, 2.945, 6.41]],
                           [:show_text_with_positioning, [['T', -416.5, 'e', -472, 'x', -611, 't']]],
@@ -721,6 +727,7 @@ describe HexaPDF::Type::AcroForm::AppearanceGenerator do
         it "creates the /N appearance stream" do
           @field[:I] = [1, 2]
           @field[:V] = ['b', 'c']
+          @field.set_default_appearance_string(font_size: 12, font_color: "red")
           @generator.create_appearances
           assert_operators(@widget[:AP][:N].stream,
                            [[:begin_marked_content, [:Tx]],
@@ -734,7 +741,7 @@ describe HexaPDF::Type::AcroForm::AppearanceGenerator do
                             [:save_graphics_state],
                             [:set_leading, [13.875]],
                             [:set_font_and_size, [:F1, 12]],
-                            [:set_device_gray_non_stroking_color, [0.0]],
+                            [:set_device_rgb_non_stroking_color, [1.0, 0.0, 0.0]],
                             [:begin_text],
                             [:set_text_matrix, [1, 0, 0, 1, 2, 23.609]],
                             [:show_text, ["a"]],

data/test/hexapdf/type/acro_form/test_form.rb

@@ -8,6 +8,7 @@ describe HexaPDF::Type::AcroForm::Form do
   before do
     @doc = HexaPDF::Document.new
     @acro_form = @doc.add({Fields: []}, type: :XXAcroForm)
+    @doc.catalog[:AcroForm] = @acro_form
   end
 
   describe "signature flags" do
@@ -140,12 +141,13 @@ describe HexaPDF::Type::AcroForm::Form do
 
     def applies_variable_text_properties(method, **args)
       field = @acro_form.send(method, "field", **args, font: 'Times')
-      font_name, font_size = field.parse_default_appearance_string
+      font_name, font_size, font_color = field.parse_default_appearance_string
       assert_equal(:'Times-Roman', @acro_form.default_resources.font(font_name)[:BaseFont])
       assert_equal(0, font_size)
+      assert_equal(HexaPDF::Content::ColorSpace::DeviceGray.new.color(0), font_color)
 
       field = @acro_form.send(method, "field", **args, font_options: {variant: :bold})
-      font_name, font_size = field.parse_default_appearance_string
+      font_name, = field.parse_default_appearance_string
       assert_equal(:'Helvetica-Bold', @acro_form.default_resources.font(font_name)[:BaseFont])
 
       field = @acro_form.send(method, "field", **args, font_size: 10)
@@ -153,6 +155,10 @@ describe HexaPDF::Type::AcroForm::Form do
       assert_equal(:Helvetica, @acro_form.default_resources.font(font_name)[:BaseFont])
       assert_equal(10, font_size)
 
+      field = @acro_form.send(method, "field", **args, font_color: "red")
+      _, _, font_color = field.parse_default_appearance_string
+      assert_equal(HexaPDF::Content::ColorSpace::DeviceRGB.new.color(255, 0, 0), font_color)
+
       field = @acro_form.send(method, "field", **args, font: 'Courier', font_size: 10, align: :center)
       font_name, font_size = field.parse_default_appearance_string
       assert_equal(:Courier, @acro_form.default_resources.font(font_name)[:BaseFont])
@@ -229,16 +235,17 @@ describe HexaPDF::Type::AcroForm::Form do
   describe "set_default_appearance_string" do
     it "uses sane default values if no arguments are provided" do
       @acro_form.set_default_appearance_string
-      assert_equal("0 g /F1 0 Tf", @acro_form[:DA])
+      assert_equal("0.0 g /F1 0 Tf", @acro_form[:DA])
       font = @acro_form.default_resources.font(:F1)
       assert(font)
       assert_equal(:Helvetica, font[:BaseFont])
     end
 
-    it "allows specifying the used font and font size" do
-      @acro_form.set_default_appearance_string(font: 'Times', font_size: 10)
-      assert_equal("0 g /F1 10 Tf", @acro_form[:DA])
-      assert_equal(:'Times-Roman', @acro_form.default_resources.font(:F1)[:BaseFont])
+    it "allows specifying the used font, font size and font color" do
+      @acro_form.set_default_appearance_string(font: 'Times', font_options: {variant: :bold},
+                                               font_size: 10, font_color: "red")
+      assert_equal("1.0 0.0 0.0 rg /F1 10 Tf", @acro_form[:DA])
+      assert_equal(:'Times-Bold', @acro_form.default_resources.font(:F1)[:BaseFont])
     end
   end
 
@@ -333,7 +340,7 @@ describe HexaPDF::Type::AcroForm::Form do
 
     it "set the default appearance string, though optional, to a valid value to avoid problems" do
       assert(@acro_form.validate)
-      assert_equal("0 g /F1 0 Tf", @acro_form[:DA])
+      assert_equal("0.0 g /F1 0 Tf", @acro_form[:DA])
     end
 
     describe "automatically creates the terminal fields; appearances" do

data/test/hexapdf/type/acro_form/test_variable_text_field.rb

@@ -31,7 +31,7 @@ describe HexaPDF::Type::AcroForm::VariableTextField do
     end
   end
 
-  describe "set_default_appearance_string" do
+  describe "set_default_appearance_string / self.create_appearance_string" do
     it "creates the AcroForm object if it doesn't exist" do
       @doc.catalog.delete(:AcroForm)
       @field.set_default_appearance_string
@@ -40,7 +40,7 @@ describe HexaPDF::Type::AcroForm::VariableTextField do
 
     it "uses sane default values if no arguments are provided" do
       @field.set_default_appearance_string
-      assert_equal("0 g /F1 0 Tf", @field[:DA])
+      assert_equal("0.0 g /F1 0 Tf", @field[:DA])
       font = @doc.acro_form.default_resources.font(:F1)
       assert(font)
       assert_equal(:Helvetica, font[:BaseFont])
@@ -48,36 +48,46 @@ describe HexaPDF::Type::AcroForm::VariableTextField do
 
     it "allows specifying the font" do
       @field.set_default_appearance_string(font: 'Times')
-      assert_equal("0 g /F2 0 Tf", @field[:DA])
+      assert_equal("0.0 g /F2 0 Tf", @field[:DA])
       assert_equal(:'Times-Roman', @doc.acro_form.default_resources.font(:F2)[:BaseFont])
     end
 
     it "allows specifying the font options" do
       @field.set_default_appearance_string(font_options: {variant: :italic})
-      assert_equal("0 g /F2 0 Tf", @field[:DA])
+      assert_equal("0.0 g /F2 0 Tf", @field[:DA])
       assert_equal(:'Helvetica-Oblique', @doc.acro_form.default_resources.font(:F2)[:BaseFont])
     end
 
     it "allows specifying the font size" do
       @field.set_default_appearance_string(font_size: 10)
-      assert_equal("0 g /F1 10 Tf", @field[:DA])
+      assert_equal("0.0 g /F1 10 Tf", @field[:DA])
+    end
+
+    it "allows specifying the font color" do
+      @field.set_default_appearance_string(font_color: "red")
+      assert_equal("1.0 0.0 0.0 rg /F1 0 Tf", @field[:DA])
     end
   end
 
   describe "parse_default_appearance_string" do
+    before do
+      @color = HexaPDF::Content::ColorSpace.prenormalized_device_color([1])
+    end
+
     it "parses the default appearance string of the field" do
       @field[:DA] = "1 g //F1 20 Tf 5 w /F2 10 Tf"
-      assert_equal([:F2, 10], @field.parse_default_appearance_string)
+      assert_equal([:F2, 10, @color], @field.parse_default_appearance_string)
     end
 
     it "uses the default appearance string of a parent field" do
       parent = @doc.add({DA: "/F1 15 Tf"}, type: :XXAcroFormField)
       @field[:Parent] = parent
-      assert_equal([:F1, 15], @field.parse_default_appearance_string)
+      assert_equal([:F1, 15, nil], @field.parse_default_appearance_string)
     end
 
     it "uses the global default appearance string" do
-      assert_equal([:F1, 0], @field.parse_default_appearance_string)
+      assert_equal([:F1, 0, HexaPDF::Content::ColorSpace.prenormalized_device_color([0])],
+                   @field.parse_default_appearance_string)
     end
 
     it "fails if no /DA value is set" do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hexapdf
 version: !ruby/object:Gem::Version
-  version: 0.17.3
+  version: 0.18.0
 platform: ruby
 authors:
 - Thomas Leitner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-10-31 00:00:00.000000000 Z
+date: 2021-11-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cmdparse