hexapdf 0.33.0 → 0.34.1

data/lib/hexapdf/type/page.rb

@@ -261,12 +261,23 @@ module HexaPDF
       # Rotates the page +angle+ degrees counterclockwise where +angle+ has to be a multiple of 90.
       #
       # Positive values rotate the page to the left, negative values to the right. If +flatten+ is
-      # +true+, the rotation is not done via the page's meta data but by "rotating" the canvas
-      # itself.
+      # +true+, the rotation is not done via the page's meta (i.e. the /Rotate key) data but by
+      # rotating the canvas itself and all other necessary objects like the various page boxes and
+      # annotations.
       #
-      # Note that the :Rotate key of a page object describes the angle in a clockwise orientation
-      # but this method uses counterclockwise rotation to be consistent with other rotation methods
-      # (e.g. HexaPDF::Content::Canvas#rotate).
+      # Notes:
+      #
+      # * The given +angle+ is applied in addition to a possibly already existing rotation
+      #   (specified via the /Rotate key) and does not replace it.
+      #
+      # * Specifying 0 for +angle+ is valid and means that no additional rotation should be applied.
+      #   The only meaningful usage of 0 for +angle+ is when +flatten+ is set to +true+ (so that the
+      #   /Rotate key is removed and the existing rotation information incorporated into the canvas,
+      #   page boxes and annotations).
+      #
+      # * The /Rotate key of a page object describes the angle in a clockwise orientation but this
+      #   method uses counterclockwise rotation to be consistent with other rotation methods (e.g.
+      #   HexaPDF::Content::Canvas#rotate).
       def rotate(angle, flatten: false)
         if angle % 90 != 0
           raise ArgumentError, "Page rotation has to be multiple of 90 degrees"
@@ -423,7 +434,7 @@ module HexaPDF
       #
       #    To check whether the origin has been translated or not, use
       #
-      #      canvas.graphics_state.ctm.evaluate(0, 0)
+      #      canvas.pos(0, 0)
       #
       #    and check whether the result is [0, 0]. If it is, then the origin has not been
       #    translated.
@@ -523,7 +534,7 @@ module HexaPDF
       def each_annotation
         return to_enum(__method__) unless block_given?
         Array(self[:Annots]).each do |annotation|
-          next unless annotation&.key?(:Subtype) && annotation&.key?(:Rect)
+          next unless annotation?(annotation)
           yield(document.wrap(annotation, type: :Annot))
         end
         self
@@ -540,17 +551,19 @@ module HexaPDF
       # field itself.
       def flatten_annotations(annotations = self[:Annots])
         not_flattened = Array(annotations) || []
-        return not_flattened unless key?(:Annots)
+        unless self[:Annots].kind_of?(PDFArray)
+          return (not_flattened == [annotations] ? [] : not_flattened)
+        end
 
         annotations = if annotations == self[:Annots]
                         not_flattened
                       else
-                        not_flattened & Array(self[:Annots])
+                        not_flattened & self[:Annots]
                       end
         return not_flattened if annotations.empty?
 
         canvas = self.canvas(type: :overlay)
-        if (pos = canvas.graphics_state.ctm.evaluate(0, 0)) != [0, 0]
+        if (pos = canvas.pos(0, 0)) != [0, 0]
           canvas.save_graphics_state
           canvas.translate(-pos[0], -pos[1])
         end
@@ -558,8 +571,8 @@ module HexaPDF
         to_delete = []
         not_flattened -= annotations
         annotations.each do |annotation|
-          unless annotation&.key?(:Subtype) && annotation&.key?(:Rect)
-            to_delete << annotation if annotation
+          unless annotation?(annotation)
+            self[:Annots].delete(annotation)
             next
           end
 
@@ -592,13 +605,18 @@ module HexaPDF
           end
 
           # Step 2) Fit calculated rectangle to annotation rectangle by translating/scaling
-          a = HexaPDF::Content::TransformationMatrix.new
-          a.translate(rect.left - left, rect.bottom - bottom)
-          a.scale(rect.width.fdiv(right - left), rect.height.fdiv(top - bottom))
+
+          # The final matrix is composed by translating the bottom-left corner of the transformed
+          # bounding box to the bottom-left corner of the annotation rectangle and scaling from the
+          # bottom-left corner of the transformed bounding box.
+          sx = rect.width.fdiv(right - left)
+          sy = rect.height.fdiv(top - bottom)
+          tx = rect.left - left + left - left * sx
+          ty = rect.bottom - bottom + bottom - bottom * sy
 
           # Step 3) Premultiply form matrix - done implicitly when drawing the XObject
 
