prawn 0.11.1.pre → 0.11.1

data/lib/prawn/images/png.rb

@@ -129,6 +129,136 @@ module Prawn
         8
       end
 
+      # Build a PDF object representing this image in +document+, and return
+      # a Reference to it.
+      #
+      def build_pdf_object(document)
+        if compression_method != 0
+          raise Errors::UnsupportedImageType,
+            'PNG uses an unsupported compression method'
+        end
+
+        if filter_method != 0
+          raise Errors::UnsupportedImageType,
+            'PNG uses an unsupported filter method'
+        end
+
+        if interlace_method != 0
+          raise Errors::UnsupportedImageType,
+            'PNG uses unsupported interlace method'
+        end
+
+        # some PNG types store the colour and alpha channel data together,
+        # which the PDF spec doesn't like, so split it out.
+        split_alpha_channel!
+
+        case colors
+        when 1
+          color = :DeviceGray
+        when 3
+          color = :DeviceRGB
+        else
+          raise Errors::UnsupportedImageType,
+            "PNG uses an unsupported number of colors (#{png.colors})"
+        end
+
+        # build the image dict
+        obj = document.ref!(
+          :Type             => :XObject,
+          :Subtype          => :Image,
+          :Height           => height,
+          :Width            => width,
+          :BitsPerComponent => bits,
+          :Length           => img_data.size,
+          :Filter           => :FlateDecode
+        )
+
+        unless alpha_channel
+          obj.data[:DecodeParms] = {:Predictor => 15,
+                                    :Colors    => colors,
+                                    :BitsPerComponent => bits,
+                                    :Columns   => width}
+        end
+
+        # append the actual image data to the object as a stream
+        obj << img_data
+        
+        # sort out the colours of the image
+        if palette.empty?
+          obj.data[:ColorSpace] = color
+        else
+          # embed the colour palette in the PDF as a object stream
+          palette_obj = document.ref!(:Length => palette.size)
+          palette_obj << palette
+
+          # build the color space array for the image
+          obj.data[:ColorSpace] = [:Indexed, 
+                                   :DeviceRGB,
+                                   (palette.size / 3) -1,
+                                   palette_obj]
+        end
+
+        # *************************************
+        # add transparency data if necessary
+        # *************************************
+
+        # For PNG color types 0, 2 and 3, the transparency data is stored in
+        # a dedicated PNG chunk, and is exposed via the transparency attribute
+        # of the PNG class.
+        if transparency[:grayscale]
+          # Use Color Key Masking (spec section 4.8.5)
+          # - An array with N elements, where N is two times the number of color
+          #   components.
+          val = transparency[:grayscale]
+          obj.data[:Mask] = [val, val]
+        elsif transparency[:rgb]
+          # Use Color Key Masking (spec section 4.8.5)
+          # - An array with N elements, where N is two times the number of color
+          #   components.
+          rgb = transparency[:rgb]
+          obj.data[:Mask] = rgb.collect { |x| [x,x] }.flatten
+        elsif transparency[:indexed]
+          # TODO: broken. I was attempting to us Color Key Masking, but I think
+          #       we need to construct an SMask i think. Maybe do it inside
+          #       the PNG class, and store it in alpha_channel
+          #obj.data[:Mask] = transparency[:indexed]
+        end
+
+        # For PNG color types 4 and 6, the transparency data is stored as a alpha
+        # channel mixed in with the main image data. The PNG class seperates
+        # it out for us and makes it available via the alpha_channel attribute
+        if alpha_channel?
+          smask_obj = document.ref!(
+            :Type             => :XObject,
+            :Subtype          => :Image,
+            :Height           => height,
+            :Width            => width,
+            :BitsPerComponent => alpha_channel_bits,
+            :Length           => alpha_channel.size,
+            :Filter           => :FlateDecode,
+            :ColorSpace       => :DeviceGray,
+            :Decode           => [0, 1]
+          )
+          smask_obj << alpha_channel
+          obj.data[:SMask] = smask_obj
+        end
+
+        obj
+      end
+
+      # Returns the minimum PDF version required to support this image.
+      def min_pdf_version
+        if bits > 8
+          # 16-bit color only supported in 1.5+ (ISO 32000-1:2008 8.9.5.1)
+          1.5
+        elsif alpha_channel?
+          # Need transparency for SMask
+          1.4
+        else
+          1.0
+        end
+      end
+
       private
 
       def unfilter_image_data

