hexapdf 0.33.0 → 0.34.1

data/test/hexapdf/type/actions/test_set_ocg_state.rb

@@ -0,0 +1,40 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/type/actions/set_ocg_state'
+
+describe HexaPDF::Type::Actions::SetOCGState do
+  before do
+    @doc = HexaPDF::Document.new
+    @action = HexaPDF::Type::Actions::SetOCGState.new({}, document: @doc)
+    @ocg = @doc.optional_content.add_ocg('Test')
+  end
+
+  describe "add_state_change" do
+    it "allows using Ruby-esque and PDF type names for the state change type" do
+      @action.add_state_change(:on, @ocg)
+      @action.add_state_change(:ON, @ocg)
+      @action.add_state_change(:off, @ocg)
+      @action.add_state_change(:OFF, @ocg)
+      @action.add_state_change(:toggle, @ocg)
+      @action.add_state_change(:Toggle, @ocg)
+      assert_equal([:ON, @ocg, :ON, @ocg, :OFF, @ocg, :OFF, @ocg, :Toggle, @ocg, :Toggle, @ocg],
+                   @action[:State].value)
+    end
+
+    it "allows specifying more than one OCG" do
+      @action.add_state_change(:on, [@ocg, @doc.optional_content.add_ocg('Test2')])
+      assert_equal([:ON, @ocg, @doc.optional_content.ocg('Test2')], @action[:State].value)
+    end
+
+    it "raises an error if the provide state change type is invalid" do
+      assert_raises(ArgumentError) { @action.add_state_change(:unknown, nil) }
+    end
+
+    it "raises an error if an OCG specified via a string does not exist" do
+      error = assert_raises(HexaPDF::Error) { @action.add_state_change(:on, "Unknown") }
+      assert_match(/Invalid OCG.*Unknown.*specified/, error.message)
+    end
+  end
+end

data/test/hexapdf/type/test_catalog.rb

@@ -39,6 +39,17 @@ describe HexaPDF::Type::Catalog do
     assert_same(outline, @catalog.outline)
   end
 
+  it "uses or creates the optional content properties dictionary on access" do
+    @catalog[:OCProperties] = hash = {}
+    assert_equal(:XXOCProperties, @catalog.optional_content.type)
+    assert_same(hash, @catalog.optional_content.value)
+
+    @catalog.delete(:OCProperties)
+    oc = @catalog.optional_content
+    assert_equal([], oc[:OCGs])
+    assert_equal(:XXOCConfiguration, oc[:D].type)
+  end
+
   describe "acro_form" do
     it "returns an existing form object" do
       @catalog[:AcroForm] = :test

data/test/hexapdf/type/test_form.rb

@@ -1,6 +1,8 @@
 # -*- encoding: utf-8 -*-
 
 require 'test_helper'
+require 'stringio'
+require 'tempfile'
 require 'hexapdf/document'
 require 'hexapdf/type/form'
 
@@ -85,6 +87,18 @@ describe HexaPDF::Type::Form do
       @form.process_contents(processor, original_resources: resources)
       assert_same(resources, processor.resources)
     end
+
+    it "uses the referenced content in case of a Reference XObject" do
+      @form[:Ref] = @doc.add({F: {}})
+      io = StringIO.new
+      HexaPDF::Document.new.tap {|d| d.pages.add.canvas.line_width(5) }.write(io)
+      @form[:Ref][:F].embed(io, name: 'test')
+      @form[:Ref][:Page] = 0
+
+      processor = HexaPDF::TestUtils::OperatorRecorder.new
+      @form.process_contents(processor)
+      assert_equal([[:set_line_width, [5]]], processor.recorded_ops)
+    end
   end
 
   describe "canvas" do
@@ -116,4 +130,109 @@ describe HexaPDF::Type::Form do
       assert_raises(HexaPDF::Error) { @form.canvas }
     end
   end
