hexapdf 0.7.0 → 0.8.0

data/examples/{boxes.rb → 015-boxes.rb}

@@ -17,7 +17,7 @@ doc = HexaPDF::Document.new
 
 annotate_box = lambda do |canvas, box|
   text = ""
-  canvas.font("Times", size: 6)
+  canvas.font("Times", size: 6).leading(7)
 
   if (data = box.style.padding)
     text << "Padding (TRBL): #{data.top}, #{data.right}, #{data.bottom}, #{data.left}\n"
@@ -37,32 +37,40 @@ end
 
 canvas = doc.pages.add.canvas
 
-[[1, 200], [5, 220], [15, 240]].each_with_index do |(width, red), row|
-  [[:solid, 180], [:dashed, 200], [:dashed_round, 220],
+[[1, 140], [5, 190], [15, 240]].each_with_index do |(width, red), row|
+  [[:solid, 140], [:dashed, 177], [:dashed_round, 207],
    [:dotted, 240]].each_with_index do |(style, green), column|
-    box = HexaPDF::Layout::Box.new(content_width: 100, content_height: 100, &annotate_box)
-    box.style.border(width: width, style: style)
-    box.style.background_color([red, green, 0])
+    box = HexaPDF::Layout::Box.create(
+      width: 100, height: 100, content_box: true,
+      border: {width: width, style: style},
+      background_color: [red, green, 0],
+      &annotate_box)
     box.draw(canvas, 20 + 140 * column, 700 - 150 * row)
   end
 end
 
 # The whole kitchen sink
-box = HexaPDF::Layout::Box.new(content_width: 470, content_height: 200, &annotate_box)
-box.style.background_color([255, 255, 180])
-box.style.padding([20, 5, 10, 15])
-box.style.border(width: [20, 40, 30, 15],
-                 color: [[46, 185, 206], [206, 199, 46], [188, 46, 206], [59, 206, 46]],
-                 style: [:solid, :dashed, :dashed_round, :dotted])
-box.style.underlays.add do |canv, _|
-  canv.stroke_color([255, 0, 0]).line_width(10).line_cap_style(:butt).
-    line(0, 0, box.width, box.height).line(0, box.height, box.width, 0).
-    stroke
-end
-box.style.overlays.add do |canv, _|
-  canv.stroke_color([0, 0, 255]).line_width(5).
-    rectangle(10, 10, box.width - 20, box.height - 20).stroke
-end
+box = HexaPDF::Layout::Box.create(
+  width: 470, height: 200, content_box: true,
+  padding: [20, 5, 10, 15],
+  border: {width: [20, 40, 30, 15],
+           color: [[46, 185, 206], [206, 199, 46], [188, 46, 206], [59, 206, 46]],
+           style: [:solid, :dashed, :dashed_round, :dotted]},
+  background_color: [255, 255, 180],
+  underlays: [
+    lambda do |canv, _|
+      canv.stroke_color([255, 0, 0]).line_width(10).line_cap_style(:butt).
+        line(0, 0, box.width, box.height).line(0, box.height, box.width, 0).
+        stroke
+    end
+  ],
+  overlays: [
+    lambda do |canv, _|
+      canv.stroke_color([0, 0, 255]).line_width(5).
+        rectangle(10, 10, box.width - 20, box.height - 20).stroke
+    end
+  ],
+  &annotate_box)
 box.draw(canvas, 20, 100)
 
 doc.write("boxes.pdf", optimize: true)

data/examples/016-frame_automatic_box_placement.rb

@@ -0,0 +1,90 @@
+# ## Frame - Automatic Box Placement
+#
+# The [HexaPDF::Layout::Frame] class is used for placing rectangular boxes.
+#
+# This example shows how to create a frame and how different box styles can be
+# used to specify where a box should be placed. After each box is drawn, the
+# frame's shape is drawn and then a new page is started. This is done to easily
+# compare the changes after each added box.
+#
+# Note how the absolutely positioned box cuts a hole into the frame's shape and
+# how that influences the positioning.
+#
+# Usage:
+# : `ruby frame_automatic_box_placement.rb`
+#
+
+require 'hexapdf'
+
+include HexaPDF::Layout
+
+doc = HexaPDF::Document.new
+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)
+
+box_counter = 1
+draw_box = lambda do |**args|
+  b = Box.create(**args, border: {width: 1, color: [[255, 0, 0]]}) do |canv, box|
+    canv.save_graphics_state do
+      canv.stroke_color(255, 0, 0)
+      canv.line(0, 0, box.content_width, box.content_height).
+        line(0, box.content_height, box.content_width, 0).
+        stroke
+    end
+    text = box_counter.to_s << "\n" + args.map {|k, v| "#{k}: #{v}"}.join("\n")
+    canv.font("Times", size: 15).leading(15).
+      text(text, at: [10, box.content_height - 20])
+    box_counter += 1
+  end
+
+  drawn = false
+  until drawn
+    drawn = frame.draw(canvas, b)
+    frame.find_next_region unless drawn
+  end
+
+  canvas.line_width(3).draw(:geom2d, object: frame.shape)
+  canvas = doc.pages.add.canvas
+end
+
+# Absolutely positioned box with margin
+draw_box.call(width: 100, height: 100, position: :absolute, margin: 10,
+              position_hint: [250, 250])
+
+# Fixed sized box with automatic width
+draw_box.call(height: 100)
+
+# Fixed sized box
+draw_box.call(width: 100, height: 100)
+
+# Fixed sized box, placed below the other because the space to the right can't
+# be used
+draw_box.call(width: 100, height: 100)
+
+# Fixed sized floating box, space to the right can be used
+draw_box.call(width: 100, height: 100, position: :float, position_hint: :left)
+
+# Fixed sized floating box again, floating to the right
+draw_box.call(width: 100, height: 100, position: :float, position_hint: :right)
+
+# Fixed sized floating box again, floating to the left with margin
+draw_box.call(width: 100, height: 100, position: :float, position_hint: :left,
+              margin: [0, 10])
+
+# Fixed sized box, no floating
+draw_box.call(width: 100, height: 100)
+
+# Fixed sized box, center aligned in the available space
+draw_box.call(width: 100, height: 100, position_hint: :center)
+
+# Fixed sized box, right aligned in the available space
+draw_box.call(width: 100, height: 100, position_hint: :right)
+
+# Fixed sized box, consuming the whole remaining available space
+draw_box.call
+
+doc.write("frame_automatic_box_placement.pdf", optimize: true)

