nurettin-prawn 1.0.0.rc1

data/lib/prawn/document/column_box.rb

@@ -0,0 +1,132 @@
+# encoding: utf-8
+#
+# column_box.rb: Extends BoundingBox to allow for columns of text
+#
+# Author Paul Ostazeski.
+
+require "prawn/document/bounding_box"
+module Prawn
+  class Document
+
+    # A column box is a bounding box with the additional property that when
+    # text flows past the bottom, it will wrap first to another column on the
+    # same page, and only flow to the next page when all the columns are
+    # filled.
+    #
+    # column_box accepts the same parameters as bounding_box, as well as the
+    # number of :columns and a :spacer (in points) between columns.
+    #
+    # Defaults are :columns = 3 and :spacer = font_size
+    # 
+    # Under PDF::Writer, "spacer" was known as "gutter"
+    # 
+    def column_box(*args, &block)
+      init_column_box(block) do |parent_box|
+        map_to_absolute!(args[0])
+        @bounding_box = ColumnBox.new(self, parent_box, *args)
+      end
+    end
+
+    private
+
+    def init_column_box(user_block, options={}, &init_block)
+      parent_box = @bounding_box
+
+      init_block.call(parent_box)
+
+      self.y = @bounding_box.absolute_top
+      user_block.call
+      self.y = @bounding_box.absolute_bottom unless options[:hold_position]
+
+      @bounding_box = parent_box
+    end
+    
+    # Implements the necessary functionality to allow Document#column_box to
+    # work.
+    #
+    class ColumnBox < BoundingBox
+
+      def initialize(document, parent, point, options={}) #:nodoc:
+        super
+        @columns = options[:columns] || 3
+        @spacer  = options[:spacer]  || @document.font_size
+        @current_column = 0
+      end
+
+      # The column width, not the width of the whole box,
+      # before left and/or right padding
+      def bare_column_width
+        (@width - @spacer * (@columns - 1)) / @columns
+      end
+
+      # The column width after padding.
+      # Used to calculate how long a line of text can be.
+      #
+      def width
+        bare_column_width - (@total_left_padding + @total_right_padding)
+      end
+
+      # Column width including the spacer.
+      #
+      def width_of_column
+        bare_column_width + @spacer
+      end
+
+      # x coordinate of the left edge of the current column
+      #
+      def left_side
+        absolute_left + (width_of_column * @current_column)
+      end
+
+      # Relative position of the left edge of the current column
+      #
+      def left
+        width_of_column * @current_column
+      end
+
+      # x co-orordinate of the right edge of the current column
+      #
+      def right_side
+        columns_from_right = @columns - (1 + @current_column)
+        absolute_right - (width_of_column * columns_from_right)
+      end
+
+      # Relative position of the right edge of the current column.
+      #
+      def right
+        left + width
+      end
+
+      # Moves to the next column or starts a new page if currently positioned at
+      # the rightmost column.
+      def move_past_bottom 
+        @current_column = (@current_column + 1) % @columns
+        @document.y = @y
+        if 0 == @current_column
+          @document.start_new_page
+        end
+      end
+
+      # Override the padding functions so as not to split the padding amount
+      # between all columns on the page.
+
+      def add_left_padding(left_padding)
+        @total_left_padding += left_padding
+        @x += left_padding
+      end
+
+      def subtract_left_padding(left_padding)
+        @total_left_padding -= left_padding
+        @x -= left_padding
+      end
+
+      def add_right_padding(right_padding)
+        @total_right_padding += right_padding
+      end
+
+      def subtract_right_padding(right_padding)
+        @total_right_padding -= right_padding
+      end
+    end
+  end
+end

data/lib/prawn/document/graphics_state.rb

