Subversion Repositories Integrator Subversion

/**!

 * easyPieChart

 * Lightweight plugin to render simple, animated and retina optimized pie charts

 *

 * @license

 * @author Robert Fleischmann <rendro87@gmail.com> (http://robert-fleischmann.de)

 * @version 2.1.5

 **/

(function(root, factory) {

    if(typeof exports === 'object') {

        module.exports = factory(require('jquery'));

    }

    else if(typeof define === 'function' && define.amd) {

        define(['jquery'], factory);

    }

    else {

        factory(root.jQuery);

    }

}(this, function($) {

/**

 * Renderer to render the chart on a canvas object

 * @param {DOMElement} el      DOM element to host the canvas (root of the plugin)

 * @param {object}     options options object of the plugin

 */

var CanvasRenderer = function(el, options) {

        var cachedBackground;

        var canvas = document.createElement('canvas');

        el.appendChild(canvas);

        if (typeof(G_vmlCanvasManager) !== 'undefined') {

                G_vmlCanvasManager.initElement(canvas);

        }

        var ctx = canvas.getContext('2d');

        canvas.width = canvas.height = options.size;

        // canvas on retina devices

        var scaleBy = 1;

        if (window.devicePixelRatio > 1) {

                scaleBy = window.devicePixelRatio;

                canvas.style.width = canvas.style.height = [options.size, 'px'].join('');

                canvas.width = canvas.height = options.size * scaleBy;

                ctx.scale(scaleBy, scaleBy);

        }

        // move 0,0 coordinates to the center

        ctx.translate(options.size / 2, options.size / 2);

        // rotate canvas -90deg

        ctx.rotate((-1 / 2 + options.rotate / 180) * Math.PI);

        var radius = (options.size - options.lineWidth) / 2;

        if (options.scaleColor && options.scaleLength) {

                radius -= options.scaleLength + 2; // 2 is the distance between scale and bar

        }

        // IE polyfill for Date

        Date.now = Date.now || function() {

                return +(new Date());

        };

        /**

         * Draw a circle around the center of the canvas

         * @param {strong} color     Valid CSS color string

         * @param {number} lineWidth Width of the line in px

         * @param {number} percent   Percentage to draw (float between -1 and 1)

         */

        var drawCircle = function(color, lineWidth, percent) {

                percent = Math.min(Math.max(-1, percent || 0), 1);

                var isNegative = percent <= 0 ? true : false;

                ctx.beginPath();

                ctx.arc(0, 0, radius, 0, Math.PI * 2 * percent, isNegative);

                ctx.strokeStyle = color;

                ctx.lineWidth = lineWidth;

                ctx.stroke();

        };

        /**

         * Draw the scale of the chart

         */

        var drawScale = function() {

                var offset;

                var length;

                ctx.lineWidth = 1;

                ctx.fillStyle = options.scaleColor;

                ctx.save();

                for (var i = 24; i > 0; --i) {

                        if (i % 6 === 0) {

                                length = options.scaleLength;

                                offset = 0;

                        } else {

                                length = options.scaleLength * 0.6;

                                offset = options.scaleLength - length;

                        }

                        ctx.fillRect(-options.size/2 + offset, 0, length, 1);

                        ctx.rotate(Math.PI / 12);

                }

                ctx.restore();

        };

        /**

         * Request animation frame wrapper with polyfill

         * @return {function} Request animation frame method or timeout fallback

         */

        var reqAnimationFrame = (function() {

                return  window.requestAnimationFrame ||

                                window.webkitRequestAnimationFrame ||

                                window.mozRequestAnimationFrame ||

                                function(callback) {

                                        window.setTimeout(callback, 1000 / 60);

                                };

        }());

        /**

         * Draw the background of the plugin including the scale and the track

         */

        var drawBackground = function() {

                if(options.scaleColor) drawScale();

                if(options.trackColor) drawCircle(options.trackColor, options.lineWidth, 1);

        };

  /**

    * Canvas accessor

   */

  this.getCanvas = function() {

    return canvas;

  };

  /**

    * Canvas 2D context 'ctx' accessor

   */

  this.getCtx = function() {

    return ctx;

  };

        /**

         * Clear the complete canvas

         */

        this.clear = function() {

                ctx.clearRect(options.size / -2, options.size / -2, options.size, options.size);

        };

        /**

         * Draw the complete chart

         * @param {number} percent Percent shown by the chart between -100 and 100

         */

        this.draw = function(percent) {

                // do we need to render a background

                if (!!options.scaleColor || !!options.trackColor) {

                        // getImageData and putImageData are supported

                        if (ctx.getImageData && ctx.putImageData) {

                                if (!cachedBackground) {

                                        drawBackground();

                                        cachedBackground = ctx.getImageData(0, 0, options.size * scaleBy, options.size * scaleBy);

                                } else {

                                        ctx.putImageData(cachedBackground, 0, 0);

                                }

                        } else {

                                this.clear();

                                drawBackground();

                        }

                } else {

                        this.clear();

                }

                ctx.lineCap = options.lineCap;

                // if barcolor is a function execute it and pass the percent as a value

                var color;

                if (typeof(options.barColor) === 'function') {

                        color = options.barColor(percent);

                } else {

                        color = options.barColor;

                }

                // draw bar

                drawCircle(color, options.lineWidth, percent / 100);

        }.bind(this);

        /**

         * Animate from some percent to some other percentage

         * @param {number} from Starting percentage

         * @param {number} to   Final percentage

         */

        this.animate = function(from, to) {

                var startTime = Date.now();

                options.onStart(from, to);

                var animation = function() {

                        var process = Math.min(Date.now() - startTime, options.animate.duration);

                        var currentValue = options.easing(this, process, from, to - from, options.animate.duration);

                        this.draw(currentValue);

                        options.onStep(from, to, currentValue);

                        if (process >= options.animate.duration) {

                                options.onStop(from, to);

                        } else {

                                reqAnimationFrame(animation);

                        }

                }.bind(this);

                reqAnimationFrame(animation);

        }.bind(this);

};

var EasyPieChart = function(el, opts) {

        var defaultOptions = {

                barColor: '#ef1e25',

                trackColor: '#f9f9f9',

                scaleColor: '#dfe0e0',

                scaleLength: 5,

                lineCap: 'round',

                lineWidth: 3,

                size: 110,

                rotate: 0,

                animate: {

                        duration: 1000,

                        enabled: true

                },

                easing: function (x, t, b, c, d) { // more can be found here: http://gsgd.co.uk/sandbox/jquery/easing/

                        t = t / (d/2);

                        if (t < 1) {

                                return c / 2 * t * t + b;

                        }

                        return -c/2 * ((--t)*(t-2) - 1) + b;

                },

                onStart: function(from, to) {

                        return;

                },

                onStep: function(from, to, currentValue) {

                        return;

                },

                onStop: function(from, to) {

                        return;

                }

        };

        // detect present renderer

        if (typeof(CanvasRenderer) !== 'undefined') {

                defaultOptions.renderer = CanvasRenderer;

        } else if (typeof(SVGRenderer) !== 'undefined') {

                defaultOptions.renderer = SVGRenderer;

        } else {

                throw new Error('Please load either the SVG- or the CanvasRenderer');

        }

        var options = {};

        var currentValue = 0;

        /**

         * Initialize the plugin by creating the options object and initialize rendering

         */

        var init = function() {

                this.el = el;

                this.options = options;

                // merge user options into default options

                for (var i in defaultOptions) {

                        if (defaultOptions.hasOwnProperty(i)) {

                                options[i] = opts && typeof(opts[i]) !== 'undefined' ? opts[i] : defaultOptions[i];

                                if (typeof(options[i]) === 'function') {

                                        options[i] = options[i].bind(this);

                                }

                        }

                }

                // check for jQuery easing

                if (typeof(options.easing) === 'string' && typeof(jQuery) !== 'undefined' && jQuery.isFunction(jQuery.easing[options.easing])) {

                        options.easing = jQuery.easing[options.easing];

                } else {

                        options.easing = defaultOptions.easing;

                }

                // process earlier animate option to avoid bc breaks

                if (typeof(options.animate) === 'number') {

                        options.animate = {

                                duration: options.animate,

                                enabled: true

                        };

                }

                if (typeof(options.animate) === 'boolean' && !options.animate) {

                        options.animate = {

                                duration: 1000,

                                enabled: options.animate

                        };

                }

                // create renderer

                this.renderer = new options.renderer(el, options);

                // initial draw

                this.renderer.draw(currentValue);

                // initial update

                if (el.dataset && el.dataset.percent) {

                        this.update(parseFloat(el.dataset.percent));

                } else if (el.getAttribute && el.getAttribute('data-percent')) {

                        this.update(parseFloat(el.getAttribute('data-percent')));

                }

        }.bind(this);

        /**

         * Update the value of the chart

         * @param  {number} newValue Number between 0 and 100

         * @return {object}          Instance of the plugin for method chaining

         */

        this.update = function(newValue) {

                newValue = parseFloat(newValue);

                if (options.animate.enabled) {

                        this.renderer.animate(currentValue, newValue);

                } else {

                        this.renderer.draw(newValue);

                }

                currentValue = newValue;

                return this;

        }.bind(this);

        /**

         * Disable animation

         * @return {object} Instance of the plugin for method chaining

         */

        this.disableAnimation = function() {

                options.animate.enabled = false;

                return this;

        };

        /**

         * Enable animation

         * @return {object} Instance of the plugin for method chaining

         */

        this.enableAnimation = function() {

                options.animate.enabled = true;

                return this;

        };

        init();

};

$.fn.easyPieChart = function(options) {

        return this.each(function() {

                var instanceOptions;

                if (!$.data(this, 'easyPieChart')) {

                        instanceOptions = $.extend({}, options, $(this).data());

                        $.data(this, 'easyPieChart', new EasyPieChart(this, instanceOptions));

                }

        });

};

}));