pdf_gen 0.7

data/lib/document.rb

@@ -0,0 +1,50 @@
+require "lib/base_region"
+require "lib/modules/composite"
+require "lib/containers/div_container"
+require "lib/containers/span_container"
+require "lib/containers/caption_container"
+require "lib/containers/image_container"
+require "lib/containers/table_container"
+
+module PDFGen
+
+  class Document < BaseRegion
+
+    include Canvas, Composite, TableContainer, CaptionContainer, SpanContainer,
+            DivContainer, ImageContainer
+
+    def initialize(pdf, page_pad_top)
+      super(nil)
+      pdf.y += pdf.top_margin # clear predefined top_margin
+      pdf.y -= page_pad_top # set y considering page_pad_top
+      pdf.top_margin = 0
+
+      @pdf = pdf
+      @page_pad_top = page_pad_top
+      @header = []
+    end
+
+    attr_reader :pdf, :header
+
+    #creates new page
+    def break_page
+      pdf.page_break @page_pad_top
+    end
+
+    def render
+      pos = [0, pdf.y]
+      regions.each do |region|
+        pos[1] = pdf.y
+        status = region.render(pos, pdf.y)
+        if status[1]
+          pdf.y -= status[0]
+        else
+          self.break_page          
+          redo
+        end
+      end
+    end
+
+  end
+
+end

data/lib/fixnum.rb

@@ -0,0 +1,18 @@
+require "pdf/writer"
+
+
+#Extension of the standard Fixnum class
+#with PDF  - related units conversions
+class Fixnum
+
+  #cm2pts
+  def cm
+    PDF::Writer.cm2pts(self)
+  end
+
+  #in2pts
+  def in
+    PDF::Writer.in2pts(self)
+  end
+
+end

data/lib/float.rb

@@ -0,0 +1,18 @@
+require "pdf/writer"
+
+
+#Extension of the standard Float class
+#with PDF  - related units conversions
+class Float
+
+  #cm2pts
+  def cm
+    PDF::Writer.cm2pts(self)
+  end
+
+  #in2pts
+  def in
+    PDF::Writer.in2pts(self)
+  end
+
+end

data/lib/image.rb

@@ -0,0 +1,46 @@
+require "pdf/writer"
+require 'lib/base_region'
+
+
+module PDFGen
+
+  class Image < BaseRegion
+
+    def initialize(parent, image_res)
+      super(parent)
+
+      @image = image_res
+      @info = PDF::Writer::Graphics::ImageInfo.new(@image)
+    end
+
+    attr_accessor :image
+
+    def set_properties(props = {})
+      super
+
+      if width.zero? && height.zero?
+        self.width = @info.width
+        self.height = @info.height
+      elsif width.zero?
+        self.width = height / @info.height.to_f * @info.width
+      elsif height.zero?
+        self.height = width * @info.height / @info.width.to_f
+      end
+      self.height = self.height - pad_top - pad_bottom
+    end
+
+    def render(pos, av_height, test=false)
+      self.check_fit_in_height
+      if av_height >= self.height
+        document.pdf.add_image(@image, pos[0]+pad_left, pos[1]-height+pad_bottom,
+                               width-pad_left-pad_right, height-pad_top-pad_bottom)
+        super
+        [self.height, true]
+      else
+        [0, false]
+      end
+    end
+
+  end
+
+end

data/lib/modules/base_attributes.rb

@@ -0,0 +1,86 @@
+module BaseAttributes
+
+  module ClassMethods
+    def common_setter(*setters)
+      setters.each do |set|
+        define_method("#{set}=") do |val|
+          if val && set != val
+            self.instance_variable_set("@#{set}",val)
+            clear_minimal_height
+          end
+        end
+      end
+    end
+  end
+  
+  extend ClassMethods
+  
+  common_setter :pad_left, :pad_right, :pad_top, :pad_bottom, :width
+
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  attr_accessor :background_color
+
+  def var_init
+    @width = 0 #document.pdf.page_width - document.pdf.left_margin - document.pdf.right_margin
+    @height = 0
+
+    @pad_top = 0
+    @pad_bottom = 0
+    @pad_left = 0
+    @pad_right = 0
+
+    @border_top = false
+    @border_left = false
+    @border_right = false
+    @border_bottom = false
+    @border_style = :solid
+    @border_width = 1
+    @border_color = Color::RGB::Black
+
+    @is_breakable = false
+
+    @background_color = nil
+  end
+
+  def breakable?
+    @is_breakable
+  end
+
+  attr_writer :is_breakable, :height
+
+  def height
+    [minimal_height, @height].max
+  end
+
+  #padding from the page top after page break
+  attr_accessor :page_pad_top
+
+  attr_reader :width
+
+  attr_accessor :border_top, :border_bottom, :border_left, :border_right,
+    :border_style, :border_color, :border_width
+
+  def border= value
+    self.border_top = self.border_bottom = self.border_left =
+      self.border_right = value
+  end
+
+  attr_reader :pad_top, :pad_bottom, :pad_left, :pad_right
+
+  def paddings=(value)
+    @pad_bottom = @pad_left = @pad_right = @pad_top = value
+  end
+
+  def border_params
+    border_type = {:solid => [1, 0], :dotted => [1, 1], :none => [0, 1]}
+    PDF::Writer::StrokeStyle.new(@border_width, :dash => {:pattern => border_type[@border_style]})
+  end
+  
+  def av_width
+    width - pad_left - pad_right 
+  end
+
+end