@@ -0,0 +1,136 @@
+# encoding: utf-8
+#
+# graphics_state.rb: Implements graphics state saving and restoring
+#
+# Copyright January 2010, Michael Witrant. All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+#
+
+module Prawn
+  class GraphicStateStack
+    attr_accessor :stack
+    
+    def initialize(previous_state = nil)
+      self.stack = [GraphicState.new(previous_state)]
+    end
+    
+    def save_graphic_state(graphic_state = nil)
+      stack.push(GraphicState.new(graphic_state || current_state))
+    end
+    
+    def restore_graphic_state
+      if stack.empty?
+        raise Prawn::Errors::EmptyGraphicStateStack, 
+          "\n You have reached the end of the graphic state stack" 
+      end
+      stack.pop
+    end
+    
+    def current_state
+      stack.last
+    end
+    
+    def present?
+      stack.size > 0
+    end
+
+    def empty?
+      stack.empty?
+    end
+      
+  end
+  
+  class GraphicState
+    attr_accessor :color_space, :dash, :cap_style, :join_style, :line_width, :fill_color, :stroke_color
+    
+    def initialize(previous_state = nil)
+      @color_space = previous_state ? previous_state.color_space.dup : {}
+      @fill_color = previous_state ? previous_state.fill_color : "000000"
+      @stroke_color = previous_state ? previous_state.stroke_color : "000000"
+      @dash = previous_state ? previous_state.dash : { :dash => nil, :space => nil, :phase => 0 }
+      @cap_style = previous_state ? previous_state.cap_style : :butt
+      @join_style = previous_state ? previous_state.join_style : :miter
+      @line_width = previous_state ? previous_state.line_width : 1
+    end
+    
+    def dash_setting
+      "[#{@dash[:dash]} #{@dash[:space]}] #{@dash[:phase]} d"
+    end
+  end
+  
+  module Core
+    class Page
+      module GraphicsState
+      
+        def graphic_state
+          stack.current_state
+        end
+    
+      end
+    end
+  end
+  
+  class Document
+    module GraphicsState
+
+      # Pushes the current graphics state on to the graphics state stack so we
+      # can restore it when finished with a change we want to isolate (such as
+      # modifying the transformation matrix). Used in pairs with
+      # restore_graphics_state or passed a block
+      #
+      # Example without a block:
+      #
+      #   save_graphics_state
+      #   rotate 30
+      #   text "rotated text"
+      #   restore_graphics_state
+      #
+      # Example with a block:
+      #
+      #   save_graphics_state do
+      #     rotate 30
+      #     text "rotated text"
+      #   end
+      #
+      
+      def open_graphics_state
+        add_content "q"
+      end
+      
+      def close_graphics_state
+        add_content "Q"
+      end
+        
+      def save_graphics_state(graphic_state = nil)
+        graphic_stack.save_graphic_state(graphic_state)
+        open_graphics_state
+        if block_given?
+          yield
+          restore_graphics_state
+        end
+      end
+
+      # Pops the last saved graphics state off the graphics state stack and
+      # restores the state to those values
+      def restore_graphics_state
+        if graphic_stack.empty?
+          raise Prawn::Errors::EmptyGraphicStateStack, 
+            "\n You have reached the end of the graphic state stack" 
+        end
+        close_graphics_state 
+        graphic_stack.restore_graphic_state
+      end
+      
+      def graphic_stack
+        state.page.stack
+      end
+      
+      def graphic_state
+        save_graphics_state unless graphic_stack.current_state
+        graphic_stack.current_state 
+      end
+      
+    end
+  end
+end

data/lib/prawn/document/internals.rb