+
+  describe "reference_xobject?" do
+    it "returns true if the form is a reference XObject" do
+      refute(@form.reference_xobject?)
+      @form[:Ref] = {}
+      assert(@form.reference_xobject?)
+    end
+  end
+
+  describe "referenced_content" do
+    before do
+      @form[:BBox] = [10, 10, 110, 60]
+      @form[:Matrix] = [1, 0, 0, 1, 10, 20]
+      @form[:Ref] = @doc.add({F: {}})
+      @ref = @form[:Ref]
+    end
+
+    it "returns a Form XObject with the imported page from an embedded file" do
+      io = StringIO.new
+      HexaPDF::Document.new.tap {|d| d.pages.add.canvas.line_width(5) }.write(io)
+      @ref[:F].embed(io, name: 'test.pdf')
+      @ref[:Page] = 0
+
+      ref_form = @form.referenced_content
+      refute_nil(ref_form)
+      assert_equal([10, 10, 110, 60], ref_form[:BBox].value)
+      assert_equal([1, 0, 0, 1, 10, 20], ref_form[:Matrix].value)
+      assert_equal("5 w\n", ref_form.contents)
+    end
+
+    it "returns a Form XObject with the imported page from an external file" do
+      file = Tempfile.new('hexapdf')
+      HexaPDF::Document.new.tap {|d| d.pages.add.canvas.line_width(5) }.write(file.path)
+      @ref[:F].path = file.path
+      @ref[:Page] = 0
+      assert_equal("5 w\n", @form.referenced_content.contents)
+    end
+
+    it "also works with a page label" do
+      file = Tempfile.new('hexapdf')
+      HexaPDF::Document.new.tap do |d|
+        d.pages.add
+        d.pages.add
+        d.pages.add.canvas.line_width(5)
+        d.pages.add
+        d.pages.add_labelling_range(1, numbering_style: :decimal, prefix: 'Test', start_number: 4)
+      end.write(file.path)
+      @ref[:F].path = file.path
+      @ref[:Page] = 'Test5'
+      assert_equal("5 w\n", @form.referenced_content.contents)
+    end
+
+    it "flattens printable annotations into the page's content stream" do
+      io = StringIO.new
+      HexaPDF::Document.new.tap do |d|
+        d.pages.add.canvas.line_width(5)
+        tf = d.acro_form(create: true).create_text_field('text')
+        widget = tf.create_widget(d.pages[0], Rect: [10, 10, 30, 30])
+        widget.border_style(color: "black")
+        widget = tf.create_widget(d.pages[0], Rect: [40, 10, 70, 30])
+        widget.border_style(color: "red")
+        tf.field_value = 't'
+        widget.unflag(:print)
+      end.write(io)
+      @ref[:F].embed(io, name: 'Test')
+      @ref[:Page] = 0
+      assert_equal(" q  Q q  5 w\n  Q q q\n1.0 0 0 1.0 10.0 10.0 cm\n/XO1 Do\nQ\n Q ",
+                   @form.referenced_content.contents)
+    end
+
+    it "returns nil if the form is not a reference XObject" do
+      @form.delete(:Ref)
+      assert_nil(@form.referenced_content)
+    end
+
+    it "returns nil if the file is not embedded and not found" do
+      @ref[:F].path = '/tmp/non_existing_path'
+      assert_nil(@form.referenced_content)
+    end
+
+    it "returns nil if the page referenced by page number is not found" do
+      io = StringIO.new
+      HexaPDF::Document.new.tap {|d| d.pages.add; d.pages.add }.write(io)
+      @ref[:F].embed(io, name: 'test.pdf')
+      @ref[:Page] = 5
+      assert_nil(@form.referenced_content)
+    end
+
+    it "returns nil if the page referenced by page label is not found" do
+      io = StringIO.new
+      HexaPDF::Document.new.tap do |d|
+        d.pages.add
+        d.pages.add
+        d.pages.add_labelling_range(1, numbering_style: :decimal, prefix: 'Test')
+      end.write(io)
+      @ref[:F].embed(io, name: 'test.pdf')
+      @ref[:Page] = 'Test5'
+      assert_nil(@form.referenced_content)
+    end
+
+    it "returns nil if an error happens during processing" do
+      @ref[:F].embed(StringIO.new('temp'), name: 'test.pdf')
+      assert_nil(@form.referenced_content)
+    end
+  end
 end

data/test/hexapdf/type/test_optional_content_configuration.rb

