jpgraph.php in Loft Data Grids 7.2

File

vendor/phpoffice/phpexcel/Classes/PHPExcel/Chart/Renderer/jpgraph.php

<?php

/**
 * PHPExcel
 *
 * Copyright (c) 2006 - 2014 PHPExcel
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 * @category	PHPExcel
 * @package		PHPExcel_Chart_Renderer
 * @copyright	Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
 * @license		http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt	LGPL
 * @version		##VERSION##, ##DATE##
 */
require_once PHPExcel_Settings::getChartRendererPath() . '/jpgraph.php';

/**
 * PHPExcel_Chart_Renderer_jpgraph
 *
 * @category	PHPExcel
 * @package		PHPExcel_Chart_Renderer
 * @copyright	Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
 */
class PHPExcel_Chart_Renderer_jpgraph {
  private static $_width = 640;
  private static $_height = 480;
  private static $_colourSet = array(
    'mediumpurple1',
    'palegreen3',
    'gold1',
    'cadetblue1',
    'darkmagenta',
    'coral',
    'dodgerblue3',
    'eggplant',
    'mediumblue',
    'magenta',
    'sandybrown',
    'cyan',
    'firebrick1',
    'forestgreen',
    'deeppink4',
    'darkolivegreen',
    'goldenrod2',
  );
  private static $_markSet = array(
    'diamond' => MARK_DIAMOND,
    'square' => MARK_SQUARE,
    'triangle' => MARK_UTRIANGLE,
    'x' => MARK_X,
    'star' => MARK_STAR,
    'dot' => MARK_FILLEDCIRCLE,
    'dash' => MARK_DTRIANGLE,
    'circle' => MARK_CIRCLE,
    'plus' => MARK_CROSS,
  );
  private $_chart = null;
  private $_graph = null;
  private static $_plotColour = 0;
  private static $_plotMark = 0;
  private function _formatPointMarker($seriesPlot, $markerID) {
    $plotMarkKeys = array_keys(self::$_markSet);
    if (is_null($markerID)) {

      //	Use default plot marker (next marker in the series)
      self::$_plotMark %= count(self::$_markSet);
      $seriesPlot->mark
        ->SetType(self::$_markSet[$plotMarkKeys[self::$_plotMark++]]);
    }
    elseif ($markerID !== 'none') {

      //	Use specified plot marker (if it exists)
      if (isset(self::$_markSet[$markerID])) {
        $seriesPlot->mark
          ->SetType(self::$_markSet[$markerID]);
      }
      else {

        //	If the specified plot marker doesn't exist, use default plot marker (next marker in the series)
        self::$_plotMark %= count(self::$_markSet);
        $seriesPlot->mark
          ->SetType(self::$_markSet[$plotMarkKeys[self::$_plotMark++]]);
      }
    }
    else {

      //	Hide plot marker
      $seriesPlot->mark
        ->Hide();
    }
    $seriesPlot->mark
      ->SetColor(self::$_colourSet[self::$_plotColour]);
    $seriesPlot->mark
      ->SetFillColor(self::$_colourSet[self::$_plotColour]);
    $seriesPlot
      ->SetColor(self::$_colourSet[self::$_plotColour++]);
    return $seriesPlot;
  }

  //	function _formatPointMarker()
  private function _formatDataSetLabels($groupID, $datasetLabels, $labelCount, $rotation = '') {
    $datasetLabelFormatCode = $this->_chart
      ->getPlotArea()
      ->getPlotGroupByIndex($groupID)
      ->getPlotCategoryByIndex(0)
      ->getFormatCode();
    if (!is_null($datasetLabelFormatCode)) {

      //	Retrieve any label formatting code
      $datasetLabelFormatCode = stripslashes($datasetLabelFormatCode);
    }
    $testCurrentIndex = 0;
    foreach ($datasetLabels as $i => $datasetLabel) {
      if (is_array($datasetLabel)) {
        if ($rotation == 'bar') {
          $datasetLabels[$i] = implode(" ", $datasetLabel);
        }
        else {
          $datasetLabel = array_reverse($datasetLabel);
          $datasetLabels[$i] = implode("\n", $datasetLabel);
        }
      }
      else {

        //	Format labels according to any formatting code
        if (!is_null($datasetLabelFormatCode)) {
          $datasetLabels[$i] = PHPExcel_Style_NumberFormat::toFormattedString($datasetLabel, $datasetLabelFormatCode);
        }
      }
      ++$testCurrentIndex;
    }
    return $datasetLabels;
  }

