rghost-ruby1.9-beta 0.8.7.2

data/lib/rghost/image.rb

@@ -0,0 +1,26 @@
+require "rghost/ps_object"
+#Super class of GIF and JPEG.
+class RGhost::Image < RGhost::PsObject
+  DEFAULT_OPTIONS={:x=> :limit_left, :y=> 1, :zoom => 100, :rotate => 0}
+  
+  def initialize(image_path,options={})
+    super("")
+    @options=DEFAULT_OPTIONS.dup.merge(options)
+    @file=image_path
+  end
+  
+  #Facade method for load image by file extension. Uses Eps, Gif and Jpeg class. Accepts gif, jpeg, jpg and eps
+  def self.for(path,options={})
+    
+    clazz=case path
+      when /gif$/i then RGhost::Gif
+      when /jpe?g$/i then RGhost::Jpeg
+      when /(eps|template)$/i then RGhost::Eps
+      else raise NameError.new("Unsupported format")
+    end
+    
+    clazz.new(path,options)
+  end
+  
+  
+end  

data/lib/rghost/jpeg.rb

@@ -0,0 +1,39 @@
+require "rghost/ps_object"
+require "rghost/graphic"
+require "rghost/cursor"
+require "rghost/variable"
+require "rghost/image"
+  #Loads JPEG image from file
+  #===Examples
+  # doc=Document.new
+  # doc.set Jpeg.new "../public/images/button.jpg", :x => 10, :y => 3
+  #Using Image.for facade 
+  # doc.set Image.for "../public/images/button.jpg", :x => 10, :y => 3
+  #Using PsFacade or Document 
+  # doc.image "images/button.jpg", :x => 10, :y => 3
+  #Using Zoom of the 200 percent
+  # doc.image "images/button.jpg", :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::Jpeg < RGhost::Image
+
+
+
+  def ps
+    #x=Units::parse( @options[:x] )
+    #y=Units::parse( @options[:y] )
+    
+    g=RGhost::Graphic.new 
+    g.set RGhost::Cursor.translate(@options)
+      #set Cursor.translate()
+    g.set RGhost::Cursor.rotate(@options[:rotate])
+    g.set RGhost::Variable.new(:zoom,@options[:zoom]/100.0)
+    g.set RGhost::PsObject.new("(#{@file}) viewJPEG")
+    g.ps
+
+  end
+
+end

data/lib/rghost/line.rb

@@ -0,0 +1,89 @@
+require "rghost/ps_object"
+require "rghost/point"
+
+#Creates straight lines 
+class RGhost::Line < RGhost::PsObject
+  DEFAULT_POINT={:x => :limit_left , :y => :current_row}
+  
+  #Draw line the one pont until another, the first point is creates by moveto and de last point using the method lineto.
+  #===Examples
+  # doc=Document.new
+  # doc.moveto :x => 2, :y => 3
+  # doc.lineto :x => 5, :y => 2
+  # 
+  #link:images/line01.png 
+  #
+  # doc=Document.new
+  # doc.moveto :x => 2, :y => 3
+  # doc.lineto :x => 4, :y => 4 
+  # 
+  #link:images/line02.png 
+  #
+  # doc=Document.new
+  # doc.border :color => '#AAFA49', :width => 4
+  # doc.moveto :x => 2, :y => 3
+  # doc.lineto :x => 4, :y => 1 
+  # 
+  #link:images/line03.png 
+  #
+  # doc=Document.new
+  # doc.border :color => '#49AAFA', :width => 1
+  # doc.moveto :x => 2, :y => 3
+  # doc.lineto :x => 4, :y => 1 
+  # doc.moveto :x => 2, :y => 3
+  # doc.lineto :x => 2, :y => 1 
+  # 
+  #link:images/line04.png 
+  #
+  #Using graphic state to close path shape
+  #
+  # doc=Document.new
+  # doc.graphic do
+  #   doc.border :color => '#49AAFA', :width => 1
+  #   doc.moveto :x => 2, :y => 3
+  #   doc.lineto :x => 4, :y => 1 
+  #   doc.lineto :x => 2, :y => 1 
+  #   doc.shape_content :color => "#F0FFFF"
+  #   doc.closepath
+  # end
+  # 
+  #link:images/line05.png 
+  def self.lineto(point={})
+  
+    RGhost::Line.make_command(:lineto,point)
+  
+  end
+  #(Relative lineto) Draw straingh line in the same manner as lineto, but from current point to distance for next :x and :y. That is, rlineto constructs a line from (x, y) to (x + dx, y + dy) and makes (x + dx, y + dy) the new current point. 
+  #
+  #===Examples
+  # doc=Document.new
+  # doc.moveto  :x => 2, :y => 1
+  # doc.rlineto :x => 3, :y => 2
+  # 
+  #link:images/line06.png 
+  #
+  # doc=Document.new
+  # doc.moveto  :x => 2, :y => 1
+  # doc.rlineto :x => 3, :y => 2
+  # doc.rlineto :x => 0, :y => -2
+  #link:images/line07.png 
+  def self.rlineto(point={})
+    line=RGhost::Line.make_command(:rlineto,point)
+  
+  end
+  
+  
+  private 
+  def self.make_command(command,point={})
+
+    p=DEFAULT_POINT.dup.merge(point)
+    p=RGhost::Point.new(p[:x],p[:y])
+    RGhost::PsObject.new "#{p.ps}#{command}"
+  end
+  
+end
+
+
+
+
+

