hexapdf 0.5.0 → 0.6.0

data/examples/text_layouter_styling.rb

@@ -0,0 +1,125 @@
+# ## Text Layouter - Styling
+#
+# The text used as part of a [HexaPDF::Layout::TextLayouter] class can be styled
+# using [HexaPDF::Layout::Style]. To do this [HexaPDF::Layout::TextFragment]
+# objects have to be created with the needed styling and then added to a text
+# layout object. In addition the style objects can be used for customizing the
+# text layouts themselves.
+#
+# This example shows how to do this and shows off the various styling option,
+# including using callbacks to further customize the appearance.
+#
+# Usage:
+# : `ruby text_layouter_styling.rb [FONT_FILE]`
+#
+
+require 'hexapdf'
+
+include HexaPDF::Layout
+
+sample_text = "Lorem ipsum dolor sit amet, consectetur adipiscing elit,
+sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut
+enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut
+aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit
+in voluptate velit esse cillum dolore eu fugiat nulla pariatur.".tr("\n", ' ')
+
+# Wraps the text in a TextFragment using the given style.
+def fragment(text, style)
+  style = Style.new(style)
+  TextFragment.new(items: style.font.decode_utf8(text), style: style)
+end
+
+# Draws the text at the given [x, y] position onto the canvas and returns the
+# new y position.
+def draw_text(layouter, canvas, x, y)
+  rest, = layouter.fit
+  raise "Error" unless rest.empty?
+  layouter.draw(canvas, x, y)
+  y - layouter.actual_height
+end
+
+doc = HexaPDF::Document.new
+canvas = doc.pages.add.canvas
+
+base_font = doc.fonts.add(ARGV[0] || "Times")
+base_style = {font: base_font, font_size: 12, text_indent: 20}
+styles = {
+  "Fonts | Font Sizes | Colors" => [
+    {font: doc.fonts.add("Times", variant: :italic),
+     font_size: 12, fill_color: [0, 0, 255]},
+    {font: doc.fonts.add("Courier"), font_size: 14,
+     fill_color: [0, 255, 0]},
+    {font: doc.fonts.add("Helvetica", variant: :bold),
+     font_size: 20, fill_alpha: 0.5},
+  ],
+  "Character Spacing | Word Spacing | Horizontal Scaling" => [
+    {**base_style, character_spacing: 3},
+    {**base_style, horizontal_scaling: 150},
+    {**base_style, word_spacing: 15},
+  ],
+  "Text Rise" => [
+    {**base_style, text_rise: 5},
+    {**base_style, text_rise: -3},
+  ],
+  "Subscript | Superscript" => [
+    {**base_style, font_size: 15, subscript: true},
+    {**base_style, font_size: 15, superscript: true},
+  ],
+  "Underline | Strikeout" => [
+    {**base_style, underline: true, strikeout: true},
+    {**base_style, underline: true, strikeout: true, text_rise: 5},
+    {**base_style, underline: true, strikeout: true, subscript: true},
+  ],
+  "Text Rendering Mode" => [
+    {**base_style, text_rendering_mode: :stroke,
+     stroke_width: 0.1},
+    {**base_style, font_size: 20, text_rendering_mode: :fill_stroke,
+     stroke_color: [0, 255, 0], stroke_width: 0.7,
+     stroke_dash_pattern: [0.5, 1, 1.5], stroke_cap_style: :round},
+  ],
+  "Underlays | Overlays" => [
+    {**base_style, underlays: [lambda do |canv, box|
+       canv.fill_color(240, 240, 0).opacity(fill_alpha: 0.5).
+         rectangle(0, 0, box.width, box.height).fill
+      end]},
+    {**base_style, overlays: [lambda do |canv, box|
+       canv.line_width(1).stroke_color([0, 255, 0]).
+         line(0, -box.y_min, box.width, box.y_max - box.y_min).stroke
+      end]},
+  ],
+  "Links" => [
+    {**base_style, overlays: [
+      [:link, dest: [canvas.context, :FitR, 100, 300, 200, 400]],
+    ]},
+    {**base_style, overlays: [
+      [:link, uri: "https://hexapdf.gettalong.org",
+       border: [0, 0, 2, [3, 3]], border_color: [89, 150, 220]],
+    ]},
+    {**base_style, overlays: [
+      [:link, file: "text_layouter_styling.pdf", border: true],
+    ]},
+  ],
+}
+
+y = 800
+left = 50
+width = 500
+
+styles.each do |desc, variations|
+  items = sample_text.split(/(Lorem ipsum dolor|\b\w{2,5}\b)/).map do |str|
+    if str.length >= 3 && str.length <= 5
+      fragment(str, variations[str.length % variations.length])
+    elsif str.length == 2
+      fragment(str, variations.first)
+    elsif str =~ /Lorem/
+      fragment(str, variations.last)
+    else
+      fragment(str, base_style)
+    end
+  end
+  items.unshift(fragment(desc + ": ", fill_color: [255, 0, 0], **base_style))
+  layouter = TextLayouter.new(items: items, width: width, style: base_style)
+  y = draw_text(layouter, canvas, left, y) - 20
+end
+
+doc.write("text_layouter_styling.pdf", optimize: true)

