lunks_rghost 0.8.7.6

data/lib/rghost/font.rb

@@ -0,0 +1,48 @@
+require "rghost/ps_object"
+require "rghost/constants"
+require "rghost/helpers"
+
+
+class RGhost::Font < RGhost::PsObject #:nodoc:
+  DEFAULT_OPTONS={ :size=> 8, :name => "Helvetica", :encoding => true }
+  include RGhost::Constants::Fonts
+  
+  attr_reader :name
+
+  def initialize(options)
+
+    @options=DEFAULT_OPTONS.dup.merge(options)
+    @options.default ""
+    @options[:name]=@options[:font] if @options[:font]
+    @name=@options[:name].to_s
+    @name+="-encoding" if @options[:encoding]
+  end
+
+  def ps
+    o=@options
+    str_ret=""
+#    if o[:barcode]
+#      bc=RGhost::Barcode.new(o[:barcode])
+#      @name=bc.font_name  
+#      o[:encoding]=false   
+#    end
+    if o[:encoding] #define enconding 
+      str_ret="/#{o[:name]} encoding_font\n"+
+        "/#{o[:name]}-encoding exch definefont pop\n"
+    end 
+     
+       
+    size= o[:size]
+    str_ret+=case size
+    when Hash then   "/#{@name} findfont [ #{size[:width]} 0 0 #{size[:height]} 0 0] makefont setfont "
+    when Array then  "/#{@name} findfont [ #{size[0]} 0 0 #{size[1]} 0 0] makefont setfont "
+    when Fixnum then "/#{@name} findfont #{size} scalefont setfont "
+    end
+    str_ret
+  end
+
+  
+
+end
+
+

data/lib/rghost/font_map.rb

@@ -0,0 +1,54 @@
+#NetDeseigners <www.ndesigners.com.br>
+#Shairon Toledo <shairon.toledo@gmail.com>
+require 'rghost/ps_object'
+require 'rghost/font'
+require 'rghost/function'
+
+
+class RGhost::FontMap < RGhost::PsObject #:nodoc:
+  include RGhost::RubyToPs
+  def initialize(options={:font => "Helvetica", :size => 8},&block)
+      
+    #options[:name]=options[:font]
+    @options=options
+    @fonts={}
+    instance_eval(&block) if block
+  end
+  
+  def new(name,options={})
+    #options[:name]=options[:font]
+    @fonts[name]=options
+    
+  end
+  def tag(name,options={})
+    new(name,options)
+  end
+  
+  
+  def ps
+    functions=[]
+    fonts=""
+    @fonts.each do |name,params|
+      options=@options
+      if params[:from]
+        [params[:from]].flatten.each do |font|
+          functions << format_custom_font(font)
+        end
+      
+      end
+      functions << RGhost::Function.new("_#{name}") do
+        raw RGhost::Font.new(options.dup.merge(params)).ps
+        raw( RGhost::Color.create(params[:color] || 0) ) 
+      end
+    end
+    functions.join
+  end
+  
+  private
+  def format_custom_font(font_path)
+    ps=RGhost::PsObject.new
+    ps.raw "#{to_string(font_path)} findfont pop"
+    ps
+  end
+end
+

data/lib/rghost/frame.rb

