hexapdf 0.7.0 → 0.8.0

data/lib/hexapdf/layout/width_from_polygon.rb

@@ -0,0 +1,246 @@
+# -*- 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-2017 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.
+#++
+
+module HexaPDF
+  module Layout
+
+    # Utility class for generating width specifications for TextLayouter#fit from polygons.
+    class WidthFromPolygon
+
+      # Creates a new object for the given polygon (or polygon set) and immediately prepares it so
+      # that #call can be used.
+      #
+      # The offset argument specifies the vertical offset from the top at which calculations
+      # should start.
+      def initialize(polygon, offset = 0)
+        @polygon = polygon
+        prepare(offset)
+      end
+
+      # Returns the width specification for the given values with respect to the wrapped polygon.
+      def call(height, line_height)
+        width(@max_y - height - line_height, @max_y - height)
+      end
+
+      private
+
+      # Calculates the width specification for the area between the horizontal lines at y1 < y2.
+      #
+      # The following algorithm is used: Given y1 < y2 as the horizontal lines between which text
+      # should be layed out, and a polygon set p that is not self-intersecting but may have
+      # arbitrarily nested holes:
+      #
+      # * Get all segments of the polygon set in sequence, removing the horizontal segments in the
+      #   process (done in #prepare).
+      #
+      # * Make sure that the first segment represents a left-most outside-inside transition,
+      #   rotate array of segments (separate for each polygon) if necessary. (done in #prepare)
+      #
+      # * For the segments of each polygon do separately:
+      #
+      #   * Ignore all segments except those with min_y < y2 and max_y > y1.
+      #
+      #   * Determine the min_x and max_x of the segment within y1 <= y2.
+      #
+      #   * If the segment crosses both, y1 and y2, store min_x/max_x and this segment is
+      #     finished. Otherwise traverse the segments in-order to find the next crossing, updating
+      #     min_x/max_x in the process. If it crosses the other line, the result is the same as if
+      #     a single segment had crossed both lines. Otherwise the result depends on whether the
+      #     segment sequence represents an outside-inside transition (it is ignored) or
+      #     inside-outside transition (store two pairs min_x/min_x and max_x/max_x).
+      #
+      # * Order stored x-values.
+      #
+      # * For each pair [a_min, a_max], [b_min, b_max]
+      #   - if inside (index is even): calculate width = b_min - a_max
+      #   - if outside: calculate offset = b_max - a_min
+      #
+      # * Prepend a0_max for first offset and remove all offset-width pairs where width is zero.
+      def width(y1, y2)
+        result = []
+
+        @polygon_segments.each do |segments|
+          temp_result = []
+          status = if segments.first[0].start_point.y > y2 || segments.first[0].start_point.y < y1
+                     :outside
+                   else
+                     :inside
+                   end
+
+          segments.each do |_segment, miny, maxy, minyx, maxyx, vertical, slope, intercept|
+            next unless miny < y2 && maxy > y1
+
+            if vertical
+              min_x = max_x = minyx
+            else
+              min_x = (miny <= y1 ? (y1 - intercept) / slope : (miny <= y2 ? minyx : maxyx))
+              max_x = (maxy >= y2 ? (y2 - intercept) / slope : (miny >= y1 ? minyx : maxyx))
+              min_x, max_x = max_x, min_x if min_x > max_x
+            end
+
+            if miny <= y1 && maxy >= y2 # segment crosses both lines
+              temp_result << [min_x, max_x, :crossed_both]
+            elsif miny <= y1 # segment crosses bottom line
+              if status == :outside
+                temp_result << [min_x, max_x, :crossed_bottom]
+                status = :inside
+              elsif temp_result.last
+                temp_result.last[0] = min_x if temp_result.last[0] > min_x
+                temp_result.last[1] = max_x if temp_result.last[1] < max_x
+                temp_result.last[2] = :crossed_both if temp_result.last[2] == :crossed_top
+                temp_result.last[2] = :crossed_bottom if temp_result.last[2] == :crossed_none
+                status = :outside
+              else
+                temp_result << [min_x, max_x, :crossed_bottom]
+                status = :outside
+              end
+            elsif maxy >= y2 # segment crosses top line
+              if status == :outside
+                temp_result << [min_x, max_x, :crossed_top]
+                status = :inside
+              elsif temp_result.last
+                temp_result.last[0] = min_x if temp_result.last[0] > min_x
+                temp_result.last[1] = max_x if temp_result.last[1] < max_x
+                temp_result.last[2] = :crossed_both if temp_result.last[2] == :crossed_bottom
+                temp_result.last[2] = :crossed_top if temp_result.last[2] == :crossed_none
+                status = :outside
+              else
+                temp_result << [min_x, max_x, :crossed_top]
+                status = :outside
+              end
+            elsif status == :inside && temp_result.last # segment crosses no line
+              temp_result.last[0] = min_x if temp_result.last[0] > min_x
+              temp_result.last[1] = max_x if temp_result.last[1] < max_x
+            else # first segment completely inside
+              temp_result << [min_x, max_x, :crossed_none]
+            end
+          end
+
+          if temp_result.empty? # Ignore degenerate results
+            next
+          elsif temp_result.size == 1
+            # either polygon completely inside or just the top/bottom part, handle the same
+            temp_result[0][2] = :crossed_top
+          elsif temp_result[0][2] != :crossed_both && temp_result[-1][2] != :crossed_both
+            # Handle case where first and last segments only crosses one line
+            temp_result[0][0] = temp_result[-1][0] if temp_result[0][0] > temp_result[-1][0]
+            temp_result[0][1] = temp_result[-1][1] if temp_result[0][1] < temp_result[-1][1]
+            temp_result[0][2] = :crossed_both if temp_result[0][2] != temp_result[-1][2]
+            temp_result.pop
+          end
+
+          result.concat(temp_result)
+        end
+
+        temp_result = result
+        outside = true
+        temp_result.sort_by! {|a| a[0] }.map! do |min, max, stat|
+          if stat == :crossed_both
+            outside = !outside
+            [min, max]
+          elsif outside
+            []
+          else
+            [min, min, max, max]
+          end
+        end.flatten!
+        temp_result.unshift(0, 0)
+
+        i = 0
+        result = []
+        while i < temp_result.size - 2
+          if i % 4 == 2 # inside the polygon, i.e. width (min2 - max1)
+            if (width = temp_result[i + 2] - temp_result[i + 1]) > 0
+              result << width
+            else
+              result.pop # remove last offset and don't add width
+            end
+          else # outside the polygon, i.e. offset (max2 - min1)
+            result << temp_result[i + 3] - temp_result[i + 0]
+          end
+          i += 2
+        end
+        result.empty? ? [0, 0] : result
+      end
+
+      # Prepare the segments and other data for later use.
+      def prepare(offset)
+        @max_y = @polygon.bbox.max_y - offset
+        @polygon_segments = if @polygon.nr_of_contours > 1
+                              @polygon.polygons.map {|polygon| process_polygon(polygon) }
+                            else
+                              [process_polygon(@polygon)]
+                            end
+      end
+
+      # Processes the given polygon segment by segment and returns an array with the following
+      # processing information for each segment of the polygon:
+      #
+      # * the segment itself
+      # * minimum y-value
+      # * maximum y-value
+      # * x-value corresponding to the minimum y-value
+      # * x-value corresponding to the maximum y-value
+      # * whether the segment is vertical
+      # * for non-vertical segments: slope and y-intercept of the segment
+      #
+      # Additionally, the returned array is rotated sothat the data for the segment with the
+      # minimum x-value is the first item (without changing the order).
+      def process_polygon(polygon)
+        rotate_nr = 0
+        min_x = Float::INFINITY
+        segments = polygon.each_segment.reject(&:horizontal?)
+        segments.map!.with_index do |segment, index|
+          (rotate_nr = index; min_x = segment.min.x) if segment.min.x < min_x
+          data = [segment]
+          if segment.start_point.y < segment.end_point.y
+            data.push(segment.start_point.y, segment.end_point.y,
+                      segment.start_point.x, segment.end_point.x)
+          else
+            data.push(segment.end_point.y, segment.start_point.y,
+                      segment.end_point.x, segment.start_point.x)
+          end
+          data.push(segment.vertical?)
+          unless segment.vertical?
+            data.push(segment.slope)
+            data.push((segment.start_point.y - segment.slope * segment.start_point.x).to_f)
+          end
+          data
+        end
+        segments.rotate!(rotate_nr)
+      end
+
+    end
+
+  end
+end

