rghost 0.7.4 → 0.8

data/lib/rghost/document.rb

@@ -8,380 +8,403 @@
 # http://creativecommons.org/licenses/by-sa/2.5/br/
 ##
 
-require "ps_object"
-require "dynamic_document_callback"
-require "static_document_callback"
-require "paper"
-require "load"
-require "horizontal_line"
-require "vertical_line"
-require "function"
-require "font"
-require "cursor"
-require "show"
-require "rectangle"
-require "color"
-require "graphic"
-require "arc"
-require "newpath"
-require "line"
-require "line_width"
-require "textarea"
-require "variable"
-require "eps"
-require "jpeg"
-require "gif"
-require "text_in"
-require "ruby_ghost_engine"
-require "barcode"
-require "convert"
+require 'ps_object'
+require 'ps_facade'
+require 'document_callback_facade'
+require 'virtual_pages'
+require 'variable'
+#The Document class child of PsFacade is used to join postscript objects to generate output file. 
 
-
-
-#Document � a classe que centraliza a estrutura do documento
-class Document < PsObject
+class RGhost::Document < RGhost::PsFacade 
+  include RGhost::DocumentCallbackFacade
+  DISABLE_VIRTUAL_PAGE=RGhost::Variable.new(:has_vp?, false)
+  ENABLE_VIRTUAL_PAGE=RGhost::Variable.new(:has_vp?, true)
   DEFAULT_OPTIONS={
-   :rows_per_page => 80 , 
-   :count_pages => 10,
-   :row_height => 0.4,
-   :row_padding => 0.1,
-   :fontsize=> RubyGhostConfig::GS[:fontsize],
-   :font_encoding=> RubyGhostConfig::GS[:font_encoding]
+    :rows_per_page => 80 , 
+    :count_pages => 10,
+    :row_height => 0.4,
+    :row_padding => 0.1,
+    :font_encoding=> RGhost::Config::GS[:font_encoding],
+    :paper => RGhost::Paper::DEFAULT_OPTIONS
   }
-  #Nova inst�ncia de Document com proxy da classe Paper.
-  #  Responde as op��es 
-  #Document
-  #   :rows_per_page => 80 ,    # M�ximo de linhas por p�gina 
-  #   :count_pages => 10,       # Total de p�ginas do documento
-  #   :row_height => 0.4,       # Altura da faixa
-  #   :row_padding => 0.1,      # Espa�o entre cada faixa
-  #   :fontsize=> 8             # Tamanho da fonte padr�o
-  #Paper
-  #   :paper => :A4             # Tamanho do papel, personalizavel com array width X height(em pontos). Exmp: :paper => [400,300]
-  #   :landscape => false       # Disposi��o do papel em 90�
-  #   :margin_top => 1,         # Margin de topo 
-  #   :margin_right => 1,       # Margin direita
-  #   :margin_bottom => 1,      # Margin da base
-  #   :margin_left => 1,        # Margin esquerda
-  #   :duplex => false,         # true - duas faces(para impress�o)
-  #   :tumble => false          # true - tipo do duplex(para impress�o)
+ 
+  #===Examples
+  #Creating document with 80 rows per page and custom paper
+  # doc=Document.new :rows_per_page => 80, paper => [30,5]
+  #Document A4 with row height 0.5 and font encoding CodePage1252
+  # doc=Document.new :row_height => 0.5, :font_encoding => 'CodePage1252'
+  #Defining all margins
+  # doc=Document.new :margin => 0.5
+  # 
+  # 
+  #==Parameters
+  #* <tt>:paper</tt> -  Facade to +paper+ defined on the construction of Paper class
+  #* <tt>:margin, :duplex and :tuble</tt> - Facade to +options+ defined on the construction of Paper class
+  #* <tt>:rows_per_page</tt> - Specifies count of rows per pages.
+  #* <tt>:landscape</tt> - Whether true invert de size(width per height)
+  #* <tt>:count_pages</tt> - Defines postscript internal variable to display with class TextIn. Example:
   #