data/examples/017-frame_text_flow.rb

@@ -0,0 +1,60 @@
+# ## Frame - Text Flow
+#
+# 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", ' ') * 10
+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 = []
+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})
+
+i = 0
+frame_filled = false
+until frame_filled
+  box = boxes[i]
+  drawn = false
+  until drawn || frame_filled
+    drawn = frame.draw(canvas, box)
+    frame_filled = !frame.find_next_region unless drawn
+  end
+  i = (i + 1) % boxes.length
+end
+
+doc.write("frame_text_flow.pdf", optimize: true)

data/lib/hexapdf/cli/command.rb

@@ -115,11 +115,12 @@ module HexaPDF
       # Writes the document to the given file or does nothing if +out_file+ is +nil+.
       def write_document(doc, out_file)
         if out_file
-          doc.validate(auto_correct: true) do |msg, correctable|
+          doc.validate(auto_correct: true) do |object, msg, correctable|
             if command_parser.strict && !correctable
               raise "Validation error: #{msg}"
             elsif command_parser.verbosity_info?
-              $stderr.puts "#{correctable ? 'Corrected' : 'Ignored'} validation problem: #{msg}"
+              $stderr.puts "#{correctable ? 'Corrected' : 'Ignored'} validation problem " \
+                "for object (#{object.oid},#{object.gen}): #{msg}"
             end
           end
           doc.write(out_file, validate: false)
@@ -278,7 +279,7 @@ module HexaPDF
       end
 
       PAGE_NUMBER_SPEC = "([1-9]\\d*|e)" #:nodoc:
-      ROTATE_MAP = {'l' => -90, 'r' => 90, 'd' => 180, 'n' => :none}.freeze #:nodoc:
+      ROTATE_MAP = {'l' => 90, 'r' => -90, 'd' => 180, 'n' => :none}.freeze #:nodoc:
 
       # Parses the pages specification string and returns an array of tuples containing a page
       # number and a rotation value (either -90, 90, 180, :none or +nil+ where an integer means

data/lib/hexapdf/cli/files.rb

@@ -88,7 +88,7 @@ module HexaPDF
           if (params = ef_stream[:Params]) && !params.empty?
             data = []
             data << "size: #{params[:Size]}" if params.key?(:Size)
-            data << "md5: #{params[:CheckSum].unpack('H*').first}" if params.key?(:CheckSum)
+            data << "md5: #{params[:CheckSum].unpack1('H*')}" if params.key?(:CheckSum)
             data << "ctime: #{params[:CreationDate]}" if params.key?(:CreationDate)
             data << "mtime: #{params[:ModDate]}" if params.key?(:ModDate)
             $stdout.write(" (#{data.join(', ')})")

data/lib/hexapdf/cli/inspect.rb

@@ -74,7 +74,6 @@ module HexaPDF
                    "numbers. The generation number defaults to 0 if not given.") do |str|
           @exec = :stream
           @param = str
-          @raw = (@raw ? @raw : false)
         end
         options.on("--raw", "Modifies --stream to show the raw stream data instead of the " \
                    "filtered one.") do

data/lib/hexapdf/cli/merge.rb

@@ -181,7 +181,7 @@ module HexaPDF
         if rotation == :none
           page.delete(:Rotate)
         elsif rotation.kind_of?(Integer)
-          page[:Rotate] = ((page[:Rotate] || 0) + rotation) % 360
+          page.rotate(rotation)
         end
         page_tree.document.add(page)
         page_tree.add_page(page)

data/lib/hexapdf/cli/modify.rb

@@ -97,7 +97,7 @@ module HexaPDF
           if rotation == :none
             page.delete(:Rotate)
           elsif rotation.kind_of?(Integer)
-            page[:Rotate] = ((page[:Rotate] || 0) + rotation) % 360
+            page.rotate(rotation)
           end
           new_page_tree.add_page(page)
         end

data/lib/hexapdf/configuration.rb

@@ -349,6 +349,7 @@ module HexaPDF
                         arc: 'HexaPDF::Content::GraphicObject::Arc',
                         endpoint_arc: 'HexaPDF::Content::GraphicObject::EndpointArc',
                         solid_arc: 'HexaPDF::Content::GraphicObject::SolidArc',