@@ -0,0 +1,173 @@
+# encoding: utf-8
+#
+# internals.rb : Implements document internals for Prawn
+#
+# Copyright August 2008, Gregory Brown. All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+
+module Prawn
+  class Document     
+    
+    # This module exposes a few low-level PDF features for those who want
+    # to extend Prawn's core functionality.  If you are not comfortable with
+    # low level PDF functionality as defined by Adobe's specification, chances
+    # are you won't need anything you find here.  
+    #
+    module Internals    
+      
+      # Creates a new Prawn::Reference and adds it to the Document's object
+      # list.  The +data+ argument is anything that Prawn::PdfObject() can convert. 
+      #
+      # Returns the identifier which points to the reference in the ObjectStore   
+      # 
+      def ref(data)
+        ref!(data).identifier
+      end                                               
+
+      # Like ref, but returns the actual reference instead of its identifier.
+      # 
+      # While you can use this to build up nested references within the object
+      # tree, it is recommended to persist only identifiers, and them provide
+      # helper methods to look up the actual references in the ObjectStore
+      # if needed.  If you take this approach, Prawn::Document::Snapshot
+      # will probably work with your extension
+      #
+      def ref!(data)
+        state.store.ref(data)
+      end
+
+      # At any stage in the object tree an object can be replaced with an
+      # indirect reference. To get access to the object safely, regardless
+      # of if it's hidden behind a Prawn::Reference, wrap it in deref().
+      #
+      def deref(obj)
+        obj.is_a?(Prawn::Core::Reference) ? obj.data : obj
+      end
+
+      # Appends a raw string to the current page content.
+      #                               
+      #  # Raw line drawing example:           
+      #  x1,y1,x2,y2 = 100,500,300,550
+      #  pdf.add_content("%.3f %.3f m" % [ x1, y1 ])  # move 
+      #  pdf.add_content("%.3f %.3f l" % [ x2, y2 ])  # draw path
+      #  pdf.add_content("S") # stroke                    
+      #
+      def add_content(str)
+        save_graphics_state if graphic_state.nil?
+        state.page.content << str << "\n"
+      end  
+
+      # The Name dictionary (PDF spec 3.6.3) for this document. It is
+      # lazily initialized, so that documents that do not need a name
+      # dictionary do not incur the additional overhead.
+      #
+      def names
+        state.store.root.data[:Names] ||= ref!(:Type => :Names)
+      end
+
+      # Returns true if the Names dictionary is in use for this document.
+      # 
+      def names?
+        state.store.root.data[:Names]
+      end
+
+      # Defines a block to be called just before the document is rendered.
+      #
+      def before_render(&block)
+        state.before_render_callbacks << block
+      end
+
+      # Defines a block to be called just before a new page is started.
+      #
+      def on_page_create(&block)
+         if block_given?
+            state.on_page_create_callback = block
+         else
+            state.on_page_create_callback = nil
+         end
+      end
+      
+      private      
+
+      # adds a new, empty content stream to each page. Used in templating so
+      # that imported content streams can be left pristine
+      #
+      def fresh_content_streams(options={})
+        (1..page_count).each do |i|
+          go_to_page i
+          state.page.new_content_stream
+          apply_margin_options(options)
+          generate_margin_box
+          use_graphic_settings(options[:template])
+        end
+      end
+
+      def finalize_all_page_contents
+        (1..page_count).each do |i|
+          go_to_page i
+          repeaters.each { |r| r.run(i) }
+          while graphic_stack.present?
+            restore_graphics_state
+          end
+          state.page.finalize
+        end
+      end
+
+      # raise the PDF version of the file we're going to generate.
+      # A private method, designed for internal use when the user adds a feature
+      # to their document that requires a particular version.
+      #
+      def min_version(min)
+        state.version = min if min > state.version
+      end
+
+      # Write out the PDF Header, as per spec 3.4.1
+      #
+      def render_header(output)
+        state.before_render_actions(self)
+
+        # pdf version
+        output << "%PDF-#{state.version}\n"
+
+        # 4 binary chars, as recommended by the spec
+        output << "%\xFF\xFF\xFF\xFF\n"
+      end
+
+      # Write out the PDF Body, as per spec 3.4.2
+      #
+      def render_body(output)
+        state.render_body(output)
+      end
+
+      # Write out the PDF Cross Reference Table, as per spec 3.4.3
+      #
+      def render_xref(output)
+        @xref_offset = output.size
+        output << "xref\n"
+        output << "0 #{state.store.size + 1}\n"
+        output << "0000000000 65535 f \n"
+        state.store.each do |ref|
+          output.printf("%010d", ref.offset)
+          output << " 00000 n \n"
+        end
+      end
+
+      # Write out the PDF Trailer, as per spec 3.4.4
+      #
+      def render_trailer(output)
+        trailer_hash = {:Size => state.store.size + 1, 
+                        :Root => state.store.root,
+                        :Info => state.store.info}
+        trailer_hash.merge!(state.trailer) if state.trailer
+
+        output << "trailer\n"
+        output << Prawn::Core::PdfObject(trailer_hash) << "\n"
+        output << "startxref\n" 
+        output << @xref_offset << "\n"
+        output << "%%EOF" << "\n"
+      end
+                 
+    end
+  end
+end

data/lib/prawn/document/page_geometry.rb

