rubyvis 0.1.3 → 0.1.4

data/lib/rubyvis/layout/stack.rb

@@ -0,0 +1,228 @@
+module Rubyvis
+  class Layout
+  def self.Stack
+    Rubyvis::Layout::Stack
+  end
+  class Stack < Rubyvis::Layout
+    @properties=Panel.properties.dup    
+    
+    attr_accessor :_x, :_y, :_values, :prop
+    attr_accessor_dsl :orient,:offset, :order, :layers
+    def self.defaults
+      Stack.new.extend(Layout.defaults).orient("bottom-left").offset("zero").layers([[]])
+    end
+    def initialize
+      super
+      @none=lambda {nil}
+      @prop = {"t"=> @none, "l"=> @none, "r"=> @none, "b"=> @none, "w"=> @none, "h"=> @none}
+      @values=nil
+      @_x=lambda {return 0}
+      @_y=lambda {return 0}
+      @_values=pv.identity
+    end
+    def x(f)
+      @_x=pv.functor(f)
+      return self
+    end
+    def y(f)
+      @_y=pv.functor(f)
+      return self
+    end
+    def values(f=nil)
+      if f.nil?
+        @values
+      else
+        @_values=pv.functor(f)
+        return self
+      end
+    end
+    
+    
+    def proxy(name)
+      that=self
+      return lambda {
+        a=that.prop[name].js_call(self, self.parent.index, self.index);
+        puts "proxy(#{name}): #{a}" if $DEBUG
+        a
+      }
+    end
+    
+    def build_implied(s)
+      # puts "Build stack" if $DEBUG
+      panel_build_implied(s)
+      data = s.layers
+      n = data.size
+      m = nil
+      orient = s.orient
+      if orient =~/^(top|bottom)\b/
+        horizontal=true
+      else
+        horizontal=false
+      end
+      h = self.parent.send(horizontal ? "height" : "width")
+      x = []
+      y = []
+      dy = []
+      
+      #
+      # Iterate over the data, evaluating the values, x and y functions. The
+      # context in which the x and y psuedo-properties are evaluated is a
+      # pseudo-mark that is a grandchild of this layout.
+      #
+      stack = Rubyvis::Mark.stack
+      
+      o = OpenStruct.new({:parent=> OpenStruct.new({:parent=> self})})
+      stack.unshift(nil)
+      values = []
+      n.times {|i|
+      dy[i] = []
+      y[i] = []
+      o.parent.index = i
+      stack[0] = data[i]
+      values[i] = self._values.js_apply(o.parent, stack);
+      m = values[i].size if (i==0) 
+      stack.unshift(nil)
+      m.times {|j|
+        stack[0] = values[i][j]
+        o.index = j
+        x[j] = self._x.js_apply(o, stack) if i==0
+        dy[i][j] = self._y.js_apply(o, stack)
+      }
+      stack.shift()
+      }
+      stack.shift()
+      
+      # order
+      _index=nil
+      case (s.order) 
+      when "inside-out" 
+        max  = dy.map {|v| pv.max.index(v) }
+        map  = pv.range(n).sort {|a,b| return max[a] - max[b]}
+        sums = dy.map {|v| pv.sum(v)}
+        top = 0
+        bottom = 0
+        tops = []
+        bottoms = []
+        n.times {|i|
+          j = map[i]
+          if (top < bottom) 
+            top += sums[j];
+            tops.push(j);
+          else
+            bottom += sums[j];
+            bottoms.push(j);
+          end
+        }
+        _index = bottoms.reverse+tops
+        
+      when "reverse"
+        _index = pv.range(n - 1, -1, -1)
+      else
+        _index = pv.range(n)
+      end
+      
+      #/* offset */
+      case (s.offset) 
+      when "silohouette"
+        m.times {|j|
+          o = 0;
+          n.times {|i| 
+            o += dy[i][j]
+          }
+          y[_index[0]][j] = (h - o) / 2.0;
+        }
+      
+      when "wiggle"
+        o = 0;
+        n.times {|i|  o += dy[i][0] }
+        
+        y[_index[0]][0] = o = (h - o) / 2.0
+        
+        (1...m).each  {|j|
+          s1 = 0
+          s2 = 0
+          dx = x[j] - x[j - 1]
+          n.times {|i| s1 += dy[i][j]}
+          n.times {|i|
+            
+            s3 = (dy[_index[i]][j] - dy[_index[i]][j - 1]) / (2.0 * dx)
+            i.times {|k|
+              s3 += (dy[_index[k]][j] - dy[_index[k]][j - 1]) / dx.to_f
+            }
+            s2 += s3 * dy[_index[i]][j]
+          }
+          o -= (s1!=0) ? s2 / s1.to_f * dx : 0
+          y[_index[0]][j] = o
+          
+        }
+      when "expand"
+        m.times {|j|
+          y[_index[0]][j] = 0
+          
+          k = 0
+          n.times {|i|k += dy[i][j]}
+          if (k!=0) 
+            k = h / k.to_f
+            n.times {|i| dy[i][j] *= k}
+          else 
+            k = h / n.to_f
+            n.times { dy[i][j] = k}
+          end
+        }
+      else
+        m.times {|j| y[_index[0]][j] = 0}
+      end
+      
+      # Propagate the offset to the other series. */
+      m.times {|j|
+      o = y[_index[0]][j]
+      (1...n).each {|i|
+        
+        o += dy[_index[i - 1]][j]
+        y[_index[i]][j] = o
+      }
+      }
+      
+      # /* Find the property definitions for dynamic substitution. */
+      
+      i = orient.index("-")
+      pdy = horizontal ? "h" : "w"
+      px = i < 0 ? (horizontal ? "l" : "b") : orient[i + 1,1]
+      py = orient[0,1]
+      
+      @values=values
+      
+      @prop.each {|k,v|
+        @prop[k]=@none
+      }
+      # puts "stack: x:#{px}, y:#{py}, dy:#{pdy}" if $DEBUG
+      @prop[px] =lambda {|i1,j| x[j]}
+      @prop[py] =lambda {|i1,j| y[i1][j]}
+      @prop[pdy]=lambda {|i1,j| dy[i1][j]}  
+    end
+    
+    def layer
+      that=self
+      value = Rubyvis::Mark.new().data(lambda { that.values[self.parent.index] })
+      .top(proxy("t"))
+      .left(proxy("l"))
+      .right(proxy("r"))
+      .bottom(proxy("b"))
+      .width(proxy("w"))
+      .height(proxy("h"))
+      
+      class << value
+        def that=(v)
+          @that = v
+        end
+        def add(type)
+          that  = @that
+          that.add( pv.Panel ).data(lambda { that.layers() }).add(type).extend( self )
+        end
+      end
+      value.that=self
+      return value
+    end
+  end
+  end
+end