@@ -0,0 +1,112 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/type/optional_content_configuration'
+require 'hexapdf/document'
+
+describe HexaPDF::Type::OptionalContentConfiguration do
+  before do
+    @doc = HexaPDF::Document.new
+    @oc_config = @doc.optional_content.default_configuration
+    @ocg = @doc.optional_content.ocg('Test')
+  end
+
+  describe "ocg_state" do
+    it "defaults to the base state if nothing specific is set" do
+      assert_equal(:on, @oc_config.ocg_state(@ocg))
+      @oc_config[:BaseState] = :OFF
+      assert_equal(:off, @oc_config.ocg_state(@ocg))
+      @oc_config[:BaseState] = :Unchanged
+      assert_nil(@oc_config.ocg_state(@ocg))
+    end
+
+    it "returns :on if the OCG is in the /ON key" do
+      @oc_config[:ON] = [@ocg]
+      [:ON, :OFF, :Unchanged].each do |base_state|
+        @oc_config[:BaseState] = base_state
+        assert_equal(:on, @oc_config.ocg_state(@ocg))
+      end
+    end
+
+    it "returns :off if the OCG is in the /OFF key" do
+      @oc_config[:OFF] = [@ocg]
+      [:ON, :OFF, :Unchanged].each do |base_state|
+        @oc_config[:BaseState] = base_state
+        assert_equal(:off, @oc_config.ocg_state(@ocg))
+      end
+    end
+
+    it "adds the OCG to the respective dictionary key if a state is given" do
+      [[:ON, :OFF], [:OFF, :ON]].each do |state, other_state|
+        @oc_config[other_state] = [@ocg]
+        @oc_config.ocg_state(@ocg, state.downcase)
+        assert_equal([], @oc_config[other_state].value)
+        assert_equal([@ocg], @oc_config[state].value)
+        @oc_config.ocg_state(@ocg, state)
+        assert_equal([@ocg], @oc_config[state].value)
+      end
+    end
+
+    it "fails if an invalid state is given" do
+      assert_raises(ArgumentError) { @oc_config.ocg_state(@ocg, :unknwo) }
+    end
+  end
+
+  it "returns whether a given ocg is on" do
+    assert(@oc_config.ocg_on?(@ocg))
+    @oc_config[:OFF] = [@ocg]
+    refute(@oc_config.ocg_on?(@ocg))
+  end
+
+  describe "add_ocg_to_ui" do
+    it "adds the ocg to the top level" do
+      @oc_config.add_ocg_to_ui(@ocg)
+      @oc_config.add_ocg_to_ui(@ocg)
+      assert_equal([@ocg, @ocg], @oc_config[:Order].value)
+    end
+
+    it "adds the ocg under an existing label" do
+      @oc_config[:Order] = [:ocg1, ['Test'], :ocg2]
+      @oc_config.add_ocg_to_ui(@ocg, path: 'Test')
+      @oc_config.add_ocg_to_ui(@ocg, path: 'Test')
+      assert_equal([:ocg1, ['Test', @ocg, @ocg], :ocg2], @oc_config[:Order].value)
+    end
+
+    it "adds the ocg under a new label" do
+      @oc_config[:Order] = []
+      @oc_config.add_ocg_to_ui(@ocg, path: 'Test')
+      @oc_config.add_ocg_to_ui(@ocg, path: 'Test')
+      @oc_config.add_ocg_to_ui(@ocg, path: 'Test2')
+      assert_equal([['Test', @ocg, @ocg], ['Test2', @ocg]], @oc_config[:Order].value)
+    end
+
+    it "adds the ocg under an existing ocg" do
+      @oc_config[:Order] = [:ocg1, :ocg2]
+      @oc_config.add_ocg_to_ui(@ocg, path: :ocg2)
+      @oc_config.add_ocg_to_ui(@ocg, path: :ocg2)
+      assert_equal([:ocg1, :ocg2, [@ocg, @ocg]], @oc_config[:Order].value)
+    end
+
+    it "adds the ocg under a new ocg" do
+      @oc_config[:Order] = []
+      @oc_config.add_ocg_to_ui(@ocg, path: :ocg1)
+      @oc_config.add_ocg_to_ui(@ocg, path: :ocg1)
+      @oc_config.add_ocg_to_ui(@ocg, path: :ocg2)
+      assert_equal([:ocg1, [@ocg, @ocg], :ocg2, [@ocg]], @oc_config[:Order].value)
+    end
+
+    it "adds the ocg under an existing multi-level path" do
+      @oc_config[:Order] = [:ocg1, ['Test', :ocg2, [:ocg4, ['Test2', :ocg5]]], :ocg3]
+      @oc_config.add_ocg_to_ui(@ocg, path: ['Test', :ocg2, 'Test2'])
+      assert_equal([:ocg1, ['Test', :ocg2, [:ocg4, ['Test2', :ocg5, @ocg]]], :ocg3],
+                   @oc_config[:Order].value)
+    end
+
+    it "adds the ocg under a new multi-level path" do
+      @oc_config[:Order] = [:ocg1, ['Test', :ocg2]]
+      @oc_config.add_ocg_to_ui(@ocg, path: ['Test2', :ocg3, 'Test3'])
+      assert_equal([:ocg1, ['Test', :ocg2], ['Test2', :ocg3, [['Test3', @ocg]]]],
+                   @oc_config[:Order].value)
+    end
+  end
+end

