prawn 0.15.0 → 1.0.0.rc1

data/lib/prawn/images/image.rb

@@ -10,24 +10,23 @@ require 'digest/sha1'
 module Prawn
   module Images
     class Image
-      # @group Extension API
 
       def calc_image_dimensions(options)
         w = options[:width] || width
         h = options[:height] || height
 
         if options[:width] && !options[:height]
-          wp = w / width.to_f
+          wp = w / width.to_f 
           w = width * wp
           h = height * wp
-        elsif options[:height] && !options[:width]
+        elsif options[:height] && !options[:width]         
           hp = h / height.to_f
           w = width * hp
-          h = height * hp
-        elsif options[:scale]
+          h = height * hp   
+        elsif options[:scale] 
           w = width * options[:scale]
           h = height * options[:scale]
-        elsif options[:fit]
+        elsif options[:fit] 
           bw, bh = options[:fit]
           bp = bw / bh.to_f
           ip = width / height.to_f
@@ -44,6 +43,23 @@ module Prawn
 
         [w,h]
       end
+
+      def self.detect_image_format(content)
+        top = content[0,128]                       
+
+        # Unpack before comparing for JPG header, so as to avoid having to worry
+        # about the source string encoding. We just want a byte-by-byte compare.
+        if top[0, 3].unpack("C*") == [255, 216, 255]
+          return :jpg
+        elsif top[0, 8].unpack("C*") == [137, 80, 78, 71, 13, 10, 26, 10]
+          return :png
+        else
+          raise Errors::UnsupportedImageType, "image file is an unrecognised format"
+        end
+      end
+
+
     end
   end
 end
+

data/lib/prawn/images/jpg.rb

@@ -10,21 +10,15 @@ require 'stringio'
 
 module Prawn
   module Images
-
     # A convenience class that wraps the logic for extracting the parts
     # of a JPG image that we need to embed them in a PDF
     #
     class JPG < Image
-      # @group Extension API
-      
       attr_reader :width, :height, :bits, :channels
       attr_accessor :scaled_width, :scaled_height
-
-      JPEG_SOF_BLOCKS = [0xC0, 0xC1, 0xC2, 0xC3, 0xC5, 0xC6, 0xC7, 0xC9, 0xCA, 0xCB, 0xCD, 0xCE, 0xCF]
-
-      def self.can_render?(image_blob)
-        image_blob[0, 3].unpack("C*") == [255, 216, 255]
-      end
+      
+      JPEG_SOF_BLOCKS = %W(\xc0 \xc1 \xc2 \xc3 \xc5 \xc6 \xc7 \xc9 \xca \xcb \xcd \xce \xcf)
+      JPEG_APP_BLOCKS = %W(\xe0 \xe1 \xe2 \xe3 \xe4 \xe5 \xe6 \xe7 \xe8 \xe9 \xea \xeb \xec \xed \xee \xef)
 
       # Process a new JPG image
       #
@@ -32,21 +26,20 @@ module Prawn
       #
       def initialize(data)
         @data = data
-        d = StringIO.new(@data)
-        d.binmode
+        data = StringIO.new(data.dup)
 
-        c_marker = 0xff # Section marker.
-        d.seek(2)    # Skip the first two bytes of JPEG identifier.
+        c_marker = "\xff" # Section marker.
+        data.read(2)   # Skip the first two bytes of JPEG identifier.
         loop do
-          marker, code, length = d.read(4).unpack('CCn')
+          marker, code, length = data.read(4).unpack('aan')
           raise "JPEG marker not found!" if marker != c_marker
 
           if JPEG_SOF_BLOCKS.include?(code)
-            @bits, @height, @width, @channels = d.read(6).unpack("CnnC")
+            @bits, @height, @width, @channels = data.read(6).unpack("CnnC")
             break
           end
 
-          d.seek(length - 2, IO::SEEK_CUR)
+          buffer = data.read(length - 2)
         end
       end
 