data/lib/rubyvis/mark.rb

@@ -6,10 +6,9 @@ module Rubyvis
   class Mark
     @properties={}
 
-    def self.property_method(name, _def, func=nil)
-      
-      return if Mark.method_defined? name
-      Mark.send(:define_method, name) do |*arguments|
+    def self.property_method(name, _def, func=nil, klass=nil)
+      return if klass.method_defined? name
+      klass.send(:define_method, name) do |*arguments|
         v,dummy = arguments
         if _def and self.scene
           if arguments.size>0
@@ -33,16 +32,35 @@ module Rubyvis
         if i.nil?
           raise "No instance for #{self} on #{name}"
         else
-#          puts "index:#{self.index}, name:#{name}, val:#{i.send(name)}"
+        #          puts "index:#{self.index}, name:#{name}, val:#{i.send(name)}"
           i.send(name)
         end
       end
       
       camel=name.to_s.gsub(/(_.)/) {|v| v[1,1].upcase}
       if camel!=name
-        Mark.send(:alias_method, camel, name)
+        klass.send(:alias_method, camel, name)
+      end
+    end
+    
+    def self.attr_accessor_dsl(*attr)
+      attr.each  do |sym|
+      if sym.is_a? Array
+        name,func=sym
+      else
+        name=sym
+        func=nil
+      end
+      
+      @properties[name]=true
+      self.property_method(name,false, func, Rubyvis::Mark)        
+      define_method(name.to_s+"=") {|v|
+        self.send(name,v)
+      }
       end
     end
