dataset axis to be used in the line chart and the bar chart

src/Chart.Scale.js

@@ -612,81 +612,81 @@
 		isHorizontal: function() {
 			return this.options.position == "top" || this.options.position == "bottom";
 		},
-		buildLabels: function() {
+		getPixelForValue: function(value, index, includeOffset) {
-			// We assume that this has been run after ticks have been generated. We try to figure out
-			// a label for each tick. 
-			
-		},
-		getPixelForValue: function(value, datasetIndex) {
 			// This must be called after fit has been run so that 
 			//		this.left, this.top, this.right, and this.bottom have been defined
 			if (this.isHorizontal()) {
-
-			} else {
-
-			}
-
 				var isRotated = (this.labelRotation > 0);
 	            var innerWidth = this.width - (this.paddingLeft + this.paddingRight);
-            var valueWidth = innerWidth / Math.max((this.max - ((this.options.offsetGridLines) ? 0 : 1)), 1);
+	            var valueWidth = innerWidth / Math.max((this.max - ((this.options.gridLines.offsetGridLines) ? 0 : 1)), 1);
 	            var valueOffset = (valueWidth * index) + this.paddingLeft;
 
-            if (this.options.offsetGridLines) {
+	            if (this.options.gridLines.offsetGridLines && includeOffset) {
 	                valueOffset += (valueWidth / 2);
 	            }
 
-            return Math.round(valueOffset);
+            	return this.left + Math.round(valueOffset);
-			
+			} else {
+				return this.top + (index * (this.height / this.max));
+			}
 		},
-		calculateXLabelRotation: function() {
+		calculateLabelRotation: function(maxHeight) {
             //Get the width of each grid by calculating the difference
             //between x offsets between 0 and 1.
-
+            var labelFont = helpers.fontString(this.options.labels.fontSize, this.options.labels.fontStyle, this.options.labels.fontFamily);
-            this.ctx.font = this.font;
+            this.ctx.font = labelFont;
 
             var firstWidth = this.ctx.measureText(this.labels[0]).width;
             var lastWidth = this.ctx.measureText(this.labels[this.labels.length - 1]).width;
 			var firstRotated;
 			var lastRotated;
 
-
             this.paddingRight = lastWidth / 2 + 3;
             this.paddingLeft = firstWidth / 2 + 3;
 
-            this.xLabelRotation = 0;
+            this.labelRotation = 0;
-            if (this.display) {
+
-                var originalLabelWidth = longestText(this.ctx, this.font, this.labels),
+            if (this.options.show) {
-                    cosRotation,
+                var originalLabelWidth = helpers.longestText(this.ctx, labelFont, this.labels);
-                    firstRotatedWidth;
+                var cosRotation;
-                this.xLabelWidth = originalLabelWidth;
+                var sinRotation;
+                var firstRotatedWidth;
+
+                this.labelWidth = originalLabelWidth;
+                
                 //Allow 3 pixels x2 padding either side for label readability
-                var xGridWidth = Math.floor(this.calculateX(1) - this.calculateX(0)) - 6;
+                // only the index matters for a dataset scale, but we want a consistent interface between scales
+                var gridWidth = Math.floor(this.getPixelForValue(0, 1) - this.getPixelForValue(0, 0)) - 6;
 
                 //Max label rotate should be 90 - also act as a loop counter
-                while ((this.xLabelWidth > xGridWidth && this.xLabelRotation === 0) || (this.xLabelWidth > xGridWidth && this.xLabelRotation <= 90 && this.xLabelRotation > 0)) {
+                while ((this.labelWidth > gridWidth && this.labelRotation === 0) || (this.labelWidth > gridWidth && this.labelRotation <= 90 && this.labelRotation > 0)) {
-                    cosRotation = Math.cos(toRadians(this.xLabelRotation));
+                    cosRotation = Math.cos(helpers.toRadians(this.labelRotation));
+                    sinRotation = Math.sin(helpers.toRadians(this.labelRotation));
 
                     firstRotated = cosRotation * firstWidth;
                     lastRotated = cosRotation * lastWidth;
 
                     // We're right aligning the text now.
-                    if (firstRotated + this.fontSize / 2 > this.yLabelWidth) {
+                    if (firstRotated + this.options.labels.fontSize / 2 > this.yLabelWidth) {
-                        this.xScalePaddingLeft = firstRotated + this.fontSize / 2;
+                        this.paddingLeft = firstRotated + this.options.labels.fontSize / 2;
                     }
-                    this.xScalePaddingRight = this.fontSize / 2;
 
+                    this.paddingRight = this.options.labels.fontSize / 2;
 
-                    this.xLabelRotation++;
+                    if (sinRotation * originalLabelWidth > maxHeight) {
-                    this.xLabelWidth = cosRotation * originalLabelWidth;
+                    	// go back one step
-
+                    	this.labelRotation--;
+                    	break;
                     }
-                if (this.xLabelRotation > 0) {
+
-                    this.endPoint -= Math.sin(toRadians(this.xLabelRotation)) * originalLabelWidth + 3;
+                    this.labelRotation++;
+                    this.labelWidth = cosRotation * originalLabelWidth;
+
                 }
             } else {
-                this.xLabelWidth = 0;
+                this.labelWidth = 0;
-                this.xScalePaddingRight = this.padding;
+                this.paddingRight = this.padding;
-                this.xScalePaddingLeft = this.padding;
+                this.paddingLeft = this.padding;
             }
 
         },
@@ -695,11 +695,107 @@
 		// @param {number} maxHeight: the max height the axis can be
 		// @return {object} minSize : the minimum size needed to draw the axis
 		fit: function(maxWidth, maxHeight) {
+			this.calculateRange();
+			this.calculateLabelRotation();
 
+			var minSize = {
+				width: 0,
+				height: 0,
+			};
+
+			var labelFont = helpers.fontString(this.options.labels.fontSize, this.options.labels.fontStyle, this.options.labels.fontFamily);
+			var longestLabelWidth = helpers.longestText(this.ctx, labelFont, this.labels);
+
+			if (this.isHorizontal()) {
+				minSize.width = maxWidth;
+				this.width = maxWidth;
+
+				var labelHeight = (Math.cos(helpers.toRadians(this.labelRotation)) * longestLabelWidth) + 1.5 * this.options.labels.fontSize;
+				minSize.height = Math.min(labelHeight, maxHeight);
+			} else {
+				minSize.height = maxHeight;
+				this.height = maxHeight;
+
+				minSize.width = Math.min(longestLabelWidth + 6, maxWidth);
+			}
+
+			this.width = minSize.width;
+			this.height = minSize.height;
+			return minSize;
 		},
 		// Actualy draw the scale on the canvas
 		// @param {rectangle} chartArea : the area of the chart to draw full grid lines on
 		draw: function(chartArea) {
+			if (this.options.show) {
+				
+				var setContextLineSettings;
+				
+				// Make sure we draw text in the correct color
+				this.ctx.fillStyle = this.options.labels.fontColor;
+				
+				if (this.isHorizontal()) {
+					setContextLineSettings = true;
+					var yTickStart = this.options.position == "bottom" ? this.top : this.bottom - 10;
+					var yTickEnd = this.options.position == "bottom" ? this.top + 10 : this.bottom;
+					var isRotated = this.labelRotation !== 0;
+
+					helpers.each(this.labels, function(label, index) {
+						var xLineValue = this.getPixelForValue(label, index, false); // xvalues for grid lines
+						var xLabelValue= this.getPixelForValue(label, index, true); // x values for labels (need to consider offsetLabel option)
+
+						if (this.options.gridLines.show) {
+							if (index === 0) {
+								// Draw the first index specially
+								this.ctx.lineWidth = this.options.gridLines.zeroLineWidth;
+								this.ctx.strokeStyle = this.options.gridLines.zeroLineColor;
+								setContextLineSettings = true; // reset next time
+							} else if (setContextLineSettings) {
+								this.ctx.lineWidth = this.options.gridLines.lineWidth;
+								this.ctx.strokeStyle = this.options.gridLines.color;
+								setContextLineSettings = false;
+							}
+							
+							xLineValue += helpers.aliasPixel(this.ctx.lineWidth);
+							
+							// Draw the label area
+							this.ctx.beginPath();
+
+							if (this.options.gridLines.drawTicks) {	
+								this.ctx.moveTo(xLineValue, yTickStart);
+								this.ctx.lineTo(xLineValue, yTickEnd);
+							}
+							
+							// Draw the chart area
+							if (this.options.gridLines.drawOnChartArea) {
+								this.ctx.moveTo(xLineValue, chartArea.top);
+								this.ctx.lineTo(xLineValue, chartArea.bottom);
+							}
+
+							// Need to stroke in the loop because we are potentially changing line widths & colours
+							this.ctx.stroke();
+						}
+
+						if (this.options.labels.show) {
+							this.ctx.save();
+							this.ctx.translate(xLabelValue, (isRotated) ? this.top + 12 : this.top + 8);
+							this.ctx.rotate(helpers.toRadians(this.labelRotation) * -1);
+							this.ctx.font = this.font;
+							this.ctx.textAlign = (isRotated) ? "right" : "center";
+							this.ctx.textBaseline = (isRotated) ? "middle" : "top";
+							this.ctx.fillText(label, 0, 0);
+							this.ctx.restore();
+						}
+					}, this);
+				} else {
+					// Vertical
+					if (this.options.gridLines.show) {
+					}
+					
+					if (this.options.labels.show) {
+						// Draw the labels
+					}
+				}
+			}
 		}
 	});
 	Chart.scales.registerScaleType("dataset", DatasetScale);