-  #
-  def initialize(options={},&block)
-    super("")
-    @head,@callbacks=PsObject.new,PsObject.new
-    @head.set Load.library(:type)
-    @head.set Load.library(:unit)
+  # doc=Document.new :count_pages => 10
+  # doc.before_page_create :except => 1 do
+  #  text_in :x => 15, :y => 5, :write => "Page %current_page% of %count_pages%"
+  # end
+  # 
+  #The value above %count_pages% will be evaluated inside of document for all pages except page one.
+  #* <tt>:fontsize</tt> - Defines the size of tag :default_font.
+  #* <tt>:row_height and row_padding</tt> - Its names say by itself :)
+  #* <tt>:font_encoding</tt> - Specifies encoding of data input. You can look for supported encoding using the method RGhost::Config.encode_test
+  def initialize(options={})
+    super()
+    @head,@callbacks=RGhost::PsObject.new,RGhost::PsObject.new
+    @head.set RGhost::Load.library(:type)
+    @head.set RGhost::Load.library(:unit)
     
     @variables=DEFAULT_OPTIONS.dup.merge(options)
     default_encoding
-    @paper=Paper.new(options[:paper] || :A4, options)
+    @paper=RGhost::Paper.new(options[:paper] || :A4, options)
     @head.set @paper
-    
+    @done=false
     
     @defines=[]
     
     default_variables
-    instance_eval(&block) if block
-  end
-  #Facade Paper.gs_paper
-  #Obtem o valor no formato esperado pelo GS.
-  def gs_paper
-      @paper.gs_paper
   end
-      
   
-  #Aceita StaticDocumentCallback::ACCEPT e DynamicDocumentCallback::ACCEPT
-  # doc=Document.new
-  # doc.before_page_create :only => [1,2] do
-  #   set HorizontalLine.new
-  # end
-  # doc.even_pages :except => [1] do
-  #   set Show.new("ET say: Hello Humans!!")
-  # end
-  # doc.last_page do
-  #   set Cursor.jump_rows(3)
-  #   set TextIn.new(:x=> 4, :y => 15.5, :text => "Total: %current_page%")
-  # end
-  def method_missing(name,*args,&block)
-    case name
-      when *DynamicDocumentCallback::ACCEPT:
-        
-        @callbacks.set DynamicDocumentCallback.new(name,args.shift || {},&block) #args.shift || {} without args
-
-      when *StaticDocumentCallback::ACCEPT:
-         
-        @callbacks.set StaticDocumentCallback.new(name,&block) 
-         
-      else
-        raise NameError.new(name.to_s)
-     end
+  def gs_paper #:nodoc:
+    @paper.gs_paper
   end
+  #  
 