  //	function _formatDataSetLabels()
  private function _percentageSumCalculation($groupID, $seriesCount) {

    //	Adjust our values to a percentage value across all series in the group
    for ($i = 0; $i < $seriesCount; ++$i) {
      if ($i == 0) {
        $sumValues = $this->_chart
          ->getPlotArea()
          ->getPlotGroupByIndex($groupID)
          ->getPlotValuesByIndex($i)
          ->getDataValues();
      }
      else {
        $nextValues = $this->_chart
          ->getPlotArea()
          ->getPlotGroupByIndex($groupID)
          ->getPlotValuesByIndex($i)
          ->getDataValues();
        foreach ($nextValues as $k => $value) {
          if (isset($sumValues[$k])) {
            $sumValues[$k] += $value;
          }
          else {
            $sumValues[$k] = $value;
          }
        }
      }
    }
    return $sumValues;
  }

  //	function _percentageSumCalculation()
  private function _percentageAdjustValues($dataValues, $sumValues) {
    foreach ($dataValues as $k => $dataValue) {
      $dataValues[$k] = $dataValue / $sumValues[$k] * 100;
    }
    return $dataValues;
  }

  //	function _percentageAdjustValues()
  private function _getCaption($captionElement) {

    //	Read any caption
    $caption = !is_null($captionElement) ? $captionElement
      ->getCaption() : NULL;

    //	Test if we have a title caption to display
    if (!is_null($caption)) {

      //	If we do, it could be a plain string or an array
      if (is_array($caption)) {

        //	Implode an array to a plain string
        $caption = implode('', $caption);
      }
    }
    return $caption;
  }

  //	function _getCaption()
  private function _renderTitle() {
    $title = $this
      ->_getCaption($this->_chart
      ->getTitle());
    if (!is_null($title)) {
      $this->_graph->title
        ->Set($title);
    }
  }

  //	function _renderTitle()
  private function _renderLegend() {
    $legend = $this->_chart
      ->getLegend();
    if (!is_null($legend)) {
      $legendPosition = $legend
        ->getPosition();
      $legendOverlay = $legend
        ->getOverlay();
      switch ($legendPosition) {
        case 'r':
          $this->_graph->legend
            ->SetPos(0.01, 0.5, 'right', 'center');

          //	right
          $this->_graph->legend
            ->SetColumns(1);
          break;
        case 'l':
          $this->_graph->legend
            ->SetPos(0.01, 0.5, 'left', 'center');

          //	left
          $this->_graph->legend
            ->SetColumns(1);
          break;
        case 't':
          $this->_graph->legend
            ->SetPos(0.5, 0.01, 'center', 'top');

          //	top
          break;
        case 'b':
          $this->_graph->legend
            ->SetPos(0.5, 0.99, 'center', 'bottom');

          //	bottom
          break;
        default:
          $this->_graph->legend
            ->SetPos(0.01, 0.01, 'right', 'top');

          //	top-right
          $this->_graph->legend
            ->SetColumns(1);
          break;
      }
    }
    else {
      $this->_graph->legend
        ->Hide();
    }
  }

  //	function _renderLegend()
  private function _renderCartesianPlotArea($type = 'textlin') {
    $this->_graph = new Graph(self::$_width, self::$_height);
    $this->_graph
      ->SetScale($type);
    $this
      ->_renderTitle();

    //	Rotate for bar rather than column chart
    $rotation = $this->_chart
      ->getPlotArea()
      ->getPlotGroupByIndex(0)
      ->getPlotDirection();
    $reverse = $rotation == 'bar' ? true : false;
    $xAxisLabel = $this->_chart
      ->getXAxisLabel();
    if (!is_null($xAxisLabel)) {
      $title = $this
        ->_getCaption($xAxisLabel);
      if (!is_null($title)) {
        $this->_graph->xaxis
          ->SetTitle($title, 'center');
        $this->_graph->xaxis->title
          ->SetMargin(35);
        if ($reverse) {
          $this->_graph->xaxis->title
            ->SetAngle(90);
          $this->_graph->xaxis->title
            ->SetMargin(90);
        }
      }
    }
    $yAxisLabel = $this->_chart
      ->getYAxisLabel();
    if (!is_null($yAxisLabel)) {
      $title = $this
        ->_getCaption($yAxisLabel);
      if (!is_null($title)) {
        $this->_graph->yaxis
          ->SetTitle($title, 'center');
        if ($reverse) {
          $this->_graph->yaxis->title
            ->SetAngle(0);
          $this->_graph->yaxis->title
            ->SetMargin(-55);
        }
      }
    }
  }

  //	function _renderCartesianPlotArea()
  private function _renderPiePlotArea($doughnut = False) {
    $this->_graph = new PieGraph(self::$_width, self::$_height);
    $this
      ->_renderTitle();
  }

