gerbilcharts 0.0.3

data/lib/gerbilcharts/surfaces/tracker.rb

@@ -0,0 +1,62 @@
+module GerbilCharts::Surfaces
+
+
+# = Tracker (allows mouse selection of timearea)
+# This sets up the hooks to interact with the gerbil.js Javascript file
+# 
+class Tracker < GraphElement
+    
+    
+    def initialize(opts={})
+      super
+    end
+    
+    def int_render(dc)
+      
+      dc.addshape(SVGCustomWin.new("GerbilTracker",self))
+      
+    end
+    
+    # render the elements directly
+    def render_direct(xfrag)
+    
+      # calculate scaling factors
+      rx = parent.modelgroup.effective_round_range_x
+      
+      # output the SVG fragment directly
+      xfrag.g(:id => 'gtrackerpanel') {
+            xfrag.rect(:id=>"trackerpanel", :class=>"trackerpanel", 
+                       :height=>@bounds.height, :width=>@bounds.width, :x=>@bounds.left, :y=>@bounds.top, 
+                       :onmousedown=>"TrackerMouseDown(evt)", 
+                       :onmousemove=>"TrackerMouseMove(evt)", 
+                       :onmouseup=>"TrackerMouseUp(evt)")
+      }
+      
+      xfrag.g(:id=> 'gtrackerrect', :visibility=>'hidden') {
+             xfrag.rect(:id=>"trackerrect", :class=>"trackerrect", 
+                       :height=>parent.anchor.bounds.height, :width=>30, :x=>100, :y=>parent.anchor.bounds.top)     
+      }
+      
+      ty = parent.anchor.bounds.height/2
+      xfrag.g(:id=> 'gtrackertext', :visibility=>'hidden', :transform => "translate(200 50)") {
+        xfrag.text( :class => 'trackertextinterval', :id=>'trackertextbox', "text-anchor" => 'middle' ) {
+            xfrag.tspan( :id => 'trackertextinterval', :x=>0, :y=>ty) {
+                "15 Minutes"
+            }
+            xfrag.tspan( :class => 'trackertextfromts', :id => 'trackertextfromts', :x=>0, :dy=>15) {
+                "Starting: Apr 2 1973, 05:00:00 PM"
+            }
+        }
+      }
+      
+      xfrag.g(:id=>"gtrackerdata",  
+              :gerb_fromts=>rx.rmin,  
+              :gerb_scale =>(rx.delta)/parent.anchor.bounds.width,
+              :gerb_selts=>"1",
+              :gerb_selsecs=>"1")
+      
+    end
+    
+  end  
+
+end

data/lib/gerbilcharts/surfaces/vertical_axis.rb

@@ -0,0 +1,46 @@
+module GerbilCharts::Surfaces
+
+# =VerticalAxis
+# Mostly contains rounded Y-values
+#
+class VerticalAxis < Axis
+
+  attr_reader 	:use_cumulative_y		# use the cumulative (sum of all models) range
+
+  def initialize(opts={})
+      @class = "vaxis"
+      super(opts)
+
+	  @use_cumulative_y = false 
+	  @use_cumulative_y = opts[:cumulative] if opts[:cumulative]
+    end
+    
+  def int_render(g)
+      
+      g.rectangle_r(@bounds, {:class => @class})
+      
+      return if parent.modelgroup.empty?
+      
+	  if @use_cumulative_y
+        ry = parent.modelgroup.cumulative_sweep_round_range_y0
+	  else
+      	ry = parent.modelgroup.effective_round_range_y0
+	  end
+
+      ry.each_label do |val,label|
+          yp = scale_y val,ry
+          yp_label=yp
+          
+          # make sure the edge ones are visible
+          yp_label = max(yp_label,@bounds.top+10)
+          
+          g.textout(@bounds.right-4, yp_label, label, {:class => "axislabel", "text-anchor" => "end"})
+          g.line(@bounds.right-3,yp,@bounds.right+2,yp, {:class => "axistickmajor"})
+      end
+
+  end
+
+end
+
+end
+

data/lib/gerbilcharts/svgdc.rb

