hexapdf 0.21.0 → 0.23.0

data/lib/hexapdf/document/destinations.rb

@@ -0,0 +1,396 @@
+# -*- encoding: utf-8; frozen_string_literal: true -*-
+#
+#--
+# This file is part of HexaPDF.
+#
+# HexaPDF - A Versatile PDF Creation and Manipulation Library For Ruby
+# Copyright (C) 2014-2022 Thomas Leitner
+#
+# HexaPDF is free software: you can redistribute it and/or modify it
+# under the terms of the GNU Affero General Public License version 3 as
+# published by the Free Software Foundation with the addition of the
+# following permission added to Section 15 as permitted in Section 7(a):
+# FOR ANY PART OF THE COVERED WORK IN WHICH THE COPYRIGHT IS OWNED BY
+# THOMAS LEITNER, THOMAS LEITNER DISCLAIMS THE WARRANTY OF NON
+# INFRINGEMENT OF THIRD PARTY RIGHTS.
+#
+# HexaPDF is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public
+# License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with HexaPDF. If not, see <http://www.gnu.org/licenses/>.
+#
+# The interactive user interfaces in modified source and object code
+# versions of HexaPDF must display Appropriate Legal Notices, as required
+# under Section 5 of the GNU Affero General Public License version 3.
+#
+# In accordance with Section 7(b) of the GNU Affero General Public
+# License, a covered work must retain the producer line in every PDF that
+# is created or manipulated using HexaPDF.
+#
+# If the GNU Affero General Public License doesn't fit your need,
+# commercial licenses are available at <https://gettalong.at/hexapdf/>.
+#++
+
+require 'hexapdf/dictionary'
+require 'hexapdf/error'
+
+module HexaPDF
+  class Document
+
+    # This class provides methods for creating and managing the destinations of a PDF file.
+    #
+    # A destination describes a particular view of a PDF document, consisting of the page, the view
+    # location and a magnification factor. See Destination for details.
+    #
+    # Such destinations may be directly specified where needed, e.g. for link annotations, or they
+    # may be named and later referenced through the name. This class allows to create destinations
+    # with or without a name.
+    #
+    # See: PDF1.7 s12.3.2
+    class Destinations
+
+      # Wraps an explicit destination array to allow easy access to query its properties.
+      #
+      # A *destination array* has the form
+      #
+      #   [page, type, *arguments]
+      #
+      # where +page+ is either a page object or a page number (in case of a destination to a page in
+      # a remote PDF document), +type+ is the destination type (see below) and +arguments+ are the
+      # required arguments for the specific type of destination.
+      #
+      # == Destination Types
+      #
+      # There are eight different types of destinations, each taking different arguments. The
+      # arguments are marked up in the list below and are in the correct order for use in the
+      # destination array. The first name in the list is the PDF internal name, the second one the
+      # explicit, more descriptive one used by HexaPDF:
+      #
+      # :XYZ, :xyz::
+      #     Display the page with the given (+left+, +top+) coordinate at the upper-left corner of
+      #     the window and the specified magnification (+zoom+) factor. A +nil+ value for any
+      #     argument means not changing it from the current value.
+      #
+      # :Fit, :fit_page::
+      #     Display the page so that it fits horizontally and vertically within the window.
+      #
+      # :FitH, :fit_page_horizontal::
+      #     Display the page so that it fits horizontally within the window, with the given +top+
+      #     coordinate being at the top of the window. A +nil+ value for +top+ means not changing it
+      #     from the current value.
+      #
+      # :FitV, :fit_page_vertical::
+      #     Display the page so that it fits vertically within the window, with the given +left+
+      #     coordinate being at the left of the window. A +nil+ value for +left+ means not changing
+      #     it from the current value.
+      #
+      # :FitR, :fit_rectangle::
+      #     Display the page so that the rectangle specified by (+left+, +bottom+)-(+right+, +top+)
+      #     fits horizontally and vertically within the window.
+      #
+      # :FitB, :fit_bounding_box::
+      #     Display the page so that its bounding box fits horizontally and vertically within the
+      #     window.
+      #
+      # :FitBH, :fit_bounding_box_horizontal::
+      #     Display the page so that its bounding box fits horizontally within the window, with the
+      #     given +top+ coordinate being at the top of the window. A +nil+ value for +top+ means not
+      #     changing it from the current value.
+      #
+      # :FitBV, :fit_bounding_box_vertical::
+      #     Display the page so that its bounding box fits vertically within the window, with the
+      #     given +left+ coordinate being at the left of the window. A +nil+ value for +left+ means
+      #     not changing it from the current value.
+      class Destination
+
+        # :nodoc:
+        TYPE_MAPPING = {
+          XYZ: :xyz,
+          Fit: :fit_page,
+          FitH: :fit_page_horizontal,
+          FitV: :fit_page_vertical,
+          FitR: :fit_rectangle,
+          FitB: :fit_bounding_box,
+          FitBH: :fit_bounding_box_horizontal,
+          FitBV: :fit_bounding_box_vertical,
+        }
+
+        # :nodoc:
+        REVERSE_TYPE_MAPPING = Hash[*TYPE_MAPPING.flatten.reverse]
+
+        # Creates a new Destination for the given +destination+ which may be an explicit destination
+        # array or a dictionary with a /D entry (as allowed for a named destination).
+        def initialize(destination)
+          @destination = (destination.kind_of?(HexaPDF::Dictionary) ? destination[:D] : destination)
+        end
+
+        # Returns +true+ if the destination references a destination in a remote document.
+        def remote?
+          @destination[0].kind_of?(Numeric)
+        end
+
+        # Returns the referenced page.
+        #
+        # The return value is either a page object or, in case of a destination to a remote
+        # document, a page number.
+        def page
+          @destination[0]
+        end
+
+        # Returns the type of destination.
+        def type
+          TYPE_MAPPING[@destination[1]]
+        end
+
+        # Returns the argument +left+ if used by the destination, raises an error otherwise.
+        def left
+          case type
+          when :xyz, :fit_page_vertical, :fit_rectangle, :fit_bounding_box_vertical
+            @destination[2]
+          else
+            raise HexaPDF::Error, "No such argument for destination type #{type}"
+          end
+        end
+
+        # Returns the argument +top+ if used by the destination, raises an error otherwise.
+        def top
+          case type
+          when :xyz
+            @destination[3]
+          when :fit_page_horizontal, :fit_bounding_box_horizontal
+            @destination[2]
+          when :fit_rectangle
+            @destination[5]
+          else
+            raise HexaPDF::Error, "No such argument for destination type #{type}"
+          end
+        end
+
+        # Returns the argument +right+ if used by the destination, raises an error otherwise.
+        def right
+          case type
+          when :fit_rectangle
+            @destination[4]
+          else
+            raise HexaPDF::Error, "No such argument for destination type #{type}"
+          end
+        end
+
+        # Returns the argument +bottom+ if used by the destination, raises an error otherwise.
+        def bottom
+          case type
+          when :fit_rectangle
+            @destination[3]
+          else
+            raise HexaPDF::Error, "No such argument for destination type #{type}"
+          end
+        end
+
+        # Returns the argument +zoom+ if used by the destination, raises an error otherwise.
+        def zoom
+          case type
+          when :xyz
+            @destination[4]
+          else
+            raise HexaPDF::Error, "No such argument for destination type #{type}"
+          end
+        end
+
+      end
+
+      include Enumerable
+
+      # Creates a new Destinations object for the given PDF document.
+      def initialize(document)
+        @document = document
+      end
+
+      # :call-seq:
+      #   destinations.create_xyz(page, left: nil, top: nil, zoom: nil)            -> dest
+      #   destinations.create_xyz(page, name: nil, left: nil, top: nil, zoom: nil) -> name
+      #
+      # Creates a new xyz destination array for the given arguments and returns it or, in case
+      # a name is given, the name.
+      #
+      # The arguments +page+, +left+, +top+ and +zoom+ are described in detail in the Destination
+      # class description.
+      #
+      # If the argument +name+ is given, the created destination array is added to the destinations
+      # name tree under that name for reuse later, overwriting an existing entry if there is one.
+      def create_xyz(page, name: nil, left: nil, top: nil, zoom: nil)
+        destination = [page, Destination::REVERSE_TYPE_MAPPING.fetch(:xyz), left, top, zoom]
+        name ? (add(name, destination); name) : destination
+      end
+
+      # :call-seq:
+      #   destinations.create_fit_page(page)            -> dest
+      #   destinations.create_fit_page(page, name: nil) -> name
+      #
+      # Creates a new fit to page destination array for the given arguments and returns it or, in
+      # case a name is given, the name.
+      #
+      # The argument +page+ is described in detail in the Destination class description.
+      #
+      # If the argument +name+ is given, the created destination array is added to the destinations
+      # name tree under that name for reuse later, overwriting an existing entry if there is one.
+      def create_fit_page(page, name: nil)
+        destination = [page, Destination::REVERSE_TYPE_MAPPING.fetch(:fit_page)]
+        name ? (add(name, destination); name) : destination
+      end
+
+      # :call-seq:
+      #   destinations.create_fit_page_horizontal(page, top: nil)            -> dest
+      #   destinations.create_fit_page_horizontal(page, name: nil, top: nil) -> name
+      #
+      # Creates a new fit page horizontal destination array for the given arguments and returns it
+      # or, in case a name is given, the name.
+      #
+      # The arguments +page and +top+ are described in detail in the Destination class description.
+      #
+      # If the argument +name+ is given, the created destination array is added to the destinations
+      # name tree under that name for reuse later, overwriting an existing entry if there is one.
+      def create_fit_page_horizontal(page, name: nil, top: nil)
+        destination = [page, Destination::REVERSE_TYPE_MAPPING.fetch(:fit_page_horizontal), top]
+        name ? (add(name, destination); name) : destination
+      end
+
+      # :call-seq:
+      #   destinations.create_fit_page_vertical(page, left: nil)            -> dest
+      #   destinations.create_fit_page_vertical(page, name: nil, left: nil) -> name
+      #
+      # Creates a new fit page vertical destination array for the given arguments and returns it or,
+      # in case a name is given, the name.
+      #
+      # The arguments +page and +left+ are described in detail in the Destination class description.
+      #
+      # If the argument +name+ is given, the created destination array is added to the destinations
+      # name tree under that name for reuse later, overwriting an existing entry if there is one.
+      def create_fit_page_vertical(page, name: nil, left: nil)
+        destination = [page, Destination::REVERSE_TYPE_MAPPING.fetch(:fit_page_vertical), left]
+        name ? (add(name, destination); name) : destination
+      end
+
+      # :call-seq:
+      #   destinations.create_fit_rectangle(page, left:, bottom:, right:, top:)            -> dest
+      #   destinations.create_fit_rectangle(page, name: nil, left:, bottom:, right:, top:) -> name
+      #
+      # Creates a new fit to rectangle destination array for the given arguments and returns it or,
+      # in case a name is given, the name.
+      #
+      # The arguments +page+, +left+, +bottom+, +right+ and +top+ are described in detail in the
+      # Destination class description.
+      #
+      # If the argument +name+ is given, the created destination array is added to the destinations
+      # name tree under that name for reuse later, overwriting an existing entry if there is one.
+      def create_fit_rectangle(page, left:, bottom:, right:, top:, name: nil)
+        destination = [page, Destination::REVERSE_TYPE_MAPPING.fetch(:fit_rectangle),
+                       left, bottom, right, top]
+        name ? (add(name, destination); name) : destination
+      end
+
+      # :call-seq:
+      #   destinations.create_fit_bounding_box(page)            -> dest
+      #   destinations.create_fit_bounding_box(page, name: nil) -> name
+      #
+      # Creates a new fit to bounding box destination array for the given arguments and returns it
+      # or, in case a name is given, the name.
+      #
+      # The argument +page+ is described in detail in the Destination class description.
+      #
+      # If the argument +name+ is given, the created destination array is added to the destinations
+      # name tree under that name for reuse later, overwriting an existing entry if there is one.
+      def create_fit_bounding_box(page, name: nil)
+        destination = [page, Destination::REVERSE_TYPE_MAPPING.fetch(:fit_bounding_box)]
+        name ? (add(name, destination); name) : destination
+      end
+
+      # :call-seq:
+      #   destinations.create_fit_bounding_box_horizontal(page, top: nil)            -> dest
+      #   destinations.create_fit_bounding_box_horizontal(page, name: nil, top: nil) -> name
+      #
+      # Creates a new fit bounding box horizontal destination array for the given arguments and
+      # returns it or, in case a name is given, the name.
+      #
+      # The arguments +page and +top+ are described in detail in the Destination class description.
+      #
+      # If the argument +name+ is given, the created destination array is added to the destinations
+      # name tree under that name for reuse later, overwriting an existing entry if there is one.
+      def create_fit_bounding_box_horizontal(page, name: nil, top: nil)
+        destination = [page, Destination::REVERSE_TYPE_MAPPING.fetch(:fit_bounding_box_horizontal), top]
+        name ? (add(name, destination); name) : destination
+      end
+
+      # :call-seq:
+      #   destinations.create_fit_bounding_box_vertical(page, left: nil)            -> dest
+      #   destinations.create_fit_bounding_box_vertical(page, name: nil, left: nil) -> name
+      #
+      # Creates a new fit bounding box vertical destination array for the given arguments and
+      # returns it or, in case a name is given, the name.
+      #
+      # The arguments +page and +left+ are described in detail in the Destination class description.
+      #
+      # If the argument +name+ is given, the created destination array is added to the destinations
+      # name tree under that name for reuse later, overwriting an existing entry if there is one.
+      def create_fit_bounding_box_vertical(page, name: nil, left: nil)
+        destination = [page, Destination::REVERSE_TYPE_MAPPING.fetch(:fit_bounding_box_vertical), left]
+        name ? (add(name, destination); name) : destination
+      end
+
+      # :call-seq:
+      #   destinations.add(name, destination)
+      #
+      # Adds the given +destination+ under +name+ to the destinations name tree.
+      #
+      # If the name does already exist, an error is raised.
+      def add(name, destination)
+        destinations.add_entry(name, destination)
+      end
+
+      # :call-seq:
+      #   destinations.delete(name)    -> destination
+      #
+      # Deletes the given destination from the destinations name tree and returns it or +nil+ if no
+      # destination was registered under that name.
+      def delete(name)
+        destinations.delete_entry(name)
+      end
+
+      # :call-seq:
+      #   destinations[name]    -> destination
+      #
+      # Returns the destination registered under the given +name+ or +nil+ if no destination was
+      # registered under that name.
+      def [](name)
+        destinations.find_entry(name)
+      end
+
+      # :call-seq:
+      #   destinations.each {|name, dest| block }  -> destinations
+      #   destinations.each                        -> Enumerator
+      #
+      # Iterates over all named destinations of the PDF, yielding the name and the destination
+      #  wrapped into a Destination object.
+      def each
+        return to_enum(__method__) unless block_given?
+
+        destinations.each_entry do |name, dest|
+          yield(name, Destination.new(dest))
+        end
+
+        self
+      end
+
+      private
+
+      # Returns the root of the destinations name tree.
+      def destinations
+        @document.catalog.names.destinations
+      end
+
+    end
+
+  end
+end

