lunks_rghost 0.8.7.6

data/lib/rghost/ps/row.ps

@@ -0,0 +1,4 @@
+/row_height 0.4 unit def 
+/row_padding 0.1 unit def 
+/row 1 def
+/current_row 0 def

data/lib/rghost/ps/show.ps

@@ -0,0 +1,21 @@
+/show_center{ dup stringwidth pop 2 div neg 0 rmoveto show } def
+/show_right{ dup stringwidth pop neg 0 rmoveto show } def
+/show_left{ show }def
+
+%%TODO: page_(center & left & right)
+
+/page_center{
+area_x 2 div margin /left get add current_row moveto
+dup stringwidth pop 2 div neg 0 rmoveto show
+} def
+
+/page_right{
+area_x margin /left get add current_row moveto
+dup stringwidth pop neg 0 rmoveto show
+} def
+
+/page_left{
+limit_left current_row moveto
+%dup stringwidth pop neg 0 rmoveto
+ show
+} def

data/lib/rghost/ps/table_callbacks.ps

@@ -0,0 +1,96 @@
+%%TABLE
+/before_table_create {} def
+/after_table_create{} def
+%%%%%%TABLE ROW---------------------
+
+/row_odd_or_even {
+	current_table_row odd? {odd_row}{even_row} ifelse
+}def
+/before_row_create 3 dict def before_row_create begin
+ 		/proc { } bind def
+ 		/except [ ] def
+ 		/only [  ] def
+end
+
+/odd_row 3 dict def odd_row begin
+ 		/proc {  } bind def
+ 		/except [  ] def
+ 		/only [   ] def
+end
+
+/even_row 3 dict def even_row begin
+ 		/proc { } bind def
+ 		/except [ ] def
+ 		/only [ ] def
+end
+
+%column
+/col_odd_or_even {
+	col odd? {odd_column}{even_column} ifelse
+}def
+
+/before_column 3 dict def before_column begin
+ 		/proc {  } bind def
+ 		/except [ ] def
+ 		/only [  ] def
+end
+
+/after_column 3 dict def 	after_column begin
+ 		/proc { } bind def
+ 		/except [ ] def
+ 		/only [ ] def
+end
+
+/odd_column 3 dict def 	odd_column begin
+ 		/proc {   } bind def
+ 		/except [  ] def
+ 		/only [ ] def
+end
+
+/even_column 3 dict def even_column begin
+ 		/proc {  } bind def
+ 		/except [ ] def
+ 		/only [ ] def
+end
+
+%%HEADER----------------------
+/before_header_create {} def
+/after_header_create {} def
+
+/before_column_header 3 dict def before_column_header begin
+ 		/proc { } bind def
+ 		/except [ ] def
+ 		/only [ ] def
+end
+
+/after_column_header 3 dict def 	after_column_header begin
+ 		/proc {  } bind def
+ 		/except [ ] def
+ 		/only [ ] def
+end
+
+%%ROW CALLBACKS
+/callback_row{
+dup dup
+ /except get length 0 ne { /except get current_table_row include? not}{
+     dup /only get length 0 ne { /only get current_table_row include?}{
+				pop true
+     }ifelse
+ }ifelse
+ { /proc get exec  }{
+   pop 
+ }ifelse
+} bind def
+
+%%COLUMN CALLBACKS
+/callback_col{
+dup dup
+ /except get length 0 ne { /except get col include? not}{
+     dup /only get length 0 ne { /only get col include?}{
+				pop true
+     }ifelse
+ }ifelse
+ { /proc get exec  }{
+   pop 
+ }ifelse
+} bind def

data/lib/rghost/ps/text.ps