@@ -0,0 +1,22 @@
+# == GerbilCharts svg helper library
+#
+# Various helpers that make it easy to work with SVG
+#
+
+
+module GerbilCharts::SVGDC;end;
+
+require 'gerbilcharts/svgdc/svgdc'
+require 'gerbilcharts/svgdc/svg_element'
+require 'gerbilcharts/svgdc/filters'
+require 'gerbilcharts/svgdc/transformations'
+require 'gerbilcharts/svgdc/presentation_attributes'
+require 'gerbilcharts/svgdc/svg_win'
+require 'gerbilcharts/svgdc/svg_custom_win'
+require 'gerbilcharts/svgdc/svg_shape'
+require 'gerbilcharts/svgdc/svg_circle'
+require 'gerbilcharts/svgdc/svg_line'
+require 'gerbilcharts/svgdc/svg_polygon'
+require 'gerbilcharts/svgdc/svg_polyline'
+require 'gerbilcharts/svgdc/svg_rect'
+require 'gerbilcharts/svgdc/svg_text'

data/lib/gerbilcharts/svgdc/filters.rb

@@ -0,0 +1,40 @@
+module GerbilCharts::SVGDC
+
+
+# =Filters
+# Various SVG filters (eg, gradients, light). You can attach
+# this to any SVG element
+#
+class Filter
+
+  attr_reader :filterid
+  
+  def initialize(id,opts={})
+    @filterid=id
+  end
+  
+  def render(xfrag)
+  end
+  
+
+end
+
+# == LinearGraidentVertical
+# A preset filter
+class LinearGradientVertical < Filter
+  def initialize(id,fromclr, toclr, opts={})
+    super(id,opts)
+    @from_color=fromclr
+    @to_color=toclr
+  end
+  
+  def render(xfrag)
+      xfrag.linearGradient(:id => @filterid, :x1=>"0%", :y1=>"0%",:x2=>"0%",:y2=>"100%") {
+          xfrag.stop(:offset=>"0%", :style=>"stop-color:#{@from_color}")
+          xfrag.stop(:offset=>"100%", :style=>"stop-color:#{@to_color}")
+     }
+  end
+  
+end
+
+end

data/lib/gerbilcharts/svgdc/presentation_attributes.rb

@@ -0,0 +1,50 @@
+module GerbilCharts::SVGDC
+
+# = PresentationAttribute
+# Wrappers around some simple attributes like Pen and Brush
+# For more complex ones, you can just attach the SVG definition to the object you are drawing
+#
+class PresentationAttribute
+  
+ attr_reader :color
+  
+ def initialize(opt) 
+   @color=opt[:color]  if defined? opt[:color] 
+ end
+  
+end
+
+
+class PPen < PresentationAttribute
+  
+  attr_reader :width
+  
+  def initialize(opt={})
+      super opt
+      @width=opt[:width]  if defined? opt[:width] 
+  end
+
+  def render
+    h={}
+    h.store("stroke",       @color) if  @color
+    h.store("stroke-width", @width) if  @width
+    h
+  end
+  
+end
+
+class PBrush < PresentationAttribute
+  
+    def initialize(opt={})
+      super opt
+    end
+    
+    def render
+      h={}
+      h.store("fill",       @color) if  @color
+      h
+    end
+end
+
+end
+

data/lib/gerbilcharts/svgdc/svg_circle.rb

@@ -0,0 +1,22 @@
+module GerbilCharts::SVGDC
+
+# = SVGCircle 
+# Draws a circle at x, y, and radius r
+#
+class SVGCircle < SVGShape
+  
+  attr_accessor :x,:y,:r
+  
+  def initialize(x,y,r)
+    @x,@y,@r=x,y,r
+    super()
+  end
+  
+  def render(xfrag)
+    h = { :cx => @x, :cy => @y, :r => @r }
+    xfrag.circle(h.merge(render_attributes))
+  end
+  
+end
+
+end

data/lib/gerbilcharts/svgdc/svg_custom_win.rb

@@ -0,0 +1,36 @@
+module GerbilCharts::SVGDC
+
+# =SVGCustomWin
+# custom window, the supplier delegate will render the SVG directly using the Builder facilities
+# use this for complex SVG elements that cant be handled via the current simplistic GDI like operations
+#
+class SVGCustomWin < SVGWin
+
+  attr_reader   :render_delegate
+
+  def initialize(name,delegate,opts={})
+    @render_delegate=delegate
+    super(name,opts)
+  end
+
+  def <<(p)
+    raise "Cannot add children to a custom SVG Window"
+  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)) {
+        @render_delegate.render_direct(xfrag)
+    }
+  end
+end
+
+end

data/lib/gerbilcharts/svgdc/svg_element.rb

