prawn 0.1.0

data/lib/prawn/font/wrapping.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+# wrapping.rb : Implementation of naive text wrap
+#
+# Copyright May 2008, Michael Daines. All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+module Prawn
+  module Font #:nodoc:
+    module Wrapping #:nodoc:
+      
+      # TODO: Replace with TeX optimal algorithm
+      def naive_wrap(string, line_width, font_size, options = {})
+        output = ""
+        string.lines.each do |line|
+          accumulated_width = 0
+          segments = line.scan(/\S+|\s+/)
+                                        
+          segments.each do |segment|    
+            segment_width = string_width(segment, font_size, 
+              :kerning => options[:kerning]) 
+      
+            if (accumulated_width + segment_width).round > line_width.round
+              output << "\n"
+              
+              if segment =~ /\s/
+                accumulated_width = 0
+              else
+                output << segment
+                accumulated_width = segment_width
+              end
+            else
+              output << segment
+              accumulated_width += segment_width
+            end
+          end
+        end
+  
+        output
+      end
+      
+    end
+  
+  end
+end

data/lib/prawn/graphics.rb

@@ -0,0 +1,285 @@
+# encoding: utf-8
+
+# graphics.rb : Implements PDF drawing primitives
+#
+# Copyright April 2008, Gregory Brown.  All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+
+require "enumerator"
+require "prawn/graphics/cell"
+
+module Prawn
+
+  # Implements the drawing facilities for Prawn::Document.  
+  # Use this to draw the most beautiful imaginable things.
+  # 
+  # This file lifts and modifies several of PDF::Writer's graphics functions
+  # ruby-pdf.rubyforge.org
+  #
+  module Graphics 
+      
+      
+    #######################################################################
+    # Low level drawing operations must translate to absolute coords!     #
+    #######################################################################
+       
+    # Moves the drawing position to a given point.  The point can be
+    # specified as a tuple or a flattened argument list
+    #
+    #   pdf.move_to [100,50]
+    #   pdf.move_to(100,50)
+    #
+    def move_to(*point)
+      x,y = translate(point)           
+      add_content("%.3f %.3f m" % [ x, y ])
+    end
+    
+    # Draws a line from the current drawing position to the specified point.
+    # The destination may be described as a tuple or a flattened list:    
+    #
+    #   pdf.line_to [50,50] 
+    #   pdf.line_to(50,50)    
+    #
+    def line_to(*point)      
+      x,y = translate(point)
+      add_content("%.3f %.3f l" % [ x, y ]) 
+    end    
+    
+    # Draws a Bezier curve from the current drawing position to the 
+    # specified point, bounded by two additional points.
+    #  
+    #   pdf.curve_to [100,100], :bounds => [[90,90],[75,75]]   
+    #
+    def curve_to(dest,options={})                           
+       options[:bounds] or raise Prawn::Errors::InvalidGraphicsPath, 
+         "Bounding points for bezier curve must be specified "+
+         "as :bounds => [[x1,y1],[x2,y2]]"       
+
+       curve_points = (options[:bounds] << dest).map { |e| translate(e) }
+       add_content("%.3f %.3f %.3f %.3f %.3f %.3f c" % 
+                     curve_points.flatten )    
+    end   
+    
+    # Draws a rectangle given <tt>point</tt>, <tt>width</tt> and 
+    # <tt>height</tt>.  The rectangle is bounded by its upper-left corner.
+    #
+    #    pdf.rectangle [300,300], 100, 200
+    # 
+    def rectangle(point,width,height)
+      x,y = translate(point)
+      add_content("%.3f %.3f %.3f %.3f re" % [ x, y - height, width, height ])      
+    end
+       
+    ###########################################################
+    #  Higher level functions: May use relative coords        #   
+    ########################################################### 
+      
+    # Sets line thickness to the <tt>width</tt> specified.
+    #
+    def line_width=(width)
+      @line_width = width
+      add_content("#{width} w")
+    end
+
+    # The current line thickness
+    #
+    def line_width
+      @line_width || 1
+    end
+       
+    # Draws a line from one point to another. Points may be specified as 
+    # tuples or flattened argument list:
+    #
+    #   pdf.line [100,100], [200,250] 
+    #   pdf.line(100,100,200,250)
+    #
+    def line(*points)
+      x0,y0,x1,y1 = points.flatten
+      move_to(x0, y0)
+      line_to(x1, y1)
+    end   
+
+    # Draws a horizontal line from <tt>x1</tt> to <tt>x2</tt> at the
+    # current <tt>y</tt> position.
+    #
+    def horizontal_line(x1,x2)
+      line(x1,y,x2,y)
+    end
+
+    # Draws a horizontal line from the left border to the right border of the
+    # bounding box at the current <tt>y</tt> position.
+    #
+    def horizontal_rule
+      horizontal_line(bounds.left, bounds.right)
+    end
+
+    # Draws a vertical line at the given x position from y1 to y2.
+    # 
+    def vertical_line_at(x,y1,y2)
+      line(x,y1,x,y2)
+    end
+               
+    # Draws a Bezier curve between two points, bounded by two additional
+    # points
+    #
+    #    pdf.curve [50,100], [100,100], :bounds => [[90,90],[75,75]]  
+    #
+    def curve(origin,dest, options={})
+      move_to *origin    
+      curve_to(dest,options)
+    end
+
+    # This constant is used to approximate a symmetrical arc using a cubic
+    # Bezier curve.   
+    #
+    KAPPA = 4.0 * ((Math.sqrt(2) - 1.0) / 3.0)
+                                                                  
+    # Draws a circle of radius <tt>:radius</tt> with the centre-point at <tt>point</tt>
+    # as a complete subpath. The drawing point will be moved to the
+    # centre-point upon completion of the drawing the circle.     
+    #                                           
+    #    pdf.circle_at [100,100], :radius => 25  
+    #
+    def circle_at(point, options)  
+      x,y = point
+      ellipse_at [x, y], options[:radius]     
+    end 
+      
+    # Draws an ellipse of +x+ radius <tt>r1</tt> and +y+ radius <tt>r2</tt>
+    # with the centre-point at <tt>point</tt> as a complete subpath. The
+    # drawing point will be moved to the centre-point upon completion of the
+    # drawing the ellipse.   
+    #                                    
+    #    # draws an ellipse with x-radius 25 and y-radius 50
+    #    pdf.ellipse_at [100,100], 25, 50   
+    #
+    def ellipse_at(point, r1, r2 = r1)  
+      x, y = point
+      l1 = r1 * KAPPA
+      l2 = r2 * KAPPA            
+      
+      move_to(x + r1, y)
+      
+      # Upper right hand corner
+      curve_to [x,  y + r2], 
+        :bounds => [[x + r1, y + l1], [x + l2, y + r2]]
+
+      # Upper left hand corner                          
+      curve_to [x - r1, y],  
+        :bounds => [[x - l2, y + r2], [x - r1, y + l1]] 
+ 
+      # Lower left hand corner
+      curve_to [x, y - r2],  
+        :bounds => [[x - r1, y - l1], [x - l2, y - r2]]  
+
+      # Lower right hand corner
+      curve_to [x + r1, y],
+        :bounds => [[x + l2, y - r2], [x + r1, y - l1]]    
+   
+      move_to(x, y)
+    end
+     
+    # Draws a polygon from the specified points.
+    #                                              
+    #    # draws a snazzy triangle
+    #    pdf.polygon [100,100], [100,200], [200,200]  
+    #
+    def polygon(*points) 
+      move_to points[0]
+      (points << points[0]).each_cons(2) do |p1,p2|
+        line_to(*p2)
+      end
+    end
+                                      
+    # Sets the fill color.  6 digit HTML color codes are used.
+    # 
+    #   pdf.fill_color "f0ffc1"
+    #
+    def fill_color(color=nil)
+      return @fill_color unless color
+      @fill_color = color
+      set_fill_color     
+    end 
+    
+    alias_method :fill_color=, :fill_color                                                                     
+    
+    # Sets the line stroking color.  6 digit HTML color codes are used.
+    #
+    #   pdf.stroke_color "cc2fde"
+    #
+    def stroke_color(color=nil) 
+      return @stroke_color unless color
+      @stroke_color = color
+      set_stroke_color
+    end   
+    
+    alias_method :stroke_color=, :stroke_color
+    
+    # Strokes and closes the current path.
+    #
+    def stroke
+      yield if block_given?
+      add_content "S"
+    end
+
+    # Fills and closes the current path
+    #
+    def fill               
+      yield if block_given?
+      add_content "f"
+    end
+    
+    # Fills, strokes, and closes the current path.
+    #
+    def fill_and_stroke  
+      yield if block_given?
+      add_content "b" 
+    end     
+    
+    # Provides the following shortcuts:
+    #
+    #    stroke_some_method(*args) #=> some_method(*args); stroke
+    #    fill_some_method(*args) #=> some_method(*args); fill
+    #
+    def method_missing(id,*args,&block)
+      case(id.to_s) 
+      when /^fill_and_stroke_(.*)/
+        send($1,*args,&block); fill_and_stroke
+      when /^stroke_(.*)/
+        send($1,*args,&block); stroke 
+      when /^fill_(.*)/
+        send($1,*args,&block); fill
+      else
+        super
+      end
+    end                    
+    
+    private    
+    
+    def translate(*point)
+      x,y = point.flatten
+      [@bounding_box.absolute_left + x, @bounding_box.absolute_bottom + y]
+    end     
+                                                                        
+    def set_fill_color
+      r,g,b = [@fill_color[0..1], @fill_color[2..3], @fill_color[4..5]].
+              map { |e| e.to_i(16) }       
+      add_content "%.3f %.3f %.3f rg" %  [r / 255.0, g / 255.0, b / 255.0]   
+    end
+    
+    def set_stroke_color
+      r,g,b = [@stroke_color[0..1], @stroke_color[2..3], @stroke_color[4..5]].
+              map { |e| e.to_i(16) }     
+      add_content "%.3f %.3f %.3f RG" %  [r / 255.0, g / 255.0, b / 255.0]       
+    end                                       
+    
+    def update_colors 
+      @fill_color   ||= "000000"
+      @stroke_color ||= "000000"                                       
+      set_fill_color
+      set_stroke_color
+    end
+
+  end
+end

