heart 0.0.1.pre

data/app/assets/javascripts/heart/flot/jquery.flot.fillbetween.js

@@ -0,0 +1,183 @@
+/*
+Flot plugin for computing bottoms for filled line and bar charts.
+
+The case: you've got two series that you want to fill the area
+between. In Flot terms, you need to use one as the fill bottom of the
+other. You can specify the bottom of each data point as the third
+coordinate manually, or you can use this plugin to compute it for you.
+
+In order to name the other series, you need to give it an id, like this
+
+  var dataset = [
+       { data: [ ... ], id: "foo" } ,         // use default bottom
+       { data: [ ... ], fillBetween: "foo" }, // use first dataset as bottom
+       ];
+
+  $.plot($("#placeholder"), dataset, { line: { show: true, fill: true }});
+
+As a convenience, if the id given is a number that doesn't appear as
+an id in the series, it is interpreted as the index in the array
+instead (so fillBetween: 0 can also mean the first series).
+  
+Internally, the plugin modifies the datapoints in each series. For
+line series, extra data points might be inserted through
+interpolation. Note that at points where the bottom line is not
+defined (due to a null point or start/end of line), the current line
+will show a gap too. The algorithm comes from the jquery.flot.stack.js
+plugin, possibly some code could be shared.
+*/
+
+(function ($) {
+    var options = {
+        series: { fillBetween: null } // or number
+    };
+    
+    function init(plot) {
+        function findBottomSeries(s, allseries) {
+            var i;
+            for (i = 0; i < allseries.length; ++i) {
+                if (allseries[i].id == s.fillBetween)
+                    return allseries[i];
+            }
+
+            if (typeof s.fillBetween == "number") {
+                i = s.fillBetween;
+            
+                if (i < 0 || i >= allseries.length)
+                    return null;
+
+                return allseries[i];
+            }
+            
+            return null;
+        }
+        
+        function computeFillBottoms(plot, s, datapoints) {
+            if (s.fillBetween == null)
+                return;
+
+            var other = findBottomSeries(s, plot.getData());
+            if (!other)
+                return;
+
+            var ps = datapoints.pointsize,
+                points = datapoints.points,
+                otherps = other.datapoints.pointsize,
+                otherpoints = other.datapoints.points,
+                newpoints = [],
+                px, py, intery, qx, qy, bottom,
+                withlines = s.lines.show,
+                withbottom = ps > 2 && datapoints.format[2].y,
+                withsteps = withlines && s.lines.steps,
+                fromgap = true,
+                i = 0, j = 0, l;
+
+            while (true) {
+                if (i >= points.length)
+                    break;
+
+                l = newpoints.length;
+
+                if (points[i] == null) {
+                    // copy gaps
+                    for (m = 0; m < ps; ++m)
+                        newpoints.push(points[i + m]);
+                    i += ps;
+                }
+                else if (j >= otherpoints.length) {
+                    // for lines, we can't use the rest of the points
+                    if (!withlines) {
+                        for (m = 0; m < ps; ++m)
+                            newpoints.push(points[i + m]);
+                    }
+                    i += ps;
+                }
+                else if (otherpoints[j] == null) {
+                    // oops, got a gap
+                    for (m = 0; m < ps; ++m)
+                        newpoints.push(null);
+                    fromgap = true;
+                    j += otherps;
+                }
+                else {
+                    // cases where we actually got two points
+                    px = points[i];
+                    py = points[i + 1];
+                    qx = otherpoints[j];
+                    qy = otherpoints[j + 1];
+                    bottom = 0;
+
+                    if (px == qx) {
+                        for (m = 0; m < ps; ++m)
+                            newpoints.push(points[i + m]);
+
+                        //newpoints[l + 1] += qy;
+                        bottom = qy;
+                        
+                        i += ps;
+                        j += otherps;
+                    }
+                    else if (px > qx) {
+                        // we got past point below, might need to
+                        // insert interpolated extra point
+                        if (withlines && i > 0 && points[i - ps] != null) {
+                            intery = py + (points[i - ps + 1] - py) * (qx - px) / (points[i - ps] - px);
+                            newpoints.push(qx);
+                            newpoints.push(intery)
+                            for (m = 2; m < ps; ++m)
+                                newpoints.push(points[i + m]);
+                            bottom = qy; 
+                        }
+
+                        j += otherps;
+                    }
+                    else { // px < qx
+                        if (fromgap && withlines) {
+                            // if we come from a gap, we just skip this point
+                            i += ps;
+                            continue;
+                        }
+                            
+                        for (m = 0; m < ps; ++m)
+                            newpoints.push(points[i + m]);
+                        
+                        // we might be able to interpolate a point below,
+                        // this can give us a better y
+                        if (withlines && j > 0 && otherpoints[j - otherps] != null)
+                            bottom = qy + (otherpoints[j - otherps + 1] - qy) * (px - qx) / (otherpoints[j - otherps] - qx);
+
+                        //newpoints[l + 1] += bottom;
+                        
+                        i += ps;
+                    }
+
+                    fromgap = false;
+                    
+                    if (l != newpoints.length && withbottom)
+                        newpoints[l + 2] = bottom;
+                }
+
+                // maintain the line steps invariant
+                if (withsteps && l != newpoints.length && l > 0
+                    && newpoints[l] != null
+                    && newpoints[l] != newpoints[l - ps]
+                    && newpoints[l + 1] != newpoints[l - ps + 1]) {
+                    for (m = 0; m < ps; ++m)
+                        newpoints[l + ps + m] = newpoints[l + m];
+                    newpoints[l + 1] = newpoints[l - ps + 1];
+                }
+            }
+
+            datapoints.points = newpoints;
+        }
+        
+        plot.hooks.processDatapoints.push(computeFillBottoms);
+    }
+    
+    $.plot.plugins.push({
+        init: init,
+        options: options,
+        name: 'fillbetween',
+        version: '1.0'
+    });
+})(jQuery);

