Added Polymer 0.5.4

polymer_0.5.4/bower_components/chartnewjs/ChartNew.js

-/*              ²
+/*              
  * ChartNew.js  
  *
  * Vancoppenolle Francois - January 2014
  * francois.vancoppenolle@favomo.be
  *
  * Source location : http:\\www.favomo.be\graphjs
  * GitHub community : https://github.com/FVANCOP/ChartNew.js
  *
  * This file is originally an adaptation of the chart.js source developped by Nick Downie (2013)
  * https://github.com/nnnick/Chart.js. But since june 2014, Nick puts a new version with a
@@ skipping 199 matching lines @@
                 }
                 return window[fctName](parameter);
         }
         return;
 };
 
 function isNumber(n) {
         return !isNaN(parseFloat(n)) && isFinite(n);
 };
 
-function tmplbis(str, data) {
+function tmplbis(str, data,config) {
+        newstr=str;
+        if(newstr.substr(0,config.templatesOpenTag.length)==config.templatesOpenTag)newstr="<%="+newstr.substr(config.templatesOpenTag.length,newstr.length-config.templatesOpenTag.length);
+        if(newstr.substr(newstr.length-config.templatesCloseTag.length,config.templatesCloseTag.length)==config.templatesCloseTag)newstr=newstr.substr(0,newstr.length-config.templatesCloseTag.length)+"%>";
+        return tmplter(newstr,data);
+}
+
+function tmplter(str, data) {
         var mathFunctionList = ["mean", "varianz", "stddev", "cv", "median"];
         var regexMath = new RegExp('<%=((?:(?:.*?)\\W)??)((?:' + mathFunctionList.join('|') + ')(?:Dif)?)\\(([0-9]*?)\\)(.*?)%>', 'g');
         while (regexMath.test(str)) {
                 str = str.replace(regexMath, function($0, $1, $2, $3, $4) {
                         if ($3) {
                                 var rndFac = $3;
                         } else {
                                 var rndFac = 2;
                         }
                         var value = addParameters2Function(data, $2, "mathFunctions");
                         if (isNumber(value)) {
                                 return '<%=' + $1 + '' + Math.round(Math.pow(10, rndFac) * value) / Math.pow(10, rndFac) + '' + $4 + '%>';
                         }
                         return '<%= %>';
                 });
         }
         // Figure out if we're getting a template, or if we need to
         // load the template - and be sure to cache the result.
         // first check if it's can be an id
         var fn = /^[A-Za-z][-A-Za-z0-9_:.]*$/.test(str) ? cachebis[str] = cachebis[str] ||
-                tmplbis(document.getElementById(str).innerHTML) :
+                tmplter(document.getElementById(str).innerHTML) :
                 // Generate a reusable function that will serve as a template
                 // generator (and which will be cached).
                 new Function("obj",
                         "var p=[],print=function(){p.push.apply(p,arguments);};" +
                         // Introduce the data as local variables using with(){}
                         "with(obj){p.push('" +
                         // Convert the template into pure JavaScript
                         str
                         .replace(/[\r\n]/g, "\\n")
                         .replace(/[\t]/g, " ")
@@ skipping 473 matching lines @@
                                 if (canvas_pos.y < myStatData.midPosY) angle = -angle;
                                 angle = (((angle  + 2 * Math.PI) % (2 * Math.PI)) + 2* Math.PI) % (2* Math.PI) ; 
                                 myStatData.startAngle=(((myStatData.startAngle  + 2 * Math.PI) % (2 * Math.PI)) + 2* Math.PI) % (2* Math.PI);
                                 myStatData.endAngle=(((myStatData.endAngle  + 2 * Math.PI) % (2 * Math.PI)) + 2* Math.PI) % (2* Math.PI);
                                 if(myStatData.endAngle<myStatData.startAngle)myStatData.endAngle+=2 * Math.PI;
                                 if ((angle > myStatData.startAngle && angle < myStatData.endAngle) || (angle > myStatData.startAngle - 2 * Math.PI && angle < myStatData.endAngle - 2 * Math.PI) || (angle > myStatData.startAngle + 2 * Math.PI && angle < myStatData.endAngle + 2 * Math.PI)) {
                                         myStatData.graphPosX = canvas_pos.x;
                                         myStatData.graphPosY = canvas_pos.y;
                                         onData = true;
                                         if (action == "annotate") {
-                                                dispString = tmplbis(setOptionValue("ANNOTATELABEL",ctx,data,jsGraphAnnotate[ctx.ChartNewId][i][3],undefined,config.annotateLabel,jsGraphAnnotate[ctx.ChartNewId][i][12],-1,{otherVal:true}), myStatData);
+                                                dispString = tmplbis(setOptionValue("ANNOTATELABEL",ctx,data,jsGraphAnnotate[ctx.ChartNewId][i][3],undefined,config.annotateLabel,jsGraphAnnotate[ctx.ChartNewId][i][12],-1,{otherVal:true}), myStatData,config);
                                                 annotateDIV.innerHTML = dispString;
                                                 show = true;
                                         } else {
                                                 funct(event, ctx, config, data, myStatData );
                                         }
                                         if (action == "annotate") {
                                                 x = bw.ns4 || bw.ns5 ? event.pageX : event.x;
                                                 y = bw.ns4 || bw.ns5 ? event.pageY : event.y;
                                                 if (bw.ie4 || bw.ie5) y = y + eval(scrolled);
                                                 oCursor.moveIt(x + fromLeft, y + fromTop);
                                         }
                                 }
                         }
                 } else if (jsGraphAnnotate[ctx.ChartNewId][i][0] == "RECT") {
                         myStatData=jsGraphAnnotate[ctx.ChartNewId][i][3][jsGraphAnnotate[ctx.ChartNewId][i][1]][jsGraphAnnotate[ctx.ChartNewId][i][2]];
                         
                         if (canvas_pos.x > Math.min(myStatData.xPosLeft,myStatData.xPosRight) && canvas_pos.x < Math.max(myStatData.xPosLeft,myStatData.xPosRight) && canvas_pos.y < Math.max(myStatData.yPosBottom,myStatData.yPosTop) && canvas_pos.y > Math.min(myStatData.yPosBottom,myStatData.yPosTop)) {
                                 myStatData.graphPosX = canvas_pos.x;
                                 myStatData.graphPosY = canvas_pos.y;
                                 onData = true;
                                 if (action == "annotate") {
-                                        dispString = tmplbis(setOptionValue("ANNOTATELABEL",ctx,data,jsGraphAnnotate[ctx.ChartNewId][i][3],undefined,config.annotateLabel,jsGraphAnnotate[ctx.ChartNewId][i][1],jsGraphAnnotate[ctx.ChartNewId][i][2],{otherVal:true}), myStatData);
+                                        dispString = tmplbis(setOptionValue("ANNOTATELABEL",ctx,data,jsGraphAnnotate[ctx.ChartNewId][i][3],undefined,config.annotateLabel,jsGraphAnnotate[ctx.ChartNewId][i][1],jsGraphAnnotate[ctx.ChartNewId][i][2],{otherVal:true}), myStatData,config);
                                         annotateDIV.innerHTML = dispString;
                                         show = true;
                                 } else {
                                         funct(event, ctx, config, data, myStatData );
                                 }
                                 if (action == "annotate") {
                                         x = bw.ns4 || bw.ns5 ? event.pageX : event.x;
                                         y = bw.ns4 || bw.ns5 ? event.pageY : event.y;
                                         if (bw.ie4 || bw.ie5) y = y + eval(scrolled);
                                         oCursor.moveIt(x + fromLeft, y + fromTop);
@@ skipping 20 matching lines @@
                                 }
                                                                 
                         } else {
                                 distance = Math.sqrt((canvas_pos.x - myStatData.posX) * (canvas_pos.x - myStatData.posX) + (canvas_pos.y - myStatData.posY) * (canvas_pos.y - myStatData.posY));
                         }
                         if (distance < config.pointHitDetectionRadius) {
                                 myStatData.graphPosX = canvas_pos.x;
                                 myStatData.graphPosY = canvas_pos.y;
                                 onData = true;
                                 if (action == "annotate") {
-                                        dispString = tmplbis(setOptionValue("ANNOTATELABEL",ctx,data,jsGraphAnnotate[ctx.ChartNewId][i][3],undefined,config.annotateLabel,jsGraphAnnotate[ctx.ChartNewId][i][1],jsGraphAnnotate[ctx.ChartNewId][i][2],{otherVal:true}), myStatData);
+                                        dispString = tmplbis(setOptionValue("ANNOTATELABEL",ctx,data,jsGraphAnnotate[ctx.ChartNewId][i][3],undefined,config.annotateLabel,jsGraphAnnotate[ctx.ChartNewId][i][1],jsGraphAnnotate[ctx.ChartNewId][i][2],{otherVal:true}), myStatData,config);
                                         annotateDIV.innerHTML = dispString;
                                         show = true;
                                 } else {
                                         funct(event, ctx, config, data, myStatData);
                                 }
                                 if (action == "annotate") {
                                         x = bw.ns4 || bw.ns5 ? event.pageX : event.x;
                                         y = bw.ns4 || bw.ns5 ? event.pageY : event.y;
                                         if (bw.ie4 || bw.ie5) y = y + eval(scrolled);
                                         oCursor.moveIt(x + fromLeft, y + fromTop);
@@ skipping 791 matching lines @@
                 crossImagePosY: [0],
                 crossImageAngle: [0],
                 spaceTop: 0,
                 spaceBottom: 0,
                 spaceRight: 0,
                 spaceLeft: 0,
                 decimalSeparator: ".",
                 thousandSeparator: "",
                 roundNumber: "none",
                 roundPct: -1,
+                templatesOpenTag : "<%=",
+                templatesCloseTag : "%>",
                 fmtV1: "none",
                 fmtV2: "none",
                 fmtV3: "none",
                 fmtV4: "none",
                 fmtV5: "none",
                 fmtV6: "none",
+                fmtV6T: "none",
                 fmtV7: "none",
                 fmtV8: "none",
+                fmtV8T: "none",
                 fmtV9: "none",
                 fmtV10: "none",
                 fmtV11: "none",
                 fmtV12: "none",
                 fmtV13: "none",
                 fmtXLabel: "none",
                 fmtYLabel: "none",
                 fmtYLabel2: "none",
                 fmtLegend: "none",
                 animationStartValue: 0,
@@ skipping 209 matching lines @@
                                                 } else ctx.textAlign = setOptionValue("INGRAPHDATAALIGN",ctx,data,statData,undefined,config.inGraphDataAlign,i,-1,{nullValue: true  });
                                                 if (setOptionValue("INGRAPHDATAVALIGN",ctx,data,statData,undefined,config.inGraphDataVAlign,i,-1,{nullValue : true} ) == "off-center") {
                                                         if ((posAngle + 2 * Math.PI) % (2 * Math.PI) > Math.PI) ctx.textBaseline = "top";
                                                         else ctx.textBaseline = "bottom";
                                                 } else if (setOptionValue("INGRAPHDATAVALIGN",ctx,data,statData,undefined,config.inGraphDataVAlign,i,-1,{nullValue : true} ) == "to-center") {
                                                         if ((posAngle + 2 * Math.PI) % (2 * Math.PI) > Math.PI) ctx.textBaseline = "bottom";
                                                         else ctx.textBaseline = "top";
                                                 } else ctx.textBaseline = setOptionValue("INGRAPHDATAVALIGN",ctx,data,statData,undefined,config.inGraphDataVAlign,i,-1,{nullValue : true} );
                                                 ctx.font = setOptionValue("INGRAPHDATAFONTSTYLE",ctx,data,statData,undefined,config.inGraphDataFontStyle,i,-1,{nullValue : true} ) + ' ' + setOptionValue("INGRAPHDATAFONTSIZE",ctx,data,statData,undefined,config.inGraphDataFontSize,i,-1,{nullValue : true} ) + 'px ' + setOptionValue("INGRAPHDATAFONTFAMILY",ctx,data,statData,undefined,config.inGraphDataFontFamily,i,-1,{nullValue : true} );
                                                 ctx.fillStyle = setOptionValue("INGRAPHDATAFONTCOLOR",ctx,data,statData,undefined,config.inGraphDataFontColor,i,-1,{nullValue : true} );
-                                                var dispString = tmplbis(setOptionValue("INGRAPHDATATMPL",ctx,data,statData,undefined,config.inGraphDataTmpl,i,-1,{nullValue : true} ), statData[i]);
+                                                var dispString = tmplbis(setOptionValue("INGRAPHDATATMPL",ctx,data,statData,undefined,config.inGraphDataTmpl,i,-1,{nullValue : true} ), statData[i],config);
                                                 ctx.translate(midPosX + labelRadius * Math.cos(posAngle), midPosY - labelRadius * Math.sin(posAngle));
                                                 if (setOptionValue("INGRAPHDATAROTATE",ctx,data,statData,undefined,config.inGraphDataRotate,i,-1,{nullValue : true} ) == "inRadiusAxis") ctx.rotate(2 * Math.PI - posAngle);
                                                 else if (setOptionValue("INGRAPHDATAROTATE",ctx,data,statData,undefined,config.inGraphDataRotate,i,-1,{nullValue : true} ) == "inRadiusAxisRotateLabels") {
                                                         if ((posAngle + 2 * Math.PI) % (2 * Math.PI) > Math.PI / 2 && (posAngle + 2 * Math.PI) % (2 * Math.PI) < 3 * Math.PI / 2) ctx.rotate(3 * Math.PI - posAngle);
                                                         else ctx.rotate(2 * Math.PI - posAngle);
                                                 } else ctx.rotate(setOptionValue("INGRAPHDATAROTATE",ctx,data,statData,undefined,config.inGraphDataRotate,i,-1,{nullValue : true} ) * (Math.PI / 180));
                                                 ctx.fillTextMultiLine(dispString, 0, 0, ctx.textBaseline, setOptionValue("INGRAPHDATAFONTSIZE",ctx,data,statData,undefined,config.inGraphDataFontSize,i,-1,{nullValue : true} ), true);
                                                 ctx.restore();
                                         }
                                 }
@@ skipping 193 matching lines @@
                                                         if(statData[i][j].calculated_offset>0) {
                                                                 ctx.translate(midPosX + statData[i][j].offsetX * (radiusPrt/statData[i][j].calculated_offset), midPosY - statData[i][j].offsetY * (radiusPrt/statData[i][j].calculated_offset));
                                                         } else {
                                                                 ctx.translate(midPosX, midPosY);
                                                         }
                                                         if (setOptionValue("INGRAPHDATAROTATE",ctx,data,statData,undefined,config.inGraphDataRotate,i,-1,{nullValue : true} ) == "inRadiusAxis") ctx.rotate(j * rotationDegree);
                                                         else if (setOptionValue("INGRAPHDATAROTATE",ctx,data,statData,undefined,config.inGraphDataRotate,i,-1,{nullValue : true} ) == "inRadiusAxisRotateLabels") {
                                                                 if ((j * rotationDegree + 2 * Math.PI) % (2 * Math.PI) > Math.PI / 2 && (j * rotationDegree + 2 * Math.PI) % (2 * Math.PI) < 3 * Math.PI / 2) ctx.rotate(3 * Math.PI + j * rotationDegree);
                                                                 else ctx.rotate(2 * Math.PI + j * rotationDegree);
                                                         } else ctx.rotate(setOptionValue("INGRAPHDATAROTATE",ctx,data,statData,undefined,config.inGraphDataRotate,i,-1,{nullValue : true} ) * (Math.PI / 180));
-                                                        var dispString = tmplbis(setOptionValue("INGRAPHDATATMPL",ctx,data,statData,undefined,config.inGraphDataTmpl,i,-1,{nullValue : true} ), statData[i][j]);
+                                                        var dispString = tmplbis(setOptionValue("INGRAPHDATATMPL",ctx,data,statData,undefined,config.inGraphDataTmpl,i,-1,{nullValue : true} ), statData[i][j],config);
                                                         ctx.fillTextMultiLine(dispString, 0, 0, ctx.textBaseline, setOptionValue("INGRAPHDATAFONTSIZE",ctx,data,statData,undefined,config.inGraphDataFontSize,i,-1,{nullValue : true} ),true);
                                                         ctx.restore();
                                                 }
                                         }
                                 }
                         }
                         if(msr.legendMsr.dispLegend)drawLegend(msr.legendMsr,data,config,ctx,"Radar");
                 };
 
                 function drawScale() {
@@ skipping 248 matching lines @@
                                                 } else ctx.textAlign = setOptionValue("INGRAPHDATAALIGN",ctx,data,statData,undefined,config.inGraphDataAlign,i,-1,{nullValue: true  });
                                                 if (setOptionValue("INGRAPHDATAVALIGN",ctx,data,statData,undefined,config.inGraphDataVAlign,i,-1,{nullValue : true} ) == "off-center") {
                                                         if ((posAngle + 2 * Math.PI) % (2 * Math.PI) > Math.PI) ctx.textBaseline = "top";
                                                         else ctx.textBaseline = "bottom";
                                                 } else if (setOptionValue("INGRAPHDATAVALIGN",ctx,data,statData,undefined,config.inGraphDataVAlign,i,-1,{nullValue : true} ) == "to-center") {
                                                         if ((posAngle + 2 * Math.PI) % (2 * Math.PI) > Math.PI) ctx.textBaseline = "bottom";
                                                         else ctx.textBaseline = "top";
                                                 } else ctx.textBaseline = setOptionValue("INGRAPHDATAVALIGN",ctx,data,statData,undefined,config.inGraphDataVAlign,i,-1,{nullValue : true} );
                                                 ctx.font = setOptionValue("INGRAPHDATAFONTSTYLE",ctx,data,statData,undefined,config.inGraphDataFontStyle,i,-1,{nullValue : true} ) + ' ' + setOptionValue("INGRAPHDATAFONTSIZE",ctx,data,statData,undefined,config.inGraphDataFontSize,i,-1,{nullValue : true} ) + 'px ' + setOptionValue("INGRAPHDATAFONTFAMILY",ctx,data,statData,undefined,config.inGraphDataFontFamily,i,-1,{nullValue : true} );
                                                 ctx.fillStyle = setOptionValue("INGRAPHDATAFONTCOLOR",ctx,data,statData,undefined,config.inGraphDataFontColor,i,-1,{nullValue : true} );
-                                                var dispString = tmplbis(setOptionValue("INGRAPHDATATMPL",ctx,data,statData,undefined,config.inGraphDataTmpl,i,-1,{nullValue : true} ), statData[i]);
+                                                var dispString = tmplbis(setOptionValue("INGRAPHDATATMPL",ctx,data,statData,undefined,config.inGraphDataTmpl,i,-1,{nullValue : true} ), statData[i],config);
                                                 ctx.translate(midPieX + labelRadius * Math.cos(posAngle), midPieY - labelRadius * Math.sin(posAngle));
                                                 if (setOptionValue("INGRAPHDATAROTATE",ctx,data,statData,undefined,config.inGraphDataRotate,i,-1,{nullValue : true} ) == "inRadiusAxis") ctx.rotate(2 * Math.PI - posAngle);
                                                 else if (setOptionValue("INGRAPHDATAROTATE",ctx,data,statData,undefined,config.inGraphDataRotate,i,-1,{nullValue : true} ) == "inRadiusAxisRotateLabels") {
                                                         if ((posAngle + 2 * Math.PI) % (2 * Math.PI) > Math.PI / 2 && (posAngle + 2 * Math.PI) % (2 * Math.PI) < 3 * Math.PI / 2) ctx.rotate(3 * Math.PI - posAngle);
                                                         else ctx.rotate(2 * Math.PI - posAngle);
                                                 } else ctx.rotate(setOptionValue("INGRAPHDATAROTATE",ctx,data,statData,undefined,config.inGraphDataRotate,i,-1,{nullValue : true} ) * (Math.PI / 180));
                                                 ctx.fillTextMultiLine(dispString, 0, 0, ctx.textBaseline, setOptionValue("INGRAPHDATAFONTSIZE",ctx,data,statData,undefined,config.inGraphDataFontSize,i,-1,{nullValue : true} ),true);
                                                 ctx.restore();
                                         }
                                 }
@@ skipping 10 matching lines @@
                         if (isBooleanOptionTrue(undefined,config.inGraphDataShow) && setOptionValue("INGRAPHDATARADIUSPOSITION",ctx,data,statData,undefined,config.inGraphDataRadiusPosition,0,-1,{nullValue : true} ) == 3 && setOptionValue("INGRAPHDATAALIGN",ctx,data,statData,undefined,config.inGraphDataAlign,0,-1,{nullValue: true  }) == "off-center" && setOptionValue("INGRAPHDATAROTATE",ctx,data,statData,undefined,config.inGraphDataRotate,0,-1,{nullValue : true} ) == 0) {
                                 pieRadius = Min([msr.availableHeight / 2, msr.availableWidth / 2]) - setOptionValue("INGRAPHDATAFONTSIZE",ctx,data,statData,undefined,config.inGraphDataFontSize,0,-1,{nullValue : true} ) - setOptionValue("INGRAPHDATAPADDINGRADIUS",ctx,data,statData,undefined,config.inGraphDataPaddingRadius,0,-1,{nullValue: true} ) - 5;
                                 var realCumulativeAngle = ((config.startAngle * (Math.PI / 180) + 2 * Math.PI) % (2*Math.PI) + 2*Math.PI) % (2*Math.PI);
                                 for (var i = 0; i < data.length; i++) {
                                         if (!(typeof(data[i].value) == 'undefined') && 1*data[i].value>=0) {
                                                 ctx.font = setOptionValue("INGRAPHDATAFONTSTYLE",ctx,data,statData,undefined,config.inGraphDataFontStyle,i,-1,{nullValue : true} ) + ' ' + setOptionValue("INGRAPHDATAFONTSIZE",ctx,data,statData,undefined,config.inGraphDataFontSize,0,-1,{nullValue : true} ) + 'px ' + setOptionValue("INGRAPHDATAFONTFAMILY",ctx,data,statData,undefined,config.inGraphDataFontFamily,i,-1,{nullValue : true} );
                                                 if (setOptionValue("INGRAPHDATAANGLEPOSITION",ctx,data,statData,undefined,config.inGraphDataAnglePosition,i,-1,{nullValue : true} ) == 1) posAngle = realCumulativeAngle + setOptionValue("INGRAPHDATAPADDINANGLE",ctx,data,statData,undefined,config.inGraphDataPaddingAngle,i,-1,{nullValue: true  }) * (Math.PI / 180);
                                                 else if (setOptionValue("INGRAPHDATAANGLEPOSITION",ctx,data,statData,undefined,config.inGraphDataAnglePosition,i,-1,{nullValue : true} ) == 2) posAngle = realCumulativeAngle - statData[i].segmentAngle / 2 + setOptionValue("INGRAPHDATAPADDINANGLE",ctx,data,statData,undefined,config.inGraphDataPaddingAngle,i,-1,{nullValue: true  }) * (Math.PI / 180);
                                                 else if (setOptionValue("INGRAPHDATAANGLEPOSITION",ctx,data,statData,undefined,config.inGraphDataAnglePosition,i,-1,{nullValue : true} ) == 3) posAngle = realCumulativeAngle - statData[i].segmentAngle + setOptionValue("INGRAPHDATAPADDINANGLE",ctx,data,statData,undefined,config.inGraphDataPaddingAngle,i,-1,{nullValue: true  }) * (Math.PI / 180);
                                                 realCumulativeAngle -= statData[i].segmentAngle;
-                                                var dispString = tmplbis(setOptionValue("INGRAPHDATATMPL",ctx,data,statData,undefined,config.inGraphDataTmpl,i,-1,{nullValue : true} ), statData[i]);
+                                                var dispString = tmplbis(setOptionValue("INGRAPHDATATMPL",ctx,data,statData,undefined,config.inGraphDataTmpl,i,-1,{nullValue : true} ), statData[i],config);
                                                 var textMeasurement = ctx.measureText(dispString).width;
                                                 var MaxRadiusX = Math.abs((msr.availableWidth / 2 - textMeasurement) / Math.cos(posAngle)) - setOptionValue("INGRAPHDATAPADDINGRADIUS",ctx,data,statData,undefined,config.inGraphDataPaddingRadius,i,-1,{nullValue: true} ) - 5;
                                                 if (MaxRadiusX < pieRadius) pieRadius = MaxRadiusX;
                                         }
                                 }
                         }
                         pieRadius = pieRadius * config.radiusScale;
                 };
         };
         var Doughnut = function(data, config, ctx) {
@@ skipping 86 matching lines @@
                                                 } else ctx.textAlign = setOptionValue("INGRAPHDATAALIGN",ctx,data,statData,undefined,config.inGraphDataAlign,i,-1,{nullValue: true  });
                                                 if (setOptionValue("INGRAPHDATAVALIGN",ctx,data,statData,undefined,config.inGraphDataVAlign,i,-1,{nullValue : true} ) == "off-center") {
                                                         if ((posAngle + 2 * Math.PI) % (2 * Math.PI) > Math.PI) ctx.textBaseline = "top";
                                                         else ctx.textBaseline = "bottom";
                                                 } else if (setOptionValue("INGRAPHDATAVALIGN",ctx,data,statData,undefined,config.inGraphDataVAlign,i,-1,{nullValue : true} ) == "to-center") {
                                                         if ((posAngle + 2 * Math.PI) % (2 * Math.PI) > Math.PI) ctx.textBaseline = "bottom";
                                                         else ctx.textBaseline = "top";
                                                 } else ctx.textBaseline = setOptionValue("INGRAPHDATAVALIGN",ctx,data,statData,undefined,config.inGraphDataVAlign,i,-1,{nullValue : true} );
                                                 ctx.font = setOptionValue("INGRAPHDATAFONTSTYLE",ctx,data,statData,undefined,config.inGraphDataFontStyle,i,-1,{nullValue : true} ) + ' ' + setOptionValue("INGRAPHDATAFONTSIZE",ctx,data,statData,undefined,config.inGraphDataFontSize,i,-1,{nullValue : true} ) + 'px ' + setOptionValue("INGRAPHDATAFONTFAMILY",ctx,data,statData,undefined,config.inGraphDataFontFamily,i,-1,{nullValue : true} );
                                                 ctx.fillStyle = setOptionValue("INGRAPHDATAFONTCOLOR",ctx,data,statData,undefined,config.inGraphDataFontColor,i,-1,{nullValue : true} );
-                                                var dispString = tmplbis(setOptionValue("INGRAPHDATATMPL",ctx,data,statData,undefined,config.inGraphDataTmpl,i,-1,{nullValue : true} ), statData[i]);
+                                                var dispString = tmplbis(setOptionValue("INGRAPHDATATMPL",ctx,data,statData,undefined,config.inGraphDataTmpl,i,-1,{nullValue : true} ), statData[i],config);
                                                 ctx.translate(midPieX + labelRadius * Math.cos(posAngle), midPieY - labelRadius * Math.sin(posAngle));
                                                 if (setOptionValue("INGRAPHDATAROTATE",ctx,data,statData,undefined,config.inGraphDataRotate,i,-1,{nullValue : true} ) == "inRadiusAxis") ctx.rotate(2 * Math.PI - posAngle);
                                                 else if (setOptionValue("INGRAPHDATAROTATE",ctx,data,statData,undefined,config.inGraphDataRotate,i,-1,{nullValue : true} ) == "inRadiusAxisRotateLabels") {
                                                         if ((posAngle + 2 * Math.PI) % (2 * Math.PI) > Math.PI / 2 && (posAngle + 2 * Math.PI) % (2 * Math.PI) < 3 * Math.PI / 2) ctx.rotate(3 * Math.PI - posAngle);
                                                         else ctx.rotate(2 * Math.PI - posAngle);
                                                 } else ctx.rotate(setOptionValue("INGRAPHDATAROTATE",ctx,data,statData,undefined,config.inGraphDataRotate,i,-1,{nullValue : true} ) * (Math.PI / 180));
                                                 ctx.fillTextMultiLine(dispString, 0, 0, ctx.textBaseline, setOptionValue("INGRAPHDATAFONTSIZE",ctx,data,statData,undefined,config.inGraphDataFontSize,i,-1,{nullValue : true} ),true);
                                                 ctx.restore();
                                         }
                                 }
@@ skipping 10 matching lines @@
                                 doughnutRadius = Min([msr.availableHeight / 2, msr.availableWidth / 2]) - setOptionValue("INGRAPHDATAFONTSIZE",ctx,data,statData,undefined,config.inGraphDataFontSize,0,-1,{nullValue : true} ) - setOptionValue("INGRAPHDATAPADDINGRADIUS",ctx,data,statData,undefined,config.inGraphDataPaddingRadius,0,-1,{nullValue: true} ) - 5;
                                 var realCumulativeAngle = (((config.startAngle * (Math.PI / 180) + 2 * Math.PI) % (2 * Math.PI)) + 2* Math.PI) % (2* Math.PI) ; 
                                 var posAngle;
                                 for (var i = 0; i < data.length; i++) {
                                         if (!(typeof(data[i].value) == 'undefined') && 1*data[i].value>=0) {
                                                 ctx.font = setOptionValue("INGRAPHDATAFONTSTYLE",ctx,data,statData,undefined,config.inGraphDataFontStyle,i,-1,{nullValue : true} ) + ' ' + setOptionValue("INGRAPHDATAFONTSIZE",ctx,data,statData,undefined,config.inGraphDataFontSize,i,-1,{nullValue : true} ) + 'px ' + setOptionValue("INGRAPHDATAFONTFAMILY",ctx,data,statData,undefined,config.inGraphDataFontFamily,i,-1,{nullValue : true} );
                                                 if (setOptionValue("INGRAPHDATAANGLEPOSITION",ctx,data,statData,undefined,config.inGraphDataAnglePosition,i,-1,{nullValue : true} ) == 1) posAngle = realCumulativeAngle + setOptionValue("INGRAPHDATAPADDINANGLE",ctx,data,statData,undefined,config.inGraphDataPaddingAngle,i,-1,{nullValue: true  }) * (Math.PI / 180);
                                                 else if (setOptionValue("INGRAPHDATAANGLEPOSITION",ctx,data,statData,undefined,config.inGraphDataAnglePosition,i,-1,{nullValue : true} ) == 2) posAngle = realCumulativeAngle - statData[i].segmentAngle / 2 + setOptionValue("INGRAPHDATAPADDINANGLE",ctx,data,statData,undefined,config.inGraphDataPaddingAngle,i,-1,{nullValue: true  }) * (Math.PI / 180);
                                                 else if (setOptionValue("INGRAPHDATAANGLEPOSITION",ctx,data,statData,undefined,config.inGraphDataAnglePosition,i,-1,{nullValue : true} ) == 3) posAngle = realCumulativeAngle - statData[i].segmentAngle + setOptionValue("INGRAPHDATAPADDINANGLE",ctx,data,statData,undefined,config.inGraphDataPaddingAngle,i,-1,{nullValue: true  }) * (Math.PI / 180);
                                                 realCumulativeAngle -= statData[i].segmentAngle;
-                                                var dispString = tmplbis(setOptionValue("INGRAPHDATATMPL",ctx,data,statData,undefined,config.inGraphDataTmpl,i,-1,{nullValue : true} ), statData[i]);
+                                                var dispString = tmplbis(setOptionValue("INGRAPHDATATMPL",ctx,data,statData,undefined,config.inGraphDataTmpl,i,-1,{nullValue : true} ), statData[i],config);
                                                 var textMeasurement = ctx.measureText(dispString).width;
                                                 var MaxRadiusX = Math.abs((msr.availableWidth / 2 - textMeasurement) / Math.cos(posAngle)) - setOptionValue("INGRAPHDATAPADDINGRADIUS",ctx,data,statData,undefined,config.inGraphDataPaddingRadius,i,-1,{nullValue: true} ) - 5;
                                                 if (MaxRadiusX < doughnutRadius) doughnutRadius = MaxRadiusX;
                                         }
                                 }
                         }
                         doughnutRadius = doughnutRadius * config.radiusScale;
                 };
         };
         var Line = function(data, config, ctx) {
@@ skipping 387 matching lines @@
                                 calculatedScale = {
                                         steps: scaleSteps,
                                         stepValue: scaleStepWidth,
                                         graphMin: scaleStartValue,
                                         labels: []
                                 }
                                 for (var i = 0; i <= calculatedScale.steps; i++) {
                                         if (labelTemplateString) {
                                                 calculatedScale.labels.push(tmpl(labelTemplateString, {
                                                         value: fmtChartJS(config, 1 * ((scaleStartValue + (scaleStepWidth * i)).toFixed(getDecimalPlaces(scaleStepWidth))), config.fmtYLabel)
-                                                }));
+                                                },config));
                                         }
                                 }
                                 msr = setMeasures(data, config, ctx, height, width, calculatedScale.labels, null, true, false, true, true, true, "StackedBar");
                         }
         
                         var prevHeight=msr.availableHeight;
         
                         msr.availableHeight = msr.availableHeight - config.scaleTickSizeBottom - config.scaleTickSizeTop;
                         msr.availableWidth = msr.availableWidth - config.scaleTickSizeLeft - config.scaleTickSizeRight;
                         scaleHop = Math.floor(msr.availableHeight / calculatedScale.steps);
@@ skipping 62 matching lines @@
                                                 if (typeof(data.datasets[i].data[j]) == 'undefined') continue;
                                                 if(setOptionValue("ANNOTATEDISPLAY",ctx,data,statData,undefined,config.annotateDisplay,i,j,{nullValue : true})) {
                                                         jsGraphAnnotate[ctx.ChartNewId][jsGraphAnnotate[ctx.ChartNewId].length] = ["RECT", i, j, statData];
                                                 }
                                                 if(setOptionValue("INGRAPHDATASHOW",ctx,data,statData,undefined,config.inGraphDataShow,i,j,{nullValue : true})) {
                                                         ctx.save();
                                                         ctx.textAlign = setOptionValue("INGRAPHDATAALIGN",ctx,data,statData,undefined,config.inGraphDataAlign,i,j,{nullValue: true  });
                                                         ctx.textBaseline = setOptionValue("INGRAPHDATAVALIGN",ctx,data,statData,undefined,config.inGraphDataVAlign,i,j,{nullValue : true} );
                                                         ctx.font = setOptionValue("INGRAPHDATAFONTSTYLE",ctx,data,statData,undefined,config.inGraphDataFontStyle,i,j,{nullValue : true} ) + ' ' + setOptionValue("INGRAPHDATAFONTSIZE",ctx,data,statData,undefined,config.inGraphDataFontSize,i,j,{nullValue : true} ) + 'px ' + setOptionValue("INGRAPHDATAFONTFAMILY",ctx,data,statData,undefined,config.inGraphDataFontFamily,i,j,{nullValue : true} );
                                                         ctx.fillStyle = setOptionValue("INGRAPHDATAFONTCOLOR",ctx,data,statData,undefined,config.inGraphDataFontColor,i,j,{nullValue : true} );
-                                                        var dispString = tmplbis(setOptionValue("INGRAPHDATATMPL",ctx,data,statData,undefined,config.inGraphDataTmpl,i,j,{nullValue : true} ), statData[i][j]);
+                                                        var dispString = tmplbis(setOptionValue("INGRAPHDATATMPL",ctx,data,statData,undefined,config.inGraphDataTmpl,i,j,{nullValue : true} ), statData[i][j],config);
                                                         ctx.beginPath();
                                                         ctx.beginPath();
                                                         yPos = 0;
                                                         xPos = 0;
                                                         if (setOptionValue("INGRAPHDATAXPOSITION",ctx,data,statData,undefined,config.inGraphDataXPosition,i,j,{nullValue : true} ) == 1) {
                                                                 xPos = statData[i][j].xPosLeft + setOptionValue("INGRAPHDATAPADDINGX",ctx,data,statData,undefined,config.inGraphDataPaddingX,i,j,{nullValue : true} );
                                                         } else if (setOptionValue("INGRAPHDATAXPOSITION",ctx,data,statData,undefined,config.inGraphDataXPosition,i,j,{nullValue : true} ) == 2) {
                                                                 xPos = statData[i][j].xPosLeft + barWidth / 2 + setOptionValue("INGRAPHDATAPADDINGX",ctx,data,statData,undefined,config.inGraphDataPaddingX,i,j,{nullValue : true} );
                                                         } else if (setOptionValue("INGRAPHDATAXPOSITION",ctx,data,statData,undefined,config.inGraphDataXPosition,i,j,{nullValue : true} ) == 3) {
                                                                 xPos = statData[i][j].xPosLeft+ barWidth + setOptionValue("INGRAPHDATAPADDINGX",ctx,data,statData,undefined,config.inGraphDataPaddingX,i,j,{nullValue : true} );
@@ skipping 234 matching lines @@
                                 calculatedScale = {
                                         steps: scaleSteps,
                                         stepValue: scaleStepWidth,
                                         graphMin: scaleStartValue,
                                         labels: []
                                 }
                                 for (var i = 0; i <= calculatedScale.steps; i++) {
                                         if (labelTemplateString) {
                                                 calculatedScale.labels.push(tmpl(labelTemplateString, {
                                                         value: fmtChartJS(config, 1 * ((scaleStartValue + (scaleStepWidth * i)).toFixed(getDecimalPlaces(scaleStepWidth))), config.fmtYLabel)
-                                                }));
+                                                },config));
                                         }
                                 }
                                 msr = setMeasures(data, config, ctx, height, width, calculatedScale.labels, null, true, true, true, true, true, "HorizontalStackedBar");
                         }
                         msr.availableHeight = msr.availableHeight - config.scaleTickSizeBottom - config.scaleTickSizeTop;
                         msr.availableWidth = msr.availableWidth - config.scaleTickSizeLeft - config.scaleTickSizeRight;
                         scaleHop = Math.floor(msr.availableHeight / data.labels.length);
                         valueHop = Math.floor(msr.availableWidth / (calculatedScale.steps));
                         if (valueHop == 0 || config.fullWidthGraph) valueHop = (msr.availableWidth / (calculatedScale.steps));
                         msr.clrwidth = msr.clrwidth - (msr.availableWidth - (calculatedScale.steps * valueHop));
@@ skipping 67 matching lines @@
                                                 if ((typeof(data.datasets[i].data[j]) == 'undefined')) continue;
                                                 if (setOptionValue("ANNOTATEDISPLAY",ctx,data,statData,undefined,config.annotateDisplay,i,j,{nullValue : true})) {
                                                         jsGraphAnnotate[ctx.ChartNewId][jsGraphAnnotate[ctx.ChartNewId].length] = ["RECT", i ,j, statData];
                                                 }
                                                 if(setOptionValue("INGRAPHDATASHOW",ctx,data,statData,undefined,config.inGraphDataShow,i,j,{nullValue : true})) {
                                                         ctx.save();
                                                         ctx.textAlign = setOptionValue("INGRAPHDATAALIGN",ctx,data,statData,undefined,config.inGraphDataAlign,i,j,{nullValue: true  });
                                                         ctx.textBaseline = setOptionValue("INGRAPHDATAVALIGN",ctx,data,statData,undefined,config.inGraphDataVAlign,i,j,{nullValue : true} );
                                                         ctx.font = setOptionValue("INGRAPHDATAFONTSTYLE",ctx,data,statData,undefined,config.inGraphDataFontStyle,i,j,{nullValue : true} ) + ' ' + setOptionValue("INGRAPHDATAFONTSIZE",ctx,data,statData,undefined,config.inGraphDataFontSize,i,j,{nullValue : true} ) + 'px ' + setOptionValue("INGRAPHDATAFONTFAMILY",ctx,data,statData,undefined,config.inGraphDataFontFamily,i,j,{nullValue : true} );
                                                         ctx.fillStyle = setOptionValue("INGRAPHDATAFONTCOLOR",ctx,data,statData,undefined,config.inGraphDataFontColor,i,j,{nullValue : true} );
-                                                        var dispString = tmplbis(setOptionValue("INGRAPHDATATMPL",ctx,data,statData,undefined,config.inGraphDataTmpl,i,j,{nullValue : true} ),statData[i][j]);
+                                                        var dispString = tmplbis(setOptionValue("INGRAPHDATATMPL",ctx,data,statData,undefined,config.inGraphDataTmpl,i,j,{nullValue : true} ),statData[i][j],config);
                                                         ctx.beginPath();
                                                         yPos = 0;
                                                         xPos = 0;
                                                         if (setOptionValue("INGRAPHDATAXPOSITION",ctx,data,statData,undefined,config.inGraphDataXPosition,i,j,{nullValue : true} ) == 1) {
                                                                 xPos = statData[i][j].xPosLeft + setOptionValue("INGRAPHDATAPADDINGX",ctx,data,statData,undefined,config.inGraphDataPaddingX,i,j,{nullValue : true} );
                                                         } else if (setOptionValue("INGRAPHDATAXPOSITION",ctx,data,statData,undefined,config.inGraphDataXPosition,i,j,{nullValue : true} ) == 2) {
                                                                 xPos = statData[i][j].xPosLeft + (statData[i][j].xPosRight-statData[i][j].xPosLeft)/2 + setOptionValue("INGRAPHDATAPADDINGX",ctx,data,statData,undefined,config.inGraphDataPaddingX,i,j,{nullValue : true} );
                                                         } else if (setOptionValue("INGRAPHDATAXPOSITION",ctx,data,statData,undefined,config.inGraphDataXPosition,i,j,{nullValue : true} ) == 3) {
                                                                 xPos = statData[i][j].xPosRight + setOptionValue("INGRAPHDATAPADDINGX",ctx,data,statData,undefined,config.inGraphDataPaddingX,i,j,{nullValue : true} );
                                                         }
                                                         if (setOptionValue("INGRAPHDATAYPOSITION",ctx,data,statData,undefined,config.inGraphDataYPosition,i,j,{nullValue : true} ) == 1) {
                                                                 yPos = statData[i][j].yPosBottom - setOptionValue("INGRAPHDATAPADDINGY",ctx,data,statData,undefined,config.inGraphDataPaddingY,i,j,{nullValue : true} );
                                                         } else if (setOptionValue("INGRAPHDATAYPOSITION",ctx,data,statData,undefined,config.inGraphDataYPosition,i,j,{nullValue : true} ) == 2) {
                                                                 yPos = statData[i][j].yPosBottom - barWidth / 2 - setOptionValue("INGRAPHDATAPADDINGY",ctx,data,statData,undefined,config.inGraphDataPaddingY,i,j,{nullValue : true} );
                                                         } else if (setOptionValue("INGRAPHDATAYPOSITION",ctx,data,statData,undefined,config.inGraphDataYPosition,i,j,{nullValue : true} ) == 3) {
                                                                 yPos = statData[i][j].yPosTop - setOptionValue("INGRAPHDATAPADDINGY",ctx,data,statData,undefined,config.inGraphDataPaddingY,i,j,{nullValue : true} );
                                                         }
-                                                        if(xPos<=msr.availableWidth+msr.leftNotUsableSize) {
+//                                                              if(xPos<=msr.availableWidth+msr.leftNotUsableSize) {
                                                                 ctx.translate(xPos, yPos);
                                                                 ctx.rotate(setOptionValue("INGRAPHDATAROTATE",ctx,data,statData,undefined,config.inGraphDataRotate,i,j,{nullValue : true} ) * (Math.PI / 180));
                                                                 ctx.fillTextMultiLine(dispString, 0, 0, ctx.textBaseline, setOptionValue("INGRAPHDATAFONTSIZE",ctx,data,statData,undefined,config.inGraphDataFontSize,i,j,{nullValue : true} ),true);
                                                                 ctx.restore();
-                                                        }
+//                                                      }
                                                 }
                                         }
                                 }
                         }
                         if(msr.legendMsr.dispLegend)drawLegend(msr.legendMsr,data,config,ctx,"HorizontalStackedBar");
                 };
 
                 function drawScale() {
                         //X axis line                                                          
                         ctx.lineWidth = config.scaleLineWidth;
@@ skipping 350 matching lines @@
                                                                 xPos = statData[i][j].xPosLeft + barWidth + setOptionValue("INGRAPHDATAPADDINGX",ctx,data,statData,undefined,config.inGraphDataPaddingX,i,j,{nullValue : true} );
                                                         }
                                                         if (setOptionValue("INGRAPHDATAYPOSITION",ctx,data,statData,undefined,config.inGraphDataYPosition,i,j,{nullValue : true} ) == 1) {
                                                                 yPos = statData[i][j].yPosBottom - setOptionValue("INGRAPHDATAPADDINGY",ctx,data,statData,undefined,config.inGraphDataPaddingY,i,j,{nullValue : true} );
                                                         } else if (setOptionValue("INGRAPHDATAYPOSITION",ctx,data,statData,undefined,config.inGraphDataYPosition,i,j,{nullValue : true} ) == 2) {
                                                                 yPos = (statData[i][j].yPosBottom+statData[i][j].yPosTop)/2 - setOptionValue("INGRAPHDATAPADDINGY",ctx,data,statData,undefined,config.inGraphDataPaddingY,i,j,{nullValue : true} );
                                                         } else if (setOptionValue("INGRAPHDATAYPOSITION",ctx,data,statData,undefined,config.inGraphDataYPosition,i,j,{nullValue : true} ) == 3) {
                                                                 yPos = statData[i][j].yPosTop - setOptionValue("INGRAPHDATAPADDINGY",ctx,data,statData,undefined,config.inGraphDataPaddingY,i,j,{nullValue : true} );
                                                         }
                                                         ctx.translate(xPos, yPos);
-                                                        var dispString = tmplbis(setOptionValue("INGRAPHDATATMPL",ctx,data,statData,undefined,config.inGraphDataTmpl,i,j,{nullValue : true} ), statData[i][j]);
+                                                        var dispString = tmplbis(setOptionValue("INGRAPHDATATMPL",ctx,data,statData,undefined,config.inGraphDataTmpl,i,j,{nullValue : true} ), statData[i][j],config);
                                                         ctx.rotate(setOptionValue("INGRAPHDATAROTATE",ctx,data,statData,undefined,config.inGraphDataRotate,i,j,{nullValue : true} ) * (Math.PI / 180));
                                                         ctx.fillTextMultiLine(dispString, 0, 0, ctx.textBaseline, setOptionValue("INGRAPHDATAFONTSIZE",ctx,data,statData,undefined,config.inGraphDataFontSize,i,j,{nullValue : true} ),true);
                                                         ctx.restore();
                                                 }
                                         }
                                 }
                         }
                         if (animPc >= 1 && typeof drawMath == "function") {
                                 drawMath(ctx, config, data, msr, {
                                         xAxisPosY: xAxisPosY,
@@ skipping 328 matching lines @@
                                                                 yPos = statData[i][j].yPosTop - setOptionValue("INGRAPHDATAPADDINGY",ctx,data,statData,undefined,config.inGraphDataPaddingY,i,j,{nullValue : true} );
                                                         }
                                                         if (setOptionValue("INGRAPHDATAXPOSITION",ctx,data,statData,undefined,config.inGraphDataXPosition,i,j,{nullValue : true} ) == 1) {
                                                                 xPos = statData[i][j].xPosLeft + setOptionValue("INGRAPHDATAPADDINGX",ctx,data,statData,undefined,config.inGraphDataPaddingX,i,j,{nullValue : true} );
                                                         } else if (setOptionValue("INGRAPHDATAXPOSITION",ctx,data,statData,undefined,config.inGraphDataXPosition,i,j,{nullValue : true} ) == 2) {
                                                                 xPos = (statData[i][j].xPosLeft+statData[i][j].xPosRight)/2 + setOptionValue("INGRAPHDATAPADDINGX",ctx,data,statData,undefined,config.inGraphDataPaddingX,i,j,{nullValue : true} );
                                                         } else if (setOptionValue("INGRAPHDATAXPOSITION",ctx,data,statData,undefined,config.inGraphDataXPosition,i,j,{nullValue : true} ) == 3) {
                                                                 xPos = statData[i][j].xPosRight + setOptionValue("INGRAPHDATAPADDINGX",ctx,data,statData,undefined,config.inGraphDataPaddingX,i,j,{nullValue : true} );
                                                         }
                                                         ctx.translate(xPos, yPos);
-                                                        var dispString = tmplbis(setOptionValue("INGRAPHDATATMPL",ctx,data,statData,undefined,config.inGraphDataTmpl,i,j,{nullValue : true} ), statData[i][j]);
+                                                        var dispString = tmplbis(setOptionValue("INGRAPHDATATMPL",ctx,data,statData,undefined,config.inGraphDataTmpl,i,j,{nullValue : true} ), statData[i][j],config);
                                                         ctx.rotate(setOptionValue("INGRAPHDATAROTATE",ctx,data,statData,undefined,config.inGraphDataRotate,i,j,{nullValue : true} ) * (Math.PI / 180));
                                                         ctx.fillTextMultiLine(dispString, 0, 0, ctx.textBaseline, setOptionValue("INGRAPHDATAFONTSIZE",ctx,data,statData,undefined,config.inGraphDataFontSize,i,j,{nullValue : true} ),true);
                                                         ctx.restore();
                                                 }
                                         }
                                 }
                         }
                         if(msr.legendMsr.dispLegend)drawLegend(msr.legendMsr,data,config,ctx,"HorizontalBar");
                 };
 
@@ skipping 358 matching lines @@
                 } else {
                         logarithmic = config.logarithmic;
                         fmtYLabel = config.fmtYLabel;
                 }
                 if (labelTemplateString) {
                         //Fix floating point errors by setting to fixed the on the same decimal as the stepValue.
                         if (!logarithmic) { // no logarithmic scale
                                 for (var i = 0; i < numberOfSteps + 1; i++) {
                                         labels.push(tmpl(labelTemplateString, {
                                                 value: fmtChartJS(config, 1 * ((graphMin + (stepValue * i)).toFixed(getDecimalPlaces(stepValue))), fmtYLabel)
-                                        }));
+                                        },config));
                                 }
                         } else { // logarithmic scale 10,100,1000,...
                                 var value = graphMin;
                                 for (var i = 0; i < numberOfSteps + 1; i++) {
                                         labels.push(tmpl(labelTemplateString, {
                                                 value: fmtChartJS(config, 1 * value.toFixed(getDecimalPlaces(value)), fmtYLabel)
-                                        }));
+                                        },config));
                                         value *= 10;
                                 }
                         }
                 }
         };
         //Max value from array
         function Max(array) {
                 return Math.max.apply(Math, array);
         };
         //Min value from array
@@ skipping 39 matching lines @@
                 for (var attrname in defaults) {
                         returnObj[attrname] = defaults[attrname];
                 }
                 for (var attrname in userDefined) {
                         returnObj[attrname] = userDefined[attrname];
                 }
                 return returnObj;
         };
         //Javascript micro templating by John Resig - source at http://ejohn.org/blog/javascript-micro-templating/
         var cache = {};
+        
+        function tmpl(str, data,config) {
+                newstr=str;
+                if(newstr.substr(0,config.templatesOpenTag.length)==config.templatesOpenTag)newstr="<%="+newstr.substr(config.templatesOpenTag.length,newstr.length-config.templatesOpenTag.length);
+                if(newstr.substr(newstr.length-config.templatesCloseTag.length,config.templatesCloseTag.length)==config.templatesCloseTag)newstr=newstr.substr(0,newstr.length-config.templatesCloseTag.length)+"%>";
+                return tmplpart2(newstr,data);
+        }
 
-        function tmpl(str, data) {
+        function tmplpart2(str, data) {
                 // Figure out if we're getting a template, or if we need to
                 // load the template - and be sure to cache the result.
                 var fn = !/\W/.test(str) ?
                         cache[str] = cache[str] ||
-                        tmpl(document.getElementById(str).innerHTML) :
+                        tmplpart2(document.getElementById(str).innerHTML) :
                         // Generate a reusable function that will serve as a template
                         // generator (and which will be cached).
                         new Function("obj",
                                 "var p=[],print=function(){p.push.apply(p,arguments);};" +
                                 // Introduce the data as local variables using with(){}
                                 "with(obj){p.push('" +
                                 // Convert the template into pure JavaScript
                                 str
                                 .replace(/[\r\t\n]/g, " ")
                                 .split("<%").join("\t")
@@ skipping 911 matching lines @@
                                                 jsGraphAnnotate[ctx.ChartNewId][jsGraphAnnotate[ctx.ChartNewId].length] = ["POINT", i, j, statData];
                                         }
                                         if (setOptionValue("INGRAPHDATASHOW",ctx,data,statData,undefined,config.inGraphDataShow,i,j,{nullValue : true})) {
                                                 ctx.save();
                                                 ctx.textAlign = setOptionValue("INGRAPHDATAALIGN",ctx,data,statData,undefined,config.inGraphDataAlign,i,j,{nullValue: true  });
                                                 ctx.textBaseline = setOptionValue("INGRAPHDATAVALIGN",ctx,data,statData,undefined,config.inGraphDataVAlign,i,j,{nullValue : true} );
                                                 ctx.font = setOptionValue("INGRAPHDATAFONTSTYLE",ctx,data,statData,undefined,config.inGraphDataFontStyle,i,j,{nullValue : true} ) + ' ' + setOptionValue("INGRAPHDATAFONTSIZE",ctx,data,statData,undefined,config.inGraphDataFontSize,i,j,{nullValue : true} ) + 'px ' + setOptionValue("INGRAPHDATAFONTFAMILY",ctx,data,statData,undefined,config.inGraphDataFontFamily,i,j,{nullValue : true} );
                                                 ctx.fillStyle = setOptionValue("INGRAPHDATAFONTCOLOR",ctx,data,statData,undefined,config.inGraphDataFontColor,i,j,{nullValue : true} );
                                                 var paddingTextX = setOptionValue("INGRAPHDATAPADDINGX",ctx,data,statData,undefined,config.inGraphDataPaddingX,i,j,{nullValue : true} ),
                                                         paddingTextY = setOptionValue("INGRAPHDATAPADDINGY",ctx,data,statData,undefined,config.inGraphDataPaddingY,i,j,{nullValue : true} );
-                                                var dispString = tmplbis(setOptionValue("INGRAPHDATATMPL",ctx,data,statData,undefined,config.inGraphDataTmpl,i,j,{nullValue : true} ), statData[i][j]);
+                                                var dispString = tmplbis(setOptionValue("INGRAPHDATATMPL",ctx,data,statData,undefined,config.inGraphDataTmpl,i,j,{nullValue : true} ), statData[i][j],config);
                                                 ctx.translate(statData[i][j].xPos + paddingTextX, statData[i][j].yAxisPos - currentAnimPc.mainVal * statData[i][j].yPosOffset - paddingTextY);
                                                 ctx.rotate(setOptionValue("INGRAPHDATAROTATE",ctx,data,statData,undefined,config.inGraphDataRotate,i,j,{nullValue : true} ) * (Math.PI / 180));
                                                 ctx.fillTextMultiLine(dispString, 0, 0, ctx.textBaseline, setOptionValue("INGRAPHDATAFONTSIZE",ctx,data,statData,undefined,config.inGraphDataFontSize,i,j,{nullValue : true} ),true);
                                                 ctx.restore();
                                         }
                                 }
                         }
                 };
 
                          
@@ skipping 545 matching lines @@
                 lminvalue[0]=[];
                 lminvalue[1]=[];
                 var lgtxt,lgtxt2,tp;
                 var prevpos=[];
                 var firstNotMissingi=[];
                 var lastNotMissingi=[];
                 var firstNotMissingj=[];
                 var lastNotMissingj=[];
                 prevpos[0]=[];
                 prevpos[1]=[];
+                var grandtotal=0;
                 for (var i = 0; i < data.datasets.length; i++) {
                         // BUG when all data are missing !
                         if (typeof data.datasets[i].xPos != "undefined" && tpdraw(ctx,data.datasets[i])=="Line") {
                                 for(var j=data.datasets[i].data.length;j<data.datasets[i].xPos.length;j++)data.datasets[i].data.push(undefined);
                         } else {
                                 for(var j=data.datasets[i].data.length;j<data.labels.length;j++)data.datasets[i].data.push(undefined);
                         }
                                 
 
                         if(data.datasets[i].axis == 2) axis=0;else axis=1;
@@ skipping 10 matching lines @@
                                         firstNotMissingj[j]=-1;
                                         lastNotMissingj[j]=-1;
                                         totvalue[0][j] = 0; 
                                         mxvalue[0][j]=-Number.MAX_VALUE;
                                         mnvalue[0][j]=Number.MAX_VALUE;
                                         totvalue[1][j] = 0; 
                                         mxvalue[1][j]=-Number.MAX_VALUE;
                                         mnvalue[1][j]=Number.MAX_VALUE;
                                 }
                                 if (!(typeof data.datasets[i].data[j] == 'undefined')) {
+                                        grandtotal += 1 * data.datasets[i].data[j];
                                         if(firstNotMissingi[i]==-1)firstNotMissingi[i]=j;
                                         lastNotMissingi[i]=j;
                                         if(firstNotMissingj[j]==-1)firstNotMissingj[j]=i;
                                         lastNotMissingj[j]=i;
                                         totvalue[axis][j] += 1 * data.datasets[i].data[j]; 
                                         mxvalue[axis][j] =Math.max(mxvalue[axis][j],1 * data.datasets[i].data[j]);
                                         mnvalue[axis][j] =Math.min(mnvalue[axis][j],1 * data.datasets[i].data[j]);
                                         lmaxvalue[axis][i] =Math.max(lmaxvalue[axis][i],1 * data.datasets[i].data[j]);
                                         lminvalue[axis][i] =Math.min(lminvalue[axis][i],1 * data.datasets[i].data[j]);
                                 }
                         }
                 }
                 
                 for (var i = 0; i < data.datasets.length; i++) {
                         if(data.datasets[i].axis == 2) axis=0;else axis=1;
                         if (typeof(data.datasets[i].title) == "string") lgtxt = data.datasets[i].title.trim();
                         else lgtxt = "";
                         var prevnotemptyj=-1;
                         var prevemptyj=-1;
                         for (var j = 0; j < data.datasets[i].data.length; j++) {
                         
                                 if(typeof cumvalue[0][j]== "undefined"){cumvalue[0][j] = 0; prevpos[0][j]=-1;cumvalue[1][j] = 0; prevpos[1][j]=-1; }
                                 lgtxt2 = "";
                                 if (typeof data.datasets[i].xPos != "undefined") {
                                         if (!(typeof data.datasets[i].xPos[j] == "undefined")) lgtxt2 = data.datasets[i].xPos[j];
                                 }
                                 if (lgtxt2 == "" && !(typeof(data.labels[j]) == "undefined")) lgtxt2 = data.labels[j];
                                 if (typeof lgtxt2 == "string") lgtxt2 = lgtxt2.trim();
 
-                                if (!(typeof(data.datasets[i].data[j]) == 'undefined')) {
+//                              if (!(typeof(data.datasets[i].data[j]) == 'undefined') && data.datasets[i].data[j] != 0) {
+                                if (!(typeof(data.datasets[i].data[j]) == 'undefined') ) {
                                         cumvalue[axis][j]+=1*data.datasets[i].data[j];
                                         switch(tpdraw(ctx,data.datasets[i]))  {
                                                 case "Bar" :
                                                 case "StackedBar" :
                                                 case "HorizontalBar" :
                                                 case "HorizontalStackedBar" :
-
                                                         result[i][j]= {
                                                                 config: config,
                                                                 v1: fmtChartJS(config, lgtxt, config.fmtV1),
                                                                 v2: fmtChartJS(config, lgtxt2, config.fmtV2),
                                                                 v3: fmtChartJS(config, 1 * data.datasets[i].data[j], config.fmtV3),
                                                                 v4: fmtChartJS(config, cumvalue[axis][j], config.fmtV4),
                                                                 v5: fmtChartJS(config, totvalue[axis][j], config.fmtV5),
                                                                 v6: roundToWithThousands(config, fmtChartJS(config, 100 * data.datasets[i].data[j] / totvalue[axis][j], config.fmtV6), config.roundPct),
+                                                                v6T: roundToWithThousands(config, fmtChartJS(config, 100 * data.datasets[i].data[j] / grandtotal, config.fmtV6T), config.roundPct),
                                                                 v11: fmtChartJS(config, i, config.fmtV11),
                                                                 v12: fmtChartJS(config, j, config.fmtV12),
                                                                 lgtxt: lgtxt,
                                                                 lgtxt2: lgtxt2,
                                                                 datavalue: 1 * data.datasets[i].data[j],
                                                                 cumvalue: cumvalue[axis][j],
                                                                 totvalue: totvalue[axis][j],
                                                                 pctvalue: 100 * data.datasets[i].data[j] / totvalue[axis][j],
+                                                                pctvalueT: 100 * data.datasets[i].data[j] / grandtotal,
                                                                 maxvalue : mxvalue[axis][j],
                                                                 minvalue : mnvalue[axis][j],
                                                                 lmaxvalue : lmaxvalue[axis][i],
                                                                 lminvalue : lminvalue[axis][i],
+                                                                grandtotal : grandtotal,
                                                                 firstNotMissing : firstNotMissingj[j],
                                                                 lastNotMissing : lastNotMissingj[j],
                                                                 prevNotMissing : prevnotemptyj,
                                                                 prevMissing : prevemptyj,
                                                                 nextNotMissing : -1,
                                                                 j: j,
                                                                 i: i,
                                                                 data: data
                                                         };
+                                                        if(1 * data.datasets[i].data[j]==0 && (tpdraw(ctx,data.datasets[i])=="HorizontalStackedBar" || tpdraw(ctx,data.datasets[i])=="StackedBar"))result[i][j].v3="";
                                                         break;
                                                 case "Line" :
                                                 case "Radar" :
                                                         result[i][j]= {
                                                                 config: config,
                                                                 v1: fmtChartJS(config, lgtxt, config.fmtV1),
                                                                 v2: fmtChartJS(config, lgtxt2, config.fmtV2),
                                                                 v3: fmtChartJS(config, 1 * data.datasets[i].data[j], config.fmtV3),
                                                                 v5: fmtChartJS(config, 1 * data.datasets[i].data[j], config.fmtV5),
-                                                                v6: fmtChartJS(config, mxvalue[axis][j], config.fmtV7),
-                                                                v7: fmtChartJS(config, totvalue[axis][j], config.fmtV6),
+                                                                v6: fmtChartJS(config, mxvalue[axis][j], config.fmtV6),
+                                                                v7: fmtChartJS(config, totvalue[axis][j], config.fmtV7),
                                                                 v8: roundToWithThousands(config, fmtChartJS(config, 100 * data.datasets[i].data[j] / totvalue[axis][j], config.fmtV8), config.roundPct),
+                                                                v8T: roundToWithThousands(config, fmtChartJS(config, 100 * data.datasets[i].data[j] / grandtotal, config.fmtV8T), config.roundPct),
                                                                 v11: fmtChartJS(config, i, config.fmtV11),
                                                                 v12: fmtChartJS(config, j, config.fmtV12),
                                                                 lgtxt: lgtxt,
                                                                 lgtxt2: lgtxt2,
                                                                 datavalue: 1 * data.datasets[i].data[j],
                                                                 diffnext: 1 * data.datasets[i].data[j],
                                                                 pctvalue: 100 * data.datasets[i].data[j] / totvalue[axis][j],
+                                                                pctvalueT: 100 * data.datasets[i].data[j] / grandtotal,
                                                                 totvalue : totvalue[axis][j],
                                                                 cumvalue: cumvalue[axis][j],
                                                                 maxvalue : mxvalue[axis][j],
                                                                 minvalue : mnvalue[axis][j],
                                                                 lmaxvalue : lmaxvalue[axis][i],
                                                                 lminvalue : lminvalue[axis][i],
                                                                 lminvalue : lminvalue[axis][i],
+                                                                grandtotal : grandtotal,
                                                                 firstNotMissing : firstNotMissingi[i],
                                                                 lastNotMissing : lastNotMissingi[i],
                                                                 prevNotMissing : prevnotemptyj,
                                                                 prevMissing : prevemptyj,
                                                                 nextNotMissing : -1,
                                                                 j: j,
                                                                 i: i,
                                                                 data: data
                                                         };
                                                         if(prevpos[axis][j]>=0){
@@ skipping 22 matching lines @@
                                                 case "HorizontalBar" :
                                                 case "HorizontalStackedBar" :
                                                         result[i][j] ={ 
                                                                 v1:lgtxt,
                                                                 lmaxvalue : lmaxvalue[axis][i],
                                                                 lminvalue : lminvalue[axis][i],
                                                                 firstNotMissing : firstNotMissingj[j],
                                                                 lastNotMissing : lastNotMissingj[j],
                                                                 prevNotMissing : prevnotemptyj,
                                                                 prevMissing : prevemptyj,
+                                                                grandtotal : grandtotal,
                                                                  }; 
                                                         break;
                                                 case "Line" :
                                                 case "Radar" :
                                                         result[i][j] ={ 
                                                                 v1:lgtxt,
                                                                 lmaxvalue : lmaxvalue[axis][i],
                                                                 lminvalue : lminvalue[axis][i],
                                                                 firstNotMissing : firstNotMissingi[i],
                                                                 lastNotMissing : lastNotMissingi[i],
                                                                 prevNotMissing : prevnotemptyj,
                                                                 prevMissing : prevemptyj,
+                                                                grandtotal : grandtotal,
                                                                  }; 
                                                         break;
                                                 }
                                 }
                         }
                 }
                 break;
         default:        
                 break;
         }
@@ skipping 200 matching lines @@
                                                 statData[i][j].v9=statData[i][j].xPosRight;
                                                 statData[i][j].v10=statData[i][j].yPosTop;
                                         }
                                         break;                  
                                 case "HorizontalStackedBar" :
                                         for (var j = 0; j < data.datasets[i].data.length; j++) {
                                                 if (i == 0) {
                                                         tempp[j]=0;
                                                         tempn[j]=0;
                                                 }
-                                                if ((typeof(data.datasets[i].data[j]) == 'undefined') || 1*data.datasets[i].data[j] == 0 ) continue;
+                                                if (typeof(data.datasets[i].data[j]) == 'undefined')  continue;
+//                                              if ((typeof(data.datasets[i].data[j]) == 'undefined') || 1*data.datasets[i].data[j] == 0 ) continue;
 
                                                 statData[i][j].xPosLeft= othervars.yAxisPosX + config.barValueSpacing + othervars.valueHop * j;
                                                 if (1*data.datasets[i].data[j]<0) {
                                                         statData[i][j].leftval=tempn[j];
                                                         statData[i][j].rightval=tempn[j]+1*data.datasets[i].data[j] ;
                                                         tempn[j]=tempn[j]+1*data.datasets[i].data[j] ;
                                                 } else {
                                                         statData[i][j].leftval=tempp[j];
                                                         statData[i][j].rightval=tempp[j]+1*data.datasets[i].data[j] ;
                                                         tempp[j]=tempp[j]+1*data.datasets[i].data[j] ;
@@ skipping 109 matching lines @@
         else if(typeof optionvar == "object") {
                         for(var j=0;j<optionvar.length;j++) if (optionvar[j])return true;
                         return false;
         } else return optionvar;
 };
 
 function setOptionValue(reference,ctx,data,statData,optionvar,defaultvalue,posi,posj,othervars) {
 
         if(typeof optionvar == "undefined") {
                 if(typeof defaultvalue=="function") return defaultvalue(reference,ctx,data,statData,posi,posj,othervars);
-                else if(typeof defaultvalue == "object") return defaultvalue[Math.min(defaultvalue.length-1,Math.max(0,posi))];
+                else if(typeof defaultvalue == "object") {
+                        if(posj==-1)return defaultvalue[Math.min(defaultvalue.length-1,Math.max(0,posi))];
+                        else return defaultvalue[Math.min(defaultvalue.length-1,Math.max(0,posj))];
+                }
                 else return defaultvalue;
         }
         if(typeof optionvar=="function") return optionvar(reference,ctx,data,statData,posi,posj,othervars);
-        else if(typeof optionvar == "object") return optionvar[Math.min(optionvar.length-1,Math.max(0,posi))];
+        else if(typeof optionvar == "object") {
+                if (posj==-1)return optionvar[Math.min(optionvar.length-1,Math.max(0,posi))];
+                else return optionvar[Math.min(optionvar.length-1,Math.max(0,posj))];
+        }
         else return optionvar;
 };
 
 function tpdraw(ctx,dataval) {
         switch(ctx.tpchart)  {
                 case "Bar" :
                         if (dataval.type=="Line") { tp="Line";}         
                         else {tp=ctx.tpchart;}
                         break;
                 default : 
                         tp=ctx.tpchart;
                         break;
         }
         return tp;
 };