@@ -0,0 +1,63 @@
+/:rh{ row_height } def
+/append{
+  dup cvx exec  3 -1 roll _concat ( ) _concat def
+} def
+
+/_concat { exch dup length    
+  2 index length add string    
+  dup dup 4 2 roll copy length
+  4 -1 roll putinterval
+} def  
+
+
+/:text{
+  /:space ( ) def
+  /:nw{ 	search false eq { /:last true def  } if strlen :this_or_next }def 
+  /:last false def
+  /:this_or_next{  X add limit_right le { show }{ nrdp show} ifelse :space show  } def
+} def
+
+
+/:text_area {
+	/:nbw{ currentpoint :rh sub exch pop 0 exch moveto } def
+	/:space ( ) def
+	/:this_or_next{  X add :bw le { show }{ :nbw show } ifelse :space show } def
+	/:nw{ 	search false eq { /:last true def  } if strlen :this_or_next }def 
+	/:last false def
+} def
+
+/:text_proc{:space { :nw :last {exit} if  } loop   /:last false def } def  
+
+/:last false def
+
+/:nbw{ 0 Y :rh sub moveto } def 
+
+/text_disp { 
+	text_align /center eq {	
+		:bw 2 div Y moveto
+		strlen 2 div neg 0 rmoveto show
+    %show
+	}{
+		:bw Y moveto
+		 strlen neg 0 rmoveto show
+    
+	}ifelse
+ } def
+/:text_proc_cr { 
+	/curstr () def
+	{ 
+		( ) search false eq /:last exch def  
+		:last false eq { 
+		  exch pop curstr stringwidth pop ( ) stringwidth pop sub  :bw le { 
+			  /curstr append
+			}{
+			  curstr text_disp ( ) _concat /curstr exch def
+        :nbw
+			} ifelse
+		}{
+			/curstr append curstr text_disp :nbw  
+      exit
+		} ifelse
+	} loop
+	/:last false def
+}def

data/lib/rghost/ps/textarea.ps

@@ -0,0 +1,11 @@
+/textarea_defaults {
+  /space ( ) def
+  /spacecount { 0 exch ( ) { search { pop 3 -1 roll 1 add 3 1 roll } { pop exit } ifelse } loop } def
+  /ssp { space search pop } def
+  /dsp { dup stringwidth pop } def
+  /cpp { currentpoint pop } def
+  /S { dup spacecount {ssp dsp cpp add rm gt { L s s }{ s s } ifelse } repeat pop } def
+  /n { show newline } def /s { show } def /L {  newline} def
+  /centre { dup stringwidth pop 2 div rm 2 div exch sub lm add tm moveto } def
+  /c{ centre n} def
+} def

data/lib/rghost/ps/type.ps

@@ -0,0 +1 @@
+%!

data/lib/rghost/ps/unit.ps

@@ -0,0 +1,3 @@
+/cm { 72 mul 	2.545 div } def
+/inch{ 72 mul } def
+/unit{ cm } def

data/lib/rghost/ps/vertical_line.ps

@@ -0,0 +1,12 @@
+/vertical_line{ exch  current_row moveto 0 exch neg rlineto stroke  } def
+/vlr {
+	gsave
+		0 row_height rlineto
+    stroke
+	grestore
+} def
+/vlrf { 
+    X Y row_padding sub moveto
+		0 row_height row_padding add rlineto
+    stroke
+} def

data/lib/rghost/ps/virtual_pages.ps

@@ -0,0 +1,55 @@
+
+%vp = virtual_page
+/current_vp 1 def
+/has_vp? false def 
+/col_size 18 cm def
+/vp_params [ [1 10] [1 20] [1 30]] def 
+/vp_count vp_params length def 
+/source_limit_left limit_left def
+/source_limit_right limit_right def
+/limit_right limit_left col_size add def
+/col_margin 2 cm def
+
+/next_page{
+  has_vp?{ (ok has virtual page, stopping) print 
+    
+    /row 1 def
+    /new_page? true def
+        
+      current_vp 2 eq {
+        /current_vp 0 def 
+        showpage 
+        
+       /limit_left source_limit_left def 
+      /limit_right limit_left col_size add def
+
+      }{
+        /limit_left col_size col_margin add def 
+        /limit_right limit_left col_size add def
+        } ifelse 
+      /current_vp inc
+      /current_row limit_top row row_height mul sub def
+      
+      new_current_row_point
+      default_point 
+      
+
+  }{
+      after_page_create callback
+      %(Page: ) print	current_page 8 string cvs print (\n) print
+
+      showpage
+      /new_page? true def
+
+      /current_page inc
+      /current_row limit_top row row_height mul sub def
+      %before_page_create callback
+      %odd_or_even callback
+      current_page count_pages eq { last_page } if
+      new_current_row_point
+      default_point 
+      before_page_create callback
+      odd_or_even callback
+  }ifelse
+
+} def

data/lib/rghost/ps_facade.rb

