hexapdf 0.33.0 → 0.34.1

data/lib/hexapdf/layout/column_box.rb

@@ -177,7 +177,8 @@ module HexaPDF
                                      [column_left, column_bottom + height])
               shape = Geom2D::Algorithms::PolygonOperation.run(frame.shape, rect, :intersection)
             end
-            column_frame = Frame.new(column_left, column_bottom, column_width, height, shape: shape)
+            column_frame = Frame.new(column_left, column_bottom, column_width, height,
+                                     shape: shape, context: frame.context)
             @box_fitter << column_frame
           end
 

data/lib/hexapdf/layout/frame.rb

@@ -133,12 +133,18 @@ module HexaPDF
         # The configuration option "debug" can be used to add visual debug output with respect to
         # box placement.
         def draw(canvas)
-          if canvas.context.document.config['debug']
-            canvas.save_graphics_state do
-              canvas.fill_color("green").stroke_color("darkgreen").
-                opacity(fill_alpha: 0.1, stroke_alpha: 0.2).
-                draw(:geom2d, object: mask, path_only: true).fill_stroke
+          doc = canvas.context.document
+          if doc.config['debug']
+            name = "#{box.class} (#{x.to_i},#{y.to_i}-#{box.width.to_i}x#{box.height.to_i})"
+            ocg = doc.optional_content.ocg(name)
+            canvas.optional_content(ocg) do
+              canvas.save_graphics_state do
+                canvas.fill_color("green").stroke_color("darkgreen").
+                  opacity(fill_alpha: 0.1, stroke_alpha: 0.2).
+                  draw(:geom2d, object: mask, path_only: true).fill_stroke
+              end
             end
+            doc.optional_content.default_configuration.add_ocg_to_ui(ocg, path: 'Debug')
           end
           box.draw(canvas, x, y)
         end
@@ -182,13 +188,18 @@ module HexaPDF
       # Also see the note in the #x documentation for further information.
       attr_reader :available_height
 
+      # The context object (a HexaPDF::Type::Page or HexaPDF::Type::Form) for which this frame
+      # should be used.
+      attr_reader :context
+
       # Creates a new Frame object for the given rectangular area.
-      def initialize(left, bottom, width, height, shape: nil)
+      def initialize(left, bottom, width, height, shape: nil, context: nil)
         @left = left
         @bottom = bottom
         @width = width
         @height = height
         @shape = shape || create_rectangle(left, bottom, left + width, bottom + height)
+        @context = context
 
         @x = left
         @y = bottom + height
@@ -199,6 +210,12 @@ module HexaPDF
         @region_selection = :max_height
       end
 
+      # Returns the HexaPDF::Document instance (through #context) that is associated with this Frame
+      # object or +nil+ if no context object has been set.
+      def document
+        @context&.document
+      end
+
       # Fits the given box into the current region of available space and returns a FitResult
       # object.
       #

data/lib/hexapdf/layout/inline_box.rb

@@ -47,9 +47,10 @@ module HexaPDF
     # beforehand! This means the box *must* have at least its width set. The height may either also
     # be set or determined during fitting.
     #
-    # Fitting of the wrapped box is done immediately after creating a InlineBox instance. For this,
-    # a frame is used that has the width of the wrapped box and its height, or if not set, a
-    # practically infinite height. In the latter case the height *must* be set during fitting.
+    # Fitting of the wrapped box via #fit_wrapped_box needs to be done before accessing any other
+    # method that uses the wrapped box. For fitting, a frame is used that has the width of the
+    # wrapped box and its height, or if not set, a practically infinite height. In the latter case
+    # the height *must* be set during fitting.
     class InlineBox
 
       # Creates an InlineBox that wraps a basic Box. All arguments (except +valign+) and the block
@@ -76,12 +77,11 @@ module HexaPDF
         raise HexaPDF::Error, "Width of box not set" if box.width == 0
         @box = box
         @valign = valign
-        @fit_result = Frame.new(0, 0, box.width, box.height == 0 ? 100_000 : box.height).fit(box)
-        if !@fit_result.success?
-          raise HexaPDF::Error, "Box for inline use could not be fit"
-        elsif box.height > 99_000
-          raise HexaPDF::Error, "Box for inline use has no valid height set after fitting"
-        end
+      end
+
+      # Returns the style of the wrapped box.
+      def style
+        box.style
       end
 
       # Returns +true+ if this inline box is just a placeholder without drawing operations.