data/test/hexapdf/type/test_optional_content_group.rb

@@ -0,0 +1,158 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/type/optional_content_group'
+require 'hexapdf/document'
+
+describe HexaPDF::Type::OptionalContentGroup do
+  before do
+    @doc = HexaPDF::Document.new
+    @ocg = @doc.add({Type: :OCG, Name: 'OCG'})
+  end
+
+  it "resolves all referenced type classes" do
+    hash = {
+      Usage: {
+        CreatorInfo: {},
+        Language: {},
+        Export: {},
+        Zoom: {},
+        Print: {},
+        View: {},
+        User: {},
+        PageElement: {}
+      }
+    }
+    ocg = @doc.add(hash, type: :OCG)
+    assert_kind_of(HexaPDF::Type::OptionalContentGroup, ocg)
+    ocu = ocg[:Usage]
+    assert_kind_of(HexaPDF::Type::OptionalContentGroup::OptionalContentUsage, ocu)
+    assert_kind_of(HexaPDF::Type::OptionalContentGroup::OptionalContentUsage::CreatorInfo,
+                   ocu[:CreatorInfo])
+    assert_kind_of(HexaPDF::Type::OptionalContentGroup::OptionalContentUsage::Language,
+                   ocu[:Language])
+    assert_kind_of(HexaPDF::Type::OptionalContentGroup::OptionalContentUsage::Export,
+                   ocu[:Export])
+    assert_kind_of(HexaPDF::Type::OptionalContentGroup::OptionalContentUsage::Zoom,
+                   ocu[:Zoom])
+    assert_kind_of(HexaPDF::Type::OptionalContentGroup::OptionalContentUsage::Print,
+                   ocu[:Print])
+    assert_kind_of(HexaPDF::Type::OptionalContentGroup::OptionalContentUsage::View,
+                   ocu[:View])
+    assert_kind_of(HexaPDF::Type::OptionalContentGroup::OptionalContentUsage::User,
+                   ocu[:User])
+    assert_kind_of(HexaPDF::Type::OptionalContentGroup::OptionalContentUsage::PageElement,
+                   ocu[:PageElement])
+  end
+
+  it "must always be an indirect object" do
+    assert(@ocg.must_be_indirect?)
+  end
+
+  it "returns the name" do
+    assert_equal('OCG', @ocg.name)
+    @ocg.name('Other')
+    assert_equal('Other', @ocg.name)
+  end
+
+  describe "intent" do
+    it "can be ask whether the intent is :View" do
+      assert(@ocg.intent_view?)
+      @ocg[:Intent] = :Design
+      refute(@ocg.intent_view?)
+    end
+
+    it "can be ask whether the intent is :Design" do
+      refute(@ocg.intent_design?)
+      @ocg[:Intent] = :Design
+      assert(@ocg.intent_design?)
+    end
+
+    it "can apply one or more intents" do
+      @ocg.apply_intent(:View)
+      @ocg.apply_intent(:Design)
+      assert(@ocg.intent_view?)
+      assert(@ocg.intent_design?)
+    end
+  end
+
+  describe "managing the OCG's default configuration" do
+    it "can be asked whether it is on by default" do
+      assert(@ocg.on?)
+      @doc.optional_content.default_configuration[:OFF] = [@ocg]
+      refute(@ocg.on?)
+    end
+
+    it "can set its default state to on" do
+      @doc.optional_content.default_configuration[:OFF] = [@ocg]
+      @ocg.on!
+      assert(@ocg.on?)
+    end
+
+    it "can set its default state to off" do
+      @ocg.off!
+      refute(@ocg.on?)
+    end
+
+    it "can add itself to the UI" do
+      @ocg.add_to_ui(path: 'Test')
+      assert_equal([['Test', @ocg]], @doc.optional_content.default_configuration[:Order].value)
+    end
+  end
+
+  it "can set and return the creator info usage entry" do
+    refute(@ocg.creator_info)
+    dict = @ocg.creator_info("HexaPDF", :Technical)
+    assert_equal({Creator: "HexaPDF", Subtype: :Technical}, dict.value)
+    assert_raises(ArgumentError) { @ocg.creator_info("HexaPDF") }
+  end
+
+  it "can set and return the language usage entry" do
+    refute(@ocg.language)
+    dict = @ocg.language('de')
+    assert_equal({Lang: "de", Preferred: :OFF}, dict.value)
+    @ocg.language('de', preferred: true)
+    assert_equal({Lang: "de", Preferred: :ON}, @ocg.language.value)
+  end
+
+  it "can set and return the export state usage entry" do
+    refute(@ocg.export_state)
+    assert(@ocg.export_state(true))
+    assert(@ocg.export_state)
+  end
+
+  it "can set and return the view state usage entry" do
+    refute(@ocg.view_state)
+    assert(@ocg.view_state(true))
+    assert(@ocg.view_state)
+  end
+
+  it "can set and return the print state usage entry" do
+    refute(@ocg.print_state)
+    dict = @ocg.print_state(true)
+    assert_equal({PrintState: :ON, Subtype: nil}, dict.value)
+    @ocg.print_state(true, subtype: :Watermark)
+    assert_equal({PrintState: :ON, Subtype: :Watermark}, @ocg.print_state.value)
+  end
+
+  it "can set and return the zoom usage entry" do
+    refute(@ocg.zoom)
+    dict = @ocg.zoom(min: 2.0)
+    assert_equal({min: 2.0, max: nil}, dict.value)
+    assert_equal({min: nil, max: 3.0}, @ocg.zoom(max: 3.0).value)
+    assert_equal({min: 1.0, max: 3.0}, @ocg.zoom(min: 1.0, max: 3.0).value)
+  end
+
+  it "can set and return the intended user usage entry" do
+    refute(@ocg.intended_user)
+    dict = @ocg.intended_user(:Ind, 'Me')
+    assert_equal({Type: :Ind, Name: "Me"}, dict.value)
+  end
+
+  it "can set and return the page element usage entry" do
+    refute(@ocg.page_element)
+    assert_equal(:HF, @ocg.page_element(:HF))
+    @ocg.page_element(:L)
+    assert_equal(:L, @ocg.page_element)
+  end
+end