data/lib/prawn/repeater.rb

@@ -96,30 +96,23 @@ module Prawn
       @stamp_name  = "prawn_repeater(#{Repeater.count})"
       @document.create_stamp(@stamp_name, &block) unless dynamic
       @block = block if dynamic
+      @graphic_state = document.state.page.graphic_state.dup
 
       Repeater.count += 1
     end
 
     def match?(page_number)
-      case @page_filter
-      when :all
-        true
-      when :odd
-        page_number % 2 == 1
-      when :even
-        page_number % 2 == 0
-      when Range, Array
-        @page_filter.include?(page_number)
-      when Proc
-        @page_filter.call(page_number)
-      end
+      @document.page_match?(@page_filter, page_number)
     end
 
     def run(page_number)
       if !@dynamic
         @document.stamp(@stamp_name) if match?(page_number)
       elsif @block
-        @block.arity < 1 ? @document.instance_eval(&@block) : @block[@document]
+        @document.save_graphics_state(@graphic_state) do
+          @document.send(:freeze_stamp_graphics)
+          @block.call
+        end
       end
     end
 

data/lib/prawn/security.rb

@@ -47,7 +47,7 @@ module Prawn
       #
       # <tt>:print_document</tt>:: Print document.
       #
-      # <tt>:modify_document</tt>:: Modify contents of document (other than text
+      # <tt>:modify_contents</tt>:: Modify contents of document (other than text
       #                             annotations and interactive form fields).
       #
       # <tt>:copy_contents</tt>:: Copy text and graphics from document.
@@ -142,6 +142,11 @@ module Prawn
       def permissions=(perms={})
         @permissions ||= FullPermissions
         perms.each do |key, value|
+          unless PermissionsBits[key]
+            raise ArgumentError, "Unknown permission :#{key}. Valid options: " +
+              PermissionsBits.keys.map { |k| k.inspect }.join(", ")
+          end
+
           # 0-based bit number, from LSB
           bit_position = PermissionsBits[key] - 1
 

data/lib/prawn/stamp.rb

@@ -21,7 +21,7 @@ module Prawn
   #
   # Example:
   #   pdf.create_stamp("my_stamp") {
-  #     pdf.fill_circle_at([10, 15], :radius => 5)
+  #     pdf.fill_circle([10, 15], 5)
   #     pdf.draw_text("hello world", :at => [20, 10])
   #   }
   #   pdf.stamp("my_stamp")
@@ -35,7 +35,7 @@ module Prawn
     #
     # Example:
     #   pdf.create_stamp("my_stamp") {
-    #     pdf.fill_circle_at([10, 15], :radius => 5)
+    #     pdf.fill_circle([10, 15], 5)
     #     pdf.text("hello world", :at => [20, 10])
     #   }
     #   pdf.stamp("my_stamp")
@@ -52,7 +52,7 @@ module Prawn
     #
     # Example:
     #   pdf.create_stamp("circle") do
-    #     pdf.fill_circle_at([0, 0], :radius => 25)
+    #     pdf.fill_circle([0, 0], 25)
     #   end
     #   # draws a circle at 100, 100
     #   pdf.stamp_at("circle", [100, 100])
@@ -71,7 +71,7 @@ module Prawn
     #
     # Example:
     #   pdf.create_stamp("my_stamp") {
-    #     pdf.fill_circle_at([10, 15], :radius => 5)
+    #     pdf.fill_circle([10, 15], 5)
     #     pdf.draw_text("hello world", :at => [20, 10])
     #   }
     #
@@ -121,6 +121,14 @@ module Prawn
                                           :stamp_dictionary      => dictionary }
       dictionary
     end
+    
+    def freeze_stamp_graphics
+      update_colors
+      write_line_width
+      write_stroke_cap_style
+      write_stroke_join_style     
+      write_stroke_dash
+    end
 
   end
 end

data/lib/prawn/table.rb

@@ -230,12 +230,42 @@ module Prawn
       ref_bounds = @pdf.bounds.stretchy? ? @pdf.margin_box : @pdf.bounds
 
       last_y = @pdf.y
