Merge pull request #889 from dnschnur/code-fixes

Fixed global variables and missing seimcolons.

jquery.flot.crosshair.js

@@ -84,11 +84,11 @@ The plugin also adds four public methods:
             if (pos)
                 plot.setCrosshair(pos);
             crosshair.locked = true;
-        }
+        };
 
         plot.unlockCrosshair = function unlockCrosshair() {
             crosshair.locked = false;
-        }
+        };
 
         function onMouseOut(e) {
             if (crosshair.locked)

jquery.flot.fillbetween.js

-/*
-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, { lines: { 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.
+/* Flot plugin for computing bottoms for filled line and bar charts.
+
+Copyright (c) 2007-2012 IOLA and Ole Laursen.
+Licensed under the MIT license.
+
+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, { lines: { 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'
-    });
+(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" ) {
+				if ( s.fillBetween < 0 || s.fillBetween >= allseries.length ) {
+					return null;
+				}
+				return allseries[ s.fillBetween ];
+			}
+
+			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, m;
+
+			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 we come from a gap, we just skip this point
+
+						if ( fromgap && withlines ) {
+							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);

jquery.flot.image.js

@@ -110,7 +110,7 @@ images (like Google Maps).
 
             $('<img />').load(handler).error(handler).attr('src', url);
         });
-    }
+    };
     
     function drawSeries(plot, ctx, series) {
         var plotOffset = plot.getPlotOffset();

jquery.flot.js

@@ -2293,7 +2293,7 @@
 
             for (var i = 0; i < entries.length; ++i) {
 
-                entry = entries[i];
+                var entry = entries[i];
 
                 if (i % options.legend.noColumns == 0) {
                     if (rowStarted)
@@ -2584,7 +2584,7 @@
 
         function drawPointHighlight(series, point) {
             var x = point[0], y = point[1],
-                axisx = series.xaxis, axisy = series.yaxis;
+                axisx = series.xaxis, axisy = series.yaxis,
                 highlightColor = (typeof series.highlightColor === "string") ? series.highlightColor : $.color.parse(series.color).scale('a', 0.5).toString();
 
             if (x < axisx.min || x > axisx.max || y < axisy.min || y > axisy.max)

jquery.flot.navigate.js

@@ -200,11 +200,11 @@ Licensed under the MIT License ~ http://threedubmedia.googlecode.com/files/MIT-L
                 args = {};
             
             if (!args.amount)
-                args.amount = plot.getOptions().zoom.amount
+                args.amount = plot.getOptions().zoom.amount;
 
             args.amount = 1 / args.amount;
             plot.zoom(args);
-        }
+        };
         
         plot.zoom = function (args) {
             if (!args)
@@ -274,7 +274,7 @@ Licensed under the MIT License ~ http://threedubmedia.googlecode.com/files/MIT-L
             
             if (!args.preventEvent)
                 plot.getPlaceholder().trigger("plotzoom", [ plot, args ]);
-        }
+        };
 
         plot.pan = function (args) {
             var delta = {
@@ -322,7 +322,7 @@ Licensed under the MIT License ~ http://threedubmedia.googlecode.com/files/MIT-L
             
             if (!args.preventEvent)
                 plot.getPlaceholder().trigger("plotpan", [ plot ]);
-        }
+        };
 
         function shutdown(plot, eventHolder) {
             eventHolder.unbind(plot.getOptions().zoom.trigger, onZoomClick);

jquery.flot.pie.js

@@ -65,20 +65,21 @@ More detail and specific examples can be found in the included HTML file.
 
 	function init(plot) {
 
-		var canvas = null;
-		var canvasWidth = 0;
-		var canvasHeight = 0;
-		var target = null;
-		var maxRadius = null;
-		var centerLeft = null;
-		var centerTop = null;
-		var total = 0;
-		var redraw = true;
-		var redrawAttempts = 10;
-		var shrink = 0.95;
-		var legendWidth = 0;
-		var processed = false;
-		var raw = false;
+		var canvas = null,
+			canvasWidth = 0,
+			canvasHeight = 0,
+			target = null,
+			maxRadius = null,
+			centerLeft = null,
+			centerTop = null,
+			total = 0,
+			redraw = true,
+			redrawAttempts = 10,
+			shrink = 0.95,
+			legendWidth = 0,
+			processed = false,
+			raw = false,
+			ctx = null;
 
 		// interactive variables
 
@@ -528,7 +529,7 @@ More detail and specific examples can be found in the included HTML file.
 				// subtract the center
 
 				layer.save();
-				innerRadius = options.series.pie.innerRadius > 1 ? options.series.pie.innerRadius : maxRadius * options.series.pie.innerRadius;
+				var innerRadius = options.series.pie.innerRadius > 1 ? options.series.pie.innerRadius : maxRadius * options.series.pie.innerRadius;
 				layer.globalCompositeOperation = "destination-out"; // this does not work with excanvas, but it will fall back to using the stroke color
 				layer.beginPath();
 				layer.fillStyle = options.series.pie.stroke.color;
@@ -563,9 +564,10 @@ More detail and specific examples can be found in the included HTML file.
 
 		function findNearbySlice(mouseX, mouseY) {
 
-			var slices = plot.getData();
-			var options = plot.getOptions();
-			var radius = options.series.pie.radius > 1 ? options.series.pie.radius : maxRadius * options.series.pie.radius;
+			var slices = plot.getData(),
+				options = plot.getOptions(),
+				radius = options.series.pie.radius > 1 ? options.series.pie.radius : maxRadius * options.series.pie.radius,
+				x, y;
 
 			for (var i = 0; i < slices.length; ++i) {
 
@@ -597,18 +599,18 @@ More detail and specific examples can be found in the included HTML file.
 
 						// excanvas for IE doesn;t support isPointInPath, this is a workaround.
 
-						p1X = radius * Math.cos(s.startAngle);
-						p1Y = radius * Math.sin(s.startAngle);
-						p2X = radius * Math.cos(s.startAngle + s.angle / 4);
-						p2Y = radius * Math.sin(s.startAngle + s.angle / 4);
-						p3X = radius * Math.cos(s.startAngle + s.angle / 2);
-						p3Y = radius * Math.sin(s.startAngle + s.angle / 2);
-						p4X = radius * Math.cos(s.startAngle + s.angle / 1.5);
-						p4Y = radius * Math.sin(s.startAngle + s.angle / 1.5);
-						p5X = radius * Math.cos(s.startAngle + s.angle);
-						p5Y = radius * Math.sin(s.startAngle + s.angle);
-						arrPoly = [[0, 0], [p1X, p1Y], [p2X, p2Y], [p3X, p3Y], [p4X, p4Y], [p5X, p5Y]];
-						arrPoint = [x, y];
+						var p1X = radius * Math.cos(s.startAngle),
+							p1Y = radius * Math.sin(s.startAngle),
+							p2X = radius * Math.cos(s.startAngle + s.angle / 4),
+							p2Y = radius * Math.sin(s.startAngle + s.angle / 4),
+							p3X = radius * Math.cos(s.startAngle + s.angle / 2),
+							p3Y = radius * Math.sin(s.startAngle + s.angle / 2),
+							p4X = radius * Math.cos(s.startAngle + s.angle / 1.5),
+							p4Y = radius * Math.sin(s.startAngle + s.angle / 1.5),
+							p5X = radius * Math.cos(s.startAngle + s.angle),
+							p5Y = radius * Math.sin(s.startAngle + s.angle),
+							arrPoly = [[0, 0], [p1X, p1Y], [p2X, p2Y], [p3X, p3Y], [p4X, p4Y], [p5X, p5Y]],
+							arrPoint = [x, y];
 
 						// TODO: perhaps do some mathmatical trickery here with the Y-coordinate to compensate for pie tilt?
 
@@ -672,9 +674,9 @@ More detail and specific examples can be found in the included HTML file.
 		}
 
 		function highlight(s, auto) {
-			if (typeof s == "number") {
-				s = series[s];
-			}
+			//if (typeof s == "number") {
+			//	s = series[s];
+			//}
 
 			var i = indexOfHighlight(s);
 
@@ -692,9 +694,9 @@ More detail and specific examples can be found in the included HTML file.
 				plot.triggerRedrawOverlay();
 			}
 
-			if (typeof s == "number") {
-				s = series[s];
-			}
+			//if (typeof s == "number") {
+			//	s = series[s];
+			//}
 
 			var i = indexOfHighlight(s);
 
@@ -723,7 +725,7 @@ More detail and specific examples can be found in the included HTML file.
 			octx.translate(centerLeft, centerTop);
 			octx.scale(1, options.series.pie.tilt);
 
-			for (i = 0; i < highlights.length; ++i) {
+			for (var i = 0; i < highlights.length; ++i) {
 				drawHighlight(highlights[i].series);
 			}
 

jquery.flot.stack.js

@@ -71,7 +71,7 @@ adjusted (e.g for bar charts or filled areas).
                 fromgap = true,
                 keyOffset = horizontal ? 1 : 0,
                 accumulateOffset = horizontal ? 0 : 1,
-                i = 0, j = 0, l;
+                i = 0, j = 0, l, m;
 
             while (true) {
                 if (i >= points.length)

jquery.flot.symbol.js

@@ -51,7 +51,7 @@ choice:
                 ctx.moveTo(x - size, y + size);
                 ctx.lineTo(x + size, y - size);
             }
-        }
+        };
 
         var s = series.points.symbol;
         if (handlers[s])

jquery.flot.threshold.js

@@ -61,7 +61,7 @@ events.
             var m;
 
             for (i = 0; i < origpoints.length; i += ps) {
-                x = origpoints[i]
+                x = origpoints[i];
                 y = origpoints[i + 1];
 
                 prevp = p;