+                        geom2d: 'HexaPDF::Content::GraphicObject::Geom2D',
                       },
                       'graphic_object.arc.max_curves' => 6,
                       'image_loader' => [
@@ -467,6 +468,7 @@ module HexaPDF
                         Font: {
                           Type0: 'HexaPDF::Type::FontType0',
                           Type1: 'HexaPDF::Type::FontType1',
+                          Type3: 'HexaPDF::Type::FontType3',
                           TrueType: 'HexaPDF::Type::FontTrueType',
                           CIDFontType0: 'HexaPDF::Type::CIDFont',
                           CIDFontType2: 'HexaPDF::Type::CIDFont',

data/lib/hexapdf/content/canvas.rb

@@ -861,14 +861,14 @@ module HexaPDF
       #   canvas.rectangle(x, y, width, height, radius: 0)       => canvas
       #
       # Appends a rectangle to the current path as a complete subpath (drawn in counterclockwise
-      # direction), with the lower-left corner specified by +x+ and +y+ and the given +width+ and
+      # direction), with the bottom left corner specified by +x+ and +y+ and the given +width+ and
       # +height+.
       #
       # If +radius+ is greater than 0, the corners are rounded with the given radius.
       #
       # If there is no current path when the method is invoked, a new path is automatically begun.
       #
-      # The current point is set to the lower-left corner if +radius+ is zero, otherwise it is set
+      # The current point is set to the bottom left corner if +radius+ is zero, otherwise it is set
       # to (x, y + radius).
       #
       # Examples:
@@ -1226,7 +1226,7 @@ module HexaPDF
       # If the filename or the IO specifies a PDF file, the first page of this file is used to
       # create a form XObject which is then drawn.
       #
-      # The +at+ argument has to be an array containing two numbers specifying the lower-left
+      # The +at+ argument has to be an array containing two numbers specifying the bottom left
       # corner at which to draw the XObject.
       #
       # If +width+ and +height+ are specified, the drawn XObject will have exactly these

data/lib/hexapdf/content/graphic_object.rb

@@ -74,6 +74,7 @@ module HexaPDF
       autoload(:Arc, 'hexapdf/content/graphic_object/arc')
       autoload(:EndpointArc, 'hexapdf/content/graphic_object/endpoint_arc')
       autoload(:SolidArc, 'hexapdf/content/graphic_object/solid_arc')
+      autoload(:Geom2D, 'hexapdf/content/graphic_object/geom2d')
 
     end
 

data/lib/hexapdf/content/graphic_object/geom2d.rb

@@ -0,0 +1,132 @@
+# -*- 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-2018 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.
+#++
+
+require 'geom2d'
+require 'hexapdf/error'
+
+module HexaPDF
+  module Content
+    module GraphicObject
+
+      # This class provides support for drawing Geom2D objects like line segments and polygons.
+      #
+      # See: Geom2D - https://github.com/gettalong/geom2d
+      class Geom2D
+
+        # Creates and configures a new Geom2D drawing support object.
+        #
+        # See #configure for the allowed keyword arguments.
+        def self.configure(**kwargs)
+          new.configure(kwargs)
+        end
+
+        # The Geom2D object that should be drawn
+        attr_accessor :object
+
+        # The radius to use when drawing Geom2D::Point objects; defaults to 1
+        attr_accessor :point_radius
+
+        # Specifies whether only paths should be drawn or if they should be stroked/filled too
+        attr_accessor :path_only
+
+        # Creates a Geom2D drawing support object.
+        def initialize
+          @object = nil
+          @point_radius = 1
+          @path_only = false
+        end
+
+        # Configures the Geom2D drawing support object. The following arguments are allowed:
+        #
+        # :object:: The object that should be drawn.
+        # :point_radius:: The radius of the points when drawing points.
+        # :path_only:: Whether only the path should be drawn.
+        #
+        # Any arguments not specified are not modified and retain their old value, see the getter
+        # methods for the inital values.
+        #
+        # Returns self.
+        def configure(object:, point_radius: nil, path_only: nil)
+          @object = object
+          @point_radius = point_radius if point_radius
+          @path_only = path_only if path_only
+          self
+        end
+
+        # Draws the Geom2D object onto the given Canvas.
+        def draw(canvas)
+          case @object
+          when ::Geom2D::Point then draw_point(canvas)
+          when ::Geom2D::Segment then draw_segment(canvas)
+          when ::Geom2D::Polygon then draw_polygon(canvas)
+          when ::Geom2D::PolygonSet then draw_polygon_set(canvas)
+          else
+            raise HexaPDF::Error, "Object of type #{@object.class} unusable"
+          end
+        end
+
+        private
+
+        def draw_point(canvas)
+          canvas.circle(@object.x, @object.y, @point_radius)
+          canvas.fill unless @path_only
+        end
+
+        def draw_segment(canvas)
+          canvas.line(@object.start_point.x, @object.start_point.y,
+                      @object.end_point.x, @object.end_point.y)
+          canvas.stroke unless @path_only
+        end
+
+        def draw_polygon(canvas)
+          return unless @object.nr_of_vertices > 1
+          canvas.move_to(@object[0].x, @object[0].y)
+          1.upto(@object.nr_of_vertices - 1) {|i| canvas.line_to(@object[i].x, @object[i].y) }
+          canvas.stroke unless @path_only
+        end
+
+        def draw_polygon_set(canvas)
+          return if @object.nr_of_contours == 0
+          @object.polygons.each do |poly|
+            canvas.move_to(poly[0].x, poly[0].y)
+            1.upto(poly.nr_of_vertices - 1) {|i| canvas.line_to(poly[i].x, poly[i].y) }
+            canvas.close_subpath
+          end
+          canvas.stroke unless @path_only
+        end
+
+      end
+
+    end
+  end
+end