  //	function _renderPiePlotArea()
  private function _renderRadarPlotArea() {
    $this->_graph = new RadarGraph(self::$_width, self::$_height);
    $this->_graph
      ->SetScale('lin');
    $this
      ->_renderTitle();
  }

  //	function _renderRadarPlotArea()
  private function _renderPlotLine($groupID, $filled = false, $combination = false, $dimensions = '2d') {
    $grouping = $this->_chart
      ->getPlotArea()
      ->getPlotGroupByIndex($groupID)
      ->getPlotGrouping();
    $labelCount = count($this->_chart
      ->getPlotArea()
      ->getPlotGroupByIndex($groupID)
      ->getPlotValuesByIndex(0)
      ->getPointCount());
    if ($labelCount > 0) {
      $datasetLabels = $this->_chart
        ->getPlotArea()
        ->getPlotGroupByIndex($groupID)
        ->getPlotCategoryByIndex(0)
        ->getDataValues();
      $datasetLabels = $this
        ->_formatDataSetLabels($groupID, $datasetLabels, $labelCount);
      $this->_graph->xaxis
        ->SetTickLabels($datasetLabels);
    }
    $seriesCount = $this->_chart
      ->getPlotArea()
      ->getPlotGroupByIndex($groupID)
      ->getPlotSeriesCount();
    $seriesPlots = array();
    if ($grouping == 'percentStacked') {
      $sumValues = $this
        ->_percentageSumCalculation($groupID, $seriesCount);
    }

    //	Loop through each data series in turn
    for ($i = 0; $i < $seriesCount; ++$i) {
      $dataValues = $this->_chart
        ->getPlotArea()
        ->getPlotGroupByIndex($groupID)
        ->getPlotValuesByIndex($i)
        ->getDataValues();
      $marker = $this->_chart
        ->getPlotArea()
        ->getPlotGroupByIndex($groupID)
        ->getPlotValuesByIndex($i)
        ->getPointMarker();
      if ($grouping == 'percentStacked') {
        $dataValues = $this
          ->_percentageAdjustValues($dataValues, $sumValues);
      }

      //	Fill in any missing values in the $dataValues array
      $testCurrentIndex = 0;
      foreach ($dataValues as $k => $dataValue) {
        while ($k != $testCurrentIndex) {
          $dataValues[$testCurrentIndex] = null;
          ++$testCurrentIndex;
        }
        ++$testCurrentIndex;
      }
      $seriesPlot = new LinePlot($dataValues);
      if ($combination) {
        $seriesPlot
          ->SetBarCenter();
      }
      if ($filled) {
        $seriesPlot
          ->SetFilled(true);
        $seriesPlot
          ->SetColor('black');
        $seriesPlot
          ->SetFillColor(self::$_colourSet[self::$_plotColour++]);
      }
      else {

        //	Set the appropriate plot marker
        $this
          ->_formatPointMarker($seriesPlot, $marker);
      }
      $dataLabel = $this->_chart
        ->getPlotArea()
        ->getPlotGroupByIndex($groupID)
        ->getPlotLabelByIndex($i)
        ->getDataValue();
      $seriesPlot
        ->SetLegend($dataLabel);
      $seriesPlots[] = $seriesPlot;
    }
    if ($grouping == 'standard') {
      $groupPlot = $seriesPlots;
    }
    else {
      $groupPlot = new AccLinePlot($seriesPlots);
    }
    $this->_graph
      ->Add($groupPlot);
  }