data/lib/modules/canvas.rb

@@ -0,0 +1,15 @@
+module PDFGen
+  
+  module Canvas
+    
+    def y
+      pdf.y
+    end
+
+    def y= (value)
+      pdf.y = value
+    end
+
+  end
+  
+end

data/lib/modules/composite.rb

@@ -0,0 +1,54 @@
+module PDFGen
+
+  module Composite
+
+    def regions
+      @regions ||= []
+    end
+    
+    def [](index)
+      regions[index]
+    end
+
+    #executes specified initialization block on all inner regions
+    def elements(style = {}, &initialization_block)
+      regions.each do |region|
+        region.set_properties style unless style.nil?
+        region.instance_eval(&initialization_block) if initialization_block
+      end
+    end
+
+    #applies specified values
+    def apply_values(values = {})
+      regions.each{|region| region.apply_values values}
+    end
+
+    def page_pad_top=(value)
+      super
+
+      regions.each {|region| region.page_pad_top=value}
+    end
+
+    #adds new region to the span
+    def add_region region
+      regions << region if region
+    end
+
+    def render_regions(x, y, test = false)
+      regions.each { |region| region.render([x, document.pdf.y], document.pdf.y, test)}
+    end
+                                                                        
+    #renders specified span at the specified position
+    #returns real position that caption was generated on
+    def render(pos,av_height, test = false)
+      if av_height >= self.height
+        render_regions(pos[0],pos[1], test)
+        [self.height, true]
+      else
+        [0, false]
+      end
+    end
+
+  end
+
+end

data/lib/pdf_gen.rb

@@ -0,0 +1,30 @@
+$:.unshift(File.expand_path(File.dirname(__FILE__) + "/../"))
+require "rubygems"
+require "pdf/writer"
+require "lib/writer"
+require "lib/base_region"
+require "lib/fixnum"
+require "lib/float"
+require "lib/table"
+require "lib/caption"
+require "lib/modules/canvas"
+require "lib/modules/composite"
+require "lib/span"
+require "lib/div"
+require "lib/image"
+require "lib/containers/table_container"
+require "lib/smart_table"
+require "lib/document"
+
+
+module PDFGen
+
+  def self.document(pdf, page_pad_top, &initialization_block)
+    document = Document.new(pdf, page_pad_top)
+    document.width = document.pdf.page_width
+    document.instance_eval(&initialization_block)
+    document.render
+    pdf
+  end
+
+end

data/lib/smart_table.rb