-  def ps
-      out=PsObject.new
-      out.set @head
-      out.set @default_variables 
-      out.set Load.rg_enviroment
-      out.raw @defines.join
-      out.set @callbacks
-      out.set Variable.new(:fontsize,@variables[:fontsize])
-      out.call :font_normal
-      out.set Load.library(:begin_document)
-      out.set Cursor.moveto
-      
-      "#{out} #{super}"
+  #Creates map of tags if will be use in 'writable' classes(Show, Text, TextIn and TextArea). 
+  #The font names file catalog can be generated by code below
+  #  RGhost::Config.enviroment_fonts.render :pdf, :filename => "mycatalog.pdf"
+  #this can take while. If waiting for much time you has any font with problem, remove some fonts mostly international fonts not used often.
+  #Below little piece of catalog
+  #link:images/font_catalog.png
+  #
+  #After genereted catalog you can map your tags. 
+  #
+  #
+  #Tags has +name+ of tag(as Symbol) and its options. The options are
+  #
+  #* <tt>:name</tt> - Font name from catalog.
+  #* <tt>:size</tt> - Font size.
+  #* <tt>:color</tt> - Color.create facade
+  #* <tt>:encoding</tt> - If true the font will be encoding using de pattern :font_encoding of the document.
+  #===Examples
+  # d=Document.new :encoding => 'IsoLatin'
+  # d.define_tags do
+  #  tag :my_italic,    :name => 'Hershey-Gothic-Italian-Oblique', :size => 10
+  #  tag :myfont,       :name => 'Hershey-Plain'
+  #  tag :font_encoded, :name => 'NimbusMonL-Regu',    :size => 8,  :color => 0.5, :encoding => true
+  #  tag :other_font,   :name => 'NimbusMonL-Regu',    :size => 10
+  #  tag :arial,        :name => 'Arial-ItalicMT',     :color => '#ADAD66'
+  #  tag :arial_bold,   :name => 'NimbusSanL-BoldItal',:size => 12, :color => '#ADAD66'
+  # end
+  #You can use :default_font tag for custom the default font.
+  #===Using tags
+  #====With Show class
+  # doc.show 'My Text on this row', :with => :my_italic, :align => :page_center 
+  #====With Show class overrinding tag's color.
+  # doc.show 'My Text on this row', :with => :my_italic, :align => :page_center, :color => :red 
+  #====With TextIn class.
+  # doc.text_in :x=> 3, :y=> 10, :tag => :arial_bold , :write => "Here's point(3,10)"
+  #====With Text
+  # doc.text '<myfont>My Text</myfont>on this row.<arial>Other text</arial><my_italic>Italic font</my_italic>' 
+  #====With TextArea
+  # txt='<myfont>My Text</myfont>on this row.<arial>Other text</arial><my_italic>Italic font</my_italic>' 
+  # doc.text_area txt, :text_align => :center, :width => 5, :x => 3, :y => 10
+  #====Using tag
+  # doc.use_tag :myfont
+  # doc.show "Simple Text", :tag => nil # it will use :myfont
+  # doc.show "Simple Text2", :tag => nil # it will use :myfont too
+  def define_tags(&block)
+    RGhost::Config::FONTMAP.instance_eval(&block)
+  end   
+  
+  
+  def ps #:nodoc:
+    done unless @done
+    
+    out=RGhost::PsObject.new
+    out.set @head
+    out.set @default_variables 
+    out.set RGhost::Load.rg_enviroment
+    out.raw @defines.join
+    out.set RGhost::Cursor.moveto
+    out.set RGhost::Config::FONTMAP
+    out.set @callbacks
+    out.set RGhost::Load.library(:begin_document)
+    RGhost::Config::GS[:preload].uniq.each{|v| out.set RGhost::Load.library(v) }
+    out.set RGhost::Cursor.moveto
+    out.raw super
+    out.raw "\n\n"
+   
+    "#{out} "
       
     #"#{@head} \n%%endhead\n#{@default_variables}\n\n #{Load.rg_enviroment} #{@defines.join} #{@callbacks} #{Load.library(:begin_document)}\n #{Cursor.moveto}#{super}"
     
     
   end
   
-  #Facade RubyGhostEngine.render
-  #Renderiza o documento.
-  # Valores v�lidos para options.
+  #Facade to RubyGhostEngine.render
+  #Converts a document to an output format, such as :pdf, :png, :ps, :jpeg, :tiff etc
+  #The paramter device can be found at RGhost::Constants::Devices or at http://pages.cs.wisc.edu/~ghost/doc/cvs/Devices.htm
+  #===Options
+  #Method render have the following options available.
+  #* <tt>:filename</tt> - File path.
+  #* <tt>:logfile</tt> - Writes the converter's process into a file.
+  #* <tt>:multipage</tt> - Whether true the output will be one page per file posfixed by _0001.ext, for example, for one file name 'test.png' with two pages will create test_001.png and test_002.png 
+  #* <tt>:resolution</tt> - Integer value to output resolution.
+  #* <tt>:size</tt> - Crops a single page using a string of dimension, example, '200x180', '140x90'.
+  #* <tt>:range</tt> - Specifies range of pages(PDF only)
+  #====Ghostscript interpreter options
   #   
-  #   :tmpdir => File::SEPARATOR + "tmp", # Diret�rio tempor�rio
-  #   :logfile => File::SEPARATOR + "tmp" +File::SEPARATOR + "ruby_ghost.log" # Arquivo de log    
-  #   :multipage=> true     # Para imagens em v�rios arquivos
-	#   :resolution => 72     # Resolu��o
-	#   :size => "200x180"    # Para crop da imagem de sa�da
-	#   :range =>2..3         # Range de p�ginas (PDF Only)
-	# Array contendo um Hash para op��es em modo raw do Ghostscript :d ou :s
-	#   :s => [{:GenericResourceDir => /dir, :DEFAULTPAPERSIZE=> "a3"}]
+  #Array of Hashes for Ghostscript interpreter look at http://pages.cs.wisc.edu/~ghost/doc/cvs/Use.htm#Parameter_switches for more details.
+  #You can use two parameter :s and :d, examples
+  #   :s => [{:GenericResourceDir => /dir, :DEFAULTPAPERSIZE=> "a3"}]
   #   :d => [ {:TextAlphaBits => 2}  ]
