上传项目

Xxxu

2020-07-07 4f953ffc89fc95f83b152e914c5e65938b440f17

 static/plugins/ueditor-1.4.3.3/third-party/highcharts/modules/annotations.src.js

对比新文件
@@ -0,0 +1,401 @@
(function (Highcharts, HighchartsAdapter) {

var UNDEFINED,
   ALIGN_FACTOR,
   ALLOWED_SHAPES,
   Chart = Highcharts.Chart,
   extend = Highcharts.extend,
   each = Highcharts.each;

ALLOWED_SHAPES = ["path", "rect", "circle"];

ALIGN_FACTOR = {
   top: 0,
   left: 0,
   center: 0.5,
   middle: 0.5,
   bottom: 1,
   right: 1
};


// Highcharts helper methods
var inArray = HighchartsAdapter.inArray,
   merge = Highcharts.merge;

function defaultOptions(shapeType) {
   var shapeOptions,
      options;

   options = {
      xAxis: 0,
      yAxis: 0,
      title: {
         style: {},
         text: "",
         x: 0,
         y: 0
      },
      shape: {
         params: {
            stroke: "#000000",
            fill: "transparent",
            strokeWidth: 2
         }
      }
   };

   shapeOptions = {
      circle: {
         params: {
            x: 0,
            y: 0
         }
      }
   };

   if (shapeOptions[shapeType]) {
      options.shape = merge(options.shape, shapeOptions[shapeType]);
   }

   return options;
}

function isArray(obj) {
   return Object.prototype.toString.call(obj) === '[object Array]';
}

function isNumber(n) {
   return typeof n === 'number';
}

function defined(obj) {
   return obj !== UNDEFINED && obj !== null;
}

function translatePath(d, xAxis, yAxis, xOffset, yOffset) {
   var len = d.length,
      i = 0;

   while (i < len) {
      if (typeof d[i] === 'number' && typeof d[i + 1] === 'number') {
         d[i] = xAxis.toPixels(d[i]) - xOffset;
         d[i + 1] = yAxis.toPixels(d[i + 1]) - yOffset;
         i += 2;
      } else {
         i += 1;
      }
   }

   return d;
}


// Define annotation prototype
var Annotation = function () {
   this.init.apply(this, arguments);
};
Annotation.prototype = {
   /* 
    * Initialize the annotation
    */
   init: function (chart, options) {
      var shapeType = options.shape && options.shape.type;

      this.chart = chart;
      this.options = merge({}, defaultOptions(shapeType), options);
   },

   /*
    * Render the annotation
    */
   render: function (redraw) {
      var annotation = this,
         chart = this.chart,
         renderer = annotation.chart.renderer,
         group = annotation.group,
         title = annotation.title,
         shape = annotation.shape,
         options = annotation.options,
         titleOptions = options.title,
         shapeOptions = options.shape;

      if (!group) {
         group = annotation.group = renderer.g();
      }


      if (!shape && shapeOptions && inArray(shapeOptions.type, ALLOWED_SHAPES) !== -1) {
         shape = annotation.shape = renderer[options.shape.type](shapeOptions.params);
         shape.add(group);
      }

      if (!title && titleOptions) {
         title = annotation.title = renderer.label(titleOptions);
         title.add(group);
      }

      group.add(chart.annotations.group);

      // link annotations to point or series
      annotation.linkObjects();

      if (redraw !== false) {
         annotation.redraw();
      }
   },

   /*
    * Redraw the annotation title or shape after options update
    */
   redraw: function () {
      var options = this.options,
         chart = this.chart,
         group = this.group,
         title = this.title,
         shape = this.shape,
         linkedTo = this.linkedObject,
         xAxis = chart.xAxis[options.xAxis],
         yAxis = chart.yAxis[options.yAxis],
         width = options.width,
         height = options.height,
         anchorY = ALIGN_FACTOR[options.anchorY],
         anchorX = ALIGN_FACTOR[options.anchorX],
         resetBBox = false,
         shapeParams,
         linkType,
         series,
         param,
         bbox,
         x,
         y;

      if (linkedTo) {
         linkType = (linkedTo instanceof Highcharts.Point) ? 'point' :
                  (linkedTo instanceof Highcharts.Series) ? 'series' : null;

         if (linkType === 'point') {
            options.xValue = linkedTo.x;
            options.yValue = linkedTo.y;
            series = linkedTo.series;
         } else if (linkType === 'series') {
            series = linkedTo;
         }

         if (group.visibility !== series.group.visibility) {
            group.attr({
               visibility: series.group.visibility
            });
         }
      }


      // Based on given options find annotation pixel position
      x = (defined(options.xValue) ? xAxis.toPixels(options.xValue + xAxis.minPointOffset) - xAxis.minPixelPadding : options.x);
      y = defined(options.yValue) ? yAxis.toPixels(options.yValue) : options.y;

      if (isNaN(x) || isNaN(y) || !isNumber(x) || !isNumber(y)) {
         return;
      }


      if (title) {
         title.attr(options.title);
         title.css(options.title.style);
         resetBBox = true;
      }

      if (shape) {
         shapeParams = extend({}, options.shape.params);

         if (options.units === 'values') {
            for (param in shapeParams) {
               if (inArray(param, ['width', 'x']) > -1) {
                  shapeParams[param] = xAxis.translate(shapeParams[param]);
               } else if (inArray(param, ['height', 'y']) > -1) {
                  shapeParams[param] = yAxis.translate(shapeParams[param]);
               }
            }

            if (shapeParams.width) {
               shapeParams.width -= xAxis.toPixels(0) - xAxis.left;
            }

            if (shapeParams.x) {
               shapeParams.x += xAxis.minPixelPadding;
            }

            if (options.shape.type === 'path') {
               translatePath(shapeParams.d, xAxis, yAxis, x, y);
            }
         }

         // move the center of the circle to shape x/y
         if (options.shape.type === 'circle') {
            shapeParams.x += shapeParams.r;
            shapeParams.y += shapeParams.r;
         }

         resetBBox = true;
         shape.attr(shapeParams);
      }

      group.bBox = null;

      // If annotation width or height is not defined in options use bounding box size
      if (!isNumber(width)) {
         bbox = group.getBBox();
         width = bbox.width;
      }

      if (!isNumber(height)) {
         // get bbox only if it wasn't set before
         if (!bbox) {
            bbox = group.getBBox();
         }

         height = bbox.height;
      }

      // Calculate anchor point
      if (!isNumber(anchorX)) {
         anchorX = ALIGN_FACTOR.center;
      }

      if (!isNumber(anchorY)) {
         anchorY = ALIGN_FACTOR.center;
      }

      // Translate group according to its dimension and anchor point
      x = x - width * anchorX;
      y = y - height * anchorY;

      if (chart.animation && defined(group.translateX) && defined(group.translateY)) {
         group.animate({
            translateX: x,
            translateY: y
         });
      } else {
         group.translate(x, y);
      }
   },

   /*
    * Destroy the annotation
    */
   destroy: function () {
      var annotation = this,
         chart = this.chart,
         allItems = chart.annotations.allItems,
         index = allItems.indexOf(annotation);

      if (index > -1) {
         allItems.splice(index, 1);
      }

      each(['title', 'shape', 'group'], function (element) {
         if (annotation[element]) {
            annotation[element].destroy();
            annotation[element] = null;
         }
      });

      annotation.group = annotation.title = annotation.shape = annotation.chart = annotation.options = null;
   },

   /*
    * Update the annotation with a given options
    */
   update: function (options, redraw) {
      extend(this.options, options);

      // update link to point or series
      this.linkObjects();

      this.render(redraw);
   },

   linkObjects: function () {
      var annotation = this,
         chart = annotation.chart,
         linkedTo = annotation.linkedObject,
         linkedId = linkedTo && (linkedTo.id || linkedTo.options.id),
         options = annotation.options,
         id = options.linkedTo;

      if (!defined(id)) {
         annotation.linkedObject = null;
      } else if (!defined(linkedTo) || id !== linkedId) {
         annotation.linkedObject = chart.get(id);
      }
   }
};


// Add annotations methods to chart prototype
extend(Chart.prototype, {
   annotations: {
      /*
       * Unified method for adding annotations to the chart
       */
      add: function (options, redraw) {
         var annotations = this.allItems,
            chart = this.chart,
            item,
            len;

         if (!isArray(options)) {
            options = [options];
         }

         len = options.length;

         while (len--) {
            item = new Annotation(chart, options[len]);
            annotations.push(item);
            item.render(redraw);
         }
      },

      /**
       * Redraw all annotations, method used in chart events
       */
      redraw: function () {
         each(this.allItems, function (annotation) {
            annotation.redraw();
         });
      }
   }
});


// Initialize on chart load
Chart.prototype.callbacks.push(function (chart) {
   var options = chart.options.annotations,
      group;

   group = chart.renderer.g("annotations");
   group.attr({
      zIndex: 7
   });
   group.add();

   // initialize empty array for annotations
   chart.annotations.allItems = [];

   // link chart object to annotations
   chart.annotations.chart = chart;

   // link annotations group element to the chart
   chart.annotations.group = group;

   if (isArray(options) && options.length > 0) {
      chart.annotations.add(chart.options.annotations);
   }

   // update annotations after chart redraw
   Highcharts.addEvent(chart, 'redraw', function () {
      chart.annotations.redraw();
   });
});
}(Highcharts, HighchartsAdapter));