@@ -0,0 +1,105 @@
+#Creates one rectangle or one shape with rounded corners.
+#===Options
+#
+#* <tt>:x and :y</tt> - Coordinates to position.
+#* <tt>:corners</tt> - Value for rounded corners. Use 0 to straight angle.
+#* <tt>:width and :height</tt> - Size of frame
+#* <tt>:content</tt> - facade to ShapeContent with same parameters.
+#* <tt>:border</tt> - facade to Border with same parameters.
+#===Examples using facade frame method inside of Document
+#  d=Document.new
+#  d.frame :x => 3, :width => 7, :height => 5, :content => {:fill => false}
+#
+#link:images/frame01.png
+#  d=Document.new
+#  d.frame :x => 3, :width => 7, :height => 5, :content => {:color => '#35F6A3' }
+#
+#link:images/frame02.png
+# 
+#  d=Document.new
+#  d.frame :x => 3, :width => 7, :height => 5, :content => {:color => '#35F6A3' }, :border =>{:width => 5, :dash => [1,3,10]}
+#
+#link:images/frame03.png
+# 
+#  d=Document.new
+#  d.frame :x => 3, :width => 7, :height => 5, :content => {:color => '#35F6A3' }, :corners => 20
+#
+#link:images/frame04.png
+#  
+#  d=Document.new
+#  d.frame :x => 3, :width => 7, :height => 5, :content => {:color => :yellow }, :border => {:color => :red, :width => 4}, :corners => 20
+#  
+#link:images/frame05.png
+class RGhost::Frame < RGhost::PsObject
+  DEFAULT_OPTIONS={
+    :x => :limit_left,
+    :y => :current_row,
+    :width => 5,
+    :height => 3.5,
+    :corners => 1,
+    :content => RGhost::ShapeContent::DEFAULT_OPTIONS,
+    :border => RGhost::Border::DEFAULT_OPTIONS
+    
+    
+  }
+  BACKGROUND_ROW_DEFAULT_OPTIONS={:start_in => :limit_left, :size => :area_x, :color => RGhost::ShapeContent::DEFAULT_OPTIONS[:color]}
+  def initialize(options={})
+
+    @options = DEFAULT_OPTIONS.dup.merge(options)
+
+  end
+  
+  
+  def ps
+    x=RGhost::Units::parse(@options[:x])
+    y=RGhost::Units::parse(@options[:y])
+    
+    h=RGhost::Units::parse(@options[:height])
+    w=RGhost::Units::parse(@options[:width])
+    
+    inside=RGhost::ShapeContent.new(@options[:content]) if @options[:content]
+    border=RGhost::Border.new(@options[:border]) if @options[:border]
+    
+    params=%Q{
+      /rcorners_params{
+        /:x #{x}   def /:y #{y} def
+    /:w #{w} def /:h #{h} def
+    /:r #{@options[:corners]} def
+    /:s 1 def
+    /:inside{
+    #{inside.ps if inside }
+    } def
+    /:outside{
+    #{border.ps if border}
+    }def
+      } def
+    }
+    
+    "#{params} rcorners_params rcorners"
+    
+  end
+  #Creates background of the row for current row. Example
+  #Here's fill the current row using width :area_x, height :row_height, and starting in :limit_left.
+  # doc.background_row :color => '#35F6A3'
+  # 
+  #link:images/background_row01.png
+  #
+  #Specifies size and where will start of background
+  # doc.background_row :start_in => 2, :size => 5.5, :color => 0.8
+  #
+  #link:images/background_row02.png
+  def self.background_row(options=BACKGROUND_ROW_DEFAULT_OPTIONS)
+    #opts=BACKGROUND_ROW_DEFAULT_OPTIONS.merge(options)
+    #start_in,size=Units::parse(opts[:start_in]),Units::parse(opts[:size])
+    #return RGhost::PsObject.new("#{start_in} #{size} {#{opts[:color]}} background_row ")
+    options =RGhost::Frame::BACKGROUND_ROW_DEFAULT_OPTIONS.merge(options)
+    g=RGhost::Graphic.new
+    g.set RGhost::Units::parse(options[:start_in])
+    g.set RGhost::Units::parse(options[:size])
+    g.set RGhost::Color.create(options[:color])  if options[:color]
+    g.raw :background_row
+    g
+    
+    
+  end
+end

data/lib/rghost/function.rb

@@ -0,0 +1,38 @@
+require "rghost/ps_object"
+
+
+#Creates postscript internal function. Example
+# f=RGhost::Function.new :foo do
+#  set Show.new("A Test")
+# end  
+#In ps stack will be
+# /foo (A Test) show def
+class RGhost::Function < RGhost::PsObject
+
+  attr_reader :name
+
+  def initialize(name,body_function=nil,&block)
+    if block
+      #super(&block)
+      super(&block)
+        
+    else
+        
+      super("")
+    end  
+    @name=name
+    @body_function=body_function
+
+  end
+  
+  def use_template(function_name)
+    call "_#{function_name}"
+   
+  end
+  def ps
+    @body_function||=super
+      
+    "\n/#{@name}{\n#{@body_function}\n} bind def \n"
+  end
+
+end

data/lib/rghost/gif.rb

