<?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		1.8.0, 2014-03-02
 */
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('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('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('jpgraph_bar.php');

        $this->_renderCartesianPlotArea();

        for ($i = 0; $i < $groupCount; ++$i) {
            $this->_renderPlotBar($i, $dimensions);
        }
    }

//	function _renderBarChart()

    private function _renderScatterChart($groupCount) {
        require_once('jpgraph_scatter.php');
        require_once('jpgraph_regstat.php');
        require_once('jpgraph_line.php');

        $this->_renderCartesianPlotArea('linlin');

        for ($i = 0; $i < $groupCount; ++$i) {
            $this->_renderPlotScatter($i, false);
        }
    }

//	function _renderScatterChart()

    private function _renderBubbleChart($groupCount) {
        require_once('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('jpgraph_pie.php');
        if ($dimensions == '3d') {
            require_once('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('jpgraph_radar.php');

        $this->_renderRadarPlotArea();

        for ($groupID = 0; $groupID < $groupCount; ++$groupID) {
            $this->_renderPlotRadar($groupID);
        }
    }

//	function _renderRadarChart()

    private function _renderStockChart($groupCount) {
        require_once('jpgraph_stock.php');

        $this->_renderCartesianPlotArea('intint');

        for ($groupID = 0; $groupID < $groupCount; ++$groupID) {
            $this->_renderPlotStock($groupID);
        }
    }

//	function _renderStockChart()

    private function _renderContourChart($groupCount, $dimensions) {
        require_once('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('jpgraph_line.php');
        require_once('jpgraph_bar.php');
        require_once('jpgraph_scatter.php');
        require_once('jpgraph_regstat.php');
        require_once('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;
    }

//	function __construct()
}

//	PHPExcel_Chart_Renderer_jpgraph
