gerbilcharts 0.0.3

data/lib/gerbilcharts/svgdc/svg_rect.rb

@@ -0,0 +1,29 @@
+module GerbilCharts::SVGDC
+
+# = SVGRect - a simple rectangle
+#
+class SVGRect < SVGShape
+  
+  attr_accessor :x,:y,:w, :h
+  
+
+  # x = x position
+  # y = y position
+  # w = width
+  # h = height 
+  #
+  # To create rectangle top left corner at (10,10) and width 200,height 100 do :
+  #  SVGRect.new (10,10,200,150) 
+  def initialize(x,y,w,h)
+    @x,@y,@w,@h=x,y,w,h
+    super()
+  end
+  
+  def render(xfrag)
+    h= { :x => @x, :y => @y, :width => @w, :height => @h }
+    render_base(xfrag) { xfrag.rect( h.merge(render_attributes)) }
+  end
+  
+end
+
+end

data/lib/gerbilcharts/svgdc/svg_shape.rb

@@ -0,0 +1,10 @@
+module GerbilCharts::SVGDC
+
+
+# = SVGShape 
+# Base class for all other shapes
+class SVGShape < SVGElement
+
+end
+
+end

data/lib/gerbilcharts/svgdc/svg_text.rb

@@ -0,0 +1,21 @@
+module GerbilCharts::SVGDC
+
+# = SVGText
+# A line of text 
+class SVGText < SVGElement
+   
+  attr_reader :x, :y, :str
+  
+  def initialize(x,y,str)
+    super()
+    @x,@y,@str=x,y,str
+  end
+  
+  def render(xfrag)
+    h= { :x => @x, :y => @y}
+    render_base(xfrag) { xfrag.text(@str, h.merge(render_attributes)) }
+  end
+  
+end
+
+end

data/lib/gerbilcharts/svgdc/svg_win.rb

@@ -0,0 +1,52 @@
+module GerbilCharts::SVGDC
+
+# = SVGWin
+# a conceptual window, maps to a 'g' element in the SVG spec
+# allows you to layer or nest easily
+#
+class SVGWin < SVGElement
+  attr_reader     :ops
+  attr_reader     :transforms
+
+  def initialize(name, opts={})
+
+	# add default options first
+    # by default windows will define fill = none and stroke = black
+	
+    add_options("id"=> name, "fill" => "none", "stroke" => "black" )
+
+    add_options opts
+
+    @ops=[]
+	super()
+  end
+  
+  def <<(p)
+    @ops<<p
+  end
+  
+  def add_transformation(t)
+    @transforms=Array.new unless @transforms
+    @transforms << t
+  end
+  
+  def render(xfrag)
+    h= {}
+    
+    if @transforms
+        strt=""
+        @transforms.each do |t|
+          strt << t.render
+        end
+        h.store(:transform, strt)
+    end
+    
+    xfrag.g(h.merge(render_attributes)) {
+      @ops.each do |op|
+         op.render(xfrag)
+      end    
+    }
+  end
+end
+
+end

data/lib/gerbilcharts/svgdc/svgdc.rb