  //	function _renderPlotLine()
  private function _renderPlotBar($groupID, $dimensions = '2d') {
    $rotation = $this->_chart
      ->getPlotArea()
      ->getPlotGroupByIndex($groupID)
      ->getPlotDirection();

    //	Rotate for bar rather than column chart
    if ($groupID == 0 && $rotation == 'bar') {
      $this->_graph
        ->Set90AndMargin();
    }
    $grouping = $this->_chart
      ->getPlotArea()
      ->getPlotGroupByIndex($groupID)
      ->getPlotGrouping();
    $labelCount = count($this->_chart
      ->getPlotArea()
      ->getPlotGroupByIndex($groupID)
      ->getPlotValuesByIndex(0)
      ->getPointCount());
    if ($labelCount > 0) {
      $datasetLabels = $this->_chart
        ->getPlotArea()
        ->getPlotGroupByIndex($groupID)
        ->getPlotCategoryByIndex(0)
        ->getDataValues();
      $datasetLabels = $this
        ->_formatDataSetLabels($groupID, $datasetLabels, $labelCount, $rotation);

      //	Rotate for bar rather than column chart
      if ($rotation == 'bar') {
        $datasetLabels = array_reverse($datasetLabels);
        $this->_graph->yaxis
          ->SetPos('max');
        $this->_graph->yaxis
          ->SetLabelAlign('center', 'top');
        $this->_graph->yaxis
          ->SetLabelSide(SIDE_RIGHT);
      }
      $this->_graph->xaxis
        ->SetTickLabels($datasetLabels);
    }
    $seriesCount = $this->_chart
      ->getPlotArea()
      ->getPlotGroupByIndex($groupID)
      ->getPlotSeriesCount();
    $seriesPlots = array();
    if ($grouping == 'percentStacked') {
      $sumValues = $this
        ->_percentageSumCalculation($groupID, $seriesCount);
    }

    //	Loop through each data series in turn
    for ($j = 0; $j < $seriesCount; ++$j) {
      $dataValues = $this->_chart
        ->getPlotArea()
        ->getPlotGroupByIndex($groupID)
        ->getPlotValuesByIndex($j)
        ->getDataValues();
      if ($grouping == 'percentStacked') {
        $dataValues = $this
          ->_percentageAdjustValues($dataValues, $sumValues);
      }

      //	Fill in any missing values in the $dataValues array
      $testCurrentIndex = 0;
      foreach ($dataValues as $k => $dataValue) {
        while ($k != $testCurrentIndex) {
          $dataValues[$testCurrentIndex] = null;
          ++$testCurrentIndex;
        }
        ++$testCurrentIndex;
      }

      //	Reverse the $dataValues order for bar rather than column chart
      if ($rotation == 'bar') {
        $dataValues = array_reverse($dataValues);
      }
      $seriesPlot = new BarPlot($dataValues);
      $seriesPlot
        ->SetColor('black');
      $seriesPlot
        ->SetFillColor(self::$_colourSet[self::$_plotColour++]);
      if ($dimensions == '3d') {
        $seriesPlot
          ->SetShadow();
      }
      if (!$this->_chart
        ->getPlotArea()
        ->getPlotGroupByIndex($groupID)
        ->getPlotLabelByIndex($j)) {
        $dataLabel = '';
      }
      else {
        $dataLabel = $this->_chart
          ->getPlotArea()
          ->getPlotGroupByIndex($groupID)
          ->getPlotLabelByIndex($j)
          ->getDataValue();
      }
      $seriesPlot
        ->SetLegend($dataLabel);
      $seriesPlots[] = $seriesPlot;
    }

    //	Reverse the plot order for bar rather than column chart
    if ($rotation == 'bar' && !($grouping == 'percentStacked')) {
      $seriesPlots = array_reverse($seriesPlots);
    }
    if ($grouping == 'clustered') {
      $groupPlot = new GroupBarPlot($seriesPlots);
    }
    elseif ($grouping == 'standard') {
      $groupPlot = new GroupBarPlot($seriesPlots);
    }
    else {
      $groupPlot = new AccBarPlot($seriesPlots);
      if ($dimensions == '3d') {
        $groupPlot
          ->SetShadow();
      }
    }
    $this->_graph
      ->Add($groupPlot);
  }

  //	function _renderPlotBar()
  private function _renderPlotScatter($groupID, $bubble) {
    $grouping = $this->_chart
      ->getPlotArea()
      ->getPlotGroupByIndex($groupID)
      ->getPlotGrouping();
    $scatterStyle = $bubbleSize = $this->_chart
      ->getPlotArea()
      ->getPlotGroupByIndex($groupID)
      ->getPlotStyle();
    $seriesCount = $this->_chart
      ->getPlotArea()
      ->getPlotGroupByIndex($groupID)
      ->getPlotSeriesCount();
    $seriesPlots = array();

    //	Loop through each data series in turn
    for ($i = 0; $i < $seriesCount; ++$i) {
      $dataValuesY = $this->_chart
        ->getPlotArea()
        ->getPlotGroupByIndex($groupID)
        ->getPlotCategoryByIndex($i)
        ->getDataValues();
      $dataValuesX = $this->_chart
        ->getPlotArea()
        ->getPlotGroupByIndex($groupID)
        ->getPlotValuesByIndex($i)
        ->getDataValues();
      foreach ($dataValuesY as $k => $dataValueY) {
        $dataValuesY[$k] = $k;
      }
      $seriesPlot = new ScatterPlot($dataValuesX, $dataValuesY);
      if ($scatterStyle == 'lineMarker') {
        $seriesPlot
          ->SetLinkPoints();
        $seriesPlot->link
          ->SetColor(self::$_colourSet[self::$_plotColour]);
      }
      elseif ($scatterStyle == 'smoothMarker') {
        $spline = new Spline($dataValuesY, $dataValuesX);
        list($splineDataY, $splineDataX) = $spline
          ->Get(count($dataValuesX) * self::$_width / 20);
        $lplot = new LinePlot($splineDataX, $splineDataY);
        $lplot
          ->SetColor(self::$_colourSet[self::$_plotColour]);
        $this->_graph
          ->Add($lplot);
      }
      if ($bubble) {
        $this
          ->_formatPointMarker($seriesPlot, 'dot');
        $seriesPlot->mark
          ->SetColor('black');
        $seriesPlot->mark
          ->SetSize($bubbleSize);
      }
      else {
        $marker = $this->_chart
          ->getPlotArea()
          ->getPlotGroupByIndex($groupID)
          ->getPlotValuesByIndex($i)
          ->getPointMarker();
        $this
          ->_formatPointMarker($seriesPlot, $marker);
      }
      $dataLabel = $this->_chart
        ->getPlotArea()
        ->getPlotGroupByIndex($groupID)
        ->getPlotLabelByIndex($i)
        ->getDataValue();
      $seriesPlot
        ->SetLegend($dataLabel);
      $this->_graph
        ->Add($seriesPlot);
    }
  }