@@ -126,6 +126,17 @@ module HexaPDF
         height
       end
 
+      # Fits the wrapped box, using the given context (see Frame#context).
+      def fit_wrapped_box(context)
+        @fit_result = Frame.new(0, 0, box.width, box.height == 0 ? 100_000 : box.height,
+                                context: context).fit(box)
+        if !@fit_result.success?
+          raise HexaPDF::Error, "Box for inline use could not be fit"
+        elsif box.height > 99_000
+          raise HexaPDF::Error, "Box for inline use has no valid height set after fitting"
+        end
+      end
+
     end
 
   end

data/lib/hexapdf/layout/list_box.rb

@@ -60,6 +60,9 @@ module HexaPDF
     #    arguments are ignored.
     class ListBox < Box
 
+      # Stores the information when fitting an item of the list box.
+      ItemResult = Struct.new(:box_fitter, :height, :marker, :marker_pos_x)
+
       # The child boxes of this ListBox. They need to be finalized before #fit is called.
       attr_reader :children
 
@@ -179,7 +182,7 @@ module HexaPDF
 
       # Returns +true+ if no box was fitted into the list box.
       def empty?
-        super && (!@results || @results.all? {|box_fitter| box_fitter.fit_results.empty? })
+        super && (!@results || @results.all? {|result| result.box_fitter.fit_results.empty? })
       end
 
       # Fits the list box into the available space.
@@ -210,9 +213,10 @@ module HexaPDF
         end
 
         @results = []
-        @results_item_marker_x = []
 
-        @children.each do |child|
+        @children.each_with_index do |child, index|
+          item_result = ItemResult.new
+
           shape = Geom2D::Polygon([left, top - height],
                                   [left + width, top - height],
                                   [left + width, top],
@@ -222,26 +226,36 @@ module HexaPDF
             remove_indent_from_frame_shape(shape) unless shape.polygons.empty?
           end
 
-          item_frame = Frame.new(item_frame_left, top - height, item_frame_width, height, shape: shape)
-          @results_item_marker_x << item_frame.x - content_indentation
+          item_frame = Frame.new(item_frame_left, top - height, item_frame_width, height,
+                                 shape: shape, context: frame.context)
+
+          if index != 0 || !split_box? || @split_box == :show_first_marker
+            box = item_marker_box(frame.document, index)
+            break unless box.fit(content_indentation, height, nil)
+            item_result.marker = box
+            item_result.marker_pos_x = item_frame.x - content_indentation
+            item_result.height = box.height
+          end
 
           box_fitter = BoxFitter.new([item_frame])
           Array(child).each {|box| box_fitter.fit(box) }
-          @results << box_fitter
+          item_result.box_fitter = box_fitter
+          item_result.height = [item_result.height.to_i, box_fitter.content_heights[0]].max
+          @results << item_result
 
-          top -= box_fitter.content_heights[0] + item_spacing
-          height -= box_fitter.content_heights[0] + item_spacing
+          top -= item_result.height + item_spacing
+          height -= item_result.height + item_spacing
 
           break if !box_fitter.fit_successful? || height <= 0
         end
 
-        @height = @results.sum {|box_fitter| box_fitter.content_heights[0] } +
+        @height = @results.sum {|item_result| item_result.height } +
           (@results.count - 1) * item_spacing +
           reserved_height
 
         @draw_pos_x = frame.x + reserved_width_left
         @draw_pos_y = frame.y - @height + reserved_height_bottom
-        @fit_successful = @results.all?(&:fit_successful?) && @results.size == @children.size
+        @fit_successful = @results.all? {|r| r.box_fitter.fit_successful? } && @results.size == @children.size
       end
 
       private
@@ -292,7 +306,7 @@ module HexaPDF
 
       # Splits the content of the list box. This method is called from Box#split.
       def split_content(_available_width, _available_height, _frame)
-        remaining_boxes = @results[-1].remaining_boxes
+        remaining_boxes = @results[-1].box_fitter.remaining_boxes
         first_is_split_box = remaining_boxes.first&.split_box?
         children = (remaining_boxes.empty? ? [] : [remaining_boxes]) + @children[@results.size..-1]
 
@@ -301,7 +315,6 @@ module HexaPDF
         box.instance_variable_set(:@start_number,
                                   @start_number + @results.size + (first_is_split_box ? -1 : 0))
         box.instance_variable_set(:@results, [])
-        box.instance_variable_set(:@results_item_marker_x, [])
 
         [self, box]
       end
@@ -315,20 +328,22 @@ module HexaPDF
         fragment = case @item_type
                    when :disc
                      TextFragment.create("•", font: document.fonts.add("Times"),
-                                         font_size: style.font_size)
+                                         font_size: style.font_size, fill_color: style.fill_color)
                    when :circle
                      TextFragment.create("❍", font: document.fonts.add("ZapfDingbats"),
                                          font_size: style.font_size / 2.0,
+                                         fill_color: style.fill_color,
                                          text_rise: -style.font_size / 1.8)
                    when :square
                      TextFragment.create("■", font: document.fonts.add("ZapfDingbats"),
                                          font_size: style.font_size / 2.0,
+                                         fill_color: style.fill_color,
                                          text_rise: -style.font_size / 1.8)
                    when :decimal
                      text = (@start_number + index).to_s << "."
                      decimal_style = {
                        font: (style.font? ? style.font : document.fonts.add("Times")),
-                       font_size: style.font_size || 10,
+                       font_size: style.font_size || 10, fill_color: style.fill_color
                      }
                      TextFragment.create(text, decimal_style)
                    else
