lunks_rghost 0.8.7.6

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

data/lib/rghost/pdf_security.rb

@@ -0,0 +1,36 @@
+
+class RGhost::PdfSecurity
+  PERMISSION_VALUES={
+     :base => -4,
+     :print => -4,
+     :modify => -8,
+     :copy => -16,
+     :annotate => -32,
+     :interactive => -256,
+     :copy_access =>  -512,
+     :assemble => -1024,
+     :high_quality_print => -2048,
+     :all => -3904
+     
+   }
+   attr_accessor :owner_password,:user_password,:key_length
+  def initialize
+    @permission_value=PERMISSION_VALUES[:all]
+    @key_lenght=128
+    @owner_password="unknow"
+    @user_password="unknow"
+  end
+  def disable(*permissions)
+    @permission_value=permissions.map{|p| PERMISSION_VALUES[p] }.inject(0){|n,i| i+=n}
+  end
+  def gs_params
+    "-sOwnerPassword##{clear_space(@owner_password)} -sUserPassword##{clear_space(@user_password)} -dEncryptionR#3 -dKeyLength##{@key_lenght} -dPermissions##{@permission_value}"
+  end
+  private
+  
+  def clear_space(value)
+    value.to_s.gsub(/([^\w])/,'')
+  end
+end
+
+

data/lib/rghost/point.rb

@@ -0,0 +1,23 @@
+require "rghost/ps_object"
+require "rghost/units"
+
+#Creates one point using default unit defined in RGhost::Config::GS[:unit]
+class RGhost::Point < RGhost::PsObject
+  attr_accessor :x,:y
+  
+  def initialize(x,y)
+    if x.is_a? Hash
+      point=x
+      @x,@y=point[:x],point[:y]
+    else
+      @x,@y=x,y
+    end
+  end
+
+  def ps
+    "#{RGhost::Units::parse(@x)} #{RGhost::Units::parse(@y)} "
+  end
+  
+
+end
+

data/lib/rghost/point_with_command.rb

@@ -0,0 +1,17 @@
+require "rghost/ps_object"
+require "rghost/units"
+
+class RGhost::PointWithCommand #:nodoc:
+  DEFAULT_POINT={:x => :limit_left , :y => :current_row}
+
+  def self.to(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/polygon.rb

@@ -0,0 +1,75 @@
+#Draw one shape based in relative node points.
+#===Options
+#
+#* <tt>:x and :y</tt> - Initial position.
+#* <tt>:content</tt> - Facade to ShapeContent with same parameters.
+#* <tt>:border</tt> - Facade to Border with same parameters.
+#===Examples
+# 
+# doc.polygon :x => 3.5, :y => 5.5 do
+#   node :x => 4,  :y => 0
+#   node :x => 0,  :y => -4
+#   node :x => -4, :y => 0
+#   node :x => 0,  :y => 4
+# end
+#
+#link:images/polygon01.png
+#
+# doc.polygon :x => 3.5, :y => 4.5 do
+#   node :x => 2,  :y => 2
+#   node :x => 2,  :y => -2
+#   node :x => -2, :y => -2
+# end
+#
+#link:images/polygon02.png
+#
+# doc.polygon :x => 1, :y => 5, :border => {:width => 2, :linejoin => 1} do
+#   node :x => 2,  :y => 2/2
+#   node :x => 2*2,:y => -2
+#   node :x => -1, :y => -3
+#   node :x => 2,  :y => 1
+#   node :x => 3,  :y => 2
+# end
+#
+#link:images/polygon03.png
+class RGhost::Polygon < RGhost::PsObject
+  attr_reader :points
+  
+  DEFAULT_OPTIONS={
+    :x => :limit_left,
+    :y => :current_row,
+    :content => RGhost::ShapeContent::DEFAULT_OPTIONS,
+    :border =>  RGhost::Border::DEFAULT_OPTIONS
+    
+    
+  }
+  def initialize(options={},&block)
+    super(''){}
+    
+    @options = DEFAULT_OPTIONS.dup.merge(options)
+    @points=[] 
+    instance_eval(&block) if block
+  end
+  #Creates new relative point by :x => 2 and :y => 4. Used as instance_eval
+  def node(point)
+    @points << point
+  end
+  
+  def ps
+    graph=RGhost::Graphic.new 
+    graph.set RGhost::Cursor.moveto(@options)
+    graph.set RGhost::Border.new(@options[:border]) if @options[:border]
+    
+    @points.each{|p|  graph.set RGhost::Line.rlineto(p) }
+    
+    graph.raw :closepath
+    #graph.raw :gsave
+    graph.set RGhost::ShapeContent.new(@options[:content]) if @options[:content]
+    #graph.raw :grestore
+    graph.raw :stroke
+    graph
+        
+    
+  end
+  
+end