@@ -68,11 +61,13 @@ module Prawn
         obj = document.ref!(
           :Type             => :XObject,
           :Subtype          => :Image,
+          :Filter           => :DCTDecode,
           :ColorSpace       => color_space,
           :BitsPerComponent => bits,
           :Width            => width,
-          :Height           => height
-        )
+          :Height           => height,
+          :Length           => @data.size
+        ) 
 
         # add extra decode params for CMYK images. By swapping the
         # min and max values from the default, we invert the colours. See
@@ -81,8 +76,7 @@ module Prawn
           obj.data[:Decode] = [ 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0 ]
         end
 
-        obj.stream << @data
-        obj.stream.filters << :DCTDecode
+        obj << @data
         obj
       end
 

data/lib/prawn/images/png.rb

@@ -17,18 +17,12 @@ module Prawn
     # of a PNG image that we need to embed them in a PDF
     #
     class PNG < Image
-      # @group Extension API
-
       attr_reader :palette, :img_data, :transparency
       attr_reader :width, :height, :bits
       attr_reader :color_type, :compression_method, :filter_method
       attr_reader :interlace_method, :alpha_channel
       attr_accessor :scaled_width, :scaled_height
 
-      def self.can_render?(image_blob)
-        image_blob[0, 8].unpack("C*") == [137, 80, 78, 71, 13, 10, 26, 10]
-      end
-
       # Process a new PNG image
       #
       # <tt>data</tt>:: A binary string of PNG data
@@ -94,8 +88,6 @@ module Prawn
 
           data.read(4)  # Skip the CRC
         end
-
-        @img_data = Zlib::Inflate.inflate(@img_data)
       end
 
       # number of color components to each pixel
@@ -109,17 +101,34 @@ module Prawn
         end
       end
 
+      # number of bits used per pixel
+      #
+      def pixel_bitlength
+        if alpha_channel?
+          self.bits * (self.colors + 1)
+        else
+          self.bits * self.colors
+        end
+      end
+
       # split the alpha channel data from the raw image data in images
       # where it's required.
       #
       def split_alpha_channel!
-        split_image_data if alpha_channel?
+        unfilter_image_data if alpha_channel?
       end
 
       def alpha_channel?
         @color_type == 4 || @color_type == 6
       end
 
+      # Adobe Reader can't handle 16-bit png channels -- chop off the second
+      # byte (least significant)
+      #
+      def alpha_channel_bits
+        8
+      end
+
       # Build a PDF object representing this image in +document+, and return
       # a Reference to it.
       #
@@ -159,31 +168,31 @@ module Prawn
           :Subtype          => :Image,
           :Height           => height,
           :Width            => width,
-          :BitsPerComponent => bits
+          :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
-
-        obj.stream.filters << {
-          :FlateDecode => {
-            :Predictor => 15,
-            :Colors    => colors,
-            :BitsPerComponent => bits,
-            :Columns   => width
-          }
-        }
-
+        
         # 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!({})
+          palette_obj = document.ref!(:Length => palette.size)
           palette_obj << palette
 
           # build the color space array for the image
-          obj.data[:ColorSpace] = [:Indexed,
+          obj.data[:ColorSpace] = [:Indexed, 
                                    :DeviceRGB,
                                    (palette.size / 3) -1,
                                    palette_obj]
@@ -224,20 +233,13 @@ module Prawn
             :Subtype          => :Image,
             :Height           => height,
             :Width            => width,
-            :BitsPerComponent => bits,
+            :BitsPerComponent => alpha_channel_bits,
+            :Length           => alpha_channel.size,
+            :Filter           => :FlateDecode,
             :ColorSpace       => :DeviceGray,
             :Decode           => [0, 1]
           )
-          smask_obj.stream << alpha_channel
-
-          smask_obj.stream.filters << {
-            :FlateDecode => {
-              :Predictor => 15,
-              :Colors    => 1,
-              :BitsPerComponent => bits,
-              :Columns   => width
-            }
-          }
+          smask_obj << alpha_channel
           obj.data[:SMask] = smask_obj
         end
 