data/examples/truetype.rb

@@ -5,7 +5,8 @@
 # fonts.
 #
 # Before a TrueType font can be used, HexaPDF needs to be made aware of it. This
-# is done by setting the configuration option 'font.map'.
+# is done by setting the configuration option 'font.map'. For one-off usage of a
+# font file, the file name itself can also be used.
 #
 # Once that is done the [HexaPDF::Content::Canvas#font] method can be used as
 # usual.
@@ -17,11 +18,8 @@
 require 'hexapdf'
 
 doc = HexaPDF::Document.new
-doc.config['font.map'] = {
-  'myfont' => {none: ARGV.shift || File.join(__dir__, '../test/data/fonts/Ubuntu-Title.ttf')},
-}
-
-wrapper = doc.fonts.load('myfont')
+font_file = ARGV.shift || File.join(__dir__, '../test/data/fonts/Ubuntu-Title.ttf')
+wrapper = doc.fonts.add(font_file)
 max_gid = wrapper.wrapped_font[:maxp].num_glyphs
 
 255.times do |page|
@@ -30,7 +28,7 @@ max_gid = wrapper.wrapped_font[:maxp].num_glyphs
   canvas.font("Helvetica", size: 10)
   canvas.text("Font: #{wrapper.wrapped_font.full_name}", at: [50, 825])
 