-  #Ou usando string
+  #Or one string using the parameter :raw, as below
   #   :raw => "-sGenericResourceDir=/test -dTextAlphaBits=2"
   #
-  #Exemplo:
-  #  d=Document.new
-  #  #fa�a o documento ....
+  #===Examples
+  #  doc=Document.new
+  #  #do something
   #  
-  #  d.render :pdf           # Sa�da em pdf    
-  #  d.render :jpeg          # Sa�da em jpeg   
-  #  d.render :png, :multipage => true  # Uma imagem por arquivo
-  #  d.render :tiff, :resolution => 300  # Imagem com resolu��o de 300 dpi
+  #  doc.render :pdf,  :filename => 'foo.pdf   # PDF output
+  #  doc.render :jpeg, :filename => 'foo.jpg'  # JPEG output
+  #  doc.render :png,  :filename => 'foo.png',  :multipage => true      # PNG output one page per file
+  #  doc.render :tiff, :filename => 'foo.tiff', :resolution => 300      # TIFF with 300dpi 
+  #  doc.render :ps, :raw => '-sFONTMAP=/var/myoptional/font/map', :filename => 'test.ps'
+  #
+  #===Testing if has errors
+  # doc=Document.new
+  # doc.raw "hahahah!" #it produce error in ps stack
+  # doc.render :jpeg, :filename => 'with_error.jpg'
+  # puts r.errors  if r.error? #=> GPL Ghostscript 8.61: Unrecoverable error, exit code 1.\ Error: /undefined in hahahah!
+  #      
+  #===Printing
+  #====Using printing system
+  #  doc=Document.new
+  #  #do something
+  #  f="myjob.prn"  
+  #  doc.render :laserjet, :filename => f
+  #  `lpr #{f}`
+  #====Windows shared printer
+  # doc.render :eps9mid, :filename => "//machine/printer"
   def render(device,options={})
-    rg=RubyGhostEngine.new(self,options)
+    rg=RGhost::Engine.new(self,options)
     rg.render(device)
     rg
   end
-  #Renderiza, abre o stream e deleta o arquivo de sa�da. N�o aceita multipage=>true
+  #Behavior as render but returns content file after convertion.
+  #===Example with Rails
+  # def my_action
+  #   doc=RGhost::Document.new
+  #   #do something    
+  #   send_data doc.render_stream(:pdf), :filename => "/tmp/myReport.pdf"   
+  # end
+  #
+  #===TCP/IP direct printer
+  # require 'socket'
+  # 
+  # doc=Document.new 
+  # #do something    
+  # printer = TCPSocket.open('192.168.1.70', 9100)  
+  # printer.write doc.render_stream(:ps) 
+  # printer.close
   def render_stream(device,options={})
     rg=render(device,options)
     out=rg.output.readlines.join
     rg.clear_output
     out
   end
-  #Facade Function.new
-  #Define uma fun��o. 
-  #Exemplo:
-  #   doc=Document.new
-  #   doc.define :myfont do
-  #     set Font.new(:name => "ZapfChancery-MediumItalic", :size => 10)
-  #   end
+  #Facade to Function.new
+  #Defines low level function to optimize repetitive piece of code.
+  #===Example
+  # doc=Document.new
+  # doc.define :piece do
+  #   set Show.new("Hello")
+  #   set Cursor.next_row
+  #   set HorizontalLine.new(:middle)
+  #   set Cursor.next_row
+  # end
+  # #Repeting ten times the same code
+  # 10.times{ doc.call :piece }
   def define(name,&block)
-    @defines << Function.new(name,&block)
+    @defines << RGhost::Function.new(name,&block)
   end