@@ -0,0 +1,41 @@
+require "rghost/ps_object"
+require "rghost/graphic"
+require "rghost/cursor"
+require "rghost/variable"
+require "rghost/image"
+require "rghost/function"
+require "rghost/scale"
+  #Loads GIF image from file
+  #===Examples
+  # doc=Document.new
+  # doc.set Gif.new "../public/images/button.gif", :x => 10, :y => 3
+  #Using Image.for facade 
+  # doc.set Image.for "../public/images/button.gif", :x => 10, :y => 3
+  #Using PsFacade or Document 
+  # doc.image "images/button.gif", :x => 10, :y => 3
+  #Using zoom of the 200 percent
+  # doc.image "images/button.gif", :zoom => 200
+  #===Options
+  #
+  #* <tt>:x and :y</tt> - Coordinates to position.
+  #* <tt>:rotate</tt> - Angle to image rotation if there is one.
+  #* <tt>:zoom</tt> - Resize proportionally the image
+class RGhost::Gif < RGhost::Image
+
+  def ps
+    s=@options[:zoom]/100.0
+    
+    g=RGhost::Graphic.new 
+    
+    params=RGhost::Function.new(:gif_params)
+    params.set RGhost::Cursor.translate(@options)  
+    params.set RGhost::Cursor.rotate(@options[:rotate])
+    params.set RGhost::Scale.new(s,s) 
+    
+    g.set params
+    g.set RGhost::PsObject.new("(#{@file}) viewGIF")  
+    g.ps
+
+  end
+
+end

data/lib/rghost/graphic.rb

@@ -0,0 +1,26 @@
+require "rghost/ps_object"
+require "rghost/cursor"
+require "rghost/point"
+require "rghost/line_width"
+#Creates a new graphic state between gsave and grestore postscript primitives. Example
+#   doc=Document.new
+#   doc.graphic do
+#     set LineWidth.new(0)
+#     set Line.lineto(5,7)
+#   end
+class RGhost::Graphic < RGhost::PsObject
+  
+  def ps
+      "gsave #{super} grestore"
+  end
+  
+  
+end
+
+
+
+ 
+
+
+
+

data/lib/rghost/grid/base_grid.rb