-  canvas.font("myfont", size: 15)
+  canvas.font(font_file, size: 15)
   16.times do |y|
     canvas.move_text_cursor(offset: [50, 800 - y * 50], absolute: true)
     canvas.show_glyphs((0..15).map do |i|

data/lib/hexapdf/cli/command.rb

@@ -96,6 +96,7 @@ module HexaPDF
       # switches.
       def pdf_options(password)
         hash = {decryption_opts: {password: password}, config: {}}
+        HexaPDF::GlobalConfiguration['filter.predictor.strict'] = command_parser.strict
         hash[:config]['parser.on_correctable_error'] =
           if command_parser.strict
             proc { true }

data/lib/hexapdf/configuration.rb

@@ -84,35 +84,46 @@ module HexaPDF
     # object (or hash) and this configuration object.
     #
     # If a key already has a value in this object, its value is overwritten by the one from
-    # +config+. However, hash values are merged instead of being overwritten.
+    # +config+. However, hash values are merged instead of being overwritten. Array values are
+    # duplicated.
     def merge(config)
       config = (config.kind_of?(self.class) ? config.options : config)
-      self.class.new(options.merge(config) do |_key, old, new|
-                       old.kind_of?(Hash) && new.kind_of?(Hash) ? old.merge(new) : new
-                     end)
+      merged_config = options.each_with_object({}) do |(key, old), conf|
+        new = config[key]
+        conf[key] = if old.kind_of?(Hash) && new.kind_of?(Hash)
+                      old.merge(new)
+                    elsif new.kind_of?(Array) || old.kind_of?(Array)
+                      (new || old).dup
+                    elsif config.key?(key)
+                      new
+                    else
+                      old
+                    end
+      end
+      self.class.new(merged_config)
     end
 
     # :call-seq:
-    #   config.constantize(name, key = nil)                  -> constant
-    #   config.constantize(name, key = nil) {|name| block}   -> obj
+    #   config.constantize(name, *keys)                  -> constant
+    #   config.constantize(name, *keys) {|name| block}   -> obj
     #
-    # Returns the constant the option +name+ is referring to. If +key+ is provided and the value
-    # of the option +name+ responds to \#[], the constant to which +key+ refers is returned.
+    # Returns the constant the option +name+ is referring to. If +keys+ are provided and the value
+    # of the option +name+ responds to \#dig, the constant to which the keys refer is returned.
     #
     # If no constant can be found and no block is provided, an error is raised. If a block is
     # provided it is called with the option name and its result will be returned.
     #
     #   config.constantize('encryption.aes')      #=> HexaPDF::Encryption::FastAES
     #   config.constantize('filter.map', :Fl)     #=> HexaPDF::Filter::FlateDecode
-    def constantize(name, key = :__unset)
+    def constantize(name, *keys)
       data = self[name]
-      data = data[key] if key != :__unset && data.respond_to?(:[])
+      data = data.dig(*keys) if data.respond_to?(:dig)
       (data = ::Object.const_get(data) rescue nil) if data.kind_of?(String)
       if data.nil? && block_given?
         data = yield(name)
       elsif data.nil?
         raise HexaPDF::Error, "Error getting constant for configuration option '#{name}'" <<
-          (key == :__unset ? "" : " and key '#{key}'")
+          (keys.empty? ? "" : " and keys '#{keys.join(', ')}'")
       end
       data
     end
@@ -141,6 +152,44 @@ module HexaPDF
   #
   #    In nearly all cases this option should not be changed from its default setting!
   #
+  # encryption.aes::
+  #    The class that should be used for AES encryption. If the value is a String, it should
+  #    contain the name of a constant to such a class.
+  #
+  #    See HexaPDF::Encryption::AES for the general interface such a class must conform to and
+  #    HexaPDF::Encryption::RubyAES as well as HexaPDF::Encryption::FastAES for implementations.
+  #
+  # encryption.arc4::
+  #    The class that should be used for ARC4 encryption. If the value is a String, it should
+  #    contain the name of a constant to such a class.
+  #
+  #    See HexaPDF::Encryption::ARC4 for the general interface such a class must conform to and
+  #    HexaPDF::Encryption::RubyARC4 as well as HexaPDF::Encryption::FastARC4 for implementations.
+  #
+  # encryption.filter_map::
+  #    A mapping from a PDF name (a Symbol) to a security handler class (see
+  #    Encryption::SecurityHandler). If the value is a String, it should contain the name of a
+  #    constant to such a class.
+  #
+  #    PDF defines a standard security handler that is implemented
+  #    (HexaPDF::Encryption::StandardSecurityHandler) and assigned the :Standard name.
+  #
+  # encryption.sub_filter_map::
+  #    A mapping from a PDF name (a Symbol) to a security handler class (see
+  #    HexaPDF::Encryption::SecurityHandler). If the value is a String, it should contain the name
+  #    of a constant to such a class.
+  #
+  #    The sub filter map is used when the security handler defined by the encryption dictionary
+  #    is not available, but a compatible implementation is.
+  #
+  # filter.map::
+  #    A mapping from a PDF name (a Symbol) to a filter object (see Filter). If the value is a
+  #    String, it should contain the name of a constant that contains a filter object.
+  #
+  #    The most often used filters are implemented and readily available.
+  #
+  #    See PDF1.7 s7.4.1, ADB sH.3 3.3
+  #
   # font.map::
   #    Defines a mapping from font names and variants to font files.
   #
@@ -197,6 +246,16 @@ module HexaPDF
   #    to compute. It should not be set to values lower than 4, otherwise the approximation of a
   #    complete ellipse is visibly false.
   #
+  # image_loader::
+  #    An array with image loader implementations. When an image should be loaded, the array is
+  #    iterated in sequence to find a suitable image loader.
+  #
+  #    If a value is a String, it should contain the name of a constant that is an image loader
+  #    object.
+  #
+  #    See the HexaPDF::ImageLoader module for information on how to implement an image loader
+  #    object.
+  #
   # image_loader.pdf.use_stringio::
   #    A boolean determining whether images specified via file names should be read into memory
   #    all at once using a StringIO object.
@@ -224,6 +283,11 @@ module HexaPDF
   #    The value can either be a rectangle defining the paper size or a Symbol referencing one of
   #    the predefined paper sizes.
   #
+  # page.default_media_orientation::
+  #    The page orientation that is used for new pages that don't define a media box. It is only
+  #    used if 'page.default_media_box' references a predefined paper size. Default value is
+  #    :portrait. The other possible value is :landscape.
+  #
   # parser.on_correctable_error::
   #    Callback hook when the parser encounters an error that can be corrected.
   #
@@ -232,8 +296,43 @@ module HexaPDF
   #
   # sorted_tree.max_leaf_node_size::
   #    The maximum number of nodes that should be in a leaf node of a node tree.
+  #
+  # style.layers_map::
+  #    A mapping from style layer names to layer objects.
+  #
+  #    See HexaPDF::Layout::Style::Layers for more information.
+  #
+  # task.map::
+  #    A mapping from task names to callable task objects. See HexaPDF::Task for more information.
   DefaultDocumentConfiguration =
     Configuration.new('document.auto_decrypt' => true,
+                      'encryption.aes' => 'HexaPDF::Encryption::FastAES',
+                      'encryption.arc4' => 'HexaPDF::Encryption::FastARC4',
+                      'encryption.filter_map' => {
+                        Standard: 'HexaPDF::Encryption::StandardSecurityHandler',
+                      },
+                      'encryption.sub_filter_map' => {
+                      },
+                      'filter.map' => {
+                        ASCIIHexDecode: 'HexaPDF::Filter::ASCIIHexDecode',
+                        AHx: 'HexaPDF::Filter::ASCIIHexDecode',
+                        ASCII85Decode: 'HexaPDF::Filter::ASCII85Decode',
+                        A85: 'HexaPDF::Filter::ASCII85Decode',
+                        LZWDecode: 'HexaPDF::Filter::LZWDecode',
+                        LZW: 'HexaPDF::Filter::LZWDecode',
+                        FlateDecode: 'HexaPDF::Filter::FlateDecode',
+                        Fl: 'HexaPDF::Filter::FlateDecode',
+                        RunLengthDecode: 'HexaPDF::Filter::RunLengthDecode',
+                        RL: 'HexaPDF::Filter::RunLengthDecode',
+                        CCITTFaxDecode: nil,
+                        CCF: nil,
+                        JBIG2Decode: nil,
+                        DCTDecode: 'HexaPDF::Filter::DCTDecode',
+                        DCT: 'HexaPDF::Filter::DCTDecode',
+                        JPXDecode: 'HexaPDF::Filter::JPXDecode',
+                        Crypt: nil,
+                        Encryption: 'HexaPDF::Filter::Encryption',
+                      },
                       'font.map' => {},
                       'font.on_missing_glyph' => proc do |char, _type, font|
                         HexaPDF::Font::InvalidGlyph.new(font, char)
@@ -245,6 +344,7 @@ module HexaPDF
                       'font_loader' => [
                         'HexaPDF::FontLoader::Standard14',
                         'HexaPDF::FontLoader::FromConfiguration',
+                        'HexaPDF::FontLoader::FromFile',
                       ],
                       'graphic_object.map' => {
                         arc: 'HexaPDF::Content::GraphicObject::Arc',
@@ -252,11 +352,24 @@ module HexaPDF
                         solid_arc: 'HexaPDF::Content::GraphicObject::SolidArc',
                       },
                       'graphic_object.arc.max_curves' => 6,
+                      'image_loader' => [
+                        'HexaPDF::ImageLoader::JPEG',
+                        'HexaPDF::ImageLoader::PNG',
+                        'HexaPDF::ImageLoader::PDF',
+                      ],
                       'image_loader.pdf.use_stringio' => true,
                       'io.chunk_size' => 2**16,
                       'page.default_media_box' => :A4,
+                      'page.default_media_orientation' => :portrait,
                       'parser.on_correctable_error' => proc { false },
-                      'sorted_tree.max_leaf_node_size' => 64)
+                      'sorted_tree.max_leaf_node_size' => 64,
+                      'style.layers_map' => {
+                        link: 'HexaPDF::Layout::Style::LinkLayer',
+                      },
+                      'task.map' => {
+                        optimize: 'HexaPDF::Task::Optimize',
+                        dereference: 'HexaPDF::Task::Dereference',
+                      })
 
   # The global configuration object, providing the following options:
   #