@@ -0,0 +1,335 @@
+module GerbilCharts::SVGDC
+
+require 'rubygems'
+gem 'builder'
+require 'builder'
+
+# =SVGDC
+#
+# Simulates a simple Device Context like CDC in MFC/Windows
+#
+# ==  A simple example
+# Create a 500x400 window, draw a circle, draw 10 rectangles and save it !
+#
+#     g=SVGDC.new(500,400)
+#     g.circle(40,50,20)
+#     1.upto(10) do |w|
+#     		g.rectangle(80+w*4,10,10*w,45)
+#     end
+#     g.render("/tmp/tbasic1.svg")
+#
+class SVGDC
+  
+  attr_accessor     :width
+  attr_accessor     :height
+  attr_reader       :curr_win, :base_win
+  attr_reader	    :curr_presentation_context
+  attr_reader       :svg_styles
+  attr_reader       :svg_predefs
+  attr_reader       :svg_javascript
+  attr_reader       :ref_javascripts
+  attr_reader       :ajaxOptions
+  attr_reader       :ajaxContext
+  attr_reader       :use_tooltips
+  
+  def initialize(w,h)
+    @width,@height=w,h
+    @ops = Array.new
+    @curr_presentation_context={}
+    @base_win=SVGWin.new("Gerbil_Root_Window")
+    setactivewindow(@base_win)
+    @svg_predefs = [] 
+    @use_tooltips=true
+  end
+  
+  # ==Note on Stylesheet
+  # 	Searches for the stylesheet in the current directory or in the gerbilcharts/public directory
+  # 	If you want to use your own stylesheets put them in the working directory, or in the
+  # 	public directory of gerbilcharts.
+  def set_stylesheet(cssfile)
+  	if File.exists? cssfile
+	   @svg_styles=File.read(cssfile)
+	else
+	   try_from_gem = File.dirname(__FILE__) + "/../public/" + cssfile
+	   if not File.exists? try_from_gem
+	   	  p "The stylesheet #{cssfile} was not found. Make sure it exists in the current directory, or in the gem public area"
+		  raise "Stylesheet #{cssfile} not found in current directory or in the gerbilcharts/public folder"
+	   else
+	      @svg_styles=File.read(try_from_gem)
+	   end
+	end
+  end
+  
+  def add_javascriptfile(jsfile,inlined)
+    if  inlined
+      @svg_javascript = "" if @svg_javascript == nil
+      @svg_javascript << File.read(jsfile)      
+    else
+      @ref_javascripts = [] if @ref_javascripts == nil
+      @ref_javascripts << jsfile
+    end
+  end
+
+  def enable_tooltips(bval)
+    @use_tooltips=bval
+  end
+  
+  def requires_ajax_block?
+    if @ajaxOptions.nil? and @ajaxContext.nil?
+      return false
+    else
+      return true
+    end
+  end
+  
+  def requires_tooltips?
+    return @use_tooltips
+  end
+ 
+  def set_ajaxContext(h)
+    @ajaxContext=h
+  end
+  
+  def set_ajaxOptions(h)
+    @ajaxOptions=h
+  end
+  
+  def add_filter(filter)
+    @svg_predefs << filter
+  end
+  
+  # create a new window ,
+  # all subsequent operations work on this new window 
+  def newwin(name, opts={})
+    w=SVGWin.new(name, opts)
+    @curr_win << w
+    w
+  end
+  
+  def setactivewindow(w=nil)
+    @curr_win = w ? w : @base_win
+  end
+  
+  # render to XML Builder fragment
+  def render_to_frag(doc,opts)
+    
+       # if options has windowonly option, then just render the top most window 
+       if opts[:windowonly] 
+         # render contents of top window
+         doc.g(:id => "GerbilSVGGraph") {
+             @curr_win.render(doc)
+         }        
+         return
+       end
+    
+    
+       # svg base attributes
+       svg_attributes = {:xmlns => "http://www.w3.org/2000/svg", "xmlns:xlink" => "http://www.w3.org/1999/xlink", :version => "1.1", :width => @width, :height => @height}
+       if @use_tooltips
+         svg_attributes.store(:onload,"Init(evt)")
+       end
+       
+       doc.svg(svg_attributes)   {
+       
+       # stylesheet (inlined into SVG)
+       if @svg_styles
+         doc.style(@svg_styles, :type => "text/css") 
+       end
+    
+       # javascripts (ajax, etc) hrefed
+       if @ref_javascripts
+         @ref_javascripts.each do |scr|
+           doc.script(:type => "text/javascript", "xlink:href" => scr)
+         end
+       end
+    
+       # javascript inlined again
+       if @svg_javascript
+         doc.script(:type => "text/javascript") {
+            doc.cdata!(@svg_javascript)
+         }
+       end
+        
+       # defs (all image filters go here)
+       doc.defs() {
+         @svg_predefs.each do |filter|
+           filter.render(doc)
+         end
+       }
+       
+       # Ajax block (for gerbilAjax.js library)
+       if requires_ajax_block?
+         doc.g(:id => "GerbilAjaxBlock") {
+            
+            ao = {:id => "GerbilAjaxOptions"}
+            @ajaxOptions.each_pair do |k,v|
+              ao.store(k,v)
+            end
+            doc.g(ao)
+            
+            if @ajaxContext
+              ac = {:id => "GerbilAjaxContext"}
+              @ajaxContext.each_pair do |k,v|
+                ac.store(k,v)
+              end
+              doc.g(ac)
+            end
+         }
+       end
+       
+       # render contents of top window
+       doc.g(:id => "GerbilSVGGraph") {
+           @curr_win.render(doc)
+       }
+       
+       # render tooltips optional
+       if @use_tooltips
+          doc.g(:id=>'ToolTip', :opacity=>'0.8', :visibility=>'hidden', "pointer-events"=>'none') {
+              doc.rect(:id=>'tipbox', :x=>'0', :y=>'5', :width=>'88', :height=> '20', :rx=> '2', :ry=> '2', :fill=>'white', :stroke=>'black')
+              doc.text(:id=>'tipText', :x=>'5', :y=>'20', "font-family"=> 'Arial', "font-size"=>'12') {
+                doc.tspan(:id=>'tipTitle', :x=>'5', "font-weight"=>'bold') {
+                  doc.cdata!("")
+                }
+                doc.tspan(:id=>'tipDesc', :x=>'5', :dy=> 15,  "fill"=>'blue') {
+                  doc.cdata!("")
+                }
+              }
+          }
+       end
+     }      
+  end
+  
+  # render the SVG fragments to a string
+  # options
+  def render_to_string(opts={})
+   
+   # render all the elements accumulated so far
+   svg_string=""
+   doc = Builder::XmlMarkup.new(:target => svg_string, :indent => 2, :standalone => "no")
+   doc.instruct!
+   doc.declare! :DOCTYPE, :svg, :PUBLIC,"-//W3C//DTD SVG 1.1//EN","http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd"
+   
+   render_to_frag(doc,opts)
+   
+   # return the svg_string
+   return svg_string
+  end
+  
+  # render the SVG to a file
+  def render_to_file(outpath,opts={})
+    svg_string = render_to_string(opts)
+    File.open(outpath, 'w') { |file|
+       file.write(svg_string)
+    } 
+  end
+  
+  # synonym for render_to_file with no options
+  def render(opts={})
+      render_to_string(opts[:string],opts) if opts[:string]
+      render_to_file(opts[:file],opts)     if opts[:file]
+      render_to_frag(opts[:xfrag],opts)  if opts[:xfrag]
+  end
+  
+  # prime the graphics object 
+  def prime_object(gobj, opt)
+    add_selected_presentations(gobj)
+    add_options(gobj,opt)
+    gobj
+  end
+  
+  # add presentation attributes
+  def add_selected_presentations(gobj)
+    @curr_presentation_context.each do |k,v|
+      gobj.add_presentation v
+    end
+  end
+  
+  # add other options (eg, CSS class)
+  def add_options(gobj, opt)
+    gobj.add_options(opt)
+    gobj
+  end
+  
+  # add a shape directly with options
+  def addshape(shape,opt={})
+      @curr_win << prime_object(shape,opt)
+  end
+  
+  def circle(x,y,r,opt={})
+    @curr_win << prime_object(SVGCircle.new(x,y,r),opt)
+  end
+  
+  def moveto(x,y)
+    @curr_polyline=SVGPolyline.new
+    @curr_polyline.lineto(x,y)
+  end
+  
+  def lineto(x,y)
+    @curr_polyline=SVGPolyline.new if not @curr_polyline
+    @curr_polyline.lineto(x,y)
+  end
+  
+  def endline(opt={})
+    if @curr_polyline
+      @curr_win << prime_object(@curr_polyline,opt)
+    end
+    @curr_polyline=nil
+  end
+  
+  def begin_polygon
+    @curr_polygon=SVGPolygon.new
+  end
+  
+  def polygon_point(x,y)
+  	  @curr_polygon ||= SVGPolygon.new
+      @curr_polygon.addpoint(x,y)
+  end
+  
+  def end_polygon(opt={})
+      @curr_win << prime_object(@curr_polygon,opt)
+      @curr_polygon=nil
+  end
+  
+  
+  def line(x1,y1,x2,y2, opt={})
+    @curr_win << prime_object(SVGLine.new(x1,y1,x2,y2), opt)
+  end
+  
+  def textout(x,y,str, opt={})
+    @curr_win << prime_object(SVGText.new(x,y,str), opt)
+  end
+
+  # utility method
+  # 	automatically adds the 'font-family: monospace" , "stroke :none", "fill: black"
+  # 	they can all be overridden by passing in an opt
+  #
+  def textout_monospace(x,y,str,opt={})
+  	defopt = { "font-family" => "monospace", "stroke" => "none", "fill" =>  "black" }
+	defopt.merge!(opt) if opt
+
+	textout(x,y,str,defopt)
+
+  end
+
+
+  def rectangle(x,y,w,h, opt={})
+    @curr_win << prime_object(SVGRect.new(x,y,w,h), opt)
+  end
+  
+  def rectangle_r(r, opt={} )
+    rectangle(r.left, r.top, r.width, r.height, opt)
+  end
+  
+  
+  def select_presentation(opt={})
+    @curr_presentation_context.store(:pen,opt[:pen])      	if opt[:pen]
+    @curr_presentation_context.store(:brush,opt[:brush])      if opt[:brush]
+  end
+
+  def clear_presentation
+  	@curr_presentation_context = []
+  end
+  
+end
+
+end