+
+      # Determine whether we're at the top of the current bounds (margin box or
+      # bounding box). If we're at the top, we couldn't gain any more room by
+      # breaking to the next page -- this means, in particular, that if the
+      # first row is taller than the margin box, we will only move to the next
+      # page if we're below the top. Some floating-point tolerance is added to
+      # the calculation.
+      #
+      # Note that we use the actual bounds, not the reference bounds. This is
+      # because even if we are in a stretchy bounding box, flowing to the next
+      # page will not buy us any space if we are at the top.
+      if @pdf.y > @pdf.bounds.height + @pdf.bounds.absolute_bottom - 0.001
+        # we're at the top of our bounds
+        started_new_page_at_row = 0
+      else
+        started_new_page_at_row = -1
+
+        # If there isn't enough room left on the page to fit the first data row
+        # (excluding the header), start the table on the next page.
+        needed_height = row(0).height
+        needed_height += row(1).height if @header
+        if needed_height > @pdf.y - ref_bounds.absolute_bottom
+          @pdf.bounds.move_past_bottom
+          offset = @pdf.y
+          started_new_page_at_row = 0
+        end
+      end
+
       @cells.each do |cell|
-        if cell.height > (cell.y + offset) - ref_bounds.absolute_bottom
+        if cell.height > (cell.y + offset) - ref_bounds.absolute_bottom &&
+           cell.row > started_new_page_at_row
           # start a new page or column
           @pdf.bounds.move_past_bottom
-          draw_header
+          draw_header unless cell.row == 0
           offset = @pdf.y - cell.y
+          started_new_page_at_row = cell.row
         end
  
         # Don't modify cell.x / cell.y here, as we want to reuse the original
@@ -275,12 +305,14 @@ module Prawn
       @column_widths ||= begin
         if width < cells.min_width
           raise Errors::CannotFit,
-            "Table's width was set too small to contain its contents"
+            "Table's width was set too small to contain its contents " +
+            "(min width #{cells.min_width}, requested #{width})"
         end
 
         if width > cells.max_width
           raise Errors::CannotFit,
-            "Table's width was set larger than its contents' maximum width"
+            "Table's width was set larger than its contents' maximum width " +
+            "(max width #{cells.max_width}, requested #{width})"
         end
 
         if width < natural_width

data/lib/prawn/table/cell.rb

@@ -55,11 +55,17 @@ module Prawn
 
       # If provided, the minimum width that this cell will permit.
       # 
-      attr_reader :min_width
+      def min_width
+        set_width_constraints
+        @min_width
+      end
       
       # If provided, the maximum width that this cell can be drawn in.
       #
-      attr_reader :max_width
+      def max_width
+        set_width_constraints
+        @max_width
+      end
 
       # Manually specify the cell's height.
       #
@@ -70,14 +76,13 @@ module Prawn
       #
       attr_accessor :borders
 
-      # Specifies the width, in PDF points, of the cell's borders.
+      # Width, in PDF points, of the cell's borders: [top, right, bottom, left].
       #
-      attr_accessor :border_width
+      attr_reader :border_widths
 
-      # Specifies the color of the cell borders. Given in HTML RGB format, e.g.,
-      # "ccffff".
+      # HTML RGB-format ("ccffff") border colors: [top, right, bottom, left].
       #
-      attr_accessor :border_color
+      attr_reader :border_colors
 
       # Specifies the content for the cell. Must be a "cellable" object. See the
       # "Data" section of the Prawn::Table documentation for details on cellable
@@ -97,8 +102,15 @@ module Prawn
       #
       def self.make(pdf, content, options={})
         at = options.delete(:at) || [0, pdf.cursor]
-        content = "" if content.nil?
-        options[:content] = content
+        content = content.to_s if content.nil? || content.kind_of?(Numeric) ||
+          content.kind_of?(Date)
+        
+        if content.is_a?(Hash)
+          options.update(content)
+          content = options[:content]
+        else
+          options[:content] = content
+        end
 
         case content
         when Prawn::Table::Cell
@@ -135,16 +147,29 @@ module Prawn
         @point = point
 
         # Set defaults; these can be changed by options