@@ -269,36 +382,6 @@ module HexaPDF
   #
   #    See PDF1.7 s8.6
   #
-  # encryption.aes::
-  #    The class that should be used for AES encryption. If the value is a String, it should
-  #    contain the name of a constant to such a class.
-  #
-  #    See HexaPDF::Encryption::AES for the general interface such a class must conform to and
-  #    HexaPDF::Encryption::RubyAES as well as HexaPDF::Encryption::FastAES for implementations.
-  #
-  # encryption.arc4::
-  #    The class that should be used for ARC4 encryption. If the value is a String, it should
-  #    contain the name of a constant to such a class.
-  #
-  #    See HexaPDF::Encryption::ARC4 for the general interface such a class must conform to and
-  #    HexaPDF::Encryption::RubyARC4 as well as HexaPDF::Encryption::FastARC4 for implementations.
-  #
-  # encryption.filter_map::
-  #    A mapping from a PDF name (a Symbol) to a security handler class (see
-  #    Encryption::SecurityHandler). If the value is a String, it should contain the name of a
-  #    constant to such a class.
-  #
-  #    PDF defines a standard security handler that is implemented
-  #    (HexaPDF::Encryption::StandardSecurityHandler) and assigned the :Standard name.
-  #
-  # encryption.sub_filter_map::
-  #    A mapping from a PDF name (a Symbol) to a security handler class (see
-  #    HexaPDF::Encryption::SecurityHandler). If the value is a String, it should contain the name
-  #    of a constant to such a class.
-  #
-  #    The sub filter map is used when the security handler defined by the encryption dictionary
-  #    is not available, but a compatible implementation is.
-  #
   # filter.flate_compression::
   #    Specifies the compression level that should be used with the FlateDecode filter. The level
   #    can range from 0 (no compression), 1 (best speed) to 9 (best compression, default).