data/lib/hexapdf/document.rb

@@ -106,6 +106,7 @@ module HexaPDF
     autoload(:Images, 'hexapdf/document/images')
     autoload(:Files, 'hexapdf/document/files')
     autoload(:Signatures, 'hexapdf/document/signatures')
+    autoload(:Destinations, 'hexapdf/document/destinations')
 
     # :call-seq:
     #   Document.open(filename, **docargs)                   -> doc
@@ -184,22 +185,9 @@ module HexaPDF
     # For references to unknown objects, +nil+ is returned but free objects are represented by a
     # PDF Null object, not by +nil+!
     #
-    # See: PDF1.7 s7.3.9
+    # See: Revisions#object
     def object(ref)
-      i = @revisions.size - 1
-      while i >= 0
-        return @revisions[i].object(ref) if @revisions[i].object?(ref)
-        i -= 1
-      end
-      nil
-    end
-
-    # Dereferences the given object.
-    #
-    # Return the object itself if it is not a reference, or the indirect object specified by the
-    # reference.
-    def deref(obj)
-      obj.kind_of?(Reference) ? object(obj) : obj
+      @revisions.object(ref)
     end
 
     # :call-seq:
@@ -212,74 +200,51 @@ module HexaPDF
     # Even though this method might return +true+ for some references, #object may return +nil+
     # because this method takes *all* revisions into account. Also see the discussion on #each for
     # more information.