-  #Define e chama uma fun��o.
-  #   doc=Document.new
-  #   doc.define_and_call :my_photo do
-  #     set Jpeg.new("/local/img/my_photo.jpg", :y=> 5,:x => 8,  :zoom=> 50)
-  #   end         
+  def define_variable(name,value)
+    set RGhost::Variable.new(name,value)
+  end
+  #Defines a function using the method define after that call de function one time.
   def define_and_call(name,&block)
     define(name,&block)
     call(name)
   end
-  #Salta uma faixa e usa a faixa corrente.
-  #   d=Document.new
-  #   doc.next_line do
-  #     set Show.new("single text in page center", :align => :page_center)
-  #   end
-  #Para cada linha de um arquivo.
-  #   d=Document.new
-  #   File.open(__FILE__).each { |line| doc.next_row{ set Show.new(line) } }
-  #   d.done
-  #   d.render :pdf
-  #Uma linha separando cada faixa
-  #File.open(__FILE__).each do |line| 
-  #  doc.next_row do
-  #    set HorizontalLine.new(:top) 
-  #    set Show.new(line) 
-  #  end
-  #end
-  def next_row(&block)
-    set PsObject.new(&block)
-    set Cursor.next_row
+ 
+  #Prints the text file using the predefined tag +:pre+
+  #===Example
+  # doc=Document.new :paper => :A4, :landscape => true
+  # doc.print_file "/etc/passwd"
+  # doc.render :pdf, :filename => "/tmp/passwd.pdf
+  def print_file(file)
+    s=File.open(file).readlines.join.gsub(/</,'&lt').gsub(/>/,'&gt').gsub(/\n/,'<br/>')
+    
+    use_tag :pre
+    set RGhost::Text.new(s,true)
     
-
   end
-  #Carrega o texto do arquivo em uma itera��o de linhas.
-  def print_file(file)
-    File.open(file).each do |line| 
-      next_row do
-        set Show.new(line) 
-      end
-    end
+  #With method virtual_pages you can define any virtual pages per physical page. 
+  #The cursor into virtual page jumps in column for each virtual page and run primitives next_page when ends columns. Look the example below.
+  #Example for a document without virtual pages we will has
+  # doc=Document.new
+  # doc.text File.readlines("/tmp/mytext.txt")
+  #will generate
+  #
+  #link:images/virtual_page1.png 
+  #
+  #Now for a document with 3 virtual pages
+  # doc=Document.new
+  # doc.virtual_pages do
+  #   new_page :width => 4
+  #   new_page :width => 7, :margin_left => 1
+  #   new_page :width => 4, :margin_left => 1
+  # end
+  # doc.text File.readlines("/tmp/mytext.txt")
+  #will generate
+  #
+  #link:images/virtual_page2.png 
+  #
+  #PS: The parameter margin left of first virtual page won't be used because it's will use page's margin left.
+  def virtual_pages(&block)
+    set RGhost::VirtualPages.new(&block)
   end
   
-  #Salta a p�gina com controlando o documento. 
-  def next_page
-    call :next_page
-  end
-  #Facade Graphic
-  #Condiciona em um bloco gr�fico. Defini��es gr�ficas v�lidas apenas para o escopo do bloco n�o interferindo nos demais gr�ficos.
-  #   doc=Document.new
-  #   doc.graphic do
-  #     set LineWidth.new(0)
-  #     set Line.lineto(5,7)
-  #   end
-  def graphic(ps_obj=PsObject.new,&block)
-    set Graphic.new(ps_obj,&block)
-  end
-  #Facade Newpath
-  #Cria um bloco que cria um novo path sem alterar o path corrente. O path v�lido apenas para o escopo do bloco. Contudo fecha o path(closepath) ao fim do bloco.
-  #   doc=Document.new
-  #   doc.newpath do
-  #     set Arc.new(:x => 10, :y => 10, :radius => 100)
-  #   end 
-  def newpath(ps_obj=PsObject.new,&block)
-    set NewPath.new(ps_obj,&block)
-  end
-  #Facade Variable.new
-  #Define uma vari�vel global em Postscript. 
-  #  d=Document.new
-  #  d.define_variable(:my_var,[3,4,5,6])
-  #      
-  def define_variable(name,value)
-    @defines << Variable.new(name,value)
-  end
-  #Use showpage para o fim do documento ou para saltar p�ginas.
-  # Obs.: showpage n�o reseta os contadores de p�ginas,faixas, etc.
-  def showpage
-    call :stroke
-    call :showpage
-  end
   