data/lib/rghost/line_width.rb

@@ -0,0 +1,28 @@
+require "rghost/ps_object"
+#Sets the line width parameter in the graphics state.
+class RGhost::LineWidth < RGhost::PsObject
+  
+  #Examples
+  #The more tiny line
+  # doc=Document.new
+  # doc.line_width 0 
+  #
+  #link:images/line_width01.png 
+  #
+  # doc.line_width 1 
+  #
+  #link:images/line_width02.png 
+  #
+  # doc.line_width 2 
+  #
+  #link:images/line_width03.png 
+  #
+  def initialize(value=0.3)
+    @value=value
+  end 
+  
+  def ps
+    "#{@value} setlinewidth "
+  end
+
+end

data/lib/rghost/load.rb

@@ -0,0 +1,43 @@
+require "rghost/ps_object"
+module RGhost::Load
+  #Loads library
+  def self.library(name, type=:ps)
+    #PsObject.new File.open(File.dirname(__FILE__)+File::SEPARATOR+type.to_s+File::SEPARATOR+name.to_s+"."+type.to_s).readlines.join("")
+    
+   RGhost::PsObject.new("(#{name.to_s}.#{type}) runlibfile\n")
+      
+  end
+  
+  def self.rg_enviroment
+    RGhost::PsObject.new do
+      raw RGhost::Load.library(:basic)
+      raw RGhost::Load.library(:cursor)
+      raw RGhost::Load.library(:rectangle)
+      raw RGhost::Load.library(:font)
+      raw RGhost::Load.library(:textarea)
+      raw RGhost::Load.library(:horizontal_line)
+      raw RGhost::Load.library(:vertical_line)
+      raw RGhost::Load.library(:callbacks)
+      raw RGhost::Load.library(:show)
+      raw RGhost::Load.library(:eps)
+      raw RGhost::Load.library(:jpeg)
+      raw RGhost::Load.library(:gif)
+      raw RGhost::Load.library(:begin_document)
+      raw RGhost::Load.library(:datagrid)
+      raw RGhost::Load.library(:text)
+      raw RGhost::Load.library(:frame)
+      raw RGhost::Load.library(:link)
+      raw RGhost::Load.library(:rect_link)
+      
+    end
+  end
+  #Loads binary library
+  def self.binary(path)
+      File.open(path).readlines.join
+  
+  end
+  
+
+  
+end
+

data/lib/rghost/newpath.rb

@@ -0,0 +1,19 @@
+require "rghost/ps_object"
+require "rghost/cursor"
+require "rghost/point"
+require "rghost/line_width"
+
+#Initializes the current path to be empty, causing the current point to become undefined. 
+class RGhost::NewPath < RGhost::PsObject
+ 
+  def initialize(&block)
+    @body=RGhost::PsFacade.new(&block)
+    
+  end
+  
+  def ps
+      "newpath #{@body} closepath"
+  end
+  
+  
+end

data/lib/rghost/paper.rb