+    #
+    # See: Revisions#object?
     def object?(ref)
-      @revisions.any? {|rev| rev.object?(ref) }
+      @revisions.object?(ref)
+    end
+
+    # Dereferences the given object.
+    #
+    # Return the object itself if it is not a reference, or the indirect object specified by the
+    # reference.
+    def deref(obj)
+      obj.kind_of?(Reference) ? object(obj) : obj
     end
 
     # :call-seq:
-    #   doc.add(obj, revision: :current, **wrap_opts)     -> indirect_object
+    #   doc.add(obj, **wrap_opts)     -> indirect_object
     #
-    # Adds the object to the specified revision of the document and returns the wrapped indirect
-    # object.
+    # Adds the object to the document and returns the wrapped indirect object.
     #
     # The object can either be a native Ruby object (Hash, Array, Integer, ...) or a
     # HexaPDF::Object. If it is not the latter, #wrap is called with the object and the
     # additional keyword arguments.
     #
-    # If the +revision+ option is +:current+, the current revision is used. Otherwise +revision+
-    # should be a revision index.
-    def add(obj, revision: :current, **wrap_opts)
+    # See: Revisions#add_object
+    def add(obj, **wrap_opts)
       obj = wrap(obj, **wrap_opts) unless obj.kind_of?(HexaPDF::Object)
 