data/lib/prawn/graphics/cell.rb

@@ -0,0 +1,226 @@
+# encoding: utf-8
+
+module Prawn
+
+  class Document
+    # Builds and renders a Graphics::Cell.  A cell is essentially a
+    # special-purpose bounding box designed for flowing text within a bordered
+    # area.  For available options, see Graphics::Cell#new.
+    #
+    #    Prawn::Document.generate("cell.pdf") do
+    #       cell [100,500], 
+    #         :width => 200,
+    #         :text  => "The rain in Spain falls mainly on the plains"
+    #    end
+    #
+    def cell(point, options={})
+      Prawn::Graphics::Cell.new(
+        options.merge(:document => self, :point => point)).draw
+    end
+  end
+
+  module Graphics
+    # A cell is a special-purpose bounding box designed to flow text within a
+    # bordered area. This is used by Prawn's Document::Table implementation but
+    # can also be used standalone for drawing text boxes via Document#cell
+    #
+    class Cell
+
+      # Creates a new cell object.  Generally used indirectly via Document#cell
+      #
+      # Of the available options listed below, <tt>:point</tt>, <tt>:width</tt>,
+      # and <tt>:text</tt> must be provided. If you are not using the
+      # Document#cell shortcut, the <tt>:document</tt> must also be provided.
+      #
+      # <tt>:point</tt>:: Absolute [x,y] coordinate of the top-left corner of the cell.
+      # <tt>:document</tt>:: The Prawn::Document object to render on. 
+      # <tt>:text</tt>:: The text to be flowed within the cell
+      # <tt>:width</tt>:: The width in PDF points of the cell.
+      # <tt>:border</tt>:: The border line width. If omitted, no border will be drawn.
+      # <tt>:horizontal_padding</tt>:: The horizontal padding in PDF points
+      # <tt>:vertical_padding</tt>:: The vertical padding in PDF points
+      # <tt>:padding</tt>:: Overrides both horizontal and vertical padding
+      # <tt>:border_style</tt>:: One of <tt>:all</tt>, <tt>:no_top</tt>, <tt>:no_bottom</tt>, <tt>:sides</tt>   
+      # <tt>:align</tt>:: One of <tt>:left</tt>, <tt>:right</tt>, <tt>:center</tt>
+      #
+      def initialize(options={})
+        @point        = options[:point]
+        @document     = options[:document]
+        @text         = options[:text].to_s
+        @width        = options[:width]
+        @border       = options[:border] || 1
+        @border_style = options[:border_style] || :all               
+        @background_color = options[:background_color] 
+        @align            = options[:align] || :left
+
+        @horizontal_padding = options[:horizontal_padding] || 0
+        @vertical_padding   = options[:vertical_padding]   || 0
+
+        if options[:padding]
+          @horizontal_padding = @vertical_padding = options[:padding]
+        end
+      end
+
+      attr_accessor :point, :border_style, :border, :background_color,
+                    :document, :horizontal_padding, :vertical_padding,
+                    :align
+      attr_writer   :height, :width #:nodoc:   
+           
+      # Returns the cell's text as a string.
+      #
+      def to_s
+        @text
+      end
+
+      # The width of the text area excluding the horizonal padding
+      #
+      def text_area_width
+        width - 2*@horizontal_padding
+      end
+
+      # The width of the cell in PDF points
+      #
+      def width
+        @width || (@document.font_metrics.string_width(@text,
+          @document.font_size)) + 2*@horizontal_padding
+      end
+
+      # The height of the cell in PDF points
+      #
+      def height
+        @height || text_area_height + 2*@vertical_padding
+      end
+
+      # The height of the text area excluding the vertical padding
+      #
+      def text_area_height
+        @document.font_metrics.string_height(@text, 
+         :font_size  => @document.font_size, 
+         :line_width => text_area_width) 
+      end
+
+      # Draws the cell onto the PDF document
+      # 
+      def draw
+        rel_point = @point                
+        
+        if @background_color    
+          @document.mask(:fill_color) do
+            @document.fill_color @background_color  
+            h  = borders.include?(:bottom) ? height - border : height + border / 2.0
+            @document.fill_rectangle [rel_point[0] + border / 2.0, 
+                                      rel_point[1] - border / 2.0 ], 
+                width - border, h  
+          end
+        end
+
+        if @border > 0
+          @document.mask(:line_width) do
+            @document.line_width = @border
+
+            if borders.include?(:left)
+              @document.stroke_line [rel_point[0], rel_point[1] + (@border / 2.0)], 
+                [rel_point[0], rel_point[1] - height - @border / 2.0 ]
+            end
+
+            if borders.include?(:right)
+              @document.stroke_line( 
+                [rel_point[0] + width, rel_point[1] + (@border / 2.0)],
+                [rel_point[0] + width, rel_point[1] - height - @border / 2.0] )
+            end
+
+            if borders.include?(:top)
+              @document.stroke_line(
+                [ rel_point[0] + @border / 2.0, rel_point[1] ], 
+                [ rel_point[0] - @border / 2.0 + width, rel_point[1] ])
+            end
+
+            if borders.include?(:bottom)
+              @document.stroke_line [rel_point[0], rel_point[1] - height ],
+                                  [rel_point[0] + width, rel_point[1] - height]
+            end
+
+          end
+          
+          borders
+
+        end
+
+        @document.bounding_box( [@point[0] + @horizontal_padding, 
+                                 @point[1] - @vertical_padding], 
+                                :width   => text_area_width,
+                                :height  => height - @vertical_padding) do
+          @document.text @text, :align => @align
+        end
+      end
+
+      private
+
+      def borders
+        @borders ||= case @border_style
+        when :all
+          [:top,:left,:right,:bottom]
+        when :sides
+          [:left,:right]
+        when :no_top
+          [:left,:right,:bottom]
+        when :no_bottom
+          [:left,:right,:top]
+        end
+      end
+
+    end
+
+    class CellBlock #:nodoc:
+
+      # Not sure if this class is something I want to expose in the public API.
+
+      def initialize(document)
+        @document = document
+        @cells    = []
+        @width    = 0
+        @height   = 0
+      end
+
+      attr_reader :width, :height
+      attr_accessor :background_color
+
+      def <<(cell)
+        @cells << cell
+        @height = cell.height if cell.height > @height 
+        @width += cell.width
+        self
+      end
+
+      def draw
+        y = @document.y
+        x = @document.bounds.absolute_left
+
+        @cells.each do |e|
+          e.point  = [x - @document.bounds.absolute_left, 
+                      y - @document.bounds.absolute_bottom]
+          e.height = @height
+          e.background_color ||= @background_color
+          e.draw
+          x += e.width
+        end
+        
+        @document.y = y - @height
+      end
+
+      def border
+        @cells[0].border
+      end
+
+      def border_style=(s)
+        @cells.each { |e| e.border_style = s }
+      end                 
+      
+      def border_style
+        @cells[0].border_style
+      end
+
+    end
+  end
+ 
+end