@@ -0,0 +1,253 @@
+[:ps_object, :dynamic_document_callback,:static_document_callback, :paper, :load,
+:cursor,:show, :color, :graphic, :newpath, :line,  :parse_text,:line_width, :textarea, 
+:variable, :eps, :jpeg, :gif, :text_in, :text_link_in, :ruby_ghost_engine, :convert,
+:text, :dash, :border, :shape_content,  :vertical_line, :horizontal_line, 
+:frame, :polygon, :circle, :how_to, :rectangle_link].each{|lib| require "rghost/#{lib}" }
+
+
+#PsFacade is just a big facade involving an instance of most postscript objects.
+class RGhost::PsFacade < RGhost::PsObject
+  attr_reader :rows
+  
+  def initialize #(&block)
+    super(""){}
+    @rows=0
+    yield self if block_given?
+    #instance_eval(&block) if block
+  end
+  
+  #A facade for the method Cursor.next_row
+  def next_row
+    @rows+=1
+    set RGhost::Cursor.next_row
+  end
+  
+
+  #Close path of the graphic state
+  def closepath
+    call :closepath
+  end
+  
+  #A facade for the method Cursor.next_page
+  def next_page
+    set RGhost::Cursor.next_page
+  end
+
+  #A facade for the class Graphic
+  def graphic(&block)
+    psfc=RGhost::PsFacade.new
+    yield psfc
+    raw :gsave
+    set psfc
+    raw :grestore
+
+  end
+
+  #A facade for the class NewPath
+  def newpath(&block)
+    psfc=RGhost::PsFacade.new
+    yield psfc
+    raw :newpath
+    set psfc
+    raw :closepath
+    #set RGhost::NewPath.new(&block)
+  end
+
+  #A facade for the method Cursor.showpage
+  def showpage
+    
+    set RGhost::Cursor.showpage
+    
+  end
+  #A facade for the class LineWidth
+  def line_width(value=nil)
+    set RGhost::LineWidth.new(value)
+  end
+  
+  #A facade for the method Cursor.goto_row
+  def goto_row(row)
+    
+    set RGhost::Cursor.goto_row(row)    
+  end
+
+  #A facade for the method Cursor.jump_rows
+  def jump_rows(row)
+    @rows+=row
+    set RGhost::Cursor.jump_rows(row)
+  end 
+  
+  #A facade for the method Cursor.rotate
+  def rotate(angle) 
+    set RGhost::Cursor.rotate(angle)
+  end
+  #A facade for the method Cursor.moveto
+  def moveto(point={})
+    set RGhost::Cursor.moveto(point)
+  end
+  
+  #A facade for the method Cursor.rmoveto
+  def rmoveto(point={})
+    set RGhost::Cursor.rmoveto(point)
+  end
+
+  #A facade for the method Cursor.translate
+  def translate(point={})
+    set RGhost::Cursor.translate(point)
+  end
+   
+  #A facade for the class DSCEntry
+  def dsc_entry(&block)
+    set RGhost::DSCEntry.new(&block)
+  end
+ 
+  #Use tag  after defined in define_tags
+  def use_tag(tag_name)
+    raw "_#{tag_name}"
+  end
+  
+  #A facade for the class Image.for
+  def image(path,options={})
+    set RGhost::Image.for(path,options)
+  end
+  
+  #alias horizontal_line
+  def hl(valign=:middle,options={})
+    set RGhost::HorizontalLine.new(valign,options)
+  end
+  
+  #A facade for the class HorizontalLine
+  def horizontal_line(valign=:middle,options={})
+    hl(valign,options)
+  end
+
+  #A facade for the method Frame.background_row
+  def background_row(options={})
+    set RGhost::Frame.background_row(options)
+  end
+  
+  #A facade for the class Scale
+  def scale(sx,sy)
+    set RGhost::Scale.new(sx,sy)
+ 
+  end
+  
+  #A facade for the method Scale.zoom
+  def zoom(percent)
+    set RGhost::Scale.zoom(percent)
+  end
+  
+  #A facade for the class TextIn
+  def text_in(options={})
+    set RGhost::TextIn.new(options)
+  end
+  
+  #A facade for the class TextLinkIn
+  def text_link(label,options={})
+     options[:label]=label
+    set RGhost::TextLinkIn.new(options)
+  end
+  
+  #A facade for the class Text
+  def text(text,tag_parse=true)
+    set RGhost::Text.new(text.to_s,tag_parse)  
+  end
+    
+  #A facade for the class Show
+  def show(text,align={ :align=> :show_left })
+    set RGhost::Show.new(text.to_s,align)  
+  end
+  
+  def show_next_row(text,align={ :align=> :show_left })
+    next_row
+    show(text,align)
+  end
+  #Alias for show
+  def write(text,align={ :align=> :show_left })
+    show(text.to_s,align)  
+  end
+  #Allows call template after it definition.
+  def use_template(name)
+    call "_#{name}"
+  end
+  
+  #Call internal function by name
+  def use_function(name)
+    call "_#{name}"
+  end
+  
+  #A facade for the class TextArea
+  def text_area(text,options={},tag_parse=true)
+    ta=RGhost::TextArea.new(text,options,tag_parse)
+    raw ta.ps
+    ta
+  end
+
+  #A facade for the class VerticalLine
+  def vertical_line(options={:start_in => :limit_left, :size => :area_y})
+    set RGhost::VerticalLine.new(options)
+  end
+  
+  #A facade for the method VerticalLine.row
+  def vertical_line_row(border_options=RGhost::Border::DEFAULT_OPTIONS)
+    set RGhost::VerticalLine.row(border_options)
+  end
+  
+  #Forces draw shapes
+  def stroke
+    
+    call :stroke
+  end
+ 
+  #A facade for the method Line.lineto
+  def lineto(point={})
+    set RGhost::Line.make_command(:lineto,point)
+  end
+  
+  #A facade for the method Line.rlineto
+  def rlineto(point={})
+    set RGhost::Line.make_command(:rlineto,point)
+  end
+
+  #A facade for the class Dash
+  def dash(options={})
+    set RGhost::Dash.new(options)
+  end
+  
+  #A facade for the method Color.create
+  def color(options)
+    set RGhost::Color.create(options)
+  end
+  
+  #A facade for the class Border
+  def border(options={})
+    set RGhost::Border.new(options)
+  end
+  
+  #A facade for the class ShapeContent
+  def shape_content(options={})
+    set RGhost::ShapeContent.new(options)
+  end
+  
+  #A facade for the class Frame
+  def frame(options)
+    set RGhost::Frame.new(options)
+  end
+  #A facade for the class Polygon
+  def polygon(options={},&block)
+    set RGhost::Polygon.new(options,&block)
+  end
+  
+  #A facade for the class Circle
+  def circle(options={})
+    set RGhost::Circle.new(options)
+  end
+
+  #A facade for the class RectangleLink
+  def rectangle_link(options={})
+    set RGhost::RectangleLink.new(options)
+  end
+
+  
+end
+
+