@@ -259,40 +261,95 @@ module Prawn
 
       private
 
-      def split_image_data
-        alpha_bytes = bits / 8
-        color_bytes = colors * bits / 8
-
-        scanline_length  = (color_bytes + alpha_bytes) * self.width + 1
-        scanlines = @img_data.bytesize / scanline_length
-        pixels = self.width * self.height
-
-        data = StringIO.new(@img_data)
-        data.binmode
-
-        color_data = [0x00].pack('C') * (pixels * color_bytes + scanlines)
-        color = StringIO.new(color_data)
-        color.binmode
-
-        @alpha_channel = [0x00].pack('C') * (pixels * alpha_bytes + scanlines)
-        alpha = StringIO.new(@alpha_channel)
-        alpha.binmode
-
-        scanlines.times do |line|
-          data.seek(line * scanline_length)
+      def unfilter_image_data
+        data = Zlib::Inflate.inflate(@img_data).unpack 'C*'
+        @img_data = ""
+        @alpha_channel = ""
+
+        pixel_bytes     = pixel_bitlength / 8
+        scanline_length = pixel_bytes * self.width + 1
+        row = 0
+        pixels = []
+        paeth, pa, pb, pc = nil
+        until data.empty? do
+          row_data = data.slice! 0, scanline_length
+          filter = row_data.shift
+          case filter
+          when 0 # None
+          when 1 # Sub
+            row_data.each_with_index do |byte, index|
+              left = index < pixel_bytes ? 0 : row_data[index - pixel_bytes]
+              row_data[index] = (byte + left) % 256
+              #p [byte, left, row_data[index]]
+            end
+          when 2 # Up
+            row_data.each_with_index do |byte, index|
+              col = index / pixel_bytes
+              upper = row == 0 ? 0 : pixels[row-1][col][index % pixel_bytes]
+              row_data[index] = (upper + byte) % 256
+            end
+          when 3  # Average
+            row_data.each_with_index do |byte, index|
+              col = index / pixel_bytes
+              upper = row == 0 ? 0 : pixels[row-1][col][index % pixel_bytes]
+              left = index < pixel_bytes ? 0 : row_data[index - pixel_bytes]
 
-          filter = data.getbyte
+              row_data[index] = (byte + ((left + upper)/2).floor) % 256
+            end
+          when 4 # Paeth
+            left = upper = upper_left = nil
+            row_data.each_with_index do |byte, index|
+              col = index / pixel_bytes
+
+              left = index < pixel_bytes ? 0 : row_data[index - pixel_bytes]
+              if row.zero?
+                upper = upper_left = 0
+              else
+                upper = pixels[row-1][col][index % pixel_bytes]
+                upper_left = col.zero? ? 0 :
+                  pixels[row-1][col-1][index % pixel_bytes]
+              end
+
+              p = left + upper - upper_left
+              pa = (p - left).abs
+              pb = (p - upper).abs
+              pc = (p - upper_left).abs
+
+              paeth = if pa <= pb && pa <= pc
+                left
+              elsif pb <= pc
+                upper
+              else
+                upper_left
+              end
+
+              row_data[index] = (byte + paeth) % 256
+            end
+          else
+            raise ArgumentError, "Invalid filter algorithm #{filter}"
+          end
 
-          color.putc filter
-          alpha.putc filter
+          s = []
+          row_data.each_slice pixel_bytes do |slice|
+            s << slice
+          end
+          pixels << s
+          row += 1
+        end
 
-          self.width.times do
-            color.write data.read(color_bytes)
-            alpha.write data.read(alpha_bytes)
+        # convert the pixel data to seperate strings for colours and alpha
+        color_byte_size = self.colors * self.bits / 8
+        alpha_byte_size = alpha_channel_bits / 8
+        pixels.each do |this_row|
+          this_row.each do |pixel|
+            @img_data << pixel[0, color_byte_size].pack("C*")
+            @alpha_channel << pixel[color_byte_size, alpha_byte_size].pack("C*")
           end
         end
 
