hexapdf 0.21.1 → 0.22.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9792b3c8be5fd3c3521aa5fe1a66e1315f677494f199e3e8b0e1eb85c9b967c7
-  data.tar.gz: a66f1d6751cac4ca2fc6a35bf493ba60eefee96edca090ae92ed810b756d8761
+  metadata.gz: 1388a344a539c7273603549e014c635c4864af4de8665a260b15ac66d19ac461
+  data.tar.gz: 471e0f4933ac37348ac5ed217446031e742099de26773b25bb23c49fc8480a05
 SHA512:
-  metadata.gz: 111570ec411684ffe5214833419128b697721c4e5fdd16b61578c3d459a8ab9dde411780dd582e06620d52a260062df30a116b7c3c8544647f5e61f131c6bdc5
-  data.tar.gz: 3d098cb4098f6a02bc832cbe70aebc0b28a40a21b33b53c8e8e055f240fd513a5d96f53846c62ebbc2a00d17d6f99271dd3850e98a70cebb6f32e1a7e279cc87
+  metadata.gz: 0ab8c16c85475e68f12faea47f8dbf7e167ebdc864d11fb1151e107af1d3678b867ad0d7a6184155e1b55ed1469d3e7443f39184e0250974f5a7df9a920adb99
+  data.tar.gz: 43c80b555018068baf314d6ed7d6a03ae0a359f2e8be498341985ecb75879fd414d066d7c356b47fb896ec0e4aa74c2044f6a5e7965922de1136ddacf409765f

data/CHANGELOG.md