@@ -310,23 +393,10 @@ module HexaPDF
   #    The HexaPDF default value of 6 has been found in tests to be nearly equivalent to the Zlib
   #    default of 8 in terms of speed and compression level but uses less memory.
   #
-  # filter.map::
-  #    A mapping from a PDF name (a Symbol) to a filter object (see Filter). If the value is a
-  #    String, it should contain the name of a constant that contains a filter object.
-  #
-  #    The most often used filters are implemented and readily available.
-  #
-  #    See PDF1.7 s7.4.1, ADB sH.3 3.3
-  #
-  # image_loader::
-  #    An array with image loader implementations. When an image should be loaded, the array is
-  #    iterated in sequence to find a suitable image loader.
-  #
-  #    If a value is a String, it should contain the name of a constant that is an image loader
-  #    object.
-  #
-  #    See the HexaPDF::ImageLoader module for information on how to implement an image loader
-  #    object.
+  # filter.predictor.strict::
+  #    Specifies whether the predictor algorithm used by LZWDecode and FlateDecode should operate in
+  #    strict mode, i.e. adhering to the PDF specification without correcting for common deficiences
+  #    of PDF writer libraries.
   #
   # object.type_map::
   #    A mapping from a PDF name (a Symbol) to PDF object classes which is based on the /Type
@@ -343,49 +413,15 @@ module HexaPDF
   #
   #    This mapping is used to provide automatic wrapping of objects in the HexaPDF::Document#wrap
   #    method.
-  #
-  # task.map::
-  #    A mapping from task names to callable task objects. See HexaPDF::Task for more information.
   GlobalConfiguration =
