fullcirclegroup-prawn 0.2.99.3

data/lib/prawn/images/jpg.rb

@@ -0,0 +1,45 @@
+# 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 PNG 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 string containing a full PNG file
+      #
+      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,199 @@
+# 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'
+
+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 string containing a full PNG file
+      #
+      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
+
+        # if our img_data contains alpha channel data, split it out
+        unfilter_image_data if alpha_channel?
+      end
+
+      def pixel_bytes
+        @pixel_bytes ||= case @color_type
+        when 0, 3, 4 then 1
+        when 1, 2, 6 then 3
+        end
+      end
+
+      private
+
+      def alpha_channel?
+        @color_type == 4 || @color_type == 6
+      end
+
+      def unfilter_image_data
+        data = Zlib::Inflate.inflate(@img_data).unpack 'C*'
+        @img_data = ""
+        @alpha_channel = ""
+
+        # each pixel has the color bytes, plus a byte of alpha channel
+        pixel_length = pixel_bytes + 1
+        scanline_length = pixel_length * @width + 1 # for filter
+        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_length ? 0 : row_data[index - pixel_length]
+              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_length
+              upper = row == 0 ? 0 : pixels[row-1][col][index % pixel_length]
+              row_data[index] = (upper + byte) % 256
+            end
+          when 3  # Average
+            row_data.each_with_index do |byte, index|
+              col = index / pixel_length
+              upper = row == 0 ? 0 : pixels[row-1][col][index % pixel_length]
+              left = index < pixel_length ? 0 : row_data[index - pixel_length]
+
+              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_length
+
+              left = index < pixel_length ? 0 : row_data[index - pixel_length]
+              if row.zero?
+                upper = upper_left = 0
+              else
+                upper = pixels[row-1][col][index % pixel_length]
+                upper_left = col.zero? ? 0 :
+                  pixels[row-1][col-1][index % pixel_length]
+              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
+              #p [byte, paeth, row_data[index]]
+            end
+          else
+            raise ArgumentError, "Invalid filter algorithm #{filter}"
+          end
+
+          s = []
+          row_data.each_slice pixel_length do |slice|
+            s << slice
+          end
+          pixels << s
+          row += 1
+        end
+
+        # convert the pixel data to seperate strings for colours and alpha
+        pixels.each do |row|
+          row.each do |pixel|
+            @img_data << pixel[0,pixel_bytes].pack("C*")
+            @alpha_channel << pixel.last
+          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/pdf_object.rb

@@ -0,0 +1,73 @@
+# encoding: utf-8
+#
+# pdf_object.rb : Handles Ruby to PDF object serialization
+#
+# Copyright April 2008, Gregory Brown.  All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+
+# Top level Module
+#
+module Prawn 
+                                             
+  module_function
+    
+  # Serializes Ruby objects to their PDF equivalents.  Most primitive objects
+  # will work as expected, but please note that Name objects are represented 
+  # by Ruby Symbol objects and Dictionary objects are represented by Ruby hashes
+  # (keyed by symbols)   
+  #
+  #  Examples:
+  #
+  #     PdfObject(true)      #=> "true"
+  #     PdfObject(false)     #=> "false" 
+  #     PdfObject(1.2124)    #=> "1.2124"
+  #     PdfObject("foo bar") #=> "(foo bar)"  
+  #     PdfObject(:Symbol)   #=> "/Symbol"
+  #     PdfObject(["foo",:bar, [1,2]]) #=> "[foo /bar [1 2]]"
+  # 
+  def PdfObject(obj, in_content_stream = false)
+    case(obj)        
+    when NilClass   then "null" 
+    when TrueClass  then "true"
+    when FalseClass then "false"
+    when Numeric    then String(obj)
+    when Array
+      "[" << obj.map { |e| PdfObject(e, in_content_stream) }.join(' ') << "]"
+    when Prawn::LiteralString
+      obj = obj.gsub(/[\\\n\(\)]/) { |m| "\\#{m}" }
+      "(#{obj})"
+    when String
+      obj = "\xFE\xFF" + obj.unpack("U*").pack("n*") unless in_content_stream
+      "<" << obj.unpack("H*").first << ">"
+    when Symbol                                                         
+       if (obj = obj.to_s) =~ /\s/
+         raise Prawn::Errors::FailedObjectConversion, 
+           "A PDF Name cannot contain whitespace"  
+       else
+         "/" << obj   
+       end 
+    when Hash           
+      output = "<< "
+      obj.each do |k,v|                                                        
+        unless String === k || Symbol === k
+          raise Prawn::Errors::FailedObjectConversion, 
+            "A PDF Dictionary must be keyed by names"
+        end                          
+        output << PdfObject(k.to_sym, in_content_stream) << " " << 
+                  PdfObject(v, in_content_stream) << "\n"
+      end   
+      output << ">>"  
+    when Prawn::Reference
+      obj.to_s      
+    when Prawn::NameTree::Node
+      PdfObject(obj.to_hash)
+    when Prawn::NameTree::Value
+      PdfObject(obj.name) + " " + PdfObject(obj.value)
+    else
+      raise Prawn::Errors::FailedObjectConversion, 
+        "This object cannot be serialized to PDF"
+    end     
+  end   
+  
+end

data/lib/prawn/reference.rb