data/test/hexapdf/type/test_optional_content_properties.rb

@@ -0,0 +1,109 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/type/optional_content_properties'
+require 'hexapdf/document'
+
+describe HexaPDF::Type::OptionalContentProperties do
+  before do
+    @doc = HexaPDF::Document.new
+    @oc = @doc.optional_content
+  end
+
+  describe "add_ocg" do
+    it "adds a given OCG object" do
+      ocg = @doc.add({Type: :OCG, Name: 'test'})
+      assert_same(ocg, @oc.add_ocg(ocg))
+      assert_equal([ocg], @oc[:OCGs])
+    end
+
+    it "doesn't add an OCG if it has been added before" do
+      ocg = @doc.add({Type: :OCG, Name: 'test'})
+      @oc.add_ocg(ocg)
+      @oc.add_ocg(ocg)
+      assert_equal([ocg], @oc[:OCGs])
+    end
+
+    it "creates a new OCG object with the given name and adds it" do
+      ocg = @oc.add_ocg('Test')
+      assert_equal([ocg], @oc[:OCGs])
+    end
+  end
+
+  describe "ocg" do
+    it "returns the first OCG with the given name, regardless of the create argument" do
+      ocg1  = @oc.add_ocg('Test')
+      _ocg2 = @oc.add_ocg('Test')
+      assert_same(ocg1, @oc.ocg('Test', create: false))
+      assert_same(ocg1, @oc.ocg('Test', create: true))
+    end
+
+    it "returns nil if no OCG with the given name exists and create is false" do
+      assert_nil(@oc.ocg('Other', create: false))
+      @oc.add_ocg('Test')
+      assert_nil(@oc.ocg('Other', create: false))
+    end
+
+    it "creates an OCG with the given name if none is found and create is true" do
+      ocg = @oc.ocg('Test')
+      assert_same(ocg, @oc.ocg('Test'))
+      assert_equal([ocg], @oc[:OCGs])
+    end
+  end
+
+  describe "ocgs" do
+    it "returns the list of the known optional content groups, with duplicates removed" do
+      ocg1 = @oc.add_ocg(@oc.add_ocg('Test'))
+      @oc[:OCGs] << nil
+      ocg2 = @oc.add_ocg('Test')
+      ocg3 = @oc.add_ocg('Other')
+      assert_equal([ocg1, ocg2, ocg3], @oc.ocgs)
+    end
+  end
+
+  describe "create_ocmd" do
+    it "creates the optional content membership dictionary for the given OCGs" do
+      ocmd = @oc.create_ocmd(@oc.ocg('Test'))
+      assert_equal({Type: :OCMD, OCGs: [@oc.ocg('Test')], P: :AnyOn}, ocmd.value)
+
+      ocmd = @oc.create_ocmd([@oc.ocg('Test'), @oc.ocg('Test2')], policy: :any_off)
+      assert_equal({Type: :OCMD, OCGs: [@oc.ocg('Test'), @oc.ocg('Test2')], P: :AnyOff}, ocmd.value)
+    end
+
+    it "fails if the policy is invalid" do
+      error = assert_raises(ArgumentError) { @oc.create_ocmd(:ocg, policy: :unknown) }
+      assert_match(/Invalid OCMD.*unknown/, error.message)
+    end
+  end
+
+  describe "default_configuration" do
+    it "returns an existing dictionary" do
+      dict = @oc.default_configuration
+      assert_same(@oc[:D], dict)
+      assert_kind_of(HexaPDF::Type::OptionalContentConfiguration, dict)
+    end
+
+    it "sets and returns a default configuration dictionary if none is set" do
+      @oc.delete(:D)
+      assert_equal({Creator: 'HexaPDF'}, @oc.default_configuration.value)
+    end
+
+    it "sets the default configuration dictionary to the given value" do
+      d_before = @oc[:D]
+      d_new = @oc.default_configuration(Creator: 'Test')
+      refute_same(d_before, d_new)
+      assert_same(@oc[:D], d_new)
+      assert_equal({Creator: 'Test'}, d_new.value)
+    end
+  end
+
+  describe "perform_validation" do
+    it "creates the /D entry if it is not set" do
+      @oc.delete(:D)
+      refute(@oc.validate(auto_correct: false))
+      refute(@oc.key?(:D))
+      assert(@oc.validate(auto_correct: true))
+      assert_equal({Creator: 'HexaPDF'}, @oc[:D].value)
+    end
+  end
+end