-      revision = (revision == :current ? @revisions.current : @revisions.revision(revision))
-      if revision.nil?
-        raise ArgumentError, "Invalid revision index specified"
-      end
-
       if obj.document? && obj.document != self
         raise HexaPDF::Error, "Can't add object that is already attached to another document"
       end
       obj.document = self
 
-      if obj.indirect? && (rev_obj = revision.object(obj.oid))
-        if rev_obj.equal?(obj)
-          return obj
-        else
-          raise HexaPDF::Error, "Can't add object because the specified revision already has " \
-            "an object with object number #{obj.oid}"
-        end
-      end
-
-      obj.oid = @revisions.map(&:next_free_oid).max unless obj.indirect?
-
-      revision.add(obj)
+      @revisions.add_object(obj)
     end
 
     # :call-seq:
-    #   doc.delete(ref, revision: :all)
-    #   doc.delete(oid, revision: :all)
+    #   doc.delete(ref)
+    #   doc.delete(oid)
     #
     # Deletes the indirect object specified by an exact reference or by an object number from the
     # document.
     #
-    # Options:
-    #
-    # revision:: Specifies from which revisions the object should be deleted:
-    #
-    #            :all:: Delete the object from all revisions.
-    #            :current:: Delete the object only from the current revision.
-    #
-    # mark_as_free:: If +true+, objects are only marked as free objects instead of being actually
-    #                deleted.
-    def delete(ref, revision: :all, mark_as_free: true)
-      case revision
-      when :current
-        @revisions.current.delete(ref, mark_as_free: mark_as_free)
-      when :all
-        @revisions.each {|rev| rev.delete(ref, mark_as_free: mark_as_free) }
-      else
-        raise ArgumentError, "Unsupported option revision: #{revision}"
-      end
+    # See: Revisions#delete_object
+    def delete(ref)
+      @revisions.delete_object(ref)
     end
 
     # :call-seq:
@@ -414,42 +379,20 @@ module HexaPDF
     end
 
     # :call-seq:
-    #   doc.each(only_current: true, only_loaded: false) {|obj| block }        -> doc
-    #   doc.each(only_current: true, only_loaded: false) {|obj, rev| block }   -> doc
+    #   doc.each(only_current: true, only_loaded: false) {|obj| block }
+    #   doc.each(only_current: true, only_loaded: false) {|obj, rev| block }
     #   doc.each(only_current: true, only_loaded: false)                       -> Enumerator
     #
-    # Calls the given block once for every object, or, if +only_loaded+ is +true+, for every loaded
-    # object in the PDF document. The block may either accept only the object or the object and the
-    # revision it is in.
-    #
-    # By default, only the current version of each object is returned which implies that each object
-    # number is yielded exactly once. If the +only_current+ option is +false+, all stored objects
-    # from newest to oldest are returned, not only the current version of each object.
+    # Yields every object and the revision it is in.
     #
-    # The +only_current+ option can make a difference because the document can contain multiple
-    # revisions:
+    # If +only_current+ is +true+, only the current version of each object is yielded, otherwise
+    # all objects from all revisions.
     #
-    # * Multiple revisions may contain objects with the same object and generation numbers, e.g.
-    #   two (different) objects with oid/gen [3,0].
+    # If +only_loaded+ is +true+, only the already loaded objects are yielded.
     #