@@ -0,0 +1,155 @@
+require "lib/data/ds_hash"
+require 'lib/data/ds_ar'
+require "lib/table"
+require "lib/div"
+
+
+module PDFGen
+
+  class SmartTable < Table
+
+    attr_accessor :header_region, :body_regions
+
+    class RowsContainer < Div
+
+      def initialize(parent)
+        super
+        @cells = []
+      end
+
+      def ds
+        parent.data_source
+      end
+
+      def cell(region=nil,style=nil)
+        if region.is_a?(Array)
+          @cells << region.last #todo
+          region.delete(region.last)
+        else  
+          caption = Caption.new(parent)
+          caption.text = region
+          caption.border_left = true
+          caption.set_properties style unless style.nil?
+          @cells << caption
+        end
+      end
+
+      def row
+        span = Span.new(self.document)
+        span.width = self.width
+        span.border = true
+        yield if block_given?
+        @cells.each do |cell|
+          if cell.width.zero? || cell.width == self.width
+            cell.width = span.width / @cells.size
+          end
+          span.add_region(cell)
+        end
+
+        @cells.clear
+        self.add_region(span)
+      end
+
+    end
+
+    def initialize(parent)
+      super(parent)
+      @title = RowsContainer.new(self)
+      @header = RowsContainer.new(self)
+      @body = RowsContainer.new(self)
+      @footer = RowsContainer.new(self)
+
+      init_width(parent)
+      
+      @data_source = nil
+      @header_data = nil
+      @body_data = nil
+
+      @is_header_rendered = false
+      @is_body_rendered = false
+      @columns = nil
+
+      @body_regions = []
+      
+    end
+
+    def data_source=(data)
+      if data.is_a?(Array)
+        @data_source = DsActiveRecord.new(data)
+      else
+        @data_source = DsHash.new(data)
+      end
+      @header_data = @data_source.columns
+      @body_data = @data_source.body
+    end
+
+    attr_reader :data_source
+
+    def calculate_minimal_height
+      regions_formation
+      super
+    end
+
+    def regions_formation
+      @header.add_region(build_header) unless @is_header_rendered
+      build_body unless @is_body_rendered
+
+      @body_regions.each { |region| @body.add_region(region) }
+    end
+
+    def render(pos, av_height, test=false)
+      @header_region = nil if @is_header_rendered
+      @body_regions.clear if @is_body_rendered
+
+      regions_formation
+      
+      super
+    end
+
+    def build_header()
+      span = Span.new(self.document)
+      span.width = self.width
+      span.border = true
+      @header_data.each do |cap|
+        caption = Caption.new(self.document)
+        caption.text = cap
+        caption.width = self.width / @header_data.size
+        caption.border_left = true
+        yield(span, caption) if block_given?
+        span.add_region(caption)
+      end
+      @is_header_rendered = true
+      span
+    end
+
+    def build_body()
+      @body_data.each do |row|
+        span = Span.new(self.document)
+        span.width = self.width
+        span.border = true
+        row.each do |cap|
+          caption = Caption.new(self.document)
+          caption.text = cap
+          caption.width = self.width / row.size
+          caption.border_left = true
+          yield(span, caption) if block_given?
+          span.add_region(caption)
+        end
+        @body_regions << span
+      end
+      @is_body_rendered = true
+    end
+
+    def header(style = nil, &initialization_block)
+      super
+      @is_header_rendered = true
+    end
+
+    def body(style = nil, &initialization_block)
+      super
+      @is_body_rendered = true
+    end
+    
+  end
+
+end

data/lib/span.rb

@@ -0,0 +1,69 @@
+require "pdf/writer"
+require "lib/image"
+require "lib/base_region"
+require "lib/modules/composite"
+require "lib/caption"
+require "lib/containers/caption_container"
+require "lib/containers/image_container"
+require "lib/containers/div_container"
+
+module PDFGen
+
+  #Horizontal captions line
+  class Span < BaseRegion
+
+    include Composite, CaptionContainer, ImageContainer, SpanContainer,
+            DivContainer, TableContainer
+
+    def initialize(parent)
+      super
+
+      @vertical_interval = 0
+      @vertical_align = false
+    end
+
+    attr_accessor :vertical_interval, :vertical_align
+
+    def calculate_minimal_height
+      render_regions
+      (regions.collect{|region| region.height}.max || 0) + pad_top + pad_bottom
+    end
+    
+    #renders inner regions
+    #returns height of the region content
+    def render_regions(x=0, y=document.y,  test=true)
+      content_width = pad_left
+      last = regions.last
+      regions.each do |region|
+        if region.breakable?
+          region.check_fit_in_height
+        end
+
+        if (content_width + region.width) > self.width
+          regions[regions.index(region), regions.size].each do |item|
+            regions.delete(item)
+          end
+        else
+          if vertical_align && !test
+            region.height = height
+          end
+          region.render([(x + content_width), (y - pad_top)], y-pad_top) unless test
+
+          content_width += region.width
+          content_width += vertical_interval unless region == last
+        end
+      end
+
+      content_width + pad_right
+    end
+
+    def render(pos, av_height, test=false)
+      self.check_fit_in_height
+      fill(pos) unless test
+      add_border(pos) unless test
+      super
+    end
+
+  end
+
+end

data/lib/table.rb

