docs: function () {
  		var series = this,
  			options = series.options,
  			chart = series.chart,
  			graph = series.graph,
  			graphPath = [],
  			fillColor,
  			area = series.area,
  			group = series.group,
  			color = options.lineColor || series.color,
  			lineWidth = options.lineWidth,
  			dashStyle =  options.dashStyle,
  			segmentPath,
  			renderer = chart.renderer,
  			translatedThreshold = series.yAxis.getThreshold(options.threshold || 0),
  			useArea = /^area/.test(series.type),
  			singlePoints = [], // used in drawTracker
  			areaPath = [],
  			attribs;
  
  
  		// divide into segments and build graph and area paths
  		each(series.segments, function (segment) {
  			segmentPath = [];
  
  			// build the segment line
  			each(segment, function (point, i) {
  
  				if (series.getPointSpline) { // generate the spline as defined in the SplineSeries object
  					segmentPath.push.apply(segmentPath, series.getPointSpline(segment, point, i));
  
  				} else {
  
  					// moveTo or lineTo
  					segmentPath.push(i ? L : M);
  
  					// step line?
  					if (i && options.step) {
  						var lastPoint = segment[i - 1];
  						segmentPath.push(
  							point.plotX,
  							lastPoint.plotY
  						);
  					}
  
  					// normal line to next point
  					segmentPath.push(
  						point.plotX,
  						point.plotY
  					);
  				}
  			});
  
  			// add the segment to the graph, or a single point for tracking
  			if (segment.length > 1) {
  				graphPath = graphPath.concat(segmentPath);
  			} else {
  				singlePoints.push(segment[0]);
  			}
  
  			// build the area
  			if (useArea) {
  				var areaSegmentPath = [],
  					i,
  					segLength = segmentPath.length;
  				for (i = 0; i < segLength; i++) {
  					areaSegmentPath.push(segmentPath[i]);
  				}
  				if (segLength === 3) { // for animation from 1 to two points
  					areaSegmentPath.push(L, segmentPath[1], segmentPath[2]);
  				}
  				if (options.stacking && series.type !== 'areaspline') {
  					// follow stack back. Todo: implement areaspline
  					for (i = segment.length - 1; i >= 0; i--) {
  						areaSegmentPath.push(segment[i].plotX, segment[i].yBottom);
  					}
  
  				} else { // follow zero line back
  					areaSegmentPath.push(
  						L,
  						segment[segment.length - 1].plotX,
  						translatedThreshold,
  						L,
  						segment[0].plotX,
  						translatedThreshold
  					);
  				}
  				areaPath = areaPath.concat(areaSegmentPath);
  			}
  		});
  
  		// used in drawTracker:
  		series.graphPath = graphPath;
  		series.singlePoints = singlePoints;
  
  		// draw the area if area series or areaspline
  		if (useArea) {
  			fillColor = pick(
  				options.fillColor,
  				Color(series.color).setOpacity(options.fillOpacity || 0.75).get()
  			);
  			if (area) {
  				area.animate({ d: areaPath });
  
  			} else {
  				// draw the area
  				series.area = series.chart.renderer.path(areaPath)
  					.attr({
  						fill: fillColor
  					}).add(group);
  			}
  		}
  
  		// draw the graph
  		if (graph) {
  			stop(graph); // cancel running animations, #459
  			graph.animate({ d: graphPath });
  
  		} else {
  			if (lineWidth) {
  				attribs = {
  					'stroke': color,
  					'stroke-width': lineWidth
  				};
  				if (dashStyle) {
  					attribs.dashstyle = dashStyle;
  				}
  
  				series.graph = renderer.path(graphPath)
  					.attr(attribs).add(group).shadow(options.shadow);
  			}
  		}
  	}