data/test/hexapdf/type/test_page.rb

@@ -592,11 +592,12 @@ describe HexaPDF::Type::Page do
     end
 
     it "gracefully handles invalid /Annot key values" do
-      @page[:Annots] << nil << @doc.add({}, stream: '')
+      @page[:Annots] << nil << @doc.add({}, stream: '') << 543
       result = @page.flatten_annotations
       assert(result.empty?)
       assert(@annot1.null?)
       assert(@annot2.null?)
+      assert_equal([], @page[:Annots].value)
 
       @page[:Annots] = @doc.add({}, stream: '')
       result = @page.flatten_annotations
@@ -706,14 +707,14 @@ describe HexaPDF::Type::Page do
       @appearance[:Matrix] = [0.707106, 0.707106, -0.707106, 0.707106, 10, 30]
       @page.flatten_annotations
       assert_operators(@canvas.contents,
-                       [:concatenate_matrix, [0.998269, 0.0, 0.0, 0.415946, 111.21318, 80.60659]],
+                       [:concatenate_matrix, [0.998269, 0.0, 0.0, 0.415946, 111.193776, 91.933396]],
                        range: 1)
     end
 
     it "scales the appearance to fit into the annotations's rectangle" do
       @annot1[:Rect] = [100, 100, 130, 150]
       @page.flatten_annotations