data/lib/hexapdf/rectangle.rb

@@ -43,30 +43,30 @@ module HexaPDF
   # This class simplifies the usage of rectangles by automatically normalizing the coordinates so
   # that they are in the order:
   #
-  #   [llx, lly, urx, ury]
+  #   [left, bottom, right, top]
   #
-  # where +llx+ is the lower-left x-coordinate, +lly+ is the lower-left y-coordinate, +urx+ is the
-  # upper-right x-coordinate and +ury+ is the upper-right y-coordinate.
+  # where +left+ is the bottom left x-coordinate, +bottom+ is the bottom left y-coordinate, +right+
+  # is the top right x-coordinate and +top+ is the top right y-coordinate.
   #
   # See: PDF1.7 s7.9.5
   class Rectangle < HexaPDF::Object
 
-    # Returns the x-coordinate of the lower-left corner.
+    # Returns the x-coordinate of the bottom-left corner.
     def left
       value[0]
     end
 
-    # Returns the x-coordinate of the upper-right corner.
+    # Returns the x-coordinate of the top-right corner.
     def right
       value[2]
     end
 
-    # Returns the y-coordinate of the lower-left corner.
+    # Returns the y-coordinate of the bottom-left corner.
     def bottom
       value[1]
     end
 
-    # Returns the y-coordinate of the upper-right corner.
+    # Returns the y-coordinate of the top-right corner.
     def top
       value[3]
     end