@@ -0,0 +1,116 @@
+require "lib/base_region"
+require "lib/div"
+require "lib/containers/table_container"
+
+
+module PDFGen
+
+  class Table < BaseRegion
+
+    def initialize(parent)
+      super(parent)
+      @is_breakable = true
+      @title = Div.new(self)
+      @header = Div.new(self)
+      @body = Div.new(self)
+      @footer = Div.new(self)
+      
+      init_width(parent)
+      
+      @repeat_header_on_each_page = false
+      @repeat_footer_on_each_page = false
+    end
+    
+    def init_width(parent)
+      self.width = parent.width - parent.pad_left - parent.pad_right
+    end
+    
+    def width=(value)
+      [@title,@header,@body,@footer].each do |region|
+        region.width = value
+      end
+
+      super
+    end
+
+    attr_accessor :repeat_header_on_each_page, :repeat_footer_on_each_page
+
+    def align_cell_in_row
+      [@header,@body,@footer].each do |container|
+        container.regions.each do |row|
+          row.vertical_align = true if row.respond_to?(:vertical_align)
+        end
+      end
+    end
+    
+    def calculate_minimal_height
+      [@title,@header,@body,@footer].inject(0){ |height, region| height + region.height }
+    end
+
+    def render(pos, av_height, test=false)
+      align_cell_in_row
+      super
+      
+      pos_x, pos_y = pos
+      title_height = @title.render([pos_x, pos_y], pos_y, true)
+      header_height = @header.render([pos_x, pos_y], pos_y, true)
+
+      if (title_height[0] + header_height[0]) > av_height
+        return [0, false]
+      end
+
+      title_status = @title.render([pos_x, pos_y], pos_y)
+      pos_y -= title_status[0]
+      @header.reset_count_rendered_regions if @repeat_header_on_each_page
+      header_status = @header.render([pos_x, pos_y], pos_y)
+      pos_y -= header_status[0]
+
+      status = @body.render([pos_x, pos_y], pos_y)
+      pos_y -= status[0]
+
+      footer_height = @footer.render([pos_x, pos_y], pos_y, true)
+      if footer_height[0] > pos[1]
+        return [av_height-pos_y, false]
+      end
+
+      if status[1]
+        footer_status = @footer.render([pos_x, pos_y], pos_y)
+      else
+        if @repeat_footer_on_each_page
+          footer_status = @footer.render([pos_x, pos_y], pos_y)
+
+          @footer.reset_count_rendered_regions
+        end
+      end
+      pos_y -= footer_status[0] if footer_status
+
+      [av_height-pos_y, status[1] && footer_status[1]]
+    end
+
+
+    def title(style = nil, &initialization_block)
+      access_region(@title, style, &initialization_block)
+    end
+
+    def header(style = nil, &initialization_block)
+      access_region(@header, style, &initialization_block)
+    end
+
+    def body(style = nil, &initialization_block)
+      access_region(@body, style, &initialization_block)
+    end
+
+    def footer(style = nil, &initialization_block)
+      access_region(@footer, style, &initialization_block)
+    end
+
+    def access_region(region, style=nil, &initialization_block)
+      region.set_properties style unless style.nil?
+      region.instance_eval(&initialization_block) if initialization_block
+    end
+
+    private :access_region
+
+  end
+  
+end

data/lib/writer.rb

@@ -0,0 +1,30 @@
+require "pdf/writer"
+
+
+module PDF
+  
+  class Writer
+
+    alias_method :save, :save_as
+    #extends PDF writer class StrikeStyle with several well known styles
+    class StrokeStyle
+      
+      DOTTED = StrokeStyle.new(1, :dash => {:pattern => [1, 1]})
+      SOLID = StrokeStyle.new(1, :dash => {:pattern => [1, 0]})
+      NONE = StrokeStyle.new(1, :dash => {:pattern => [0, 1]})
+      
+    end
+
+    #performs page break with the specified top padding (page header height for ex.)
+    def page_break(pad_top)
+      start_new_page  
+      self.y = self.y - pad_top
+    end
+
+    def y=(yy)
+      @y = yy
+    end
+    
+  end
+  
+end

data/samples/border.rb

@@ -0,0 +1,15 @@
+$:.unshift(File.expand_path(File.dirname(__FILE__) + "/../"))
+require "lib/pdf_gen"
+
+
+PDFGen::document PDF::Writer.new, 2.cm do
+  span :pad_left => 2.cm do
+    caption 'test text'*50, :width=>5.cm, 
+          :border => true, :border_style => :solid, :border_width => 2
+
+    caption 'test text'*50, :width=>5.cm, 
+          :border => true, :border_style => :dotted, :border_width => 3
+  end
+end.save("#{File.basename(__FILE__, ".rb")}.pdf")
+
+