@@ -348,12 +363,11 @@ module HexaPDF
           canvas.translate(x - @draw_pos_x, y - @draw_pos_y)
         end
 
-        @results.each_with_index do |box_fitter, index|
-          if index != 0 || !split_box? || @split_box == :show_first_marker
-            box = item_marker_box(canvas.context.document, index)
-            box.fit(content_indentation, box_fitter.content_heights[0], nil)
-            box.draw(canvas, @results_item_marker_x[index],
-                     box_fitter.frames[0].bottom + box_fitter.frames[0].height - box.height)
+        @results.each do |item_result|
+          box_fitter = item_result.box_fitter
+          if (marker = item_result.marker)
+            marker.draw(canvas, item_result.marker_pos_x,
+                        box_fitter.frames[0].bottom + box_fitter.frames[0].height - marker.height)
           end
           box_fitter.fit_results.each {|result| result.draw(canvas) }
         end

data/lib/hexapdf/layout/page_style.rb

@@ -135,7 +135,8 @@ module HexaPDF
         Layout::Frame.new(box.left + margin.left,
                           box.bottom + margin.bottom,
                           box.width - margin.left - margin.right,
-                          box.height - margin.bottom - margin.top)
+                          box.height - margin.bottom - margin.top,
+                          context: page)
       end
 
     end

data/lib/hexapdf/layout/style.rb

@@ -464,12 +464,12 @@ module HexaPDF
 
         # Creates a new LinkLayer object.
         #
-        # The following arguments are allowed (note that only *one* of +dest+, +uri+ or +file+ may
-        # be specified):
+        # The following arguments are allowed (note that only *one* of +dest+, +uri+, +file+ or
+        # +action+ may be specified):
         #
         # +dest+::
         #   The destination array or a name of a named destination for in-document links. If neither
-        #   +dest+ nor +uri+ nor +file+ is specified, it is assumed that the box has a custom
+        #   +dest+, +uri+, +file+ nor +action+ is specified, it is assumed that the box has a custom
         #   property named 'link' which is used for the destination.
         #
         # +uri+::
@@ -480,6 +480,9 @@ module HexaPDF
         #   should be launched. Can either be a string or a Filespec object. Also see:
         #   HexaPDF::Type::FileSpecification.
         #
+        # +action+::
+        #   The PDF action that should be executed.
+        #
         # +border+::
         #   If set to +true+, a standard border is used. Also accepts an array that adheres to the
         #   rules for annotation borders.
@@ -492,15 +495,17 @@ module HexaPDF
         #   LinkLayer.new(dest: [page, :XYZ, nil, nil, nil], border: true)
         #   LinkLayer.new(uri: "https://my.example.com/path", border: [5 5 2])
         #   LinkLayer.new     # use 'link' custom box property for dest