  //	function _renderPlotScatter()
  private function _renderPlotRadar($groupID) {
    $radarStyle = $this->_chart
      ->getPlotArea()
      ->getPlotGroupByIndex($groupID)
      ->getPlotStyle();
    $seriesCount = $this->_chart
      ->getPlotArea()
      ->getPlotGroupByIndex($groupID)
      ->getPlotSeriesCount();
    $seriesPlots = array();

    //	Loop through each data series in turn
    for ($i = 0; $i < $seriesCount; ++$i) {
      $dataValuesY = $this->_chart
        ->getPlotArea()
        ->getPlotGroupByIndex($groupID)
        ->getPlotCategoryByIndex($i)
        ->getDataValues();
      $dataValuesX = $this->_chart
        ->getPlotArea()
        ->getPlotGroupByIndex($groupID)
        ->getPlotValuesByIndex($i)
        ->getDataValues();
      $marker = $this->_chart
        ->getPlotArea()
        ->getPlotGroupByIndex($groupID)
        ->getPlotValuesByIndex($i)
        ->getPointMarker();
      $dataValues = array();
      foreach ($dataValuesY as $k => $dataValueY) {
        $dataValues[$k] = implode(' ', array_reverse($dataValueY));
      }
      $tmp = array_shift($dataValues);
      $dataValues[] = $tmp;
      $tmp = array_shift($dataValuesX);
      $dataValuesX[] = $tmp;
      $this->_graph
        ->SetTitles(array_reverse($dataValues));
      $seriesPlot = new RadarPlot(array_reverse($dataValuesX));
      $dataLabel = $this->_chart
        ->getPlotArea()
        ->getPlotGroupByIndex($groupID)
        ->getPlotLabelByIndex($i)
        ->getDataValue();
      $seriesPlot
        ->SetColor(self::$_colourSet[self::$_plotColour++]);
      if ($radarStyle == 'filled') {
        $seriesPlot
          ->SetFillColor(self::$_colourSet[self::$_plotColour]);
      }
      $this
        ->_formatPointMarker($seriesPlot, $marker);
      $seriesPlot
        ->SetLegend($dataLabel);
      $this->_graph
        ->Add($seriesPlot);
    }
  }

  //	function _renderPlotRadar()
  private function _renderPlotContour($groupID) {
    $contourStyle = $this->_chart
      ->getPlotArea()
      ->getPlotGroupByIndex($groupID)
      ->getPlotStyle();
    $seriesCount = $this->_chart
      ->getPlotArea()
      ->getPlotGroupByIndex($groupID)
      ->getPlotSeriesCount();
    $seriesPlots = array();
    $dataValues = array();

    //	Loop through each data series in turn
    for ($i = 0; $i < $seriesCount; ++$i) {
      $dataValuesY = $this->_chart
        ->getPlotArea()
        ->getPlotGroupByIndex($groupID)
        ->getPlotCategoryByIndex($i)
        ->getDataValues();
      $dataValuesX = $this->_chart
        ->getPlotArea()
        ->getPlotGroupByIndex($groupID)
        ->getPlotValuesByIndex($i)
        ->getDataValues();
      $dataValues[$i] = $dataValuesX;
    }
    $seriesPlot = new ContourPlot($dataValues);
    $this->_graph
      ->Add($seriesPlot);
  }