-    # * Additionally, there may also be objects with the same object number but different
-    #   generation numbers in different revisions, e.g. one object with oid/gen [3,0] and one with
-    #   oid/gen [3,1].
+    # For details see Revisions#each_object
     def each(only_current: true, only_loaded: false, &block)
-      unless block_given?
-        return to_enum(__method__, only_current: only_current, only_loaded: only_loaded)
-      end
-
-      yield_rev = (block.arity == 2)
-      oids = {}
-      @revisions.reverse_each do |rev|
-        rev.each(only_loaded: only_loaded) do |obj|
-          next if only_current && oids.include?(obj.oid)
-          (yield_rev ? yield(obj, rev) : yield(obj))
-          oids[obj.oid] = true
-        end
-      end
-      self
+      @revisions.each_object(only_current: only_current, only_loaded: only_loaded, &block)
     end
 
     # :call-seq:
@@ -529,6 +472,12 @@ module HexaPDF
       @fonts ||= Fonts.new(self)
     end
 
+    # Returns the Destinations object that provides convenience methods for working with destination
+    # objects.
+    def destinations
+      @destinations ||= Destinations.new(self)
+    end
+
     # Returns the main AcroForm object for dealing with interactive forms.
     #
     # See HexaPDF::Type::Catalog#acro_form for details on the arguments.

data/lib/hexapdf/encryption/aes.rb

@@ -114,10 +114,12 @@ module HexaPDF
         #
         # See: PDF1.7 s7.6.2.
         def decrypt(key, data)
-          if data.length % BLOCK_SIZE != 0 || data.length < 2 * BLOCK_SIZE
+          if data.length % BLOCK_SIZE != 0 || data.length < BLOCK_SIZE
             raise HexaPDF::EncryptionError, "Invalid data for decryption, need 32 + 16*n bytes"
           end
-          unpad(new(key, data.slice!(0, BLOCK_SIZE), :decrypt).process(data))
+          iv = data.slice!(0, BLOCK_SIZE)
+          # Handle invalid files with missing padding
+          data.empty? ? data : unpad(new(key, iv, :decrypt).process(data))
         end
 
         # Returns a Fiber object that decrypts the data from the given source fiber with the
@@ -140,11 +142,13 @@ module HexaPDF
               Fiber.yield(algorithm.process(new_data))
             end
 
-            if data.length < BLOCK_SIZE || data.length % BLOCK_SIZE != 0
+            if data.length % BLOCK_SIZE != 0
               raise HexaPDF::EncryptionError, "Invalid data for decryption, need 32 + 16*n bytes"
+            elsif data.empty?
+              data # Handle invalid files with missing padding
+            else
+              unpad(algorithm.process(data))
             end
-
-            unpad(algorithm.process(data))
           end
         end
 

data/lib/hexapdf/layout/frame.rb

@@ -252,14 +252,6 @@ module HexaPDF
                       else
                         create_rectangle(x, y, x + width, y + height)
                       end
-        when :float
-          x = @x + @fit_data.margin_left
-          x += @fit_data.available_width - width if box.style.position_hint == :right
-          y = @y - height - @fit_data.margin_top
-          # We use the real margins from the box because they either have the desired effect or just
-          # extend the rectangle outside the frame.
-          rectangle = create_rectangle(x - (margin&.left || 0), y - (margin&.bottom || 0),
-                                       x + width + (margin&.right || 0), @y)
         when :flow
           x = 0
           y = @y - height
@@ -280,7 +272,14 @@ module HexaPDF
                 @x + @fit_data.margin_left
               end
           y = @y - height - @fit_data.margin_top
-          rectangle = create_rectangle(left, y - (margin&.bottom || 0), left + self.width, @y)
+          rectangle = if box.style.position == :float
+                        # We use the real margins from the box because they either have the desired
+                        # effect or just extend the rectangle outside the frame.
+                        create_rectangle(x - (margin&.left || 0), y - (margin&.bottom || 0),
+                                         x + width + (margin&.right || 0), @y)
+                      else
+                        create_rectangle(left, y - (margin&.bottom || 0), left + self.width, @y)
+                      end
         end
 
         box.draw(canvas, x, y)