-        def initialize(dest: nil, uri: nil, file: nil, border: false, border_color: nil)
-          if dest && (uri || file) || uri && file
-            raise ArgumentError, "Only one of dest, uri and file is allowed"
+        def initialize(dest: nil, uri: nil, file: nil, action: nil, border: false, border_color: nil)
+          if dest && (uri || file || action) || uri && (file || action) || file && action
+            raise ArgumentError, "Only one of dest, uri, file or action is allowed"
           end
           @dest = dest
           @action = if uri
                       {S: :URI, URI: uri}
                     elsif file
                       {S: :Launch, F: file, NewWindow: true}
+                    elsif action
+                      action
                     end
           @border = case border
                     when false then [0, 0, 0]
@@ -1045,6 +1050,40 @@ module HexaPDF
       #                 line_spacing: 1.5, last_line_gap: true)
       #   composer.text("There is spacing above this line due to last_line_gap.")
 
+      ##
+      # :method: fill_horizontal
+      # :call-seq:
+      #   fill_horizontal(factor = nil)
+      #
+      # If set to a positive number, it specifies that the content of the text item should be
+      # repeated and appropriate spacing applied so that the remaining space of the line is
+      # completely filled.
+      #
+      # If there are multiple text items with this property set for a single line, the remaining
+      # space is split between those items using the set +factors+. For example, if item A has a
+      # factor of 1 and item B a factor of 2, the remaining space will be split so that item
+      # B will receive twice the space of A.
+      #
+      # Notes:
+      #
+      # * This property _must not_ be applied to inline boxes, it only works for text items.
+      # * If the filling should be done with spaces, the non-breaking space character \u{00a0} has
+      #   to be used.
+      #
+      # Examples:
+      #
+      #   #>pdf-composer100
+      #   composer.formatted_text(["Left", {text: "\u{00a0}", fill_horizontal: 1},
+      #                            "Right"])
+      #   composer.formatted_text(["Typical table of contents entry",
+      #                            {text: ".", fill_horizontal: 1}, "34"])
+      #   composer.formatted_text(["Factor 1", {text: "\u{00a0}", fill_horizontal: 1},
+      #                            "Factor 3", {text: "\u{00a0}", fill_horizontal: 3}, "End"])
+      #   overlays = [proc {|c, b| c.line(0, b.height / 2.0, b.width, b.height / 2.0).stroke}]
+      #   composer.formatted_text([{text: "\u{00a0}", fill_horizontal: 1, overlays: overlays},
+      #                            'Centered',
+      #                            {text: "\u{00a0}", fill_horizontal: 1, overlays: overlays}])
+
       ##
       # :method: background_color
       # :call-seq:
@@ -1293,6 +1332,7 @@ module HexaPDF
            "{type: value, value: extra_arg} : value))",
           extra_args: ", extra_arg = nil"}],
         [:last_line_gap, false, {valid_values: [true, false]}],
+        [:fill_horizontal, nil],
         [:background_color, nil],
         [:background_alpha, 1],
         [:padding, "Quad.new(0)", {setter: "Quad.new(value)"}],

data/lib/hexapdf/layout/table_box.rb

@@ -212,13 +212,13 @@ module HexaPDF
         end
 
         # Fits the children of the table cell into the given rectangular area.
-        def fit(available_width, available_height, _frame)
+        def fit(available_width, available_height, frame)
           @width = available_width
           width = available_width - reserved_width
           height = available_height - reserved_height
           return false if width <= 0 || height <= 0
 
-          frame = Frame.new(0, 0, width, height)
+          frame = Frame.new(0, 0, width, height, context: frame.context)
           case children
           when Box
             fit_result = frame.fit(children)
@@ -376,9 +376,11 @@ module HexaPDF
         # The +column_info+ argument needs to be an array of arrays of the form [x_pos, width]
         # containing the horizontal positions and widths of each column.
         #
+        # The +frame+ argument is further handed down to the Cell instances for fitting.
+        #
         # The fitting of a cell is done through the Cell#fit method which stores the result in the
         # cell itself. Furthermore, Cell#left and Cell#top are also assigned correctly.
-        def fit_rows(start_row, available_height, column_info)
+        def fit_rows(start_row, available_height, column_info, frame)
           height = available_height
           last_fitted_row_index = -1
           @cells[start_row..-1].each.with_index(start_row) do |columns, row_index|
@@ -391,7 +393,7 @@ module HexaPDF
                                      else
                                        column_info[cell.column].last
                                      end