-        @padding      = [5, 5, 5, 5]
-        @borders      = [:top, :bottom, :left, :right]
-        @border_width = 1
-        @border_color = '000000'
+        @padding       = [5, 5, 5, 5]
+        @borders       = [:top, :bottom, :left, :right]
+        @border_widths = [1] * 4
+        @border_colors = ['000000'] * 4
 
         options.each { |k, v| send("#{k}=", v) }
+      end
+
+      # Supports setting multiple properties at once.
+      #
+      #   cell.style(:padding => 0, :border_width => 2)
+      #
+      # is the same as:
+      #
+      #   cell.padding = 0
+      #   cell.border_width = 2
+      #
+      def style(options={}, &block)
+        options.each { |k, v| send("#{k}=", v) }
 
-        # Sensible defaults for min / max.
-        @min_width = padding_left + padding_right
-        @max_width = @pdf.bounds.width
+        # The block form supports running a single block for multiple cells, as
+        # in Cells#style.
+        block.call(self) if block
       end
 
       # Returns the cell's width in points, inclusive of padding.
@@ -209,13 +234,15 @@ module Prawn
       # location at which the cell is drawn.
       #
       def draw(pt=[x, y])
+        set_width_constraints
+
         draw_background(pt)
+        draw_borders(pt)
         @pdf.bounding_box([pt[0] + padding_left, pt[1] - padding_top], 
                           :width  => content_width + FPTolerance,
                           :height => content_height + FPTolerance) do
           draw_content
         end
-        draw_borders(pt)
       end
 
       # x-position of the cell within the parent bounds.
@@ -267,19 +294,179 @@ module Prawn
         end
       end
 
+      def padding_top
+        @padding[0]
+      end
+      
+      def padding_top=(val)
+        @padding[0] = val
+      end
+
+      def padding_right
+        @padding[1]
+      end
+      
+      def padding_right=(val)
+        @padding[1] = val
+      end
+
+      def padding_bottom
+        @padding[2]
+      end
+      
+      def padding_bottom=(val)
+        @padding[2] = val
+      end
+
+      def padding_left
+        @padding[3]
+      end
+      
+      def padding_left=(val)
+        @padding[3] = val
+      end
+
+      # Sets border colors on this cell. The argument can be one of:
+      #
+      # * an integer (sets all colors)
+      # * a two-element array [vertical, horizontal]
+      # * a three-element array [top, horizontal, bottom]
+      # * a four-element array [top, right, bottom, left]
+      #
+      def border_color=(color)
+        @border_colors = case
+        when color.nil?
+          ["000000"] * 4
+        when String === color # all colors
+          [color, color, color, color]
+        when color.length == 2 # vert, horiz
+          [color[0], color[1], color[0], color[1]]
+        when color.length == 3 # top, horiz, bottom
+          [color[0], color[1], color[2], color[1]]
+        when color.length == 4 # top, right, bottom, left
+          [color[0], color[1], color[2], color[3]]
+        else
+          raise ArgumentError, ":border_color must be a string " +
+            "or an array [v,h] or [t,r,b,l]"
+        end
+      end
+      alias_method :border_colors=, :border_color=
+
+      def border_top_color
+        @border_colors[0]
+      end
+
+      def border_top_color=(val)
+        @border_colors[0] = val
+      end
+
+      def border_top_color
+        @border_colors[0]
+      end
+
+      def border_top_color=(val)
+        @border_colors[0] = val
+      end
+
+      def border_right_color
+        @border_colors[1]
+      end
+
+      def border_right_color=(val)
+        @border_colors[1] = val
+      end
+
+      def border_bottom_color
+        @border_colors[2]
+      end
+
+      def border_bottom_color=(val)
+        @border_colors[2] = val
+      end
+
+      def border_left_color
+        @border_colors[3]
+      end
+
+      def border_left_color=(val)
+        @border_colors[3] = val
+      end
+
+      # Sets border widths on this cell. The argument can be one of:
+      #
+      # * an integer (sets all widths)
+      # * a two-element array [vertical, horizontal]
+      # * a three-element array [top, horizontal, bottom]
+      # * a four-element array [top, right, bottom, left]
+      #
+      def border_width=(width)
+        @border_widths = case
+        when width.nil?
+          ["000000"] * 4
+        when Numeric === width # all widths
+          [width, width, width, width]
+        when width.length == 2 # vert, horiz
+          [width[0], width[1], width[0], width[1]]
+        when width.length == 3 # top, horiz, bottom
+          [width[0], width[1], width[2], width[1]]
+        when width.length == 4 # top, right, bottom, left
+          [width[0], width[1], width[2], width[3]]
+        else
+          raise ArgumentError, ":border_width must be a string " +
+            "or an array [v,h] or [t,r,b,l]"
+        end
+      end
+      alias_method :border_widths=, :border_width=
+
+      def border_top_width
+        @borders.include?(:top) ? @border_widths[0] : 0
+      end
+
+      def border_top_width=(val)
+        @border_widths[0] = val
+      end
+
+      def border_right_width
+        @borders.include?(:right) ? @border_widths[1] : 0
+      end
+
+      def border_right_width=(val)
+        @border_widths[1] = val
+      end
+
+      def border_bottom_width
+        @borders.include?(:bottom) ? @border_widths[2] : 0
+      end
+
+      def border_bottom_width=(val)
+        @border_widths[2] = val
+      end
+
+      def border_left_width
+        @borders.include?(:left) ? @border_widths[3] : 0
+      end
+
+      def border_left_width=(val)
+        @border_widths[3] = val
+      end
+
       protected
 