@@ -0,0 +1,56 @@
+# encoding: utf-8
+
+# reference.rb : Implementation of PDF indirect objects
+#
+# Copyright April 2008, Gregory Brown.  All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+
+require 'zlib'
+
+module Prawn  
+  
+  class Reference #:nodoc:
+             
+   attr_accessor :gen, :data, :offset
+   attr_reader :identifier, :stream
+    
+    def initialize(id,data)
+      @identifier = id 
+      @gen   = 0       
+      @data  = data     
+      @compressed = false
+    end            
+    
+    def object 
+      output = "#{@identifier} #{gen} obj\n" <<
+               Prawn::PdfObject(data) << "\n"
+      if @stream
+        output << "stream\n" << @stream << "\nendstream\n" 
+      end
+      output << "endobj\n"
+    end  
+    
+    def <<(data)
+      raise 'Cannot add data to a stream that is compressed' if @compressed
+      (@stream ||= "") << data  
+    end  
+    
+    def to_s            
+      "#{@identifier} #{gen} R"
+    end
+
+    def compress_stream
+      @stream = Zlib::Deflate.deflate(@stream)
+      @data[:Filter] = :FlateDecode
+      @compressed = true
+    end
+  end         
+  
+  module_function
+  
+  def Reference(*args) #:nodoc:
+    Reference.new(*args)
+  end     
+
+end

data/spec/bounding_box_spec.rb

@@ -0,0 +1,141 @@
+# encoding: utf-8
+
+require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
+
+describe "A bounding box" do
+
+  before(:each) do
+    @x      = 100
+    @y      = 125
+    @width  = 50
+    @height = 75
+    @box = Prawn::Document::BoundingBox.new(nil, [@x,@y], :width  => @width,
+                                                          :height => @height )
+  end
+
+  it "should have an anchor at (x, y - height)" do
+    @box.anchor.should == [@x,@y-@height]           
+  end
+
+  it "should have a left boundary of 0" do
+    @box.left.should == 0
+  end
+  
+  it "should have a right boundary equal to the width" do
+    @box.right.should == @width
+  end
+  
+  it "should have a top boundary of height" do
+    @box.top.should == @height
+  end
+  
+  it "should have a bottom boundary of 0" do
+    @box.bottom.should == 0
+  end
+
+  it "should have a top-left of [0,height]" do
+    @box.top_left.should == [0,@height]
+  end
+
+  it "should have a top-right of [width,height]" do
+    @box.top_right.should == [@width,@height]
+  end
+
+  it "should have a bottom-left of [0,0]" do
+    @box.bottom_left.should == [0,0]
+  end
+
+  it "should have a bottom-right of [width,0]" do
+    @box.bottom_right.should == [@width,0]
+  end
+
+  it "should have an absolute left boundary of x" do
+    @box.absolute_left.should == @x
+  end
+  
+  it "should have an absolute right boundary of x + width" do
+    @box.absolute_right.should == @x + @width
+  end
+  
+  it "should have an absolute top boundary of y" do
+    @box.absolute_top.should == @y
+  end
+  
+  it "should have an absolute bottom boundary of y - height" do
+    @box.absolute_bottom.should == @y - @height
+  end
+
+  it "should have an absolute bottom-left of [x,y-height]" do
+    @box.absolute_bottom_left.should == [@x, @y - @height]
+  end
+
+  it "should have an absolute bottom-right of [x+width,y-height]" do
+    @box.absolute_bottom_right.should == [@x + @width , @y - @height]
+  end
+
+  it "should have an absolute top-left of [x,y]" do
+    @box.absolute_top_left.should == [@x, @y]
+  end
+
+  it "should have an absolute top-right of [x+width,y]" do
+    @box.absolute_top_right.should == [@x + @width, @y]
+  end
+  
+
+end
+
+describe "drawing bounding boxes" do    
+  
+  before(:each) { create_pdf }   
+
+  it "should restore the margin box when bounding box exits" do
+    margin_box = @pdf.bounds
+
+    @pdf.bounding_box [100,500] do
+      #nothing
+    end
+
+    @pdf.bounds.should == margin_box
+
+  end
+
+  it "should restore the parent bounding box when calls are nested" do
+    @pdf.bounding_box [100,500], :width => 300, :height => 300 do 
+
+      @pdf.bounds.absolute_top.should  == 500 + @pdf.margin_box.absolute_bottom
+      @pdf.bounds.absolute_left.should == 100 + @pdf.margin_box.absolute_left
+
+      parent_box = @pdf.bounds
+
+      @pdf.bounding_box [50,200], :width => 100, :height => 100 do
+        @pdf.bounds.absolute_top.should == 200 + parent_box.absolute_bottom
+        @pdf.bounds.absolute_left.should == 50 + parent_box.absolute_left
+      end
+
+      @pdf.bounds.absolute_top.should  == 500 + @pdf.margin_box.absolute_bottom
+      @pdf.bounds.absolute_left.should == 100 + @pdf.margin_box.absolute_left
+
+    end
+  end   
+  
+  it "should calculate a height if none is specified" do 
+    @pdf.bounding_box([100, 500], :width => 100) do
+      @pdf.text "The rain in Spain falls mainly on the plains." 
+    end     
+    
+    @pdf.y.should.be.close 458.384, 0.001 
+  end
+  
+end
+
+describe "A canvas" do
+  before(:each) { create_pdf }
+  
+  it "should use whatever the last set y position is" do
+    @pdf.canvas do
+      @pdf.bounding_box([100,500],:width => 200) { @pdf.move_down 50 }
+    end
+    @pdf.y.should == 450
+  end
+end      
+