-          canvas.transform(*a) do
+          canvas.transform(sx, 0, 0, sy, tx, ty) do
             # Use [box.left, box.bottom] to counter default translation in #xobject since that
             # is already taken care of in matrix a
             canvas.xobject(appearance, at: [box.left, box.bottom])
@@ -621,6 +639,12 @@ module HexaPDF
 
       private
 
+      # Returns +true+ if the given object seems to be an annotation.
+      def annotation?(obj)
+        (obj.kind_of?(Hash) || obj.kind_of?(Dictionary)) &&
+          obj&.key?(:Subtype) && obj&.key?(:Rect)
+      end
+
       # Ensures that the required inheritable fields are set.
       def perform_validation(&block)
         root_node = document.catalog.pages

data/lib/hexapdf/type/page_label.rb

@@ -103,8 +103,7 @@ module HexaPDF
         end
       end
 
-      # :nodoc:
-      NUMBERING_STYLE_MAPPING = {
+      NUMBERING_STYLE_MAPPING = { # :nodoc:
         decimal: :D, D: :D,
         uppercase_roman: :R, R: :R,
         lowercase_roman: :r, r: :r,
@@ -113,8 +112,7 @@ module HexaPDF
         none: nil
       }
 
-      # :nodoc:
-      REVERSE_NUMBERING_STYLE_MAPPING = Hash[*NUMBERING_STYLE_MAPPING.flatten.reverse]
+      REVERSE_NUMBERING_STYLE_MAPPING = Hash[*NUMBERING_STYLE_MAPPING.flatten.reverse] # :nodoc:
 
       # :call-seq:
       #   page_label.numbering_style             -> numbering_style
@@ -174,8 +172,7 @@ module HexaPDF
 
       private
 
-      # :nodoc:
-      ALPHABET = ('A'..'Z').to_a
+      ALPHABET = ('A'..'Z').to_a # :nodoc:
 
       # Maps the given number to uppercase (or, if +lowercase+ is +true+, lowercase) letters (e.g. 1
       # -> A, 27 -> AA, 28 -> AB, ...).
@@ -188,8 +185,7 @@ module HexaPDF
         lowercase ? result.downcase : result
       end
 
-      # :nodoc:
-      ROMAN_NUMERAL_MAPPING = {
+      ROMAN_NUMERAL_MAPPING = { # :nodoc:
         1000 => "M",
         900 => "CM",
         500 => "D",

data/lib/hexapdf/type.rb

@@ -76,6 +76,10 @@ module HexaPDF
     autoload(:OutlineItem, 'hexapdf/type/outline_item')
     autoload(:PageLabel, 'hexapdf/type/page_label')
     autoload(:MarkInformation, 'hexapdf/type/mark_information')
+    autoload(:OptionalContentGroup, 'hexapdf/type/optional_content_group')
+    autoload(:OptionalContentMembership, 'hexapdf/type/optional_content_membership')
+    autoload(:OptionalContentProperties, 'hexapdf/type/optional_content_properties')
+    autoload(:OptionalContentConfiguration, 'hexapdf/type/optional_content_configuration')
 
   end
 

data/lib/hexapdf/utils/pdf_doc_encoding.rb

@@ -52,7 +52,6 @@ module HexaPDF
     # See: PDF2.0 s7.9.2, D.1, D.3
     module PDFDocEncoding
 
-      # :nodoc:
       CHARACTER_MAP = %W[\uFFFD \uFFFD \uFFFD \uFFFD \uFFFD \uFFFD \uFFFD \uFFFD
                          \uFFFD \u0009 \u000A \uFFFD \uFFFD \u000D \uFFFD \uFFFD
                          \uFFFD \uFFFD \uFFFD \uFFFD \uFFFD \uFFFD \uFFFD \uFFFD

data/lib/hexapdf/version.rb

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

data/test/hexapdf/content/test_canvas.rb

@@ -71,6 +71,13 @@ describe HexaPDF::Content::Canvas do
     end
   end
 
+  describe "pos" do
+    it "returns the transformed position" do
+      @canvas.translate(9, 4)
+      assert_equal([10, 5], @canvas.pos(1, 1))
+    end
+  end
+
   describe "save_graphics_state" do
     it "invokes the operator implementation" do
       assert_operator_invoked(:q) { @canvas.save_graphics_state }
@@ -1280,6 +1287,48 @@ describe HexaPDF::Content::Canvas do
     end
   end
 
+  describe "optional_content" do
+    it "invokes the marked-sequence operator implementation" do
+      assert_operator_invoked(:BDC, :OC, :P1) { @canvas.optional_content('Test') }
+    end
+
+    it "is serialized correctly when no block is used" do
+      @canvas.optional_content('Test')
+      assert_operators(@canvas.contents, [[:begin_marked_content_with_property_list, [:OC, :P1]]])
+    end
+
+    it "is serialized correctly when a block is used" do
+      @canvas.optional_content('Test') {}
+      assert_operators(@canvas.contents, [[:begin_marked_content_with_property_list, [:OC, :P1]],
+                                          [:end_marked_content]])
+    end
+
+    it "uses the provided OCG dictionary" do
+      ocg = @doc.optional_content.add_ocg('Test')
+      @canvas.optional_content(ocg)
+      assert_equal(ocg, @page.resources.property_list(:P1))
+    end
+
+    it "uses an existing OCG specified by name" do
+      ocg = @doc.optional_content.add_ocg('Test')
+      @canvas.optional_content('Test')
+      assert_equal(ocg, @page.resources.property_list(:P1))
+    end
+
+    it "creates an OCG if the named one doesn't yet exist" do
+      @canvas.optional_content('Test')
+      assert_equal(@doc.optional_content.ocg('Test'), @page.resources.property_list(:P1))
+    end
+
+    it "always creates a new OCG if use_existing_ocg is false" do
+      ocg = @doc.optional_content.add_ocg('Test')
+      @canvas.optional_content('Test', use_existing_ocg: false)
+      pl_item = @page.resources.property_list(:P1)
+      refute_equal(ocg, pl_item)
+      assert_equal(@doc.optional_content.ocgs.last, pl_item)
+    end
+  end
+
   describe "color_from_specification "do
     it "accepts a color string" do
       assert_equal([1, 0, 0], @canvas.color_from_specification("red").components)

data/test/hexapdf/content/test_operator.rb

@@ -195,7 +195,8 @@ describe_operator :SetGraphicsStateParameters, :gs do
     font.glyph_scaling_factor = 0.01
     @processor.resources[:ExtGState] = {Name: {LW: 10, LC: 2, LJ: 2, ML: 2, D: [[3, 5], 2],
                                                RI: 2, SA: true, BM: :Multiply, CA: 0.5, ca: 0.5,
-                                               AIS: true, TK: false, Font: [font, 10]}}
+                                               AIS: true, TK: false, Font: [font, 10],
+                                               SMask: {Type: :Mask, S: :Luminosity}}}
     @processor.resources.define_singleton_method(:document) do
       Object.new.tap {|obj| obj.define_singleton_method(:deref) {|o| o } }
     end
@@ -213,6 +214,7 @@ describe_operator :SetGraphicsStateParameters, :gs do
     assert_equal(0.5, gs.stroke_alpha)
     assert_equal(0.5, gs.fill_alpha)
     assert(gs.alpha_source)
+    assert_equal({Type: :Mask, S: :Luminosity}, gs.soft_mask)
     assert_equal(font, gs.font)
     assert_equal(10, gs.font_size)
     refute(gs.text_knockout)

data/test/hexapdf/document/test_layout.rb

@@ -219,6 +219,10 @@ describe HexaPDF::Document::Layout do
       box = @layout.text_box("Test", box_style: :named)
       assert_equal(20, box.style.font_size)
     end
+
+    it "raises an error if the to-be-used style doesn't exist" do
+      assert_raises(HexaPDF::Error) { @layout.text_box("Test", style: :unknown) }
+    end
   end
 
   describe "formatted_text" do
@@ -305,9 +309,10 @@ describe HexaPDF::Document::Layout do
 
     it "allows creating an inline box through a hash with a :box key" do
       block = lambda {|item| item.box(:base, width: 5, height: 15) }
-      box = @layout.formatted_text_box([{box: :list, width: 10, block: block}])
+      box = @layout.formatted_text_box([{box: :column, columns: 1, width: 100, block: block}])
       ibox = box.instance_variable_get(:@items).first
-      assert_equal(10, ibox.width)
+      ibox.fit_wrapped_box(nil)
+      assert_equal(100, ibox.width)
       assert_equal(15, ibox.height)
     end
 

data/test/hexapdf/document/test_pages.rb

@@ -196,15 +196,15 @@ describe HexaPDF::Document::Pages do
     end
 
     it "works for multiple page label entries" do
-      @doc.catalog[:PageLabels] = {Nums: [0, {S: :r}, 2, {S: :d}, 7, {S: :A}]}
+      @doc.catalog[:PageLabels] = {Nums: [0, {S: :r}, 2, {S: :D}, 7, {S: :A}]}
       result = @doc.pages.each_labelling_range.to_a
-      assert_equal([[0, 2, {S: :r}], [2, 5, {S: :d}], [7, 3, {S: :A}]],
+      assert_equal([[0, 2, {S: :r}], [2, 5, {S: :D}], [7, 3, {S: :A}]],
                    result.map {|s, c, l| [s, c, l.value] })
     end
 
     it "returns a zero or negative count for the last range if there aren't enough pages" do
       assert_equal(10, @doc.pages.count)
-      @doc.catalog[:PageLabels] = {Nums: [0, {S: :d}, 10, {S: :r}]}
+      @doc.catalog[:PageLabels] = {Nums: [0, {S: :D}, 10, {S: :r}]}
       assert_equal(0, @doc.pages.each_labelling_range.to_a[-1][1])
       @doc.catalog[:PageLabels][:Nums][2] = 11
       assert_equal(-1, @doc.pages.each_labelling_range.to_a[-1][1])
@@ -221,19 +221,19 @@ describe HexaPDF::Document::Pages do
 
     it "adds an entry for the range starting at 0 if it doesn't exist" do
       label = @doc.pages.add_labelling_range(5)
-      assert_equal([{S: :d}, label],
+      assert_equal([{S: :D}, label],
                    @doc.catalog.page_labels[:Nums].value.values_at(1, 3))
     end
   end
 
   describe "delete_labelling_range" do
     before do
-      @doc.catalog[:PageLabels] = {Nums: [0, {S: :r}, 5, {S: :d}]}
+      @doc.catalog[:PageLabels] = {Nums: [0, {S: :r}, 5, {S: :D}]}
     end
 
     it "deletes the labelling range for a given start index" do
       label = @doc.pages.delete_labelling_range(5)
-      assert_equal({S: :d}, label)
+      assert_equal({S: :D}, label)
     end
 
     it "deletes the labelling range for 0 if it is the last, together with the number tree" do

data/test/hexapdf/layout/test_box.rb

@@ -56,8 +56,8 @@ describe HexaPDF::Layout::Box do
     end
 
     it "allows setting custom properties" do
-      box = create_box(properties: {'key' => :value})
-      assert_equal({'key' => :value}, box.properties)
+      assert_equal({}, create_box(properties: nil).properties)
+      assert_equal({'key' => :value}, create_box(properties: {'key' => :value}).properties)
     end
   end
 
@@ -150,6 +150,10 @@ describe HexaPDF::Layout::Box do
   end
 
   describe "draw" do
+    before do
+      @canvas = HexaPDF::Document.new.pages.add.canvas
+    end
+
     it "draws the box onto the canvas" do
       box = create_box(width: 150, height: 130) do |canvas, _|
         canvas.line_width(15)
@@ -161,7 +165,6 @@ describe HexaPDF::Layout::Box do
       box.style.underlays.add {|canvas, _| canvas.line_width(10) }
       box.style.overlays.add {|canvas, _| canvas.line_width(20) }
 
-      @canvas = HexaPDF::Document.new.pages.add.canvas
       box.draw(@canvas, 5, 5)
       assert_operators(@canvas.contents, [[:save_graphics_state],
                                           [:set_graphics_state_parameters, [:GS1]],
@@ -195,7 +198,6 @@ describe HexaPDF::Layout::Box do
     end
 
     it "draws nothing onto the canvas if the box is empty" do
-      @canvas = HexaPDF::Document.new.pages.add.canvas
       box = create_box
       box.draw(@canvas, 5, 5)
       assert_operators(@canvas.contents, [])
@@ -204,6 +206,13 @@ describe HexaPDF::Layout::Box do
       refute(box.style.border?)
       refute(box.style.overlays?)
     end
+
+    it "wraps the box in optional content markers if the optional_content property is set" do
+      box = create_box(properties: {'optional_content' => 'Text'})
+      box.draw(@canvas, 0, 0)
+      assert_operators(@canvas.contents, [[:begin_marked_content_with_property_list, [:OC, :P1]],
+                                          [:end_marked_content]])
+    end
   end
 
   describe "empty?" do

data/test/hexapdf/layout/test_frame.rb

@@ -5,7 +5,7 @@ require 'hexapdf/layout/frame'
 require 'hexapdf/layout/box'
 require 'hexapdf/document'
 
-describe HexaPDF::Layout::Frame do
+describe HexaPDF::Layout::Frame::FitResult do
   it "shows the box's mask area on #draw when using debug output" do
     doc = HexaPDF::Document.new(config: {'debug' => true})
     canvas = doc.pages.add.canvas
@@ -15,6 +15,7 @@ describe HexaPDF::Layout::Frame do
     result.x = result.y = 0
     result.draw(canvas)
     assert_equal(<<~CONTENTS, canvas.contents)
+      /OC /P1 BDC
       q
       0.0 0.501961 0.0 rg
       0.0 0.392157 0.0 RG
@@ -22,10 +23,13 @@ describe HexaPDF::Layout::Frame do
       0 0 20 20 re
       B
       Q
+      EMC
       q
       1 0 0 1 0 0 cm
       Q
     CONTENTS
+    ocg = doc.optional_content.ocgs.first
+    assert_equal([['Debug', ocg]], doc.optional_content.default_configuration[:Order])
   end
 end
 
@@ -34,6 +38,14 @@ describe HexaPDF::Layout::Frame do
     @frame = HexaPDF::Layout::Frame.new(5, 10, 100, 150)
   end
 
+  it "allows accessing the context's document" do
+    assert_nil(@frame.document)
+    context = Minitest::Mock.new
+    context.expect(:document, :document)
+    assert_equal(:document, HexaPDF::Layout::Frame.new(0, 0, 10, 10, context: context).document)
+    context.verify
+  end
+
   it "allows access to the bounding box attributes" do
     assert_equal(5, @frame.left)
     assert_equal(10, @frame.bottom)

data/test/hexapdf/layout/test_inline_box.rb

@@ -24,25 +24,28 @@ describe HexaPDF::Layout::InlineBox do
       assert_equal(:top, ibox.valign)
     end
 
+    it "fails if the wrapped box has not width set" do
+      box = HexaPDF::Document.new.layout.text("test is not going good")
+      assert_raises(HexaPDF::Error) { inline_box(box) }
+    end
+  end
+
+  describe "fit_wrapped_box" do
     it "automatically fits the provided box into a frame" do
       ibox = inline_box(HexaPDF::Document.new.layout.text("test is going good", width: 20))
+      ibox.fit_wrapped_box(nil)
       assert_equal(20, ibox.width)
       assert_equal(45, ibox.height)
     end
 
-    it "fails if the wrapped box has not width set" do
-      box = HexaPDF::Document.new.layout.text("test is not going good")
-      assert_raises(HexaPDF::Error) { inline_box(box) }
-    end
-
     it "fails if the wrapped box could not be fit" do
       box = HexaPDF::Document.new.layout.text("test is not going good", width: 1)
-      assert_raises(HexaPDF::Error) { inline_box(box) }
+      assert_raises(HexaPDF::Error) { inline_box(box).fit_wrapped_box(nil) }
     end
 
     it "fails if the height is not set explicitly and during fitting" do
       assert_raises(HexaPDF::Error) do
-        inline_box(HexaPDF::Layout::Box.create(width: 10))
+        inline_box(HexaPDF::Layout::Box.create(width: 10)).fit_wrapped_box(nil)
       end
     end
   end
@@ -50,7 +53,9 @@ describe HexaPDF::Layout::InlineBox do
   it "draws the wrapped box at the correct position" do
     doc = HexaPDF::Document.new
     canvas = doc.pages.add.canvas
-    inline_box(doc.layout.text("", width: 20, margin: [15, 10])).draw(canvas, 100, 200)
+    box = inline_box(doc.layout.text("", width: 20, margin: [15, 10]))
+    box.fit_wrapped_box(nil)
+    box.draw(canvas, 100, 200)
     assert_equal("q\n1 0 0 1 110 -99785 cm\nQ\n", canvas.contents)
   end
 
@@ -59,6 +64,10 @@ describe HexaPDF::Layout::InlineBox do
     refute(HexaPDF::Layout::InlineBox.create(width: 10, height: 15) {}.empty?)
   end
 
+  it "returns the style of the box" do
+    assert_same(@box.box.style, @box.style)
+  end
+
   describe "valign" do
     it "has a default value of :baseline" do
       assert_equal(:baseline, @box.valign)