@@ -0,0 +1,136 @@
+# encoding: utf-8
+
+# page_geometry.rb : Describes PDF page geometries
+#
+# Copyright April 2008, Gregory Brown.  All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+
+module Prawn
+  class Document
+    
+    # Dimensions pulled from PDF::Writer, rubyforge.org/projects/ruby-pdf
+    # 
+    # All of these dimensions are in PDF Points, see Prawn::Measurements for
+    # conversion utilities.
+    # 
+    # Additionally, if the size you are after is not listed below, you can always
+    # specify your size by passing an array of width and height to Prawn::Document.new
+    # like:
+    # 
+    #  Prawn::Document.new(:page_size => [1000, 20000])
+    #
+    # The sizes below can be used by passing the appropriate string to :size:
+    # 
+    #  Prawn::Document.new(:page_size => '2A0')
+    # 
+    # ===Inbuilt Sizes:
+    # 
+    # 
+    # 4A0:: => 4767.87 x 6740.79
+    # 2A0:: => 3370.39 x 4767.87
+    # A0:: => 2383.94 x 3370.39
+    # A1:: => 1683.78 x 2383.94
+    # A2:: => 1190.55 x 1683.78
+    # A3:: => 841.89 x 1190.55
+    # A4:: => 595.28 x 841.89
+    # A5:: => 419.53 x 595.28
+    # A6:: => 297.64 x 419.53
+    # A7:: => 209.76 x 297.64
+    # A8:: => 147.40 x 209.76
+    # A9:: => 104.88 x 147.40
+    # A10:: => 73.70 x 104.88
+    # B0:: => 2834.65 x 4008.19
+    # B1:: => 2004.09 x 2834.65
+    # B2:: => 1417.32 x 2004.09
+    # B3:: => 1000.63 x 1417.32
+    # B4:: => 708.66 x 1000.63
+    # B5:: => 498.90 x 708.66
+    # B6:: => 354.33 x 498.90
+    # B7:: => 249.45 x 354.33
+    # B8:: => 175.75 x 249.45
+    # B9:: => 124.72 x 175.75
+    # B10:: => 87.87 x 124.72
+    # C0:: => 2599.37 x 3676.54
+    # C1:: => 1836.85 x 2599.37
+    # C2:: => 1298.27 x 1836.85
+    # C3:: => 918.43 x 1298.27
+    # C4:: => 649.13 x 918.43
+    # C5:: => 459.21 x 649.13
+    # C6:: => 323.15 x 459.21
+    # C7:: => 229.61 x 323.15
+    # C8:: => 161.57 x 229.61
+    # C9:: => 113.39 x 161.57
+    # C10:: => 79.37 x 113.39
+    # RA0:: => 2437.80 x 3458.27
+    # RA1:: => 1729.13 x 2437.80
+    # RA2:: => 1218.90 x 1729.13
+    # RA3:: => 864.57 x 1218.90
+    # RA4:: => 609.45 x 864.57
+    # SRA0:: => 2551.18 x 3628.35
+    # SRA1:: => 1814.17 x 2551.18
+    # SRA2:: => 1275.59 x 1814.17
+    # SRA3:: => 907.09 x 1275.59
+    # SRA4:: => 637.80 x 907.09
+    # EXECUTIVE:: => 521.86 x 756.00
+    # FOLIO:: => 612.00 x 936.00
+    # LEGAL:: => 612.00 x 1008.00
+    # LETTER:: => 612.00 x 792.00
+    # TABLOID:: => 792.00 x 1224.00 
+    #
+    module PageGeometry
+
+      SIZES = { "4A0" => [4767.87, 6740.79],
+                "2A0" => [3370.39, 4767.87],
+                 "A0" => [2383.94, 3370.39],
+                 "A1" => [1683.78, 2383.94],
+                 "A2" => [1190.55, 1683.78],
+                 "A3" => [841.89, 1190.55],
+                 "A4" => [595.28, 841.89],
+                 "A5" => [419.53, 595.28],
+                 "A6" => [297.64, 419.53],
+                 "A7" => [209.76, 297.64],
+                 "A8" => [147.40, 209.76],
+                 "A9" => [104.88, 147.40],
+                "A10" => [73.70, 104.88],
+                 "B0" => [2834.65, 4008.19],
+                 "B1" => [2004.09, 2834.65],
+                 "B2" => [1417.32, 2004.09],
+                 "B3" => [1000.63, 1417.32],
+                 "B4" => [708.66, 1000.63],
+                 "B5" => [498.90, 708.66],
+                 "B6" => [354.33, 498.90],
+                 "B7" => [249.45, 354.33],
+                 "B8" => [175.75, 249.45],
+                 "B9" => [124.72, 175.75],
+                "B10" => [87.87, 124.72],
+                 "C0" => [2599.37, 3676.54],
+                 "C1" => [1836.85, 2599.37],
+                 "C2" => [1298.27, 1836.85],
+                 "C3" => [918.43, 1298.27],
+                 "C4" => [649.13, 918.43],
+                 "C5" => [459.21, 649.13],
+                 "C6" => [323.15, 459.21],
+                 "C7" => [229.61, 323.15],
+                 "C8" => [161.57, 229.61],
+                 "C9" => [113.39, 161.57],
+                "C10" => [79.37, 113.39],
+                "RA0" => [2437.80, 3458.27],
+                "RA1" => [1729.13, 2437.80],
+                "RA2" => [1218.90, 1729.13],
+                "RA3" => [864.57, 1218.90],
+                "RA4" => [609.45, 864.57],
+               "SRA0" => [2551.18, 3628.35],
+               "SRA1" => [1814.17, 2551.18],
+               "SRA2" => [1275.59, 1814.17],
+               "SRA3" => [907.09, 1275.59],
+               "SRA4" => [637.80, 907.09],
+          "EXECUTIVE" => [521.86, 756.00],
+              "FOLIO" => [612.00, 936.00],
+              "LEGAL" => [612.00, 1008.00],
+             "LETTER" => [612.00, 792.00],
+            "TABLOID" => [792.00, 1224.00] }
+
+   end
+  end
+end