@@ -0,0 +1,147 @@
+require "rghost/ps_object"
+require "rghost/units"
+require "rghost/load"
+require "rghost/constants"
+require "rghost/ruby_to_ps"
+#Paper is the area where the Postscript elements/objects are drawn. 
+#The margin is the document's non-printable area (both by the cursors and by the page's internal controllers). 
+#The :area_x and :area_y are the printable section of the paper.
+#It's used to configure definitions of paper. It automatically defined into Document by :paper parameter.
+#
+#link:images/paper01.png
+#
+class RGhost::Paper < RGhost::PsObject
+  
+  
+  DEFAULT_OPTIONS={ :landscape => false, 
+    :margin_top => 1, 
+    :margin_right => 1, 
+    :margin_bottom => 1,
+    :margin_left => 1, 
+    :duplex => false, 
+    :tumble => false
+  }
+  
+  include RGhost::RubyToPs
+  #===Examples
+  #
+  #====Create paper by name 
+  # doc=Document.new :paper => :A4 
+  #====Create paper by name in landscape
+  # doc=Document.new :paper => :A4 , :landscape => true
+  #====Create custom paper 
+  # doc=Document.new :paper => [10,15] 
+  #====Defining all margins
+  # doc=Document.new :paper => :A5, :margin => 0.5
+  #====Defining custom margins
+  # doc=Document.new :paper => :A5, :margin => [0.5, 1, 0.5, 2]   #=>[top,right,bottom,left] clockwise 
+  #====Defining particular margin
+  # doc=Document.new :paper => :A5, :margin_top => 1, :margin_left => 0.3
+  #====Defining two faces document to printer
+  # doc=Document.new :paper => :A5, :duplex => true
+  #===Parameters
+  #* paper - The paper parameter can be either a Symbol or a Array. If paper parameter is a Symbol its value will search in RGhost::Constants::Papers .  If paper parameter is a Array(with two numeric elements) will be position [0] width and [1] height of page. Example:
+  #   doc=Document.new :paper => :A3   #=> Build new A3 paper
+  #   doc=Document.new :paper => [5,5] #=> Build new custom paper 5x5, using default unit defined in RGhost::Config::GS[:unit].
+  #
+  #====Configuration options:
+  #* <tt>:landscape</tt> -  If set to true will invert width to height and height to width.
+  #* <tt>:margin</tt> - Specifies margins non-printable area. It can be one Numeric for all margins or Array [top,right,bottom,left] margins.
+  #* <tt>:duplex</tt> - Specifies two faces(for print)
+  #* <tt>:tumble</tt> - Specifies kind of duplex
+  #
+  #
+  def initialize(paper=:A4, options={})
+    
+    @options=DEFAULT_OPTIONS.merge(options)
+    @paper=paper  
+  end 
+  
+  def ps
+    d=format_duplex
+    p=format_paper[:rg]
+    m=format_margin
+
+    lib=RGhost::Load.library :paper
+    
+    d<< p << m << lib.ps    
+  end 
+
+  
+  def gs_paper #:nodoc:
+    fp=format_paper
+    p=fp[:gs]
+    #["-dDEVICEWIDTHPOINTS=#{p[0]}", "-dDEVICEHEIGHTPOINTS=#{p[1]}"]
+    if fp[:done]
+      ["-dDEVICEWIDTHPOINTS=#{p[0]}", "-dDEVICEHEIGHTPOINTS=#{p[1]}"]
+    else
+      ["-dDEVICEWIDTHPOINTS=#{to_pt(p[0])}", "-dDEVICEHEIGHTPOINTS=#{to_pt(p[1])}"]
+    end
+  
+  end
+
+
+  private
+  
+  def to_pt(value)
+    
+    
+    return case RGhost::Config::GS[:unit].new
+    when RGhost::Units::Cm then (value.to_f*72/2.545).to_i
+    when RGhost::Units::Inch then (value.to_f*72).to_i
+    else
+      value
+    end
+    
+  end
+  def format_margin
+    #if @options[:margin]
+    #  mt=mr=mb=ml=RGhost::Units::parse(@options[:margin])
+    #else
+    #  mt=RGhost::Units::parse(@options[:margin_top])
+    #  mr=RGhost::Units::parse(@options[:margin_right])
+    #  mb=RGhost::Units::parse(@options[:margin_bottom])
+    #  ml=RGhost::Units::parse(@options[:margin_left])
+    #end
+     
+    case @options[:margin]
+    when Numeric then mt=mr=mb=ml=RGhost::Units::parse(@options[:margin])
+    when Array then
+        mt=RGhost::Units::parse(@options[:margin][0] || DEFAULT_OPTIONS[:margin_top] )
+      mr=RGhost::Units::parse(@options[:margin][1] || DEFAULT_OPTIONS[:margin_right])
+      mb=RGhost::Units::parse(@options[:margin][2] || DEFAULT_OPTIONS[:margin_bottom])
+      ml=RGhost::Units::parse(@options[:margin][3] || DEFAULT_OPTIONS[:margin_left] )
+    when Hash,NilClass
+      mt=RGhost::Units::parse(@options[:margin_top   ] || DEFAULT_OPTIONS[:margin_top] )
+      mr=RGhost::Units::parse(@options[:margin_right ] || DEFAULT_OPTIONS[:margin_right])
+      mb=RGhost::Units::parse(@options[:margin_bottom] || DEFAULT_OPTIONS[:margin_bottom])
+      ml=RGhost::Units::parse(@options[:margin_left  ] || DEFAULT_OPTIONS[:margin_left] )
+    end
+    
+    "/margin 3 dict def margin begin /top #{mt} def /right #{mr} def /bottom #{mb} def /left	#{ml} def end\n"
+  end
+  
+  def format_paper
+
+    case @paper
+    when Symbol then 
+     
+        p=RGhost::Constants::Papers::STANDARD[@paper.to_s.downcase.to_sym]
+      p.reverse! if @options[:landscape] 
+      {:rg => "/pagesize #{to_array( p  ) } def\n", :gs => p, :done => true}
+    when Array then
+        @paper.reverse! if @options[:landscape] 
+      {:rg => "/pagesize #{to_array( @paper.map{|v| to_pt(v) } ) } def\n", :gs => @paper, :done => false}
+    end
+    
+    
+  end
+  
+  
+  def format_duplex
+    "\n<< /Duplex #{@options[:duplex]} /Tumble #{@options[:tumble]} >> setpagedevice\n"
+  end
+  
+end
+
+#puts Paper.new(:A4, :landscape => true, :duplex => true, :margin=> [2,3,4,5])