data/lib/rghost/ps_object.rb

@@ -0,0 +1,55 @@
+#Postscript wrapper class
+class RGhost::PsObject
+  
+  #Creates new instance of PsObject. Example
+  #   PsObject.new("/my_proc { 33 45 2 10 sub mul div} bind def") 
+  #Or by block code
+  #   PsObject.new do
+  #     set PsObject.new("(A test) show")
+  #     raw "(Other Test in raw) show "
+  #   end
+  def initialize(body="",&block)
+    @body=if body.is_a? RGhost::PsObject
+      body.ps
+    else
+      "#{body} "
+    end
+    
+    instance_eval(&block) if block
+    
+  end
+  #Alias for ps.
+  def to_s
+    ps
+  end
+  #Gets postscript code.
+  def ps
+    @body.to_s
+  end
+  #Pushes elements on the stack.
+  def raw(*value)
+    @body << "#{value.join(' ')} "
+  end 
+  #Freezes graphic state
+  def graphic_scope
+    "beging #{self} endg "
+  end
+  #Sets PsObject into this object.
+  def set(value)
+
+    raise TypeError.new("can't convert #{value.class} into PsObject") unless value.is_a? RGhost::PsObject
+    @body << "#{value.ps} "
+    value
+  end
+  #Alias for set
+  def <<(value)
+    set value
+   
+  end
+  
+  #Call operator in the stack
+  def call(name)
+    set RGhost::PsObject.new(name)
+  end  
+   
+end

data/lib/rghost/rectangle_link.rb

@@ -0,0 +1,65 @@
+#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::RectangleLink < RGhost::PsObject
+	include RGhost::RubyToPs
+  DEFAULT_OPTIONS={
+    :x => :limit_left,
+    :y => :current_row,
+    :width => 5,
+    :height => 3.5,
+    :url => "http://rghost.rubyforge.org",
+    :border_color => RGhost::Border::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])
+    url=@options[:url]
+    scolor=RGhost::Color.create(@options[:border_color]).ps.gsub(/setrgbcolor/,'')
+		"/:rect_color [#{scolor}] def /:rect_x #{x} def /:rect_y #{y} def /:rect_w #{w} def /:rect_h #{h} def /:rect_uri #{to_string(url)} def :rect_link"
+    
+    
+  end
+  
+end