@@ -83,8 +83,8 @@ module HexaPDF
 
     private
 
-    # Ensures that the value is an array containing four numbers that specify the lower-left and
-    # upper-right corner.
+    # Ensures that the value is an array containing four numbers that specify the bottom left and
+    # top right corner.
     def after_data_change
       super
       unless value.kind_of?(Array) && value.size == 4 && value.all? {|i| i.kind_of?(Numeric) }

data/lib/hexapdf/stream.rb

@@ -116,10 +116,10 @@ module HexaPDF
 
     define_field :Length,       type: Integer # not required, will be auto-filled when writing
     define_field :Filter,       type: [Symbol, Array]
-    define_field :DecodeParms,  type: [Dictionary, Hash, Array]
+    define_field :DecodeParms,  type: [Dictionary, Array]
     define_field :F,            type: :Filespec, version: '1.2'
     define_field :FFilter,      type: [Symbol, Array], version: '1.2'
-    define_field :FDecodeParms, type: [Dictionary, Hash, Array], version: '1.2'
+    define_field :FDecodeParms, type: [Dictionary, Array], version: '1.2'
     define_field :DL,           type: Integer
 
     # Stream objects must always be indirect.

data/lib/hexapdf/type.rb

@@ -66,6 +66,7 @@ module HexaPDF
     autoload(:FontTrueType, 'hexapdf/type/font_true_type')
     autoload(:FontType0, 'hexapdf/type/font_type0')
     autoload(:CIDFont, 'hexapdf/type/cid_font')
+    autoload(:FontType3, 'hexapdf/type/font_type3')
 
   end
 

data/lib/hexapdf/type/action.rb

@@ -48,7 +48,7 @@ module HexaPDF
 
       define_field :Type, type: Symbol, default: type
       define_field :S,    type: Symbol, required: true
-      define_field :Next, type: [Dictionary, Hash, Array], version: '1.2'
+      define_field :Next, type: [Dictionary, Array], version: '1.2'
 
     end
 

data/lib/hexapdf/type/annotations/markup_annotation.rb

@@ -46,7 +46,7 @@ module HexaPDF
         define_field :T,            type: String, version: '1.1'
         define_field :Popup,        type: :Annotation, version: '1.3'
         define_field :CA,           type: Numeric, default: 1.0, version: '1.4'
-        define_field :RC,           type: [String, Stream], version: '1.5'
+        define_field :RC,           type: [Stream, String], version: '1.5'
         define_field :CreationDate, type: PDFDate, version: '1.5'
         define_field :IRT,          type: Dictionary, version: '1.5'
         define_field :Subj,         type: String, version: '1.5'

data/lib/hexapdf/type/catalog.rb

@@ -61,7 +61,7 @@ module HexaPDF
       define_field :PageMode,          type: Symbol,     default: :UseNone
       define_field :Outlines,          type: Dictionary, indirect: true
       define_field :Threads,           type: Array,      version: '1.1'
-      define_field :OpenAction,        type: [Array, Dictionary, Hash], version: '1.1'
+      define_field :OpenAction,        type: [Dictionary, Array], version: '1.1'
       define_field :AA,                type: Dictionary, version: '1.4'
       define_field :URI,               type: Dictionary, version: '1.1'
       define_field :AcroForm,          type: Dictionary, version: '1.2'

data/lib/hexapdf/type/cid_font.rb

@@ -44,7 +44,8 @@ module HexaPDF
 
       DEFAULT_WIDTH = 1000 # :nodoc:
 
