fullcirclegroup-prawn 0.2.99.3

data/lib/prawn/graphics.rb

@@ -0,0 +1,252 @@
+# 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"
+require "prawn/graphics/color"
+
+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
+
+    include Color
+
+    #######################################################################
+    # 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(width=nil)
+      if width
+        self.line_width = width
+      else
+        @line_width || 1
+      end
+    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, or the position specified by the :at option.
+    #
+    #  # draw a line from [25, 75] to [100, 75]
+    #  horizontal_line 25, 100, :at => 75  
+    #
+    def horizontal_line(x1,x2,options={})
+      if options[:at]
+        y1 = options[:at]
+      else
+        y1 = y - bounds.absolute_bottom
+      end
+      
+      line(x1,y1,x2,y1)
+    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 x cooordinate given by :at from y1 to y2.
+    #
+    #   # draw a line from [25, 100] to [25, 300]
+    #   vertical_line 100, 300, :at => 25
+    #
+    def vertical_line(y1,y2,params)
+      line(params[:at],y1,params[:at],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
+
+    # Strokes and closes the current path. See Graphic::Color for color details
+    #
+    def stroke
+      yield if block_given?
+      add_content "S"
+    end
+    
+    # Draws and strokes a rectangle represented by the current bounding box
+    #
+    def stroke_bounds
+      stroke_rectangle bounds.top_left, bounds.width, bounds.height
+    end
+
+    # Fills and closes the current path. See Graphic::Color for color details
+    #
+    def fill
+      yield if block_given?
+      add_content "f"
+    end
+
+    # Fills, strokes, and closes the current path. See Graphic::Color for color details
+    #
+    def fill_and_stroke
+      yield if block_given?
+      add_content "b"
+    end
+
+    private
+
+    def translate(*point)
+      x,y = point.flatten
+      [@bounding_box.absolute_left + x, @bounding_box.absolute_bottom + y]
+    end
+
+    def translate!(point)
+      point.replace(translate(point))
+    end
+
+  end
+end

data/lib/prawn/graphics/cell.rb

@@ -0,0 +1,264 @@
+# encoding: utf-8   
+
+
+# cell.rb : Table support functions
+#
+# Copyright June 2008, Gregory Brown.  All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+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>:height</tt>:: The height in PDF points of the cell.
+      # <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>:align</tt>:: One of <tt>:left</tt>, <tt>:right</tt>, <tt>:center</tt>
+      # <tt>:borders</tt>:: An array of sides which should have a border. Any of <tt>:top</tt>, <tt>:left</tt>, <tt>:right</tt>, <tt>:bottom</tt>
+      # <tt>:border_width</tt>:: The border line width. Defaults to 1.
+      # <tt>:border_style</tt>:: One of <tt>:all</tt>, <tt>:no_top</tt>, <tt>:no_bottom</tt>, <tt>:sides</tt>, <tt>:none</tt>, <tt>:bottom_only</tt> or <tt>:top_and_bottom</tt>. Defaults to :all.
+      #
+      def initialize(options={})
+        @point        = options[:point]
+        @document     = options[:document]
+        @text         = options[:text].to_s
+        @text_color   = options[:text_color]
+        @width        = options[:width]
+        @height       = options[:height]
+        @borders      = options[:borders]
+        @border_width = options[:border_width] || 1
+        @border_style = options[:border_style] || :all             
+        @border_color = options[:border_color]
+        @background_color = options[:background_color] 
+        @align            = options[:align] || :left
+        @font_size        = options[:font_size]
+
+        @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_width, :background_color,
+                    :document, :horizontal_padding, :vertical_padding, :align,
+                    :borders, :text_color, :border_color
+                    
+      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,
+          @font_size || @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.height_of(@text, :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_width : height + border_width / 2.0
+            @document.fill_rectangle [rel_point[0] + border_width / 2.0, 
+                                      rel_point[1] - border_width / 2.0 ], 
+                width - border_width, h  
+          end
+        end
+
+        if @border_width > 0
+          @document.mask(:line_width) do
+            @document.line_width = @border_width
+
+            @document.mask(:stroke_color) do
+              @document.stroke_color @border_color if @border_color
+
+              if borders.include?(:left)
+                @document.stroke_line [rel_point[0], rel_point[1] + (@border_width / 2.0)], 
+                  [rel_point[0], rel_point[1] - height - @border_width / 2.0 ]
+              end
+
+              if borders.include?(:right)
+                @document.stroke_line( 
+                  [rel_point[0] + width, rel_point[1] + (@border_width / 2.0)],
+                  [rel_point[0] + width, rel_point[1] - height - @border_width / 2.0] )
+              end
+
+              if borders.include?(:top)
+                @document.stroke_line(
+                  [ rel_point[0] + @border_width / 2.0, rel_point[1] ], 
+                  [ rel_point[0] - @border_width / 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
+
+          end
+          
+          borders
+
+        end
+
+        @document.bounding_box( [@point[0] + @horizontal_padding, 
+                                 @point[1] - @vertical_padding], 
+                                :width   => text_area_width,
+                                :height  => height - @vertical_padding) do
+          @document.move_up @document.font.line_gap
+
+          options = {:align => @align}
+
+          options[:size] = @font_size if @font_size
+
+          @document.mask(:fill_color) do
+            @document.fill_color @text_color if @text_color                        
+            @document.text @text, options
+          end
+        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]
+        when :bottom_only
+          [:bottom]
+        when :top_and_bottom
+          [:top, :bottom]
+        when :none
+          []
+        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, :cells
+      attr_accessor :background_color, :text_color, :border_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.text_color ||= @text_color
+          e.border_color ||= @border_color
+          e.draw
+          x += e.width
+        end
+        
+        @document.y = y - @height
+      end
+
+      def border_width
+        @cells[0].border_width
+      end
+
+      def border_style=(s)
+        @cells.each { |e| e.border_style = s }
+      end    
+      
+      def align=(align) 
+        @cells.each { |e| e.align = align } 
+      end           
+      
+      def border_style
+        @cells[0].border_style
+      end
+
+    end
+  end
+ 
+end