  //	function _renderPlotContour()
  private function _renderPlotStock($groupID) {
    $seriesCount = $this->_chart
      ->getPlotArea()
      ->getPlotGroupByIndex($groupID)
      ->getPlotSeriesCount();
    $plotOrder = $this->_chart
      ->getPlotArea()
      ->getPlotGroupByIndex($groupID)
      ->getPlotOrder();
    $dataValues = array();

    //	Loop through each data series in turn and build the plot arrays
    foreach ($plotOrder as $i => $v) {
      $dataValuesX = $this->_chart
        ->getPlotArea()
        ->getPlotGroupByIndex($groupID)
        ->getPlotValuesByIndex($v)
        ->getDataValues();
      foreach ($dataValuesX as $j => $dataValueX) {
        $dataValues[$plotOrder[$i]][$j] = $dataValueX;
      }
    }
    if (empty($dataValues)) {
      return;
    }
    $dataValuesPlot = array();

    // Flatten the plot arrays to a single dimensional array to work with jpgraph
    for ($j = 0; $j < count($dataValues[0]); $j++) {
      for ($i = 0; $i < $seriesCount; $i++) {
        $dataValuesPlot[] = $dataValues[$i][$j];
      }
    }

    // Set the x-axis labels
    $labelCount = count($this->_chart
      ->getPlotArea()
      ->getPlotGroupByIndex($groupID)
      ->getPlotValuesByIndex(0)
      ->getPointCount());
    if ($labelCount > 0) {
      $datasetLabels = $this->_chart
        ->getPlotArea()
        ->getPlotGroupByIndex($groupID)
        ->getPlotCategoryByIndex(0)
        ->getDataValues();
      $datasetLabels = $this
        ->_formatDataSetLabels($groupID, $datasetLabels, $labelCount);
      $this->_graph->xaxis
        ->SetTickLabels($datasetLabels);
    }
    $seriesPlot = new StockPlot($dataValuesPlot);
    $seriesPlot
      ->SetWidth(20);
    $this->_graph
      ->Add($seriesPlot);
  }

  //	function _renderPlotStock()
  private function _renderAreaChart($groupCount, $dimensions = '2d') {
    require_once PHPExcel_Settings::getChartRendererPath() . 'jpgraph_line.php';
    $this
      ->_renderCartesianPlotArea();
    for ($i = 0; $i < $groupCount; ++$i) {
      $this
        ->_renderPlotLine($i, True, False, $dimensions);
    }
  }

  //	function _renderAreaChart()
  private function _renderLineChart($groupCount, $dimensions = '2d') {
    require_once PHPExcel_Settings::getChartRendererPath() . 'jpgraph_line.php';
    $this
      ->_renderCartesianPlotArea();
    for ($i = 0; $i < $groupCount; ++$i) {
      $this
        ->_renderPlotLine($i, False, False, $dimensions);
    }
  }

  //	function _renderLineChart()
  private function _renderBarChart($groupCount, $dimensions = '2d') {
    require_once PHPExcel_Settings::getChartRendererPath() . 'jpgraph_bar.php';
    $this
      ->_renderCartesianPlotArea();
    for ($i = 0; $i < $groupCount; ++$i) {
      $this
        ->_renderPlotBar($i, $dimensions);
    }
  }

  //	function _renderBarChart()
  private function _renderScatterChart($groupCount) {
    require_once PHPExcel_Settings::getChartRendererPath() . 'jpgraph_scatter.php';
    require_once PHPExcel_Settings::getChartRendererPath() . 'jpgraph_regstat.php';
    require_once PHPExcel_Settings::getChartRendererPath() . 'jpgraph_line.php';
    $this
      ->_renderCartesianPlotArea('linlin');
    for ($i = 0; $i < $groupCount; ++$i) {
      $this
        ->_renderPlotScatter($i, false);
    }
  }

  //	function _renderScatterChart()
  private function _renderBubbleChart($groupCount) {
    require_once PHPExcel_Settings::getChartRendererPath() . 'jpgraph_scatter.php';
    $this
      ->_renderCartesianPlotArea('linlin');
    for ($i = 0; $i < $groupCount; ++$i) {
      $this
        ->_renderPlotScatter($i, true);
    }
  }