+
+    
     def property_value(name,v)
       prop=Property.new({:name=>name, :id=>Rubyvis.id, :value=>v})
       @_properties.delete_if{|v1| v1.name==name}
@@ -63,23 +81,6 @@ module Rubyvis
     end
 
 
-    def self.attr_accessor_dsl(*attr)
-      attr.each  do |sym|
-        
-        if sym.is_a? Array
-          name,func=sym
-        else
-          name=sym
-          func=nil
-        end
-        
-        @properties[name]=true
-        self.property_method(name,false, func)        
-        define_method(name.to_s+"=") {|v|
-          self.send(name,v)
-        }
-      end
-    end
 
     attr_accessor :parent, :root, :index, :child_index, :scene, :proto, :target, :scale
     attr_reader :_properties
@@ -119,11 +120,7 @@ module Rubyvis
     end
 
     def initialize(opts=Hash.new)
-      #@_properties_values={}
-      #@_properties_types={}
       @_properties=[]
-      #@options=opts
-      # @stack=[]
       opts.each {|k,v|
         self.send("#{k}=",v) if self.respond_to? k
       }
@@ -253,19 +250,22 @@ module Rubyvis
       t=s.top
       b=s.bottom
       prop=self.properties
+      
       #p self
+      
       w = (prop[:width])  ? s.width : 0
       h = (prop[:height])  ? s.height : 0
-      #puts "l:#{l},r:#{r},t:#{t},b:#{b}"
-      #puts "w:#{w},h:#{h}"
-      width=self.parent ? self.parent.width(): (w+(l.nil? ? 0 : l)+(r.nil? ? 0 :r))
+      
+      width=self.parent ? self.parent.width() : (w+(l.nil? ? 0 : l)+(r.nil? ? 0 : r))
+      #puts (self.parent)? "parent width: #{self.parent.width}" : "no parent" if $DEBUG
+      #p prop.sort if $DEBUG
+      puts "build implied #{type}: l:#{l},r:#{r},t:#{t},b:#{b}, w:#{prop[:width]} #{w},h: #{prop[:height]} #{h}, width:#{width}" if $DEBUG
       if w.nil?
         r||=0
         l||=0
         w=width-r-l
       elsif r.nil?
         if l.nil?
-
           r=(width-w) / (2.0)
           l=r
         else
@@ -299,9 +299,10 @@ module Rubyvis
       s.top=t
       s.bottom=b
 
-      # puts "#{l},#{r},#{t},#{b}"
+      puts "Post->left: #{l},right:#{r},top:#{t},bottom:#{b}, width:#{w}, height:#{h}" if $DEBUG
 
       s.width=w if prop[:width]
+      #puts "width:#{s.width}" if $DEBUG
       s.height=h if prop[:height]
       s.text_style=Rubyvis::Color.transparent if prop[:text_style] and !s.text_style
       s.fill_style=Rubyvis::Color.transparent if prop[:fill_style] and !s.fill_style
@@ -543,7 +544,7 @@ module Rubyvis
     def mark_build_instance(s1)
       build_properties(s1, self.binds.required)
       if s1.visible
-        build_properties(s1,self.binds.optional)
+        build_properties(s1, self.binds.optional)
         build_implied(s1)
       end
     end

data/lib/rubyvis/mark/area.rb

@@ -112,7 +112,8 @@ module Rubyvis
       area_build_instance(s)
     end
     def self.defaults