-              unless cell.fit(available_cell_width, available_height, nil)
+              unless cell.fit(available_cell_width, available_height, frame)
                 row_fit = false
                 break
               end
@@ -587,7 +589,7 @@ module HexaPDF
       end
 
       # Fits the table into the available space.
-      def fit(available_width, available_height, _frame)
+      def fit(available_width, available_height, frame)
         return false if (@initial_width > 0 && @initial_width > available_width) ||
           (@initial_height > 0 && @initial_height > available_height)
 
@@ -608,14 +610,14 @@ module HexaPDF
         @special_cells_fit_not_successful = false
         [@header_cells, @footer_cells].each do |special_cells|
           next unless special_cells
-          special_used_height, last_fitted_row_index = special_cells.fit_rows(0, height, columns)
+          special_used_height, last_fitted_row_index = special_cells.fit_rows(0, height, columns, frame)
           height -= special_used_height
           used_height += special_used_height
           @special_cells_fit_not_successful = (last_fitted_row_index != special_cells.number_of_rows - 1)
           return false if @special_cells_fit_not_successful
         end
 
-        main_used_height, @last_fitted_row_index = @cells.fit_rows(@start_row_index, height, columns)
+        main_used_height, @last_fitted_row_index = @cells.fit_rows(@start_row_index, height, columns, frame)
         used_height += main_used_height
 
         @width = (@initial_width > 0 ? @initial_width : columns[-1].sum + rw)

data/lib/hexapdf/layout/text_box.rb

@@ -54,6 +54,13 @@ module HexaPDF
         @result = nil
       end
 
+      # Returns the text that will be drawn.
+      #
+      # This will ignore any inline boxes or kerning values.
+      def text
+        @items.map {|item| item.kind_of?(TextFragment) ? item.text : '' }.join
+      end
+
       # Returns +true+ as the 'position' style property value :flow is supported.
       def supports_position_flow?
         true
@@ -75,13 +82,13 @@ module HexaPDF
         @width = @height = 0
         @result = if style.position == :flow
                     @tl.fit(@items, frame.width_specification, frame.shape.bbox.height,
-                            apply_first_text_indent: !split_box?)
+                            apply_first_text_indent: !split_box?, frame: frame)
                   else
                     @width = reserved_width
                     @height = reserved_height
                     width = (@initial_width > 0 ? @initial_width : available_width) - @width
                     height = (@initial_height > 0 ? @initial_height : available_height) - @height
-                    @tl.fit(@items, width, height, apply_first_text_indent: !split_box?)
+                    @tl.fit(@items, width, height, apply_first_text_indent: !split_box?, frame: frame)
                   end
         @width += if @initial_width > 0 || style.align == :center || style.align == :right
                     width

data/lib/hexapdf/layout/text_fragment.rb

@@ -111,6 +111,11 @@ module HexaPDF
         @properties = properties
       end
 
+      # Returns the text of the fragment.
+      def text
+        items.reject {|i| i.kind_of?(Numeric) }.map(&:str).join
+      end
+
       # Creates a new TextFragment with the same style and custom properties as this one but with
       # the given +items+.
       def dup_attributes(items)
@@ -283,6 +288,28 @@ module HexaPDF
         :text
       end
 
+      # Creates a new text fragment that repeats this fragment's items and applies the necessary
+      # spacing so that the returned text fragment fills the given +width+ completely.
+      #
+      # If the given +width+ is less than the fragment's width, +self+ is returned.
+      def fill_horizontal!(width)
+        return self if width < self.width
+
+        factor, rest = width.divmod(self.width)
+        items = @items * factor
+        rest = @items.inject(rest) do |available_width, item|
+          new_available_width = available_width - style.scaled_item_width(item)
+          break available_width if new_available_width < 0
+          items << item
+          new_available_width
+        end
+
+        spacing = rest / (items.size - 1)
+        new_style = @style.dup.update(character_spacing: spacing)
+        items << spacing / new_style.scaled_font_size # correct spacing after last item
+        self.class.new(items, new_style, properties: @properties.dup)
+      end
+
       # Clears all cached values.
       #
       # This method needs to be called if the fragment's items or attributes are changed!
@@ -293,8 +320,7 @@ module HexaPDF
 
       # :nodoc:
       def inspect