-  #Facade Cursor.goto_row
-  def goto_row(row)
-     set Cursor.goto_row(row)    
-  end
-  #Facade Cursor.jump_rows
-  def jump_rows(row)
-    set Cursor.jump_rows(row)
-  end 
-  #Facade Cursor.rotate
-  def rotate(angle) 
-    set Cursor.rotate(angle)
-  end
-  #Facade Cursor.moveto
-  def moveto(point={})
-    set Cursor.moveto(point)
-  end
-  #Facade Cursor.rmoveto
-  def rmoveto(point={})
-    set Cursor.rmoveto(point)
-  end
-  #Facade Cursor.translate
-  def translate(point={})
-    set Cursor.translate(point)
-  end
-  #Facade DSCEntry.new 
-  def dsc_entry(&block)
-     set DSCEntry.new(&block)
-  end
-  #Facade EPS.new
-  def template(file_path,options={})
-    set EPS.new(file_path,options)
-  end
-  #Define um template/eps
-  # dt=Document.new
-  # dt.define_template(:myform, '/local/template/form1.eps', :x=> 3, :y => 5)
-  # dt.call :myform       # Executa o template
-  def define_template(name,file_path,options)
-    set Function.new(name,EPS.new(file_path,options))
-  end
-  #Facade Font.new
-  def font(options)
-    set Font.new(options)
-  end
-  #Facade Image.for
-  def image(path,options={})
-    set Image.for(path,options)
-  end
-  #Idem horizontal_line 
-  def hl(valign=:middle,options={})
-    set HorizontalLine.new(valign,options)
-  end
-  #Facade HorizontalLine.new
-  def horizontal_line(valign=:middle,options={})
-     hl(valign,options)
-  end
-  #Facade Rectangle.new
-  def rectangle(options={})
-     set Rectangle.new(options)
-  end
-  #Facade Rectangle.background_row
-  def background_row(options={})
-    set Rectangle.background_row(options={})
-  end
-  #Facade Scale.new
-  def scale(sx,sy)
-    set Scale.new(sx,sy)
-  end
-  #Facade TextIn.new
-  def text_in(options={})
-    set TextIn.new(options)
-  end
-  #Facade Show.new
-  def text(text,align={ :align=>:show_left })
-    set Show.new(text,align)  
-  end
-  #Facade Show.new
-  def show(text,align={ :align=>:show_left })
-    set Show.new(text,align)  
-  end
-  #Facade TextArea.new
-  def text_area(text,options={})
-    set TextArea.new(text,options)
+  #Starts and Ends internal benckmark will write in bottom of page.
+  #===Example
+  # doc=Document.new
+  # doc.benchmark :start
+  # doc.... #do something
+  # doc.benchmarck :stop
+  # doc.render ...
+  def benchmark(state=:start)
+    case state
+    when :stop
+      moveto(:x => "20", :y => "20")
+      raw %Q{
+      default_font (RGhost::Ghostscript benchmark: ) show
+      realtime benchmark sub 1000 div 20 string cvs show ( seconds ) show
+      }
+    when :start
+      set RGhost::Variable.new(:benchmark,"realtime")
+    end
   end