+      # Sets the cell's minimum and maximum width. Deferred until requested
+      # because padding and size can change.
+      #
+      def set_width_constraints
+        @min_width ||= padding_left + padding_right
+        @max_width ||= @pdf.bounds.width
+      end
+
       # Draws the cell's background color.
       #
       def draw_background(pt)
-        x, y = pt
-        margin = @border_width / 2
         if @background_color
           @pdf.mask(:fill_color) do
             @pdf.fill_color @background_color
-            h = @borders.include?(:bottom) ? height - (2*margin) : 
-                                             height + margin
-            @pdf.fill_rectangle [x, y], width, h
+            @pdf.fill_rectangle pt, width, height
           end
         end
       end
@@ -291,26 +478,32 @@ module Prawn
       #
       def draw_borders(pt)
         x, y = pt
-        return if @border_width <= 0
-        # Draw left / right borders one-half border width beyond the center of
-        # the corner, so that the corners end up square.
-        margin = @border_width / 2.0
 
         @pdf.mask(:line_width, :stroke_color) do
-          @pdf.line_width   = @border_width
-          @pdf.stroke_color = @border_color if @border_color
-
           @borders.each do |border|
+            idx = {:top => 0, :right => 1, :bottom => 2, :left => 3}[border]
+            border_color = @border_colors[idx]
+            border_width = @border_widths[idx]
+
+            next if border_width <= 0
+
+            # Left and right borders are drawn one-half border beyond the center
+            # of the corner, so that the corners end up square.
             from, to = case border
                        when :top
                          [[x, y], [x+width, y]]
                        when :bottom
                          [[x, y-height], [x+width, y-height]]
                        when :left
-                         [[x, y+margin], [x, y-height-margin]]
+                         [[x, y + (border_top_width / 2.0)],
+                          [x, y - height - (border_bottom_width / 2.0)]]
                        when :right
-                         [[x+width, y+margin], [x+width, y-height-margin]]
+                         [[x+width, y + (border_top_width / 2.0)],
+                          [x+width, y - height - (border_bottom_width / 2.0)]]
                        end
+
+            @pdf.line_width   = border_width
+            @pdf.stroke_color = border_color
             @pdf.stroke_line(from, to)
           end
         end
@@ -323,38 +516,6 @@ module Prawn
         raise NotImplementedError, "subclasses must implement draw_content"
       end
 
-      def padding_top
-        @padding[0]
-      end
-      
-      def padding_top=(val)
-        @padding[0] = val
-      end
-
-      def padding_right
-        @padding[1]
-      end
-      
-      def padding_right=(val)
-        @padding[1] = val
-      end
-
-      def padding_bottom
-        @padding[2]
-      end
-      
-      def padding_bottom=(val)
-        @padding[2] = val
-      end
-
-      def padding_left
-        @padding[3]
-      end
-      
-      def padding_left=(val)
-        @padding[3] = val
-      end
-
     end
   end
 end