-        "#<#{self.class.name} #{items.reject {|i| i.kind_of?(Numeric) }.map(&:str).join.inspect} " \
-          "#{items.inspect}>"
+        "#<#{self.class.name} #{text.inspect} #{items.inspect}>"
       end
 
       private

data/lib/hexapdf/layout/text_layouter.rb

@@ -340,8 +340,8 @@ module HexaPDF
         # current start of the line index should be stored for later use.
         #
         # After the algorithm is finished, it returns the unused items.
-        def self.call(items, width_block, &block)
-          obj = new(items, width_block)
+        def self.call(items, width_block, frame, &block)
+          obj = new(items, width_block, frame)
           if width_block.arity == 1
             obj.variable_width_wrapping(&block)
           else
@@ -353,9 +353,10 @@ module HexaPDF
 
         # Creates a new line wrapping object that arranges the +items+ on lines with the given
         # width.
-        def initialize(items, width_block)
+        def initialize(items, width_block, frame)
           @items = items
           @width_block = width_block
+          @frame = frame
           @line_items = []
           @width = 0
           @glue_items = []
@@ -363,6 +364,7 @@ module HexaPDF
           @last_breakpoint_index = 0
           @last_breakpoint_line_items_index = 0
           @break_prohibited_state = false
+          @fill_horizontal = false
 
           @height_calc = Line::HeightCalculator.new
           @line = DummyLine.new(0, 0)
@@ -505,9 +507,11 @@ module HexaPDF
         #
         # Returns +true+ if the item could be added and +false+ otherwise.
         def add_box_item(item)
+          item.fit_wrapped_box(@frame&.context) if item.kind_of?(InlineBox)
           return false unless @width + item.width <= @available_width
           @line_items.concat(@glue_items).push(item)
           @width += item.width
+          @fill_horizontal ||= item.style.fill_horizontal
           @glue_items.clear
           true
         end
@@ -547,6 +551,17 @@ module HexaPDF
 
         # Creates a Line object from the current line items.
         def create_line
+          if @fill_horizontal
+            rest_width = @available_width - @width
+            indices = []
+            @line_items.each_with_index do |item, index|
+              next unless item.style.fill_horizontal
+              indices << [index, item.style.fill_horizontal]
+              rest_width += item.width
+            end
+            unit_width = rest_width / indices.sum(&:last)
+            indices.each {|i, count| @line_items[i] = @line_items[i].fill_horizontal!(unit_width * count) }
+          end
           Line.new(@line_items)
         end
 
@@ -566,6 +581,7 @@ module HexaPDF
           @last_breakpoint_index = index
           @last_breakpoint_line_items_index = 0
           @break_prohibited_state = false
+          @fill_horizontal = false
           @available_width = @width_block.call(@line)
         end
 
@@ -701,7 +717,7 @@ module HexaPDF
       #     Specifies whether style.text_indent should be applied to the first line. This should be
       #     set to +false+ if the items start with a continuation of a paragraph instead of starting
       #     a new paragraph (e.g. after a page break).
-      def fit(items, width, height, apply_first_text_indent: true)
+      def fit(items, width, height, apply_first_text_indent: true, frame: nil)
         unless items.empty? || items[0].respond_to?(:type)
           items = style.text_segmentation_algorithm.call(items)
         end
@@ -765,7 +781,7 @@ module HexaPDF
           too_wide_box = nil
           line_height = 0
 
-          rest = style.text_line_wrapping_algorithm.call(rest, width_block) do |line, item|
+          rest = style.text_line_wrapping_algorithm.call(rest, width_block, frame) do |line, item|
             # make sure empty lines broken by mandatory paragraph breaks are not empty
             line << TextFragment.new([], style) if item&.type != :box && line.items.empty?
 

data/lib/hexapdf/stream.rb

@@ -278,9 +278,8 @@ module HexaPDF
       end
     end
 
-    # :nodoc:
     # A mapping from short name to long name for filters.
-    FILTER_MAP = {AHx: :ASCIIHexDecode, A85: :ASCII85Decode, LZW: :LZWDecode,
+    FILTER_MAP = {AHx: :ASCIIHexDecode, A85: :ASCII85Decode, LZW: :LZWDecode, # :nodoc:
                   Fl: :FlateDecode, RL: :RunLengthDecode, CCF: :CCITTFaxDecode,
                   DCT: :DCTDecode}.freeze