@@ -1,3 +1,24 @@
+## 0.22.0 - 2022-03-26
+
+### Added
+
+- Support for writing images with an ICCBased color space
+- Support for writing images with soft masks
+
+### Changed
+
+- CLI command `hexapdf form` to show a warning when working with a file
+  containing an XFA form
+
+### Fixed
+
+- [HexaPDF::Type::AcroForm::Form#field_by_name] to work correctly when field
+  name parts are UTF-16BE encoded
+- `hexapdf inspect` command 'revision' to correctly detect the end of revisions
+- [HexaPDF::DictionaryFields::StringConverter] to use correct method name
+  `HexaPDF::Document#config`
+
+
 ## 0.21.1 - 2022-03-12
 
 ### Fixed

data/lib/hexapdf/cli/form.rb

@@ -97,6 +97,10 @@ module HexaPDF
         end
         with_document(in_file, password: @password, out_file: out_file,
                       incremental: @incremental) do |doc|
+          if doc.acro_form[:XFA]
+            $stderr.puts "Warning: Unsupported XFA form detected, some things may not work correctly"
+          end
+
           if !doc.acro_form
             raise "This PDF doesn't contain an interactive form"
           elsif out_file

data/lib/hexapdf/cli/inspect.rb

@@ -342,10 +342,14 @@ module HexaPDF
             end_index = sig[:ByteRange][-2] + sig[:ByteRange][-1]
           else
             io.seek(startxrefs[index], IO::SEEK_SET)
+            buffer = ''.b
             while io.pos < startxrefs[index + 1]
-              if io.gets =~ /^\s*%%EOF\s*$/
-                end_index = io.pos
+              buffer << io.read(1_000)
+              if (buffer_index = buffer.index(/(?:\n|\r\n?)\s*%%EOF\s*(?:\n|\r\n?)/))
+                end_index = io.pos - buffer.size + buffer_index + $~[0].size
+                break
               end
+              buffer = buffer[-20..-1]
             end
           end
           yield(rev, index, rev.next_free_oid - 1, sig, end_index)

data/lib/hexapdf/dictionary_fields.rb

@@ -241,7 +241,7 @@ module HexaPDF
           if str.valid_encoding?
             str.encode!(Encoding::UTF_8)
           else
-            document.configuration['document.on_invalid_string'].call(str)
+            document.config['document.on_invalid_string'].call(str)
           end
         else
           Utils::PDFDocEncoding.convert_to_utf8(str)

data/lib/hexapdf/type/acro_form/form.rb

@@ -139,13 +139,19 @@ module HexaPDF
         def field_by_name(name)
           fields = root_fields
           field = nil
+
           name.split('.').each do |part|
-            field = fields&.find {|f| f[:T] == part }
-            break unless field
-            field = document.wrap(field, type: :XXAcroFormField,
-                                  subtype: Field.inherited_value(field, :FT))
-            fields = field[:Kids] unless field.terminal_field?
+            field = nil
+            fields&.each do |f|
+              f = document.wrap(f, type: :XXAcroFormField,
+                                subtype: Field.inherited_value(f, :FT))
+              next unless f[:T] == part
+              field = f
+              fields = field[:Kids] unless field.terminal_field?
+              break
+            end
           end
+
           field
         end
 

data/lib/hexapdf/type/image.rb

@@ -163,13 +163,23 @@ module HexaPDF
           result.color_space = :cmyk
           result.components = 4
           result.writable = false if result.type == :png
+        when :ICCBased
+          result.color_space = :icc
+          result.components = self[:ColorSpace][1][:N]
+          result.writable = false if result.type == :png && result.components == 4
         else
           result.color_space = :other
           result.components = -1
           result.writable = false if result.type == :png
         end
 
-        result.writable = false if self[:SMask]
+        smask = self[:SMask]
+        if smask && (result.type != :png ||
+                     !(result.bits_per_component == 8 || result.bits_per_component == 16) ||
+                     result.bits_per_component != smask[:BitsPerComponent] ||
+                     result.width != smask[:Width] || result.height != smask[:Height])
+          result.writable = false
+        end
 
         result
       end
@@ -224,10 +234,18 @@ module HexaPDF
                        ImageLoader::PNG::INDEXED
                      elsif info.color_space == :rgb
                        ImageLoader::PNG::TRUECOLOR
+                     elsif info.color_space == :icc
+                       info.components == 3 ? ImageLoader::PNG::TRUECOLOR : ImageLoader::PNG::GREYSCALE
                      else
                        ImageLoader::PNG::GREYSCALE
                      end
 
+        if self[:SMask] && color_type != ImageLoader::PNG::INDEXED
+          color_type += 4 # change it to TrueColor/Greyscale with Alpha
+        end
+
+        flate_decode = config.constantize('filter.map', :FlateDecode)
+
         io << png_chunk('IHDR', [info.width, info.height, info.bits_per_component,
                                  color_type, 0, 0, 0].pack('N2C5'))
 
@@ -239,6 +257,12 @@ module HexaPDF
             png_chunk('cHRM', [31270, 32900, 64000, 33000, 30000, 60000, 15000, 6000].pack('N8'))
         end
 
+        if info.color_space == :icc
+          _, stream = *self[:ColorSpace]
+          data = flate_decode.encoder(stream.stream_decoder)
+          io << png_chunk('iCCP', "ICCProfile\x00\x00".b << Filter.string_from_source(data))
+        end
+
         if color_type == ImageLoader::PNG::INDEXED
           palette_data = self[:ColorSpace][3]
           palette_data = palette_data.stream unless palette_data.kind_of?(String)
@@ -258,11 +282,14 @@ module HexaPDF
 
         filter, = *self[:Filter]
         decode_parms, = *self[:DecodeParms]
-        if filter == :FlateDecode && decode_parms && decode_parms[:Predictor].to_i >= 10
+        if self[:SMask]
+          data = flate_decode.encoder(Fiber.new { png_combine_image_and_soft_mask(info) }, Predictor: 15,
+                                      Colors: info.components + 1, Columns: info.width,
+                                      BitsPerComponent: info.bits_per_component)
+        elsif filter == :FlateDecode && decode_parms && decode_parms[:Predictor].to_i >= 10
           data = stream_source
         else
           colors = (color_type == ImageLoader::PNG::INDEXED ? 1 : info.components)
-          flate_decode = config.constantize('filter.map', :FlateDecode)
           data = flate_decode.encoder(stream_decoder, Predictor: 15,
                                       Colors: colors, Columns: info.width,
                                       BitsPerComponent: info.bits_per_component)
@@ -277,6 +304,23 @@ module HexaPDF
         [data.length].pack("N") << type << data << [Zlib.crc32(data, Zlib.crc32(type))].pack("N")
       end
 
+      # Combines the image data with the soft mask data as needed for a PNG data stream.
+      def png_combine_image_and_soft_mask(info)
+        bytes_per_colors = info.bits_per_component * info.components / 8
+        bytes_per_alpha = info.bits_per_component / 8
+        image_data = stream
+        mask_data = self[:SMask].stream
+
+        data = ''.b
+        ii = im = 0
+        while ii < image_data.length
+          data << image_data[ii, bytes_per_colors] << mask_data[im, bytes_per_alpha]
+          ii += bytes_per_colors
+          im += bytes_per_alpha
+        end
+        data
+      end
+
     end
 
   end

data/lib/hexapdf/version.rb

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

data/test/hexapdf/test_dictionary_fields.rb

@@ -134,7 +134,7 @@ describe HexaPDF::DictionaryFields do
       assert_equal(Encoding::UTF_8, str.encoding)
     end
 
-    def configuration
+    def config
       HexaPDF::Configuration.with_defaults
     end
 

data/test/hexapdf/test_writer.rb

@@ -40,7 +40,7 @@ describe HexaPDF::Writer do
       219
       %%EOF
       3 0 obj
-      <</Producer(HexaPDF version 0.21.1)>>
+      <</Producer(HexaPDF version 0.22.0)>>
       endobj
       xref
       3 1
@@ -72,7 +72,7 @@ describe HexaPDF::Writer do
       141
       %%EOF
       6 0 obj
-      <</Producer(HexaPDF version 0.21.1)>>
+      <</Producer(HexaPDF version 0.22.0)>>
       endobj
       2 0 obj
       <</Length 10>>stream

data/test/hexapdf/type/acro_form/test_form.rb

@@ -86,7 +86,8 @@ describe HexaPDF::Type::AcroForm::Form do
     before do
       @acro_form[:Fields] = [
         {T: "root only", Kids: [{Subtype: :Widget}]},
-        {T: "children", Kids: [{T: "child", FT: :Btn}, {T: "sub", Kids: [{T: "child"}]}]},
+        {T: "children", Kids: [{T: "\xFE\xFF".b << "child".encode('UTF-16BE').b, FT: :Btn},
+                               {T: "sub", Kids: [{T: "child"}]}]},
       ]
     end
 

data/test/hexapdf/type/test_image.rb

@@ -115,16 +115,42 @@ describe HexaPDF::Type::Image do
       assert(info.indexed)
       assert(info.writable)
 
-      @image[:ColorSpace] = :ICCBased
+      @image[:ColorSpace] = [:ICCBased, {N: 3}]
       info = @image.info
-      assert_equal(:other, info.color_space)
-      assert_equal(-1, info.components)
+      assert_equal(:icc, info.color_space)
+      assert_equal(3, info.components)
+      assert(info.writable)
+      @image[:ColorSpace] = [:ICCBased, {N: 4}]
+      info = @image.info
+      refute(info.writable)
     end
 
     it "processes the SMask entry" do
-      @image[:SMask] = :something
-      info = @image.info
-      refute(info.writable)
+      @image[:SMask] = {BitsPerComponent: 8, Width: 10, Height: 5}
+
+      @image[:BitsPerComponent] = 8
+      assert(@image.info.writable)
+
+      @image[:BitsPerComponent] = 16
+      refute(@image.info.writable)
+      @image[:SMask][:BitsPerComponent] = 16
+      assert(@image.info.writable)
+
+      @image[:BitsPerComponent] = 4
+      refute(@image.info.writable)
+      @image[:SMask][:BitsPerComponent] = 4
+      refute(@image.info.writable)
+
+      @image[:BitsPerComponent] = @image[:SMask][:BitsPerComponent] = 8
+      @image[:SMask][:Width] = 8
+      refute(@image.info.writable)
+
+      @image[:SMask][:Width] = 10
+      @image[:SMask][:Height] = 8
+      refute(@image.info.writable)
+
+      @image[:SMask][:Height] = 5
+      assert(@image.info.writable)
     end
   end
 
@@ -184,7 +210,7 @@ describe HexaPDF::Type::Image do
     end
 
     Dir.glob(File.join(TEST_DATA_DIR, 'images', '*.png')).each do |png_file|
-      next if png_file =~ /alpha/
+      next if png_file =~ /indexed-alpha/
       it "writes #{File.basename(png_file)} correctly as PNG file" do
         image = @doc.images.add(png_file)
         if png_file =~ /greyscale-1bit.png/ # force use of arrays for one image
@@ -208,6 +234,7 @@ describe HexaPDF::Type::Image do
         else
           assert_nil(new_image[:Mask], "file: #{png_file}")
         end
+        assert(new_image[:SMask]) if png_file =~ /alpha/
         assert_equal(image.stream, new_image.stream, "file: #{png_file}")
 
         # ColorSpace is currently not always preserved, e.g. with CalRGB
@@ -236,6 +263,15 @@ describe HexaPDF::Type::Image do
       assert_equal(image.stream, new_image.stream)
     end
 
+    it "works for images with an ICCBased color space" do
+      image = @doc.add({Type: :XObject, Subtype: :Image, Width: 2, Height: 2, BitsPerComponent: 2,
+                        ColorSpace: [:ICCBased, @doc.wrap({}, stream: 'abcd')]})
+      image.stream = HexaPDF::StreamData.new(filter: :ASCIIHexDecode) { "10 B0".b }
+      image.write(@file.path)
+      assert_valid_png(@file.path)
+      assert_match(/iCCPICCProfile\x00\x00/, File.binread(@file.path))
+    end
+
     it "fails if an unsupported stream filter is used" do
       image = @doc.images.add(@jpg)
       image.set_filter([:DCTDecode, :ASCIIHexDecode])
@@ -244,13 +280,13 @@ describe HexaPDF::Type::Image do
 
     it "fails if an unsupported colorspace is used" do
       image = @doc.add({Type: :XObject, Subtype: :Image, Width: 1, Height: 1, BitsPerComponent: 8,
-                        ColorSpace: :ICCBased})
+                        ColorSpace: :Unknown})
       assert_raises(HexaPDF::Error) { image.write(@file) }
     end
 
     it "fails if an indexed image with an unsupported colorspace is used" do
       image = @doc.add({Type: :XObject, Subtype: :Image, Width: 1, Height: 1, BitsPerComponent: 8,
-                        ColorSpace: [:Indexed, :ICCBased, 0, "0"]})
+                        ColorSpace: [:Indexed, :Unknown, 0, "0"]})
       assert_raises(HexaPDF::Error) { image.write(@file) }
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hexapdf
 version: !ruby/object:Gem::Version
