prawn 0.8.4 → 0.11.1.pre

data/lib/prawn/images/jpg.rb

@@ -0,0 +1,46 @@
+# encoding: ASCII-8BIT
+
+# jpg.rb : Extracts the data from a JPG that is needed for embedding
+#
+# Copyright April 2008, James Healy.  All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+
+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 
+      attr_reader :width, :height, :bits, :channels
+      attr_accessor :scaled_width, :scaled_height
+      
+      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
+      #
+      # <tt>:data</tt>:: A binary string of JPEG data
+      #
+      def initialize(data)
+        data = StringIO.new(data.dup)
+
+        c_marker = "\xff" # Section marker.
+        data.read(2)   # Skip the first two bytes of JPEG identifier.
+        loop do
+          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 = data.read(6).unpack("CnnC")
+            break
+          end
+
+          buffer = data.read(length - 2)
+        end
+      end
+    end
+  end
+end

data/lib/prawn/images/png.rb

@@ -0,0 +1,226 @@
+# encoding: ASCII-8BIT
+
+# png.rb : Extracts the data from a PNG that is needed for embedding
+#
+# Based on some similar code in PDF::Writer by Austin Ziegler
+#
+# Copyright April 2008, James Healy.  All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+
+require 'stringio'
+require 'enumerator'
+
+module Prawn
+  module Images
+    # A convenience class that wraps the logic for extracting the parts
+    # of a PNG image that we need to embed them in a PDF
+    #
+    class PNG
+      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
+
+      # Process a new PNG image
+      #
+      # <tt>data</tt>:: A binary string of PNG data
+      #
+      def initialize(data)
+        data = StringIO.new(data.dup)
+
+        data.read(8)  # Skip the default header
+
+        @palette  = ""
+        @img_data = ""
+        @transparency = {}
+
+        loop do
+          chunk_size  = data.read(4).unpack("N")[0]
+          section     = data.read(4)
+          case section
+          when 'IHDR'
+            # we can grab other interesting values from here (like width,
+            # height, etc)
+            values = data.read(chunk_size).unpack("NNCCCCC")
+
+            @width              = values[0]
+            @height             = values[1]
+            @bits               = values[2]
+            @color_type         = values[3]
+            @compression_method = values[4]
+            @filter_method      = values[5]
+            @interlace_method   = values[6]
+          when 'PLTE'
+            @palette << data.read(chunk_size)
+          when 'IDAT'
+            @img_data << data.read(chunk_size)
+          when 'tRNS'
+            # This chunk can only occur once and it must occur after the
+            # PLTE chunk and before the IDAT chunk
+            @transparency = {}
+            case @color_type
+            when 3
+              # Indexed colour, RGB. Each byte in this chunk is an alpha for
+              # the palette index in the PLTE ("palette") chunk up until the
+              # last non-opaque entry. Set up an array, stretching over all
+              # palette entries which will be 0 (opaque) or 1 (transparent).
+              @transparency[:indexed]  = data.read(chunk_size).unpack("C*")
+              short = 255 - @transparency[:indexed].size
+              @transparency[:indexed] += ([255] * short) if short > 0
+            when 0
+              # Greyscale. Corresponding to entries in the PLTE chunk.
+              # Grey is two bytes, range 0 .. (2 ^ bit-depth) - 1
+              grayval = data.read(chunk_size).unpack("n").first
+              @transparency[:grayscale] = grayval
+            when 2
+              # True colour with proper alpha channel.
+              @transparency[:rgb] = data.read(chunk_size).unpack("nnn")
+            end
+          when 'IEND'
+            # we've got everything we need, exit the loop
+            break
+          else
+            # unknown (or un-important) section, skip over it
+            data.seek(data.pos + chunk_size)
+          end
+
+          data.read(4)  # Skip the CRC
+        end
+      end
+
+      # number of color components to each pixel
+      #
+      def colors
+        case self.color_type
+        when 0, 3, 4
+          return 1
+        when 2, 6
+          return 3
+        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!
+        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
+
+      private
+
+      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]
+
+              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
+
+          s = []
+          row_data.each_slice pixel_bytes do |slice|
+            s << slice
+          end
+          pixels << s
+          row += 1
+        end
+
+        # 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
+
+        # compress the data
+        @img_data = Zlib::Deflate.deflate(@img_data)
+        @alpha_channel = Zlib::Deflate.deflate(@alpha_channel)
+      end
+    end
+  end
+end

data/lib/prawn/layout.rb

@@ -0,0 +1,20 @@
+require "prawn/table"
+require 'prawn/layout/grid'
+
+module Prawn
+  
+ module Errors
+   
+   # 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
+
+ module Layout
+
+ end
+end

data/lib/prawn/layout/grid.rb

@@ -0,0 +1,259 @@
+module Prawn
+  class Document
+    
+    # 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
+    #
+    def define_grid(options = {})
+      @grid = Grid.new(self, options)
+    end
+  
+    # 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
+    #   @pdf.grid([0,1])          # Get the box at [0,1]
+    #   @pdf.grid([0,1], [1,2])   # Get a multi-box spanning from [0,1] to [1,2]
+    #
+    def grid(*args)
+      @boxes ||= {}
+      @boxes[args] ||= if args.empty?
+        @grid
+      else
+        g1, g2 = args
+        if(g1.class == Array && g2.class == Array && 
+          g1.length == 2 && g2.length == 2)
+          multi_box(single_box(*g1), single_box(*g2))
+        else
+          single_box(g1, g2)
+        end
+      end
+    end
+  
+    # A Grid represents the entire grid system of a Page and calculates 
+    # the column width and row height of the base box.
+    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]
+        set_gutter(options)
+      end
+
+      # Calculates the base width of boxes.
+      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)
+      end
+
+      # Diagnostic tool to show all of the grids.  Defaults to gray.
+      def show_all(color = "CCCCCC")
+        self.rows.times do |i|
+          self.columns.times do |j|
+            pdf.grid(i,j).show(color)
+          end
+        end
+      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
+          @row_gutter, @column_gutter = @gutter, @gutter
+        else
+          @row_gutter    = options[:row_gutter].to_f
+          @column_gutter = options[:column_gutter].to_f
+          @gutter = 0
+        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 
+    # its corners, which can be plugged into most existing prawnmethods.
+    #
+    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 
+      # 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 
+      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    
+      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
+          original_stroke_color = pdf.stroke_color
+
+          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.
+    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
+
+      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)
+      Box.new(self, i, j)
+    end
+  
+    def multi_box(b1, b2)
+      MultiBox.new(self, b1, b2)
+    end
+  end
+end