  //	function _renderBubbleChart()
  private function _renderPieChart($groupCount, $dimensions = '2d', $doughnut = False, $multiplePlots = False) {
    require_once PHPExcel_Settings::getChartRendererPath() . 'jpgraph_pie.php';
    if ($dimensions == '3d') {
      require_once PHPExcel_Settings::getChartRendererPath() . 'jpgraph_pie3d.php';
    }
    $this
      ->_renderPiePlotArea($doughnut);
    $iLimit = $multiplePlots ? $groupCount : 1;
    for ($groupID = 0; $groupID < $iLimit; ++$groupID) {
      $grouping = $this->_chart
        ->getPlotArea()
        ->getPlotGroupByIndex($groupID)
        ->getPlotGrouping();
      $exploded = $this->_chart
        ->getPlotArea()
        ->getPlotGroupByIndex($groupID)
        ->getPlotStyle();
      if ($groupID == 0) {
        $labelCount = count($this->_chart
          ->getPlotArea()
          ->getPlotGroupByIndex($groupID)
          ->getPlotValuesByIndex(0)
          ->getPointCount());
        if ($labelCount > 0) {
          $datasetLabels = $this->_chart
            ->getPlotArea()
            ->getPlotGroupByIndex($groupID)
            ->getPlotCategoryByIndex(0)
            ->getDataValues();
          $datasetLabels = $this
            ->_formatDataSetLabels($groupID, $datasetLabels, $labelCount);
        }
      }
      $seriesCount = $this->_chart
        ->getPlotArea()
        ->getPlotGroupByIndex($groupID)
        ->getPlotSeriesCount();
      $seriesPlots = array();

      //	For pie charts, we only display the first series: doughnut charts generally display all series
      $jLimit = $multiplePlots ? $seriesCount : 1;

      //	Loop through each data series in turn
      for ($j = 0; $j < $jLimit; ++$j) {
        $dataValues = $this->_chart
          ->getPlotArea()
          ->getPlotGroupByIndex($groupID)
          ->getPlotValuesByIndex($j)
          ->getDataValues();

        //	Fill in any missing values in the $dataValues array
        $testCurrentIndex = 0;
        foreach ($dataValues as $k => $dataValue) {
          while ($k != $testCurrentIndex) {
            $dataValues[$testCurrentIndex] = null;
            ++$testCurrentIndex;
          }
          ++$testCurrentIndex;
        }
        if ($dimensions == '3d') {
          $seriesPlot = new PiePlot3D($dataValues);
        }
        else {
          if ($doughnut) {
            $seriesPlot = new PiePlotC($dataValues);
          }
          else {
            $seriesPlot = new PiePlot($dataValues);
          }
        }
        if ($multiplePlots) {
          $seriesPlot
            ->SetSize(($jLimit - $j) / ($jLimit * 4));
        }
        if ($doughnut) {
          $seriesPlot
            ->SetMidColor('white');
        }
        $seriesPlot
          ->SetColor(self::$_colourSet[self::$_plotColour++]);
        if (count($datasetLabels) > 0) {
          $seriesPlot
            ->SetLabels(array_fill(0, count($datasetLabels), ''));
        }
        if ($dimensions != '3d') {
          $seriesPlot
            ->SetGuideLines(false);
        }
        if ($j == 0) {
          if ($exploded) {
            $seriesPlot
              ->ExplodeAll();
          }
          $seriesPlot
            ->SetLegends($datasetLabels);
        }
        $this->_graph
          ->Add($seriesPlot);
      }
    }
  }

  //	function _renderPieChart()
  private function _renderRadarChart($groupCount) {
    require_once PHPExcel_Settings::getChartRendererPath() . 'jpgraph_radar.php';
    $this
      ->_renderRadarPlotArea();
    for ($groupID = 0; $groupID < $groupCount; ++$groupID) {
      $this
        ->_renderPlotRadar($groupID);
    }
  }

  //	function _renderRadarChart()
  private function _renderStockChart($groupCount) {
    require_once PHPExcel_Settings::getChartRendererPath() . 'jpgraph_stock.php';
    $this
      ->_renderCartesianPlotArea('intint');
    for ($groupID = 0; $groupID < $groupCount; ++$groupID) {
      $this
        ->_renderPlotStock($groupID);
    }
  }

  //	function _renderStockChart()
  private function _renderContourChart($groupCount, $dimensions) {
    require_once PHPExcel_Settings::getChartRendererPath() . 'jpgraph_contour.php';
    $this
      ->_renderCartesianPlotArea('intint');
    for ($i = 0; $i < $groupCount; ++$i) {
      $this
        ->_renderPlotContour($i);
    }
  }