-  version: 0.21.1
+  version: 0.22.0
 platform: ruby
 authors:
 - Thomas Leitner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-03-12 00:00:00.000000000 Z
+date: 2022-03-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cmdparse
@@ -217,7 +217,6 @@ files:
 - examples/017-frame_text_flow.rb
 - examples/018-composer.rb
 - examples/019-acro_form.rb
-- examples/020-column_box.rb
 - examples/emoji-smile.png
 - examples/emoji-wink.png
 - examples/machupicchu.jpg
@@ -334,7 +333,6 @@ files:
 - lib/hexapdf/importer.rb
 - lib/hexapdf/layout.rb
 - lib/hexapdf/layout/box.rb
-- lib/hexapdf/layout/column_box.rb
 - lib/hexapdf/layout/frame.rb
 - lib/hexapdf/layout/image_box.rb
 - lib/hexapdf/layout/inline_box.rb
@@ -673,7 +671,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.3
+rubygems_version: 3.2.32
 signing_key: 
 specification_version: 4
 summary: HexaPDF - A Versatile PDF Creation and Manipulation Library For Ruby

data/examples/020-column_box.rb

@@ -1,57 +0,0 @@
-# ## Column Box
-#
-# This example shows how [HexaPDF::Layout::Frame] and [HexaPDF::Layout::TextBox]
-# can be used to flow text around objects.
-#
-# Three boxes are placed repeatedly onto the frame until it is filled: two
-# floating boxes (one left, one right) and a text box. The text box is styled to
-# flow its content around the other two boxes.
-#
-# Usage:
-# : `ruby frame_text_flow.rb`
-#
-
-require 'hexapdf'
-require 'hexapdf/utils/graphics_helpers'
-
-include HexaPDF::Layout
-include HexaPDF::Utils::GraphicsHelpers
-
-doc = HexaPDF::Document.new
-
-sample_text = "Lorem ipsum dolor sit amet, con\u{00AD}sectetur
-adipis\u{00AD}cing 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.
-".tr("\n", ' ') * 5
-items = [TextFragment.create(sample_text, font: doc.fonts.add("Times"))]
-
-page = doc.pages.add
-media_box = page.box(:media)
-canvas = page.canvas
-frame = Frame.new(media_box.left + 20, media_box.bottom + 20,
-                  media_box.width - 40, media_box.height - 40)
-
-image = doc.images.add(File.join(__dir__, 'machupicchu.jpg'))
-iw, ih = calculate_dimensions(image.width, image.height, rwidth: 100)
-
-boxes = []
-3.times do
-  boxes << Box.create(width: iw, height: ih,
-    margin: [10, 30], position: :float) do |canv, box|
-    canv.image(image, at: [0, 0], width: 100)
-  end
-  boxes << Box.create(width: 50, height: 50, margin: 20,
-    position: :float, position_hint: :right,
-    border: {width: 1, color: [[255, 0, 0]]})
-  boxes << TextBox.new(items, style: {position: :flow, align: :justify})
-end
-columns = ColumnBox.new(boxes) #, style: {position: :flow})
-polygon = Geom2D::Polygon([250, 350], [350, 350], [350, 500], [250, 500])
-#frame.remove_area(polygon)
-#canvas.draw(:geom2d, object: polygon)
-result = frame.fit(columns)
-p result.success?
-frame.draw(canvas, result)
-
-doc.write("column_box.pdf", optimize: true)