@@ -0,0 +1,228 @@
+require 'enumerator'
+# RGhost::Grid::Base is a helper object to create a tabular
+# representations, composed of rows, columns and a title.  This
+# prototype used to join the common attributes for data grids. To use
+# a Grid you must first setup the columns, then load the data.
+#
+# Example:
+#  grid=Grid::Matrix.new
+#  grid.column :title => "Code", :width => 1
+#  grid.column :title => "Name", :width => 3, :align => :center
+#  grid.column :title => "Date", :width => 3, :align => :center
+#
+# Note that both the width and align of the last two columns are
+# identical. To avoid repetition, you can specify a default width upon
+# creating the DataGrid::Grid object. Any columns that do not specify
+# an explicit width and align property will inherit the defaults.
+#
+# Example:
+#
+#  grid=Grid::Matrix.new :width => 3, :align => :center
+#  grid.column :title => "Code", :width => 1    #:width => 1, :align => :center
+#  grid.column :title => "Name"                 #:width => 3, :align => :center
+#  grid.column :title => "Date"                 #:width => 3, :align => :center
+#
+# The actual content needs to be passed in as an array of arrays
+#
+#  values=[
+#    [1,"Name 1", Time.now],
+#    [2,"Name 2", Time.now],
+#    [3,"Name 3", Time.now],
+#    [4,"Name 4", Time.now],
+#    [5,"Name 5", Time.now]
+#  ]
+#
+# Bind the content to the grid:
+#  grid.data(values)
+# Add the Grid to a document
+#  d=Document.new
+#  d.set grid
+#
+class RGhost::Grid::Base < RGhost::PsObject
+  attr_reader :header
+  attr_accessor :column_padding
+  include RGhost::RubyToPs
+  include RGhost::Grid::CallbackFacade
+
+  #===Options
+  #* <tt>:headings</tt> - To disable headers set this attribute to false.
+  #* <tt>:column_padding</tt> - Padding between column content and its edge.
+  #* <tt>:width</tt> - Width for all columns.
+  #* <tt>:align</tt> - Align for all  data(:left, :center and :right).
+  #* <tt>:title_align</tt> - Align for all the header's name(:left, :center and :right).
+  def initialize(options={})
+    
+    @header=RGhost::Grid::Header.new( (options[:headings] == false)?false:true  )
+    @header.default_options(options)
+    @callbacks=RGhost::PsObject.new
+    @column_padding= options[:column_padding] || 0.1
+    @record_count=1
+    @data=[]
+    @data[0]=[]
+    @data_index=0
+    @max_stack=RGhost::Config::GS[:stack_elements]
+  end
+
+
+  # Defines properties of a column. Parameters are the same as for new,
+  # plus some additional ones like :format.
+  # * <tt>:format</tt> - Format of the data. You can format data in four
+  #                      different ways with Rghost, passing in a Symbol
+  #                      a String a Class or Proc.
+  #
+  # ==== :format Parameters type
+  # * Symbol - Searches for a method defined as  Grid::FieldFormat::method_name
+  #  :format => :eurodate
+  # * Class - A class that inherits Grid::FieldFormat::Custom with a overridden format method.
+  #  :format => MyFormat
+  # * String - Formats using the same parameters used in sprintf
+  #  :format => "%0.2f"
+  # * Proc - A block. In the  example a text limited to 9 characters.
+  #  :format => lambda {|s| s.gsub(/^(.{9}).*$/,'\1...')}
+  # ====Customizing formats
+  # Replace spaces with a double dash.
+  #  class MyFormat < DataGrid::FieldFormat::Custom
+  #   def format
+  #      @value.to_s.gsub(/ /,'--')
+  #   end
+  #  end
+  #
+  # Using
+  #
+  #  grid.column :title => "Name", :format => MyFormat
+  #
+  # Below, the columns with their proper formats.
+  #
+  #  grid.column :title => "Code",:format => "(%d)", :width => 1
+  #  grid.column :title => "Name",  :format => MyFormat
+  #  grid.column :title => "Date",  :format => lambda {|date| date.strftime("%d/%m/%Y") }
+  #  values=[
+  #    [1,"Name 1", Time.now],
+  #    [2,"Name 2", Time.now],
+  #    [3,"Name 3", Time.now],
+  #    [4,"Name 4", Time.now],
+  #    [5,"Name 5", Time.now]
+  #  ]
+  #  grid.data(values)
+  # Add the Grid to a document
+  #
+  #  d=Document.new
+  #  d.set grid
+  # link:images/format01.png
+  def col(title="", options={})
+    if title.is_a? Hash
+      
+      @header.col(title[:title],title)
+    else
+      
+      @header.col(title,options)
+    end
+  end
+  #Alias for col
+  def column(title="", options={})
+    col(title,options)
+
+  end
+
+  def format_field(value,type) #:nodoc:
+    case type
+    when Symbol
+      RGhost::Grid::FieldFormat.send(type,value)
+    when String
+      RGhost::Grid::FieldFormat.string(type % value)
+    when NilClass
+      RGhost::Grid::FieldFormat.string(value)
+    when Class
+      type.new(value).gs_format
+    when Proc
+      RGhost::Grid::FieldFormat.string(type.call(value))
+
+    else raise TypeError.new("type=#{type}, value type=#{value.class}")
+    end
+
+  end
+  def width
+    @header.size
+  end
+  def proc_line(line) #:nodoc:
+    h=@header.data_types
+    rec=[]
+    line.each_with_index do |v,i|
+      #puts "#{i} == #{h[i]} = #{v}, #{format_field(v,h[i])}"
+      rec << format_field(v,h[i])
+    end
+    @data[@data_index] <<  "[#{rec.join(' ')}]\n"
+
+
+    if @record_count == @max_stack
+      @record_count=0
+      @data_index+=1
+      @data[@data_index]=[]
+    end
+    @record_count+=1
+
+
+  end
+  #Defines data to grid processor.
+  def data(data)
+
+  end
+  public
+
+  def ps
+
+
+    grid_names=[]
+    p=RGhost::PsObject.new
+    p.set RGhost::Variable.new(:col_padding,RGhost::Units::parse(@column_padding))
+    @data.each do |ary|
+      r=(rand*99999).to_i
+      p.raw "/data#{r}[\n#{ary.join('')}\n] def"
+      grid_names << r
+    end
+    p.raw "#{@header.ps} #{@callbacks}"
+
+    g=RGhost::Graphic.new do
+      raw :before_table_create
+      raw grid_names.map{|m| " data#{m} table_proc \n" }.join('')
+      raw :after_table_create
+    end
+    p.set g
+    p.raw :nrdp
+    p
+
+
+  end
+
+  # Grid has 3 preset styles :bottom_lines, :border_lines and
+  # old_forms. To set any of them, use:
+  #
+  #   grid.style(:border_lines)
+  #
+  # :border_lines - instance of Grid::Style::BorderLines
+  #
+  # link:images/setstyle01.png
+  #
+  # :bottom_lines - instance of Grid::Style::BottomLines
+  #
+  # link:images/setstyle02.png
+  #
+  # :old_forms - instance of Grid::Style::OldForms
+  #
+  # link:images/setstyle03.png
+  def style(type=:border_lines)
+    st=case type
+    when :border_lines
+      RGhost::Grid::Style::BorderLines.new
+    when :old_forms
+      RGhost::Grid::Style::OldForms.new
+    when :bottom_lines
+      RGhost::Grid::Style::BottomLines.new
+    else raise NameError.new("Why? #{type} ?")
+    end
+
+    st.set_style(self)
+
+  end
+
+end