data/app/assets/javascripts/heart/flot/jquery.flot.growing.js

@@ -0,0 +1,140 @@
+/*
+ * The MIT License
+
+Copyright (c) 2010 by Juergen Marsch
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+(function ($)
+{	 var options =
+     {	series: {
+	 	grow: {
+	 		active: true,
+			valueIndex: 1,
+	 		stepDelay: 20,
+			steps:1,
+	 		stepMode: "linear",
+			stepDirection: "up"
+	 	}
+	 }
+    };
+    function init(plot) {
+		var done = false;
+		var growfunc;
+		var plt = plot;
+		var data = null;
+		var opt = null;
+		var valueIndex;
+		plot.hooks.bindEvents.push(processbindEvents);
+		plot.hooks.drawSeries.push(processSeries);
+		function processSeries(plot, canvascontext, series)
+		{   opt = plot.getOptions();
+		    valueIndex = opt.series.grow.valueIndex;
+			if(opt.series.grow.active == true && typeof(opt.grow) != 'undefined')
+			{	if (done == false)
+				{	data = plot.getData();
+					data.actualStep = 0;
+					for (var j = 0; j < data.length; j++)
+					{	data[j].dataOrg = clone(data[j].data);
+						for (var i = 0; i < data[j].data.length; i++)
+							data[j].data[i][valueIndex] = 0;
+					}
+					plot.setData(data);
+					done = true;
+				}
+			}
+		}
+		function processbindEvents(plot,eventHolder)
+		{	opt = plot.getOptions();
+			if (opt.series.grow.active == true && typeof(opt.grow) != 'undefined')
+			{	var d = plot.getData();
+				for (var j = 0; j < data.length; j++) {
+					opt.series.grow.steps = Math.max(opt.series.grow.steps, d[j].grow.steps);
+				}
+				if(opt.series.grow.stepDelay == 0) opt.series.grow.stepDelay++;
+				growfunc = window.setInterval(growing, opt.series.grow.stepDelay);
+			}
+		}
+		function growing()
+		{	if (data.actualStep < opt.series.grow.steps)
+			{	data.actualStep++;
+				for(var j = 0; j < data.length; j++)
+				{ if (typeof data[j].grow.stepMode == "function")
+					{	data[j].grow.stepMode(data[j],data.actualStep,valueIndex); }
+					else
+					{	if (data[j].grow.stepMode == "linear") growLinear();
+						else if (data[j].grow.stepMode == "maximum") growMaximum();
+						else if (data[j].grow.stepMode == "delay") growDelay();
+						else growNone();
+					}
+				}
+				plt.setData(data);
+				plt.draw();
+			}
+			else
+			{	window.clearInterval(growfunc); }
+			function growNone()
+			{	if (data.actualStep == 1)
+				{	for (var i = 0; i < data[j].data.length; i++)
+					{	data[j].data[i][valueIndex] = data[j].dataOrg[i][valueIndex]; }
+				}
+			}
+			function growLinear()
+			{	if (data.actualStep <= data[j].grow.steps)
+				{	for (var i = 0; i < data[j].data.length; i++)
+					{	if (data[j].grow.stepDirection == "up")
+						{	data[j].data[i][valueIndex] = data[j].dataOrg[i][valueIndex] / data[j].grow.steps * data.actualStep;}
+						else if(data[j].grow.stepDirection == "down")
+						{	data[j].data[i][valueIndex] = data[j].dataOrg[i][valueIndex] + (data[j].yaxis.max - data[j].dataOrg[i][valueIndex]) / data[j].grow.steps * (data[j].grow.steps - data.actualStep); }
+					}
+				}
+			}
+			function growMaximum()
+			{	if (data.actualStep <= data[j].grow.steps)
+				{	for (var i = 0; i < data[j].data.length; i++)
+					{	if (data[j].grow.stepDirection == "up")
+						{	data[j].data[i][valueIndex] = Math.min(data[j].dataOrg[i][valueIndex], data[j].yaxis.max / data[j].grow.steps * data.actualStep); }
+						else if (data[j].grow.stepDirection == "down")
+						{	data[j].data[i][valueIndex] = Math.max(data[j].dataOrg[i][valueIndex], data[j].yaxis.max / data[j].grow.steps * (data[j].grow.steps - data.actualStep) ); }
+					}
+				}
+			}
+			function growDelay()
+			{	if (data.actualStep == data[j].grow.steps)
+				{	for (var i = 0; i < data[j].data.length; i++)
+					{	data[j].data[i][valueIndex] = data[j].dataOrg[i][valueIndex]; }
+				}
+			}
+		}
+		function clone(obj)
+		{	if(obj == null || typeof(obj) != 'object') return obj;
+			var temp = new obj.constructor();
+			for(var key in obj)	temp[key] = clone(obj[key]);
+			return temp;
+		}
+    }
+
+	$.plot.plugins.push({
+      init: init,
+      options: options,
+      name: 'grow',
+      version: '0.2'
+    });
+})(jQuery);