-    Configuration.new('encryption.aes' => 'HexaPDF::Encryption::FastAES',
-                      'encryption.arc4' => 'HexaPDF::Encryption::FastARC4',
-                      'encryption.filter_map' => {
-                        Standard: 'HexaPDF::Encryption::StandardSecurityHandler',
-                      },
-                      'encryption.sub_filter_map' => {
-                      },
-                      'filter.flate_compression' => 9,
+    Configuration.new('filter.flate_compression' => 9,
                       'filter.flate_memory' => 6,
-                      'filter.map' => {
-                        ASCIIHexDecode: 'HexaPDF::Filter::ASCIIHexDecode',
-                        AHx: 'HexaPDF::Filter::ASCIIHexDecode',
-                        ASCII85Decode: 'HexaPDF::Filter::ASCII85Decode',
-                        A85: 'HexaPDF::Filter::ASCII85Decode',
-                        LZWDecode: 'HexaPDF::Filter::LZWDecode',
-                        LZW: 'HexaPDF::Filter::LZWDecode',
-                        FlateDecode: 'HexaPDF::Filter::FlateDecode',
-                        Fl: 'HexaPDF::Filter::FlateDecode',
-                        RunLengthDecode: 'HexaPDF::Filter::RunLengthDecode',
-                        RL: 'HexaPDF::Filter::RunLengthDecode',
-                        CCITTFaxDecode: nil,
-                        CCF: nil,
-                        JBIG2Decode: nil,
-                        DCTDecode: 'HexaPDF::Filter::DCTDecode',
-                        DCT: 'HexaPDF::Filter::DCTDecode',
-                        JPXDecode: 'HexaPDF::Filter::JPXDecode',
-                        Crypt: nil,
-                        Encryption: 'HexaPDF::Filter::Encryption',
-                      },
+                      'filter.predictor.strict' => false,
                       'color_space.map' => {
                         DeviceRGB: 'HexaPDF::Content::ColorSpace::DeviceRGB',
                         DeviceCMYK: 'HexaPDF::Content::ColorSpace::DeviceCMYK',
                         DeviceGray: 'HexaPDF::Content::ColorSpace::DeviceGray',
                       },
-                      'image_loader' => [
-                        'HexaPDF::ImageLoader::JPEG',
-                        'HexaPDF::ImageLoader::PNG',
-                        'HexaPDF::ImageLoader::PDF',
-                      ],
                       'object.type_map' => {
                         XRef: 'HexaPDF::Type::XRefStream',
                         ObjStm: 'HexaPDF::Type::ObjectStream',
@@ -405,19 +441,47 @@ module HexaPDF
                         XXResources: 'HexaPDF::Type::Resources',
                         XXTrailer: 'HexaPDF::Type::Trailer',
                         XXViewerPreferences: 'HexaPDF::Type::ViewerPreferences',
+                        Action: 'HexaPDF::Type::Action',
+                        XXLaunchActionWinParameters: 'HexaPDF::Type::Actions::Launch::WinParameters',
+                        Annotation: 'HexaPDF::Type::Annotation',
                       },
                       'object.subtype_map' => {
-                        Image: 'HexaPDF::Type::Image',
-                        Form: 'HexaPDF::Type::Form',
-                        Type0: 'HexaPDF::Type::FontType0',
-                        Type1: 'HexaPDF::Type::FontType1',
-                        TrueType: 'HexaPDF::Type::FontTrueType',
-                        CIDFontType0: 'HexaPDF::Type::CIDFont',
-                        CIDFontType2: 'HexaPDF::Type::CIDFont',
-                      },
-                      'task.map' => {
-                        optimize: 'HexaPDF::Task::Optimize',
-                        dereference: 'HexaPDF::Task::Dereference',
+                        nil => {
+                          Image: 'HexaPDF::Type::Image',
+                          Form: 'HexaPDF::Type::Form',
+                          Type0: 'HexaPDF::Type::FontType0',
+                          Type1: 'HexaPDF::Type::FontType1',
+                          TrueType: 'HexaPDF::Type::FontTrueType',
+                          CIDFontType0: 'HexaPDF::Type::CIDFont',
+                          CIDFontType2: 'HexaPDF::Type::CIDFont',
+                          GoTo: 'HexaPDF::Type::Actions::GoTo',
+                          GoToR: 'HexaPDF::Type::Actions::GoToR',
+                          Launch: 'HexaPDF::Type::Actions::Launch',
+                          URI: 'HexaPDF::Type::Actions::URI',
+                          Text: 'HexaPDF::Type::Annotations::Text',
+                          Link: 'HexaPDF::Type::Annotations::Link',
+                        },
+                        XObject: {
+                          Image: 'HexaPDF::Type::Image',
+                          Form: 'HexaPDF::Type::Form',
+                        },
+                        Font: {
+                          Type0: 'HexaPDF::Type::FontType0',
+                          Type1: 'HexaPDF::Type::FontType1',
+                          TrueType: 'HexaPDF::Type::FontTrueType',
+                          CIDFontType0: 'HexaPDF::Type::CIDFont',
+                          CIDFontType2: 'HexaPDF::Type::CIDFont',
+                        },
+                        Action: {
+                          GoTo: 'HexaPDF::Type::Actions::GoTo',
+                          GoToR: 'HexaPDF::Type::Actions::GoToR',
+                          Launch: 'HexaPDF::Type::Actions::Launch',
+                          URI: 'HexaPDF::Type::Actions::URI',
+                        },
+                        Annotation: {
+                          Text: 'HexaPDF::Type::Annotations::Text',
+                          Link: 'HexaPDF::Type::Annotations::Link',
+                        },
                       })
 
 end