-        @img_data = color_data
+        # compress the data
+        @img_data = Zlib::Deflate.deflate(@img_data)
+        @alpha_channel = Zlib::Deflate.deflate(@alpha_channel)
       end
     end
   end

data/lib/prawn/layout.rb

@@ -1,15 +1,20 @@
-require_relative "table"
-require_relative "layout/grid"
+require "prawn/table"
+require 'prawn/layout/grid'
 
 module Prawn
-  module Errors
+  
+ module Errors
+   
+   # This error is raised when table data is malformed
+   #
+   InvalidTableData = Class.new(StandardError)
 
-    # This error is raised when table data is malformed
-    #
-    InvalidTableData = Class.new(StandardError)
+   # This error is raised when an empty or nil table is rendered
+   #
+   EmptyTable = Class.new(StandardError)
+ end
 
-    # This error is raised when an empty or nil table is rendered
-    #
-    EmptyTable = Class.new(StandardError)
-  end
+ module Layout
+
+ end
 end

data/lib/prawn/layout/grid.rb

@@ -1,22 +1,15 @@
 module Prawn
   class Document
-    # @group Experimental API
-
-    # Defines the grid system for a particular document.  Takes the number of
-    # rows and columns and the width to use for the gutter as the
+    
+    # Defines the grid system for a particular document.  Takes the number of 
+    # rows and columns and the width to use for the gutter as the 
     # keys :rows, :columns, :gutter, :row_gutter, :column_gutter
     #
-    # Note that a completely new grid object is built each time define_grid()
-    # is called. This means that all subsequent calls to grid() will use
-    # the newly defined Grid object -- grids are not nestable like 
-    # bounding boxes are.
-
     def define_grid(options = {})
-      @boxes = nil
       @grid = Grid.new(self, options)
     end
-
-    # A method that can either be used to access a particular grid on the page
+  
+    # A method that can either be used to access a particular grid on the page 
     # or work with the grid system directly.
     #
     #   @pdf.grid                 # Get the Grid directly
@@ -29,7 +22,7 @@ module Prawn
         @grid
       else
         g1, g2 = args
