corrade-nucleus-nucleons – Diff between revs 1 and 11

Subversion Repositories:

?pathlinks?

Rev 1 – Go to most recent revision – Details – Blame – Last modification – View Log

 /**
- * @license Highcharts JS v5.0.10 (2017-03-31)
+ * @license Highcharts JS v5.0.12 (2017-05-24)
+ *
  * (c) 2009-2017 Torstein Honsi
+ *
  * License: www.highcharts.com/license
  */
                 // Prepare data classes
                 if (userOptions.dataClasses) {
                     this.initDataClasses(userOptions);
                 }
-                this.initStops(userOptions);
+                this.initStops();
                 // Override original axis properties
                 this.horiz = horiz;
                 this.zoomEnabled = false;
-                // Add default values
-                this.defaultLegendLength = 200;
-            },
-            /*
-             * Return an intermediate color between two colors, according to pos where 0
-             * is the from color and 1 is the to color.
-             * NOTE: Changes here should be copied
-             * to the same function in drilldown.src.js and solid-gauge-src.js.
-             */
-            tweenColors: function(from, to, pos) {
-                // Check for has alpha, because rgba colors perform worse due to lack of
-                // support in WebKit.
-                var hasAlpha,
-                    ret;
-                // Unsupported color, return to-color (#3920)
-                if (!to.rgba.length || !from.rgba.length) {
-                    ret = to.input || 'none';
-                    // Interpolate
-                } else {
-                    from = from.rgba;
-                    to = to.rgba;
-                    hasAlpha = (to[3] !== 1 || from[3] !== 1);
-                    ret = (hasAlpha ? 'rgba(' : 'rgb(') +
-                        Math.round(to[0] + (from[0] - to[0]) * (1 - pos)) + ',' +
-                        Math.round(to[1] + (from[1] - to[1]) * (1 - pos)) + ',' +
-                        Math.round(to[2] + (from[2] - to[2]) * (1 - pos)) +
-                        (hasAlpha ? (',' + (to[3] + (from[3] - to[3]) * (1 - pos))) : '') + ')';
                 // Add default values
-                return ret;
-            },
+                this.defaultLegendLength = 200;
             },
             initDataClasses: function(userOptions) {
-                var axis = this,
+            initDataClasses: function(userOptions) {
-                    chart = this.chart,
+                var chart = this.chart,
                     dataClasses,
                             colorCounter++;
                             if (colorCounter === colorCount) {
                                 colorCounter = 0;
+                            }
                         } else {
-                            dataClass.color = axis.tweenColors(
+                            dataClass.color = color(options.minColor).tweenTo(
-                                color(options.minColor),
                                 color(options.maxColor),
                                 len < 2 ? 0.5 : i / (len - 1) // #3219
                             );
+                        }
+                    }
                 });
             },
-            initStops: function(userOptions) {
+            initStops: function() {
-                this.stops = userOptions.stops || [
+                this.stops = this.options.stops || [
                     [0, this.options.minColor],
                     [1, this.options.maxColor]
                 ];
                 each(this.stops, function(stop) {
                     // Fake length for disabled legend to avoid tick issues and such (#5205)
                     this.len = (this.horiz ? legendOptions.symbolWidth : legendOptions.symbolHeight) || this.defaultLegendLength;
+                }
             },
+            normalizedValue: function(value) {
+                if (this.isLog) {
+                    value = this.val2lin(value);
+                }
+                return 1 - ((this.max - value) / ((this.max - this.min) || 1));
+            },
             /**
              * Translate from a value to a color
              */
             toColor: function(value, point) {
+                        }
+                    }
+                } else {
                     pos = this.normalizedValue(value);
                     i = stops.length;
                     while (i--) {
                         if (pos > stops[i][0]) {
                     to = stops[i + 1] || from;
                     // The position within the gradient
+                    pos = 1 - (to[0] - pos) / ((to[0] - from[0]) || 1);
                     color = from.color.tweenTo(
                         to.color,
                         pos
                     );
              * Create the color gradient
              */
             setLegendColor: function() {
                 var grad,
                     horiz = this.horiz,
                     reversed = this.reversed,
                     one = reversed ? 1 : 0,
                     zero = reversed ? 0 : 1;
                         x1: grad[0],
                         y1: grad[1],
                         x2: grad[2],
                         y2: grad[3]
                     },
+                    stops: this.stops
                 };
             },
             /**
 < axisPos) {                });
 < axisPos) {
 < axisPos) {                // When updating data classes, destroy old items and make sure new ones are created (#3207)
 < axisPos) {                if (newOptions.dataClasses && legend.allItems) {
+< axisPos) {                    each(legend.allItems, function(item) {
 < axisPos) {                        if (item.isDataClass && item.legendGroup) {
 < axisPos) {                            item.legendGroup.destroy();
 < axisPos) {                        }
 < axisPos) {                    });
 < axisPos) {                    chart.isDirtyLegend = true;
 < axisPos) {                    legend.colorizeItem(this, true);
 < axisPos) {                }
 < axisPos) {            },
 < axisPos) {
+< axisPos) {            /**
+< axisPos) {             * Extend basic axis remove by also removing the legend item.
+< axisPos) {             */
+< axisPos) {            remove: function() {
+< axisPos) {                if (this.legendItem) {
+< axisPos) {                    this.chart.legend.destroyItem(this);
+< axisPos) {                }
+< axisPos) {                Axis.prototype.remove.call(this);
+< axisPos) {            },
+< axisPos) {
 < axisPos) {            /**
 < axisPos) {             * Get the legend item symbols for data classes
 < axisPos) {             */
 < axisPos) {            getDataClassLegendSymbols: function() {
 < axisPos) {                var axis = this,
 < axisPos) {< ';         */
 < axisPos) {< ';        each(['fill', 'stroke'], function(prop) {
 < axisPos) {< ';            H.Fx.prototype[prop + 'Setter'] = function() {
 < axisPos) {< ';                this.elem.attr(
 < axisPos) {< ';                    prop,
+< axisPos) {< ';                    color(this.start).tweenTo(
 < axisPos) {< ';                        color(this.end),
 < axisPos) {< ';                        this.pos
 < axisPos) {< ';                    ),
 < axisPos) {< ';                    null,
 < axisPos) {< ';                    true