data/lib/hexapdf/layout/column_box.rb

@@ -1,168 +0,0 @@
-# -*- 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/layout/box'
-
-module HexaPDF
-  module Layout
-
-    # A ColumnBox arranges boxes in one or more columns.
-    #
-    # The number of columns as well as the size of the gap between the columns can be modified.
-    class ColumnBox < Box
-
-      # The child boxes of this ColumnBox.
-      attr_reader :children
-
-      # The number of columns.
-      # TODO: allow array with column widths later like [100, :*, :*]; same for gaps
-      attr_reader :columns
-
-      # The size of the gap between the columns.
-      attr_reader :gap
-
-      # Creates a new ColumnBox object for the given +children+ boxes.
-      def initialize(children = [], columns = 2, gap: 36, **kwargs)
-        super(**kwargs)
-        @children = children
-        @columns = columns
-        @gap = gap
-      end
-
-      # Fits the column box into the available space.
-      def fit(available_width, available_height, frame)
-        last_height_difference = 1_000_000
-        height = if style.position == :flow
-                   frame.height
-                 else
-                   (@initial_height > 0 ? @initial_height : available_height) - reserved_height
-                 end
-        while true
-          p '-'*100
-          @frames = []
-          if style.position == :flow
-            column_width = (frame.width - gap * (@columns - 1)).to_f / @columns
-            @columns.times do |col_nr|
-              left = (column_width + gap) * col_nr + frame.left
-              bottom = frame.bottom
-              rect = Geom2D::Polygon([left, bottom],
-                                     [left + column_width, bottom],
-                                     [left + column_width, bottom + height],
-                                     [left, bottom + height])
-              shape = Geom2D::Algorithms::PolygonOperation.run(frame.shape, rect, :intersection)
-              col_frame = Frame.new(left, bottom, column_width, height)
-              col_frame.shape = shape
-              @frames << col_frame
-            end
-            @frame_index = 0
-            @results = @children.map {|child_box| fit_box(child_box) }
-            @width = frame.width
-            @height = frame.height - @frames.min_by(&:y).y
-          else
-            width = (@initial_width > 0 ? @initial_width : available_width) - reserved_width
-            column_width = (width - gap * (@columns - 1)).to_f / @columns
-            @columns.times do |col_nr|
-              @frames << Frame.new((column_width + gap) * col_nr, 0, column_width, height)
-            end
-            @frame_index = 0
-            @results = @children.map {|child_box| fit_box(child_box) }
-            @width = width
-            @height = height - @frames.min_by(&:y).y
-          end
-          min_y, max_y = @frames.minmax_by(&:y).map(&:y)
-          p [height, @frames.map(&:y), last_height_difference, min_y, max_y]
-          # TOOD: @result.any?(&:empty?) only for the first run!!!! if the first run fails, we
-          # cannot balance the columns because there is too much content.
-          # TODO: another break condition is if the @results didn't change since the last run
-          p [:maybe_redo, min_y, max_y, height, last_height_difference]
-          p [@results.map {|arr| arr.all? {|r| r.status }}]
-          break if max_y != height && @results.all? {|arr| !arr.empty? && arr.all? {|r| r.success? }} &&
-            (@results.any?(&:empty?) ||
-             max_y - min_y >= last_height_difference ||
-             max_y - min_y < 0.5)
-          if max_y == 0 && min_y == 0
-            height += last_height_difference / 4.0
-          else
-            last_height_difference = max_y - min_y
-            height -= last_height_difference / 2.0
-          end
-        end
-        @results.all? {|res| res.length == 1 }
-      end
-
-      private
-
-      def fit_box(box)
-        cur_frame = @frames[@frame_index]
-        fit_results = []
-        while cur_frame
-          result = cur_frame.fit(box)
-          if result.success?
-            cur_frame.remove_area(result.mask)
-            fit_results << result
-            break
-          elsif cur_frame.full?
-            @frame_index += 1
-            break if @frame_index == @frames.length
-            cur_frame = @frames[@frame_index]
-          else
-            draw_box, box = cur_frame.split(result)
-            if draw_box
-              cur_frame.remove_area(result.mask)
-              fit_results << result
-            elsif !cur_frame.find_next_region
-              @frame_index += 1
-              break if @frame_index == @frames.length
-              cur_frame = @frames[@frame_index]
-            end
-          end
-        end
-        fit_results
-      end
-
-      # Draws the child boxes onto the canvas at position [x, y].
-      def draw_content(canvas, x, y)
-        x = y = 0 if style.position == :flow
-        @results.each do |result_boxes|
-          result_boxes.each do |result|
-            result.box.draw(canvas, x + result.x, y + result.y)
-          end
-        end
-      end
-
-    end
-
-  end
-end