-      define_field :CIDSystemInfo,   type: [Hash, Dictionary], required: true
+      define_field :BaseFont,        type: Symbol, required: true
+      define_field :CIDSystemInfo,   type: Dictionary, required: true
       define_field :FontDescriptor,  type: :FontDescriptor, indirect: true, required: true
       define_field :DW,              type: Integer, default: DEFAULT_WIDTH
       define_field :W,               type: Array

data/lib/hexapdf/type/font.rb

@@ -45,7 +45,6 @@ module HexaPDF
       define_type :Font
 
       define_field :Type, type: Symbol, required: true, default: type
-      define_field :BaseFont, type: Symbol, required: true
       define_field :ToUnicode, type: Stream, version: '1.2'
 
       # Font objects must always be indirect.

data/lib/hexapdf/type/font_descriptor.rb

@@ -69,7 +69,7 @@ module HexaPDF
       define_field :FontFile,     type: Stream
       define_field :FontFile2,    type: Stream, version: '1.1'
       define_field :FontFile3,    type: Stream, version: '1.2'
-      define_field :CharSet,      type: [String, PDFByteString], version: '1.1'
+      define_field :CharSet,      type: [PDFByteString, String], version: '1.1'
 
       define_field :Style,        type: Dictionary
       define_field :Lang,         type: Symbol, version: '1.5'

data/lib/hexapdf/type/font_simple.rb

@@ -48,7 +48,7 @@ module HexaPDF
       define_field :LastChar, type: Integer
       define_field :Widths, type: Array
       define_field :FontDescriptor, type: :FontDescriptor, indirect: true
-      define_field :Encoding, type: [Symbol, Dictionary, Hash]
+      define_field :Encoding, type: [Dictionary, Symbol]
 
       # Returns the encoding object used for this font.
       #
@@ -60,7 +60,7 @@ module HexaPDF
             encoding = HexaPDF::Font::Encoding.for_name(val)
             encoding = encoding_from_font if encoding.nil?
             encoding
-          when HexaPDF::Dictionary, Hash
+          when HexaPDF::Dictionary
             encoding = val[:BaseEncoding] && HexaPDF::Font::Encoding.for_name(val[:BaseEncoding])
             encoding ||= if embedded? || symbolic?
                            encoding_from_font
@@ -164,7 +164,7 @@ module HexaPDF
         super()
         return if ignore_missing_font_fields
 
-        [:FirstChar, :LastChar, :Widths, :FontDescriptor].each do |field|
+        [:FirstChar, :LastChar, :Widths].each do |field|
           yield("Required field #{field} is not set", false) if self[field].nil?
         end
         if self[:Widths].length != (self[:LastChar] - self[:FirstChar] + 1)

data/lib/hexapdf/type/font_true_type.rb

@@ -40,6 +40,14 @@ module HexaPDF
     class FontTrueType < FontSimple
 
       define_field :Subtype, type: Symbol, required: true, default: :TrueType
+      define_field :BaseFont, type: Symbol, required: true
+
+      private
+
+      def perform_validation
+        super
+        yield("Required field FontDescriptor is not set", false) if self[:FontDescriptor].nil?
+      end
 
     end
 

data/lib/hexapdf/type/font_type0.rb

@@ -49,7 +49,8 @@ module HexaPDF
     class FontType0 < Font
 
       define_field :Subtype, type: Symbol, required: true, default: :Type0
-      define_field :Encoding, type: [Symbol, Stream], required: true
+      define_field :BaseFont, type: Symbol, required: true
+      define_field :Encoding, type: [Stream, Symbol], required: true
       define_field :DescendantFonts, type: Array, required: true
 
       # Returns the CID font of this type 0 font.

data/lib/hexapdf/type/font_type1.rb

@@ -100,6 +100,7 @@ module HexaPDF
       end
 
       define_field :Subtype, type: Symbol, required: true, default: :Type1
+      define_field :BaseFont, type: Symbol, required: true
 
       # Returns the unscaled width of the given code point in glyph units, or 0 if the width for the
       # code point is missing.
@@ -153,7 +154,12 @@ module HexaPDF
 
       # Validates the Type1 font dictionary.
       def perform_validation
-        super(ignore_missing_font_fields: StandardFonts.standard_font?(self[:BaseFont]))
+        std_font = StandardFonts.standard_font?(self[:BaseFont])
+        super(ignore_missing_font_fields: std_font)
+
+        if !std_font && self[:FontDescriptor].nil?
+          yield("Required field FontDescriptor is not set", false)
+        end
       end
 
     end