  //	function _renderContourChart()
  private function _renderCombinationChart($groupCount, $dimensions, $outputDestination) {
    require_once PHPExcel_Settings::getChartRendererPath() . 'jpgraph_line.php';
    require_once PHPExcel_Settings::getChartRendererPath() . 'jpgraph_bar.php';
    require_once PHPExcel_Settings::getChartRendererPath() . 'jpgraph_scatter.php';
    require_once PHPExcel_Settings::getChartRendererPath() . 'jpgraph_regstat.php';
    require_once PHPExcel_Settings::getChartRendererPath() . 'jpgraph_line.php';
    $this
      ->_renderCartesianPlotArea();
    for ($i = 0; $i < $groupCount; ++$i) {
      $dimensions = null;
      $chartType = $this->_chart
        ->getPlotArea()
        ->getPlotGroupByIndex($i)
        ->getPlotType();
      switch ($chartType) {
        case 'area3DChart':
          $dimensions = '3d';
        case 'areaChart':
          $this
            ->_renderPlotLine($i, True, True, $dimensions);
          break;
        case 'bar3DChart':
          $dimensions = '3d';
        case 'barChart':
          $this
            ->_renderPlotBar($i, $dimensions);
          break;
        case 'line3DChart':
          $dimensions = '3d';
        case 'lineChart':
          $this
            ->_renderPlotLine($i, False, True, $dimensions);
          break;
        case 'scatterChart':
          $this
            ->_renderPlotScatter($i, false);
          break;
        case 'bubbleChart':
          $this
            ->_renderPlotScatter($i, true);
          break;
        default:
          $this->_graph = null;
          return false;
      }
    }
    $this
      ->_renderLegend();
    $this->_graph
      ->Stroke($outputDestination);
    return true;
  }

  //	function _renderCombinationChart()
  public function render($outputDestination) {
    self::$_plotColour = 0;
    $groupCount = $this->_chart
      ->getPlotArea()
      ->getPlotGroupCount();
    $dimensions = null;
    if ($groupCount == 1) {
      $chartType = $this->_chart
        ->getPlotArea()
        ->getPlotGroupByIndex(0)
        ->getPlotType();
    }
    else {
      $chartTypes = array();
      for ($i = 0; $i < $groupCount; ++$i) {
        $chartTypes[] = $this->_chart
          ->getPlotArea()
          ->getPlotGroupByIndex($i)
          ->getPlotType();
      }
      $chartTypes = array_unique($chartTypes);
      if (count($chartTypes) == 1) {
        $chartType = array_pop($chartTypes);
      }
      elseif (count($chartTypes) == 0) {
        echo 'Chart is not yet implemented<br />';
        return false;
      }
      else {
        return $this
          ->_renderCombinationChart($groupCount, $dimensions, $outputDestination);
      }
    }
    switch ($chartType) {
      case 'area3DChart':
        $dimensions = '3d';
      case 'areaChart':
        $this
          ->_renderAreaChart($groupCount, $dimensions);
        break;
      case 'bar3DChart':
        $dimensions = '3d';
      case 'barChart':
        $this
          ->_renderBarChart($groupCount, $dimensions);
        break;
      case 'line3DChart':
        $dimensions = '3d';
      case 'lineChart':
        $this
          ->_renderLineChart($groupCount, $dimensions);
        break;
      case 'pie3DChart':
        $dimensions = '3d';
      case 'pieChart':
        $this
          ->_renderPieChart($groupCount, $dimensions, False, False);
        break;
      case 'doughnut3DChart':
        $dimensions = '3d';
      case 'doughnutChart':
        $this
          ->_renderPieChart($groupCount, $dimensions, True, True);
        break;
      case 'scatterChart':
        $this
          ->_renderScatterChart($groupCount);
        break;
      case 'bubbleChart':
        $this
          ->_renderBubbleChart($groupCount);
        break;
      case 'radarChart':
        $this
          ->_renderRadarChart($groupCount);
        break;
      case 'surface3DChart':
        $dimensions = '3d';
      case 'surfaceChart':
        $this
          ->_renderContourChart($groupCount, $dimensions);
        break;
      case 'stockChart':
        $this
          ->_renderStockChart($groupCount, $dimensions);
        break;
      default:
        echo $chartType . ' is not yet implemented<br />';
        return false;
    }
    $this
      ->_renderLegend();
    $this->_graph
      ->Stroke($outputDestination);
    return true;
  }

  //	function render()

  /**
   * Create a new PHPExcel_Chart_Renderer_jpgraph
   */
  public function __construct(PHPExcel_Chart $chart) {
    $this->_graph = null;
    $this->_chart = $chart;
  }

}

//	PHPExcel_Chart_Renderer_jpgraph

Classes

Name	Description
PHPExcel_Chart_Renderer_jpgraph	PHPExcel_Chart_Renderer_jpgraph