@@ -0,0 +1,87 @@
+module GerbilCharts::SVGDC
+
+#  = SVGElement
+#  Base class for all SVG shapes.
+#  Contains rendering,  and svg presentation handling code
+#  Note : the presentation as passed on as is to the SVG
+class SVGElement
+  attr_accessor    :custom_style
+  attr_reader      :presentations
+  attr_reader      :href
+  
+  
+  def initialize()
+    @presentations=Array.new
+
+	# default fill and stroke (you can override it)
+	@custom_attributes||={}
+
+  end
+
+  def has_presentations?
+    defined? @presentations
+  end
+    
+  def render_attributes
+    h={}
+
+    if has_presentations?
+      @presentations.each do |p|
+        h.merge!(p.render)
+      end
+    end
+
+    if @custom_attributes 
+      @custom_attributes.each_pair do |k,v|
+        h.store( k, v) 
+      end
+    end
+  
+    return h
+  end
+
+  def add_presentation(p)
+    @presentations << p
+  end
+  
+  def add_options(opt)
+    @custom_attributes = {} if not defined? @custom_attributes
+
+    opt.each_pair do |k,v|
+      @custom_attributes.store(k,v)
+    end
+    
+    # treat the href custom attribute separately
+    if @custom_attributes[:href]
+      @href=@custom_attributes[:href]
+      @custom_attributes.delete(:href)
+    end
+  end
+  
+  def set_id(css_id)
+    add_options(:id=> css_id)
+  end
+  
+  def set_class(css_class)
+    add_options(:class=> css_class)
+  end
+  
+  def set_href(url)
+    @href=url
+  end
+  
+  # base render allows for wrapping with a Anchor tag
+  def render_base(xfrag)
+    if @href
+      xfrag.a("xlink:href" => @href, :target => "_top") {
+        yield
+      }
+    else
+      yield
+    end
+  end
+  
+end
+
+end
+

data/lib/gerbilcharts/svgdc/svg_line.rb

@@ -0,0 +1,26 @@
+module GerbilCharts::SVGDC
+
+# = SVGLine
+# A simple svg line that honors the rendering attributes 
+#
+# See tests for examples
+#
+class SVGLine < SVGShape
+  
+  attr_reader :x1, :y1, :x2, :y2
+  
+  def initialize(x1,y1,x2,y2)
+    super()
+    @x1,@y1,@x2,@y2=x1,y1,x2,y2
+  end
+  
+  def render(xfrag)
+    fmt="%.2f"
+    h= { :x1 => fmt%@x1, :y1 => fmt%@y1, :x2 => fmt%@x2, :y2 => fmt%@y2 }
+    xfrag.line( h.merge(render_attributes))
+  end
+  
+end
+
+
+end

data/lib/gerbilcharts/svgdc/svg_polygon.rb

@@ -0,0 +1,34 @@
+module GerbilCharts::SVGDC
+
+# = SVGPolygon
+#
+# A polygon identified by the operstring. Sorry this is not the best way to do it
+# The oper string consists of M x y L x y style commands. See SVG spec.
+# todo : accept an array of coords and automatically construct the oper string
+#
+class SVGPolygon < SVGShape
+
+  attr_reader :operstring
+  
+  def initialize
+    @operstring = ""
+  end
+  
+  def addpoint(x,y)
+    # truncate to 2 significant places (cuts down SVG size)
+    xf,yf = "%.2f"%x, "%.2f"%y
+    @operstring << "#{xf},#{yf} "
+  end
+  
+  def render(xfrag)
+    h= {:points => @operstring }
+    xfrag.polygon( h.merge(render_attributes))
+  end
+  
+  def isempty?
+    return @operstring.length==0
+  end
+  
+end
+
+end

data/lib/gerbilcharts/svgdc/svg_polyline.rb

@@ -0,0 +1,27 @@
+module GerbilCharts::SVGDC
+
+# = SVGPolyLine
+# A polyline, like the polygon class 
+#
+# Send this a series of lineto messages
+#
+class SVGPolyline < SVGShape
+  
+  attr_reader :operstring
+  
+  def initialize
+    @operstring = ""
+  end
+  
+  def lineto(x,y)
+    @operstring << "#{x},#{y} "
+  end
+  
+  def render(xfrag)
+    h= {:points => @operstring }
+    xfrag.polyline( h.merge(render_attributes))
+  end
+  
+end
+
+end