-  #Facade VerticalLine.new
-  def vertical_line(start_in=:limit_left,size=:area_y)
-    set TextArea.new(start_in, size)
+  
+  #Rghost can make use of Encapsulated Postscript files to act as templates(EPS).
+  #This way you can create the visual layout of the page using a graphics tool and just paint the dynamic pieces over using Rghost.
+  #
+  #link:images/templates_demo.jpg
+  #
+  #Above we have mytemplate.eps that was generated by a graphic app, my_ruby_program.rb that takes care of the positioning and at last the generated output.
+  #
+  #
+  #A Template use example
+  #Let's say that the files first.eps and content.eps already exist. Now we shall see how to create a document that uses the template first.eps for the cover and the rest of the document uses content.eps.
+  #
+  # d = Document.new :margin_top => 5, :margin_bottom => 2
+  #
+  #Just for the first page
+  #
+  # d.first_page do
+  #  image "/my/dir/first.eps" 				#loads the template
+  #  text_in :x=> 5, :y=> 17, :text => "My Report", :with => :big
+  #  next_page 						#go to the next page using cursors
+  # end
+  #Callback for all other pages.
+  #
+  # d.before_page_create :except => 1 do
+  #  image "/my/dir/content.eps"
+  #  text_in :text => "Page %current_page% of %count_pages%", :x => 18, :y => 27, :with => :normal  
+  # end
+  # 
+  #1500 rows 
+  #
+  # 1500.times do |n|
+  #   d.show "Value #{n}"
+  #   d.next_row
+  # end
+  #We have a cover page and 1500 rows, judging by the margins each page supports 46 rows, so we have 1500/46 = 32.60 pages plus the cover. Rounding it up totals 34 pages for the :count_pages
+  #
+  #  d.define_variable(:count_pages, 34) 
+  #  d.showpage
+  #  d.render :pdf, :filename => "/tmp/test.pdf"
+  #  
+  #If we knew the amount of pages beforehand we could state it on the creation of the document, i.e.
+  #
+  #  :current_pages => 34 
+  #
+  #The example uses  one template per page, but this is not a limit in RGhost. You can have multiple images and templates on per page. Just have to define the template:
+  # 
+  #   d=Document.new :margin_top => 5, :margin_bottom => 2
+  #   d.define_template(:myform, '/local/template/form1.eps', :x=> 3, :y => 5)
+  #   
+  #and call it  on the document.
+  #  d.use_template :myform
+  #  
+  #===Arguments
+  #* <tt>:name</tt> - Template's name.
+  #* <tt>:file_path</tt> - Path to file.
+  #* <tt>:options</tt> - Options facade to Image.for(or image)
+  def define_template(name,file_path,options={})
+    
+    @defines <<  RGhost::Function.new("_#{name}",RGhost::Image.for(file_path,options))
   end
-  #Carrega de c�digo de barras(GNU Barcodes) da API
-  def load_font(name=:CODE39)
+
+
+  #Informs is ready to converts/prints
+  def done
+    @done=true
+    raw "\n\n"
+    call :after_page_create
+    call :callback
+    call :after_document_create
     
-    raw Load.library(name,:font) 
-  
+    showpage
+    raw "\n%%EOF"
   end
-  #Executa o comando stoke para desenho de vertores
-  def stroke
+  def enable_virtual_pages
+    set RGhost::Variable.new(:has_vp?, true)
     
-    call :stroke
   end
-  #Informa que o documento est� pronto para ser convertido/impresso
-  def done
-     showpage
-     raw "\n%%EOF"
+  def disable_virtual_pages
+    set RGhost::Variable.new(:has_vp?, false)
+    set RGhost::Variable.new(:limit_left,  'source_limit_left')
+    set RGhost::Variable.new(:limit_right, 'source_limit_right')
+    
   end
   
+
+  #  def load_library(name)
+  #    raw RGhost::Load.library(name)
+  #  end
   private
+  
   def default_variables
-    ps=PsObject.new
-    ps.set Variable.new(:rows_per_page,@variables[:rows_per_page])
-    ps.set Variable.new(:count_pages,@variables[:count_pages])
-    ps.set Variable.new(:row_height,Units::parse(@variables[:row_height]))
-    ps.set Variable.new(:row_padding,Units::parse(@variables[:row_padding]))
-    
+    ps=RGhost::PsObject.new
+    ps.set RGhost::Variable.new(:rows_per_page,@variables[:rows_per_page])
+    ps.set RGhost::Variable.new(:count_pages,@variables[:count_pages])
+    ps.set RGhost::Variable.new(:row_height,RGhost::Units::parse(@variables[:row_height]))
+    ps.set RGhost::Variable.new(:row_padding,RGhost::Units::parse(@variables[:row_padding]))
     
     @default_variables=ps  
-      
     
   end
+  
   def default_encoding
-    @head.set Load.library(@variables[:font_encoding],:enc)
-    @head.set Variable.new(:default_encoding,@variables[:font_encoding])
+    @head.set RGhost::Load.library(@variables[:font_encoding],:enc)
+    @head.set RGhost::Variable.new(:default_encoding,@variables[:font_encoding])
     
   end