data/lib/rghost/parse_text.rb

@@ -0,0 +1,53 @@
+
+module RGhost::ParseText #:nodoc:
+  
+  def text_to_ps
+    
+    unless @tag_parse
+      case @options[:text_align]
+      when :center, :right then
+        @text.split(/\n/).map{|l| "#{to_string(l)} :text_proc_cr :nbw " }.to_s  
+        jump_with=':nbw'
+      when :left,nil then
+        if self.class == RGhost::Text
+          return @text.split(/\n/).map{|l| " :text #{to_string(l)} :text_proc nrdp " }.to_s 
+
+        else
+          @text.split(/\n/).map{|l| " :text_area #{to_string(l)} :text_proc_cr :nbw " }.to_s        
+          jump_with='nrdp'
+        end
+      end
+    end
+    
+    
+    
+    jump_with=':nbw' if self.class == RGhost::TextArea        
+    
+    
+    ret=@text.split(/<br\/?>|\n/).map do |piece|
+      text_ok=""
+      piece.scan(/<([^>]+)>([^<]*.)<\/\1>|([^<>]+)/).each do |t|
+        t.compact!
+        if t && t.size == 1
+          text_ok << ta_entry(t.first.to_s)
+        else
+          text_ok << ta_entry(t[1],t.first)
+        end
+      end
+      text_ok
+    end
+    
+    ret.join(" #{jump_with || 'nrdp' } ").gsub(/&lt/,'<').gsub(/&gt/,'>')
+  end
+
+  def ta_entry(e,tag="default_font")
+    if self.class == RGhost::Text and  @options[:text_align] == :left
+      " :text _#{tag} #{to_string(e)} :text_proc "  
+    elsif self.class == RGhost::TextArea and @options[:text_align] == :left
+      " :text_area _#{tag} #{to_string(e)} :text_proc "  
+    else
+      "  _#{tag} #{to_string(e)} :text_proc_cr "  
+    end
+  end
+
+end