-      Area.new.extend(Mark.defaults).line_width(1.5).fill_style(lambda {pv.Colors.category20.scale(self.parent.index)}).interpolate('linear').tension(0.7)
+      a= Rubyvis::Colors.category20
+      Area.new.extend(Mark.defaults).line_width(1.5).fill_style(lambda {a.scale(self.parent.index)}).interpolate('linear').tension(0.7)
     end
     def anchor(name)
       area_anchor(name)
@@ -120,7 +121,7 @@ module Rubyvis
     def build_implied(s)
       s.heigth=0 if s.height.nil?
       s.width=0 if s.width.nil?
-      super(s)
+      mark_build_implied(s)
     end
   end
 end

data/lib/rubyvis/mark/bar.rb

@@ -10,7 +10,10 @@ module Rubyvis
     @properties=Mark.properties.dup
     attr_accessor_dsl :width, :height, :line_width, [:stroke_style, lambda {|d| pv.color(d)}], [:fill_style, lambda {|d| pv.color(d)}]
     def self.defaults
-      Bar.new.extend(Mark.defaults).line_width(1.5).fill_style( lambda {Rubyvis.Colors.category20().scale(self.parent.index)})
+      a=Rubyvis.Colors.category20()
+      Bar.new.extend(Mark.defaults).line_width(1.5).fill_style( lambda {
+          a.scale(self.parent.index)
+      })
     end
   end
 end

data/lib/rubyvis/mark/dot.rb

@@ -12,57 +12,57 @@ module Rubyvis
     attr_accessor_dsl :shape, :shape_angle, :shape_radius, :shape_size, :line_width, [:stroke_style, lambda {|d| pv.color(d)}], [:fill_style, lambda {|d| pv.color(d)}]
     
     def self.defaults()
-      Dot.new().extend(Mark.defaults).shape("circle"). line_width(1.5). stroke_style(lambda {pv.Colors.category10().scale(self.parent.index)})
+      a=Rubyvis::Colors.category10
+      Dot.new().extend(Mark.defaults).shape("circle"). line_width(1.5). stroke_style(lambda {a.scale(self.parent.index)})
     end
     
     def anchor(name)
       
       
       mark_anchor(name).left(lambda {
-          s=scene.target[self.index]
-          case self.name
+        s=scene.target[self.index]
+        case self.name
           when 'bottom' then s.left;
           when 'top' then s.left;
           when 'center' then s.left;
           when 'left' then nil;
           else
             s.left+s.shape_radius
-          end
+        end
       }).right(lambda {
-          s=scene.target[self.index]
-          self.name()=='left' ? s.right+s.shape_radius : nil
-        
+        s=scene.target[self.index]
+        self.name()=='left' ? s.right+s.shape_radius : nil
       }).top(lambda {
         s=scene.target[self.index]
-          case self.name
+        case self.name
           when 'left' then  s.top;
           when 'right' then s.top;
           when 'center' then s.top;
           when 'top' then nil;
           else
             s.top+s.shape_radius
-          end
+        end
       }).bottom(lambda {
-         s=scene.target[self.index]
-          self.name()=='top' ? s.bottom+s.shape_radius : nil
+        s=scene.target[self.index]
+        self.name()=='top' ? s.bottom+s.shape_radius : nil
       }).text_align(lambda {
-       case self.name
+        case self.name
           when 'left' then  'right';
           when 'bottom' then 'center';
           when 'top' then 'center';
           when 'center' then 'center';
           else
             'left'
-          end
+        end
       }).text_baseline( lambda {
-       case self.name
-       when 'right' then  'middle';
-       when 'left' then 'middle';
-       when 'center' then 'middle';
+        case self.name
+          when 'right' then  'middle';
+          when 'left' then 'middle';
+          when 'center' then 'middle';
           when 'bottom' then 'top';
           else
             'bottom'
-          end
+        end
       
       })
     end