-      assert_operators(@canvas.contents, [:concatenate_matrix, [0.5, 0, 0, 2, 110, 105]], range: 1)
+      assert_operators(@canvas.contents, [:concatenate_matrix, [0.5, 0, 0, 2, 105, 110]], range: 1)
     end
   end
 
@@ -722,12 +723,13 @@ describe HexaPDF::Type::Page do
     annot1 = @doc.add({Type: :Annot, Subtype: :Text, Rect: [100, 100, 160, 125]})
     annot2 = @doc.add({Subtype: :Unknown, Rect: [10, 10, 70, 35]})
     not_an_annot = @doc.add({}, stream: '')
-    page[:Annots] = [not_an_annot, annot1, nil, annot2]
+    page[:Annots] = [not_an_annot, annot1, nil, annot2, {Type: :Annot, Subtype: :Text, Rect: [0, 0, 0, 0]}]
 
     annotations = page.each_annotation.to_a
-    assert_equal(2, annotations.size)
+    assert_equal(3, annotations.size)
     assert_equal([100, 100, 160, 125], annotations[0][:Rect])
     assert_equal(:Annot, annotations[0].type)
     assert_equal(:Annot, annotations[1].type)
+    assert_equal(:Annot, annotations[2].type)
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hexapdf
 version: !ruby/object:Gem::Version
-  version: 0.33.0
+  version: 0.34.1
 platform: ruby
 authors:
 - Thomas Leitner
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-08-02 00:00:00.000000000 Z
+date: 2023-11-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cmdparse
@@ -299,6 +299,8 @@ files:
 - examples/023-images.rb
 - examples/024-digital-signatures.rb
 - examples/025-table_box.rb
+- examples/026-optional_content.rb
+- examples/027-composer_optional_content.rb
 - examples/emoji-smile.png
 - examples/emoji-wink.png
 - examples/machupicchu.jpg
@@ -474,6 +476,7 @@ files:
 - lib/hexapdf/type/actions/go_to.rb
 - lib/hexapdf/type/actions/go_to_r.rb
 - lib/hexapdf/type/actions/launch.rb
+- lib/hexapdf/type/actions/set_ocg_state.rb
 - lib/hexapdf/type/actions/uri.rb
 - lib/hexapdf/type/annotation.rb
 - lib/hexapdf/type/annotations.rb
@@ -500,6 +503,10 @@ files:
 - lib/hexapdf/type/mark_information.rb
 - lib/hexapdf/type/names.rb
 - lib/hexapdf/type/object_stream.rb
+- lib/hexapdf/type/optional_content_configuration.rb
+- lib/hexapdf/type/optional_content_group.rb
+- lib/hexapdf/type/optional_content_membership.rb
+- lib/hexapdf/type/optional_content_properties.rb
 - lib/hexapdf/type/outline.rb
 - lib/hexapdf/type/outline_item.rb
 - lib/hexapdf/type/page.rb
@@ -728,6 +735,7 @@ files:
 - test/hexapdf/type/acro_form/test_text_field.rb
 - test/hexapdf/type/acro_form/test_variable_text_field.rb
 - test/hexapdf/type/actions/test_launch.rb
+- test/hexapdf/type/actions/test_set_ocg_state.rb
 - test/hexapdf/type/actions/test_uri.rb
 - test/hexapdf/type/annotations/test_markup_annotation.rb
 - test/hexapdf/type/annotations/test_text.rb
@@ -748,6 +756,9 @@ files:
 - test/hexapdf/type/test_info.rb
 - test/hexapdf/type/test_names.rb
 - test/hexapdf/type/test_object_stream.rb
+- test/hexapdf/type/test_optional_content_configuration.rb
+- test/hexapdf/type/test_optional_content_group.rb
+- test/hexapdf/type/test_optional_content_properties.rb
 - test/hexapdf/type/test_outline.rb
 - test/hexapdf/type/test_outline_item.rb
 - test/hexapdf/type/test_page.rb
@@ -784,7 +795,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.0.dev
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: HexaPDF - A Versatile PDF Creation and Manipulation Library For Ruby