-        if(g1.class == Array && g2.class == Array &&
+        if(g1.class == Array && g2.class == Array && 
           g1.length == 2 && g2.length == 2)
           multi_box(single_box(*g1), single_box(*g2))
         else
@@ -37,17 +30,15 @@ module Prawn
         end
       end
     end
-
-    # A Grid represents the entire grid system of a Page and calculates
+  
+    # A Grid represents the entire grid system of a Page and calculates 
     # the column width and row height of the base box.
-    #
-    # @private
     class Grid
       attr_reader :pdf, :columns, :rows, :gutter, :row_gutter, :column_gutter
       def initialize(pdf, options = {}) # :nodoc:
         valid_options = [:columns, :rows, :gutter, :row_gutter, :column_gutter]
         Prawn.verify_options valid_options, options
-
+      
         @pdf = pdf
         @columns = options[:columns]
         @rows = options[:rows]
@@ -58,7 +49,7 @@ module Prawn
       def column_width
         @column_width ||= subdivide(pdf.bounds.width, columns, column_gutter)
       end
-
+    
       # Calculates the base height of boxes.
       def row_height
        @row_height ||= subdivide(pdf.bounds.height, rows, row_gutter)
@@ -74,11 +65,11 @@ module Prawn
       end
 
       private
-
+      
       def subdivide(total, num, gutter)
         (total.to_f - (gutter * (num - 1).to_f)) / num.to_f
       end
-
+      
       def set_gutter(options)
         if options.has_key?(:gutter)
           @gutter = options[:gutter].to_f
@@ -90,93 +81,92 @@ module Prawn
         end
       end
     end
-
-    # A Box is a class that represents a bounded area of a page.
-    # A Grid object has methods that allow easy access to the coordinates of
+  
+    # A Box is a class that represents a bounded area of a page.  
+    # A Grid object has methods that allow easy access to the coordinates of 
     # its corners, which can be plugged into most existing prawnmethods.
     #
-    # @private
-    class GridBox
+    class Box #:nodoc:
       attr_reader :pdf
-
+    
       def initialize(pdf, i, j)
         @pdf = pdf
         @i = i
         @j = j
       end
-
-      # Mostly diagnostic method that outputs the name of a box as
+    
+      # Mostly diagnostic method that outputs the name of a box as 
       # col_num, row_num
       #
       def name
         "#{@i.to_s},#{@j.to_s}"
       end
-
+      
       # :nodoc
       def total_height
         pdf.bounds.height.to_f
       end
-
+      
       # Width of a box
       def width
         grid.column_width.to_f
       end
-
+    
       # Height of a box
       def height
         grid.row_height.to_f
       end
-
+      
       # Width of the gutter
       def gutter
         grid.gutter.to_f
       end
-
+      
       # x-coordinate of left side
       def left
         @left ||= (width + grid.column_gutter) * @j.to_f
       end
-
-      # x-coordinate of right side
+    
+      # x-coordinate of right side 
       def right
         @right ||= left + width
       end
-
+    
       # y-coordinate of the top
       def top
         @top ||= total_height - ((height + grid.row_gutter) * @i.to_f)
       end
-
+    
       # y-coordinate of the bottom
       def bottom
         @bottom ||= top - height
       end
-
+    
       # x,y coordinates of top left corner
       def top_left
         [left, top]
       end
-
-      # x,y coordinates of top right corner
+    
+      # x,y coordinates of top right corner    
       def top_right
         [right, top]
       end
-
+    
       # x,y coordinates of bottom left corner
       def bottom_left
         [left, bottom]
       end
-
+    
       # x,y coordinates of bottom right corner
       def bottom_right
         [right, bottom]
       end
-
+    
       # Creates a standard bounding box based on the grid box.
       def bounding_box(&blk)
         pdf.bounding_box(top_left, :width => width, :height => height, &blk)
       end
-
+    
       # Diagnostic method
       def show(grid_color = "CCCCCC")
         self.bounding_box do
@@ -185,30 +175,28 @@ module Prawn
           pdf.stroke_color = grid_color
           pdf.text self.name
           pdf.stroke_bounds
-
+          
           pdf.stroke_color = original_stroke_color
         end
       end
-
+    
       private
       def grid
         pdf.grid
       end
     end
-
+  
     # A MultiBox is specified by 2 Boxes and spans the areas between.
-    #
-    # @private
-    class MultiBox < GridBox #:nodoc:
+    class MultiBox < Box #:nodoc:
       def initialize(pdf, b1, b2)
         @pdf = pdf
         @bs = [b1, b2]
       end
-
+    
       def name
         @bs.map {|b| b.name}.join(":")
       end
-
+    
       def total_height
         @bs[0].total_height
       end
@@ -216,54 +204,54 @@ module Prawn
       def width
         right_box.right - left_box.left
       end
-
+    
       def height
         top_box.top - bottom_box.bottom
       end
-
+    
       def gutter
         @bs[0].gutter
       end
-
+    
       def left
         left_box.left
       end
-
+    
       def right
         right_box.right
       end
-
+    
       def top
         top_box.top
       end
-
+    
       def bottom
         bottom_box.bottom
       end
-
+    
       private
       def left_box
         @left_box ||= @bs.min {|a,b| a.left <=> b.left}
       end
-
+    
       def right_box
         @right_box ||= @bs.max {|a,b| a.right <=> b.right}
       end
-
+    
       def top_box
         @top_box ||= @bs.max {|a,b| a.top <=> b.top}
       end
-
+    
       def bottom_box
         @bottom_box ||= @bs.min {|a,b| a.bottom <=> b.bottom}
       end
     end
-
+  
     private
     def single_box(i, j)
-      GridBox.new(self, i, j)
+      Box.new(self, i, j)
     end
-
+  
     def multi_box(b1, b2)
       MultiBox.new(self, b1, b2)
     end