data/lib/rghost/grid/callback_facade.rb

@@ -0,0 +1,136 @@
+
+module RGhost::Grid
+  # The callbacks for the grid are defined here. Let's see them in action.
+  # ===Grid::CallbackFacade examples
+  #  grid=Grid::Matrix.new :column_padding => 1
+  #  grid.column :title => "Id", :width => 1
+  #  grid.column :title => "Name", :width => 3, :align => :center
+  #  grid.column :title => "Date", :width => 3, :align => :right, :title_align => :center,  :format => lambda{|v| v.strftime("%d/%m/%Y")}
+  #  values=('A'..'E').to_a.map{|v|  [v,"Name #{v}", Time.now]}
+  #
+  # even_row:
+  #  grid.even_row do |e|
+  #   e.background_row(:size => grid.width)
+  #  end
+  # link:images/grid01.png
+  #
+  # Now before_row to create a top and bottom line:
+  #  grid.before_row do |b|
+  #   b.horizontal_line(:top,    :size => grid.width )
+  #   b.horizontal_line(:bottom, :size => grid.width)
+  #  end
+  #
+  # link:images/grid02.png
+  #
+  # before_column:
+  #  grid.before_column do |v|
+  #   v.vertical_line_row
+  #  end
+  #
+  # link:images/grid03.png
+  #
+  # after_column:
+  #  grid.after_column {|c|  c.vertical_line_row  }
+  #
+  #
+  # link:images/grid04.png
+  #
+  # Moving to the header
+  #  grid.header.before_create do |b|
+  #   b.horizontal_line(:top, :size => grid.width)
+  #  end
+  #
+  # link:images/grid05.png
+  #
+  # Finishing the grid lines:
+  #  grid.header.before_column do |b|
+  #    b.vertical_line_row
+  #  end
+  #
+  #
+  #  grid.header.after_column do |b|
+  #   b.vertical_line_row
+  #  end
+  #
+  # link:images/grid06.png
+  #
+  # Now a adding a bold font to the header
+  #  grid.header.before_create do |b|
+  #    b.horizontal_line(:top, :size => grid.width)
+  #    b.use_tag :bold
+  #   end
+  #
+  # link:images/grid07.png
+  #
+  # Oops. Not quite what we expected, the entire grid used bold
+  # face. We need to use a header callback to reset the font.
+  #
+  #  grid.header.after_create do
+  #     b.use_tag :normal
+  #   end
+  #
+  # link:images/grid08.png
+  #
+  # Don't forget
+  #
+  #  doc=Document.new
+  #  doc.set grid
+  module CallbackFacade
+
+    # Executes before processing row. Responds to :only and :except
+    # options.
+    def before_row(options={},&block)
+      new_dynamic_callback(:before_row,options,&block)
+    end
+
+    # Executes on creating an odd rows. Responds to :only and :except
+    # options.
+    def odd_row(options={},&block)
+      new_dynamic_callback(:odd_row,options,&block)
+    end
+
+    # Executes upon creating even rows. Responds to :only and :except
+    # options.
+    def even_row(options={},&block)
+      new_dynamic_callback(:even_row,options,&block)
+    end
+
+    # Executes before creating a column. Responds to :only and :except
+    # options.
+    def before_column(options={},&block)
+      new_dynamic_callback(:before_column,options,&block)
+    end
+
+    # Executes after a column was created. Responds to :only and
+    # :except options.
+    def after_column(options={},&block)
+      new_dynamic_callback(:after_column,options,&block)
+    end
+
+    # Executes when creating an odd column. Responds to :only and
+    # :except options.
+    def odd_column(options={},&block)
+      new_dynamic_callback(:odd_column,options,&block)
+    end
+
+    # Executes upon creating an even column. Responds to :only and
+    # :except options.
+    def even_column(options={},&block)
+      new_dynamic_callback(:even_column,options,&block)
+    end
+
+
+    private
+
+    def new_dynamic_callback(name,options={},&block)
+      @callbacks.set RGhost::Callback.new(name,options,&block)
+    end
+    def new_static_callback(name,&block)
+
+      callback_body= RGhost::PsFacade.new(&block)
+      @callbacks.set RGhost::Function.new(name,callback_body)
+    end
+
+
+  end
+end