<?php

define("PLOT_RESULT_FILE_KEY", "plot");

/**
 * @class IHMInputOutputParamsPlotClass
 * @brief Implementation of IHMInputOutputParamsAbstractClass to treat plot request
 * @details

 */

class IHMInputOutputParamsPlotClass extends IHMInputOutputParamsAbstractClass
{
	private $isInteractiveRequest = false;

	private $isFromWS = false;

	private $isInstantPlot = false;

	private $interactiveTimeSelectionState = array();

	private $interactivePlotTitle = array();
	private $interactivePlotIndex = array();

	private $interactiveCrtTTFileIndex = -1;

	private $interactivePreview = false;

	protected $isMultiPlot = FALSE;

	/*
	 * @brief method to unmarshall a plot request
	*/
	protected function unmarshallRequest($input)
	{

		$forceTimeZoomReset = false;

		$resetZoom = false;

		if (isset($input->{'action'})) {

			$input = $this->unmarshallActionRequest($input);

			$forceTimeZoomReset = isset($input->{'force-time-zoom-reset'}) ? $input->{'force-time-zoom-reset'} : false;

		} else {

			$resetZoom = true;

			//save request

			$this->saveIHMRequest(PLOT_RESULT_FILE_KEY . "_" . $input->{'tab-index'}, $input);

		}

		//Request

		$this->isInteractiveRequest = ($input->{'file-output'} == 'INTERACTIVE');

		$this->isFromWS = ($input->{'file-output'} == 'WS');

		if ($resetZoom || $forceTimeZoomReset)

			$this->resetZoomList(PLOT_RESULT_FILE_KEY . "_" . $input->{'tab-index'}, $forceTimeZoomReset);

		$requestNode = $this->paramsData->addRequestNode($input->{'tab-index'});

		$outputsNode = $requestNode->getOutputsNode();
		$paramsNode  = $requestNode->getParamsNode();

		//unmarshall time definition
		$isIntervalRequest = ($input->timesrc == 'Interval');
		$ttFileIndex = -1;
		$ttIntIndex  = -1;

		if ($this->isInteractiveRequest && !$isIntervalRequest && !$input->{'page-superpose-mode'}) {

			$ttFileIndex = !isset($input->{'ttFileIndex'}) ? 0 : $input->{'ttFileIndex'};
			$ttIntIndex = !isset($input->{'intIndex'}) ? 0 : $input->{'intIndex'};
		}

		$this->unmarshallTimeDefinition($input, $input->{'tab-index'}, $ttFileIndex, $ttIntIndex);

		$this->interactiveCrtTTFileIndex = $ttFileIndex;

		$plotOutputNode = $outputsNode->addNewOutput(RequestOutputTypeEnum::PLOT);

		$plotOutputNode->setWriteContextFile($this->isInteractiveRequest ? "true" : "false");

		$compression = "";

		if (!$this->isInteractiveRequest && !$this->isFromWS) {
			switch ($input->{'file-output'}) {
				case 'TGZ':

					$plotOutputNode->addPostProcessing(RequestOutputPostProcessingEnumClass::TAR);
					$plotOutputNode->addPostProcessing(RequestOutputPostProcessingEnumClass::GZIP);
					$compression = ".tar.gz";
					break;

				case 'ZIP':

					$plotOutputNode->addPostProcessing(RequestOutputPostProcessingEnumClass::ZIP);
					$compression = ".zip";
					break;
				default:
					throw new Exception('Compression not implemented.');

			}

		}

		if ($input->{'one-file-per-interval'})
			$plotOutputNode->setStructure(RequestOutputPlotStructureEnum::ONE_FILE_PER_INTERVAL);
		else
			$plotOutputNode->setStructure(RequestOutputPlotStructureEnum::ONE_FILE);

		//prefix
		$filePrefix = "plot_";
		if ($input->{'file-prefix'} && ($input->{'file-prefix'} != ""))
			$filePrefix = $input->{'file-prefix'};

		$filePrefix .= $input->{'tab-index'};

		$plotOutputNode->setFilePrefix($filePrefix);

		//page
		$pageNode = $plotOutputNode->getPage();

		$fileFormat = RequestOutputPlotPageFormatEnum::PNG;
		$extension = ".png";

		switch ($input->{'file-format'}) {
			case 'PNG':

				$fileFormat = RequestOutputPlotPageFormatEnum::PNG;
				$extension = ".png";
				break;

			case 'PDF':

				$fileFormat = RequestOutputPlotPageFormatEnum::PDF;
				$extension = ".pdf";
				break;

			case 'PS':

				$fileFormat = RequestOutputPlotPageFormatEnum::PS;
				$extension = ".ps";
				break;

			case 'SVG':

				$fileFormat = RequestOutputPlotPageFormatEnum::SVG;
				$extension = ".svg";
				break;
			default:
				throw new Exception('File format not implemented.');
		}

		$pageNode->setFormat($fileFormat);

		$this->unmarshallTitle($input, 'page-title', $pageNode->getTitle());

		$isPortrait = false;

		switch ($input->{'page-orientation'}) {
			case 'landscape':

				$pageNode->setOrientation(RequestOutputPlotPageOrientationEnum::LANDSCAPE);
				break;

			case 'portrait':

				$pageNode->setOrientation(RequestOutputPlotPageOrientationEnum::PORTRAIT);
				$isPortrait = true;
				break;
		}

		switch ($input->{'page-dimension'}) {
			case 'ISO A4':

				$pageNode->setDimension(RequestOutputPlotPageDimensionEnum::ISO_A4);
				break;

			case 'US letter':

				$pageNode->setDimension(RequestOutputPlotPageDimensionEnum::US_LETTER);
				break;
			default:
				throw new Exception('Page dimension not implemented.');
		}

		switch ($input->{'page-mode'}) {

			case 'grayscale':

				$pageNode->setMode(RequestOutputPlotPageModeEnum::GRAYSCALE);
				break;

			case 'color':

			default:
				$pageNode->setMode(RequestOutputPlotPageModeEnum::COLOR);
				break;
		}

		if ($input->{'page-margins-activated'}) {

			$pageNode->getMargins()->setHorizontal($input->{'page-margin-x'});
			$pageNode->getMargins()->setVertical($input->{'page-margin-y'});
		}

		if ($input->{'page-font-activated'})
			$this->unmarshallFont($input, 'page-font', $pageNode->getFont());

		//Superpose mode

		$pageNode->setSuperposeMode($input->{'page-superpose-mode'} ? "true" : "false");

		//Layout
		$this->unmarshallLayout($input, $pageNode);

		foreach ($input->{'panels'} as $panelData)
			$this->unmarshallPanel($panelData, $pageNode, $paramsNode);

		if ($this->isInteractiveRequest || $this->isFromWS) {
			$resultFile = $filePrefix . "_*" . $extension;
			$waitingResultFile = $filePrefix . $extension;
		} else {
			$resultFile = $filePrefix . "_*" . $compression;
			$waitingResultFile = $filePrefix . $compression;

		}

		if ($this->isInteractiveRequest) {
			$this->interactiveTimeSelectionState[PLOT_RESULT_FILE_KEY . "_" . $input->{'tab-index'}] = $isIntervalRequest;
			$this->interactivePlotTitle[PLOT_RESULT_FILE_KEY . "_" . $input->{'tab-index'}] = $input->{'tab-title'};
			$this->interactivePlotIndex[PLOT_RESULT_FILE_KEY . "_" . $input->{'tab-index'}] = $input->{'tab-index'};

			$this->interactivePreview = isset($input->{'interactive-preview'}) && ($input->{'interactive-preview'});

			$this->paramsData->addWaitingResult(PLOT_RESULT_FILE_KEY . "_" . $input->{'tab-index'}, $waitingResultFile);
		} else

			$this->paramsData->addWaitingResult(PLOT_RESULT_FILE_KEY, $waitingResultFile);

		//Remove old result files

		foreach (glob($this->paramsData->getWorkingPath() . $resultFile) as $oldFile) {

			unlink($oldFile);
		}

		//Post process command to apply to the result file

		$postProcessCmd = $this->paramsData->getPostCmd();

		if ($postProcessCmd != "")
			$postProcessCmd .= " | ";

		$postProcessCmd .= "mv " . $resultFile . " " . $waitingResultFile;

		if (($this->isInteractiveRequest) && $isPortrait)

			$postProcessCmd .= " | convert " . $waitingResultFile . " -rotate -90 " . $waitingResultFile;
		else if ($this->isFromWS) {

			if ($isPortrait)

				$postProcessCmd .= " | convert " . $waitingResultFile . " -rotate -90 " . $input->{"ws-result-file"};

			else

				$postProcessCmd .= " | mv " . $waitingResultFile . " " . $input->{"ws-result-file"};

		}

		$this->paramsData->setBatchEnable(!(($fileFormat == RequestOutputPlotPageFormatEnum::PNG) && $this->isInteractiveRequest));
		$this->paramsData->setPostCmd($postProcessCmd);

		return $this->paramsData;
	}

	protected function unmarshallLayout($request, $pageNode)

	{

		switch ($request->{'page-layout-type'}) {
			case 'vertical':

				$pageNode->getLayout()->setType(RequestOutputPlotLayoutTypeEnum::VERTICAL);

				$pageNode->getLayout()->setPanelHeight($request->{'page-layout-object'}->{'layout-panel-height'});
				$pageNode->getLayout()->setPanelSpacing($request->{'page-layout-object'}->{'layout-panel-spacing'});
				$pageNode->getLayout()->setExpand($request->{'page-layout-object'}->{'layout-expand'} ? "true" : "false");
				$pageNode->getLayout()->setOnlyLowerTimeAxesLegend($request->{'page-layout-object'}->{'layout-timeaxes-legend-lowerone'} ? "true" : "false");
				//if ($request->{'page-layout-object'}->{'layout-timeplot-width'} > 0)
				//	$pageNode->setDefaultTimePlotWidth($request->{'page-layout-object'}->{'layout-timeplot-width'});
				if ($request->{'page-layout-object'}->{'layout-timeplot-height'} > 0)
					$pageNode->setDefaultTimePlotHeight($request->{'page-layout-object'}->{'layout-timeplot-height'});
				if ($request->{'page-layout-object'}->{'layout-xyplot-width'} > 0)
					$pageNode->setDefaultXYPlotWidth($request->{'page-layout-object'}->{'layout-xyplot-width'});
				if ($request->{'page-layout-object'}->{'layout-xyplot-height'} > 0)
					$pageNode->setDefaultXYPlotHeight($request->{'page-layout-object'}->{'layout-xyplot-height'});

				break;

			case 'auto':

				$pageNode->getLayout()->setType(RequestOutputPlotLayoutTypeEnum::AUTO);

				$pageNode->getLayout()->setPanelHeight($request->{'page-layout-object'}->{'layout-panel-height'});
				$pageNode->getLayout()->setPanelSpacing($request->{'page-layout-object'}->{'layout-panel-spacing'});
				$pageNode->getLayout()->setExpand($request->{'page-layout-object'}->{'layout-expand'} ? "true" : "false");
				$pageNode->getLayout()->setOnlyLowerTimeAxesLegend($request->{'page-layout-object'}->{'layout-timeaxes-legend-lowerone'} ? "true" : "false");

				break;

			case 'manual':

				$pageNode->getLayout()->setType(RequestOutputPlotLayoutTypeEnum::MANUAL);

				$timePlotLeftMargin = $request->{'page-layout-object'}->{'layout-timeplot-margin-left'} ? $request->{'page-layout-object'}->{'layout-timeplot-margin-left'} : -1;
				$timePlotRightMargin = $request->{'page-layout-object'}->{'layout-timeplot-margin-right'} ? $request->{'page-layout-object'}->{'layout-timeplot-margin-right'} : -1;

				$pageNode->setDefaultTimePlotXMargin($timePlotLeftMargin, $timePlotRightMargin);

				$xyPlotLeftMargin = $request->{'page-layout-object'}->{'layout-xyplot-margin-left'} ? $request->{'page-layout-object'}->{'layout-xyplot-margin-left'} : -1;
				$xyPlotRightMargin = $request->{'page-layout-object'}->{'layout-xyplot-margin-right'} ? $request->{'page-layout-object'}->{'layout-xyplot-margin-right'} : -1;

				$pageNode->setDefaultXYPlotXMargin($xyPlotLeftMargin, $xyPlotRightMargin);
				break;
			default:
				throw new Exception('Layout type not implemented.');
		}

	}

	protected function unmarshallPanel($panelData, $pageNode, $paramsNode)
	{
		$panelNode = $pageNode->addPanel();

		switch ($pageNode->getLayout()->getType()) {
			case RequestOutputPlotLayoutTypeEnum::MANUAL:

				//Panel bounds
				$panelNode->getBounds()->setX($panelData->{'panel-bounds-x'});
				$panelNode->getBounds()->setY($panelData->{'panel-bounds-y'});
				$panelNode->getBounds()->setWidth($panelData->{'panel-bounds-width'});
				$panelNode->getBounds()->setHeight($panelData->{'panel-bounds-height'});
				//Panel margins
				$leftMargin = $panelData->{'panel-margin-left'} ? $panelData->{'panel-margin-left'} : -1;
				$rightMargin = $panelData->{'panel-margin-right'} ? $panelData->{'panel-margin-right'} : -1;
				$panelNode->setXMargin($leftMargin, $rightMargin);
				break;

			case RequestOutputPlotLayoutTypeEnum::VERTICAL:

				//Panel prefered dimensions
				if ($panelData->{'panel-prefered-width'} > 0)
					$panelNode->setPreferedWidth($panelData->{'panel-prefered-width'});
				if ($panelData->{'panel-prefered-height'} > 0)
					$panelNode->setPreferedHeight($panelData->{'panel-prefered-height'});
				break;

			default:

				//Nothing to do
		}

		//Panel id

		if (isset($panelData->{'id'}))
			$panelNode->setId($panelData->{'id'});

		//Panel id
		if (isset($panelData->{'panel-index'}))
			$panelNode->setIndex($panelData->{'panel-index'});

		//Panel background color
		if (($panelData->{'panel-background-color'} != 'none') && ($panelData->{'panel-background-color'} != ''))
			$panelNode->setBackgroundColor($this->hexColor2KernelColor($panelData->{'panel-background-color'}));

		//Plot Area background color
		if (($panelData->{'panel-plotareabackground-color'} != 'none') && ($panelData->{'panel-plotareabackground-color'} != '')) {
			$panelNode->setPlotAreaBackgroundColor($this->hexColor2KernelColor($panelData->{'panel-plotareabackground-color'}));
		}

		//Panel font
		$this->unmarshallFont($panelData, 'panel-font', $panelNode->getFont());

		//Panel title
		$this->unmarshallTitle($panelData, 'panel-title', $panelNode->getTitle());

		//Plot type

		$this->isInstantPlot = false;

		$plotNode = $this->unmarshallPlotType($panelData, $panelNode);

		$isTimePlot = ($plotNode->getName() == REQUESTOUTPUTPLOTELEMENTTIME_NAME);

		//Tick plot
		$tickPlotNode = NULL;

		if ($isTimePlot) {
			if ($this->hasTickBar($panelData->{'params'})) {
				$tickPlotNode = $panelNode->addPlotElement(RequestOutputPlotElementTypeEnum::TICKPLOT, true);

				if ($panelData->{'panel-tick-format'} != '')
					$tickPlotNode->setFormat($panelData->{'panel-tick-format'});
			}
		}

		//Status plot
		$statusPlotNode = NULL;

		if ($isTimePlot) {
			if ($this->hasStatusBar($panelData->{'params'})) {
				$statusPlotNode = $panelNode->addPlotElement(RequestOutputPlotElementTypeEnum::STATUSPLOT, true);
				switch ($panelData->{'panel-status-position'}) {
					case 'top':

						$statusPlotNode->setPosition(RequestOutputPlotElementStatusPosition::TOP);
						break;

					case 'bottom':

						$statusPlotNode->setPosition(RequestOutputPlotElementStatusPosition::BOTTOM);
						break;
				}
				$statusPlotNode->setColorMap($panelData->{'panel-status-colormap'});
			}
		}

		//Axes
		foreach ($panelData->{'axes'} as $axisData)
			$this->unmarshallAxis($axisData, $panelData->{'constants'}, $plotNode);

		//Params

		$this->unmarshallParams($panelData->{'params'}, $paramsNode, $plotNode, $panelNode, $statusPlotNode, $tickPlotNode, $panelData->{'axes'});

		//Additional objects
		if ($plotNode->getAdditionalObjects() != NULL)
			$this->unmarshallAdditionalObjects($panelData, $plotNode->getAdditionalObjects(), $isTimePlot);

		//Fills
		if ($plotNode->getFills() != NULL)
			$this->unmarshallFills($panelData, $plotNode->getFills());

		return $panelNode;
	}

	protected function unmarshallPlotType($panelData, $panelNode)
	{

		switch ($panelData->{'panel-plot-type'}) {
			case 'timePlot':

				$plotNode = $panelNode->addPlotElement(RequestOutputPlotElementTypeEnum::TIMEPLOT);
				break;

			case 'xyPlot':

				$plotNode = $panelNode->addPlotElement(RequestOutputPlotElementTypeEnum::XYPLOT);
				$plotNode->setIsIsotropic($panelData->{'panel-scatter-isotropic'});
				break;

			case 'statusPlot':

				$plotNode = $panelNode->addPlotElement(RequestOutputPlotElementTypeEnum::STATUSPLOT);

				switch ($panelData->{'panel-status-position'}) {
					case 'top':

						$plotNode->setPosition(RequestOutputPlotElementStatusPosition::TOP);
						break;

					case 'bottom':

						$plotNode->setPosition(RequestOutputPlotElementStatusPosition::BOTTOM);
						break;
				}
				$plotNode->setColorMap($panelData->{'panel-status-colormap'});
				break;

			case 'tickPlot':

				$plotNode = $panelNode->addPlotElement(RequestOutputPlotElementTypeEnum::TICKPLOT);
				if ($panelData->{'panel-tick-format'} != '')
					$plotNode->setFormat($panelData->{'panel-tick-format'});
				break;

			case 'epochPlot':

				$plotNode = $panelNode->addPlotElement(RequestOutputPlotElementTypeEnum::EPOCHPLOT);

				if ($panelData->{'panel-epoch-centertimeid'} != '')
					$plotNode->setCenterTimeId($panelData->{'panel-epoch-centertimeid'});

				break;

			case 'instantPlot':

				$plotNode = $panelNode->addPlotElement(RequestOutputPlotElementTypeEnum::INSTANTPLOT);
				date_default_timezone_set('UTC');

				$time = CommonClass::strTimeToDDTime($panelData->{'panel-instant-time'});

				$plotNode->setTime($time);

				$this->isInstantPlot = true;

				break;

			case RequestOutPutPlotElementPlotFunctionNodeClass::REQUESTOUTPUTPLOTELEMENT_PLOTFUNCTION_NAME:
				$plotNode = $panelNode->addPlotElement(RequestOutputPlotElementTypeEnum::PLOTFUNCTION);
				$plotNode->setAbscisse($panelData->{RequestOutPutPlotElementPlotFunctionNodeClass::PLOT_FUNCTION_ABSCISSE});
				$plotNode->setType($panelData->{RequestOutPutPlotElementPlotFunctionNodeClass::PLOT_FUNCTION_TYPE});
				$plotNode->setScaleAbscisse($panelData->{RequestOutPutPlotElementPlotFunctionNodeClass::PLOT_FUNCTION_SCALE_ABSCISSE});
				$plotNode->setScaleOrdonnee($panelData->{RequestOutPutPlotElementPlotFunctionNodeClass::PLOT_FUNCTION_SCALE_ORDONNEE});

				//$plotNode->setParamsNbPoints($panelData->{RequestOutPutPlotElementPlotFunctionNodeClass::PLOT_FUNCTION_PARAMS_NB_POINTS});

				break;

			default:
				throw new Exception('Plot type not implemented.');
		}

		//Params Legend
		if (isset($panelData->{'panel-series-legend'}) && $panelData->{'panel-series-legend'}->{'legend-series-activated'})
			$this->unmarshallParamsLegend($panelData->{'panel-series-legend'}, $plotNode->getLegends()->getParamsLegend());

		//Text Legends

		foreach ($panelData->{'text-legends'} as $textLegendData) {
			$legendNode = $plotNode->getLegends()->addTextLegend();
			$this->unmarshallTextLegend($textLegendData, $legendNode);
		}

		return $plotNode;
	}

	protected function unmarshallAxis($axisData, $constantsData, $plotNode)
	{
		//axis type
		$constantAxisId = '';

		switch ($axisData->{'axis-type'}) {
			case 'time':

				$axisNode = $plotNode->getTimeAxis();
				$axisNode->setFormat($axisData->{'axis-time-format'});
				$constantAxisId = 'x';
				break;

			case 'epoch':

				$axisNode = $plotNode->getEpochAxis();
				$axisNode->setNormalized($axisData->{'axis-epoch-normalized'} ? "true" : "false");
				$constantAxisId = 'x';
				break;

			case 'x':

				$axisNode = $plotNode->getXAxis();
				$constantAxisId = 'x';
				break;

			case 'y-left':

				$axisNode = $plotNode->addYAxis('y-left');
				$constantAxisId = 'y-left';
				break;

			case 'y-right':

				$axisNode = $plotNode->addYAxis('y-right');
				$axisNode->setPosition(RequestOutputPlotAxisElementPosition::RIGHT);
				$constantAxisId = 'y-right';
				break;

			case 'color':

				$axisNode = $plotNode->getZAxis();
				$axisNode->setColorMapIndex($axisData->{'axis-color-map'});
				if ($axisData->{'axis-color-minval'} != 'none')
					$axisNode->setMinValColor($this->hexColor2KernelColor($axisData->{'axis-color-minval'}));
				if ($axisData->{'axis-color-maxval'} != 'none')
					$axisNode->setMaxValColor($this->hexColor2KernelColor($axisData->{'axis-color-maxval'}));
				break;
			default:
				throw new Exception('Axis type not implemented.');
		}

		//reverse axis

		if (isset($axisData->{'axis-reverse'}))
			$axisNode->setReverse($axisData->{'axis-reverse'} ? "true" : "false");

		//axis scale

		switch ($axisData->{'axis-scale'}) {
			case 'logarithmic':

				$axisNode->setScale(RequestOutputPlotAxisElementScale::LOGARITHMIC);
				break;
			default:
				$axisNode->setScale(RequestOutputPlotAxisElementScale::LINEAR);
		}

		//axis range
		if ($axisData->{'axis-range-min'} < $axisData->{'axis-range-max'})
			$axisNode->getRange()->setMinMax($axisData->{'axis-range-min'}, $axisData->{'axis-range-max'});

		if (isset($axisData->{'axis-range-extend'}))
			$axisNode->getRange()->setExtend($axisData->{'axis-range-extend'} ? "true" : "false");

		//axis color

		if (isset($axisData->{'axis-color'}))
			$axisNode->setColor($this->hexColor2KernelColor($axisData->{'axis-color'}));

		//axis thickness

		if (isset($axisData->{'axis-thickness'}))
			$axisNode->setThickness($axisData->{'axis-thickness'});

		//axis ticks position

		switch ($axisData->{'axis-tick-position'}) {
			case 'inwards':

				$axisNode->getTick()->setPosition(RequestOutputPlotAxisElementTickPosition::INWARDS);
				break;

			default:

				$axisNode->getTick()->setPosition(RequestOutputPlotAxisElementTickPosition::OUTWARDS);
		}

		//axis minor and major grid

		if (isset($axisData->{'axis-grid-minor'}))
			$axisNode->getTick()->setMinorGrid($axisData->{'axis-grid-minor'} ? "true" : "false");

		if (isset($axisData->{'axis-grid-major'}))
			$axisNode->getTick()->setMajorGrid($axisData->{'axis-grid-major'} ? "true" : "false");

		if ($axisData->{'axis-grid-specify-ticks-number'}) {

			if (isset($axisData->{'axis-grid-minor-number'}) && $axisData->{'axis-grid-minor-number'} != 0)
				$axisNode->getTick()->setMinorGridNumber($axisData->{'axis-grid-minor-number'});

			if (isset($axisData->{'axis-grid-major-number'}) && $axisData->{'axis-grid-major-number'} != 0)
				$axisNode->getTick()->setMajorGridNumber($axisData->{'axis-grid-major-number'});
		} elseif ($axisData->{'axis-grid-specify-ticks-spacing'}) {

			if (isset($axisData->{'axis-grid-major-space'}) && $axisData->{'axis-grid-major-space'} != 0)
				$axisNode->getTick()->setMajorGridSpace($axisData->{'axis-grid-major-space'});

			if (isset($axisData->{'axis-grid-minor-space'}) && $axisData->{'axis-grid-minor-space'} != 0)
				$axisNode->getTick()->setMinorGridSpace($axisData->{'axis-grid-minor-space'});
		}


		//legend
		if (isset($axisData->{'axis-legend-text'}) && $axisData->{'axis-legend-text'} != '') {

			$axisNode->getLegend()->setText($axisData->{'axis-legend-text'});

		}

		$axisNode->getLegend()->setColor($this->hexColor2KernelColor($axisData->{'axis-legend-color'}));
		$this->unmarshallLabel($axisData, "axis-legend", $axisNode->getLegend());

		//Show legend

		if (isset($axisData->{'axis-legend-activated'}))
			$axisNode->setShowLegend($axisData->{'axis-legend-activated'} ? "true" : "false");

		//Show tick marks

		if (isset($axisData->{'axis-tick-showmarks'}))
			$axisNode->setShowTickMarks($axisData->{'axis-tick-showmarks'} ? "true" : "false");

		//Add constants

		if ($constantAxisId != '') {

			foreach ($constantsData as $constantData)
				if ($constantData->{'constant-axis-id'} == $constantAxisId)

					$this->unmarshallConstant($constantData, $axisNode);

		}
	}

	protected function unmarshallParams($paramsData, $requestParamsNode, $plotNode, $panelNode, $statusPlotNode, $tickPlotNode, $axesData)

	{
		//X parameters
		$isScatter = ($plotNode->getName() == REQUESTOUTPUTPLOTELEMENTXY_NAME);

		$xIds = array();

		if ($isScatter) {

			$crtXId = 0;

			foreach ($paramsData as $paramData) {

				if ($paramData->{'param-drawing-object'}->{'serie-xaxis-param'} == '')
					continue;

				if (array_key_exists($paramData->{'param-drawing-object'}->{'serie-xaxis-param'}, $xIds)) {
					//x param already exists
					continue;
				}

				$paramXInfo = $this->paramManager->addExistingParam($paramData->{'param-drawing-object'}->{'serie-xaxis-param'}, $this->paramsData);

				if ($paramXInfo['id'] == '')
					throw new Exception('Cannot retrieve X parameter.');
				$requestParamsNode->addParam($paramXInfo['id']);
				$xParamNode = $plotNode->getParams()->getParamById($paramXInfo['id']);

				switch ($paramData->{'param-drawing-type'}) {

					case 'histogram2d':

					case 'serie':

						//Unmarshall x serie
						if (count($paramXInfo['indexes']) == 0)

							$xParamNode->addXSerie(-1, $crtXId, $paramData->{'param-drawing-object'}->{'serie-xvalue-min'}, $paramData->{'param-drawing-object'}->{'serie-xvalue-max'});

						else if (count($paramXInfo['indexes']) == 1)

							$xParamNode->addXSerie($paramXInfo['indexes'][0], $crtXId, $paramData->{'param-drawing-object'}->{'serie-xvalue-min'}, $paramData->{'param-drawing-object'}->{'serie-xvalue-max'});

						else
							throw new Exception('X parameter for serie must be a component.');
						break;

					default:

						throw new Exception('X parameter not allowed for this drawing type. ');
				}

				$xIds[$paramData->{'param-drawing-object'}->{'serie-xaxis-param'}] = $crtXId;
				++$crtXId;

			}
		}

		//Main drawing element parameter
		$drawingEltIndex = 0;

		foreach ($paramsData as $paramData) {

			$isTTCat = ($paramData->{'param-type'} == 'ttcat');

			//Param

			if (!$isTTCat) {
				$paramInfo = $this->paramManager->addExistingParam($paramData->{'paramid'}, $this->paramsData, isset($paramData->{'template_args'}) ? $paramData->{'template_args'} : NULL);

			} else {

				$paramInfo = $this->paramManager->addTTCatParam($paramData->{'paramid'}, $this->paramsData);
			}

			$paramInfo['indexes'] = array();

			if ($paramData->{'param-drawing-type'} == 'sauvaud') {
				$this->paramManager->applyRangesAndIndexes($this->paramsData, $paramData, false, $paramInfo);
			} else {
				$this->paramManager->applyRangesAndIndexes($this->paramsData, $paramData, !$this->isInstantPlot, $paramInfo);
			}

			$this->paramManager->applyFilter($this->paramsData, $paramData, $paramInfo);

			$requestParamsNode->addParam($paramInfo['id']);

			$colorSerieId = -1;

			if (!empty($paramData->{'param-drawing-object'}->{'serie-colored-param'}))

				$colorSerieId = $drawingEltIndex;

			$xId = ($isScatter && !empty($paramData->{'param-drawing-object'}->{'serie-xaxis-param'})) ? $xIds[$paramData->{'param-drawing-object'}->{'serie-xaxis-param'}] : -1;

			switch ($paramData->{'param-drawing-type'}) {
				case 'serie':

					$paramNode = $plotNode->getParams()->getParamById($paramInfo['id']);

					$this->unmarshallSerie($paramData, $requestParamsNode, $plotNode, $paramNode, $paramInfo['indexes'], $xId, $colorSerieId, false);

					break;

				case 'histogram2d':
					$paramNode = $plotNode->getParams()->getParamById($paramInfo['id']);

					if(!empty($paramData->{'param-drawing-object'}->{'histotype-param'}))
						$paramZInfo = $this->paramManager->addExistingParam($paramData->{'param-drawing-object'}->{'histotype-param'}, $this->paramsData);
					else
						$paramZInfo = NULL;

					$this->unmarshallHistogram2D($paramData, $requestParamsNode, $plotNode, $paramNode, $paramInfo['indexes'], $xId, $paramZInfo,$axesData);
					break;	

				case 'orbit-serie':

					$paramNode = $plotNode->getParams()->getParamById($paramInfo['id']);

					$this->unmarshallSerie($paramData, $requestParamsNode, $plotNode, $paramNode, -1, $xId, $colorSerieId, true);

					break;

				case 'spectro':

					$paramNode = $plotNode->getParams()->getParamById($paramInfo['id']);
					$this->unmarshallSpectro($paramData->{'param-drawing-object'}, $plotNode, $paramNode, $paramInfo['indexes']);
					break;

				case 'sauvaud':
					$paramNode = $plotNode->getParams()->getParamById($paramInfo['id']);
					$this->unmarshallSauvaud($paramData->{'param-drawing-object'}, $plotNode, $paramNode, $paramInfo['indexes']);

					break;

				case 'status-bar':

					if (($plotNode->getName() == REQUESTOUTPUTPLOTELEMENTSTATUS_NAME) && !isset($statusPlotNode))
						$paramNode = $plotNode->getParams()->getParamById($paramInfo['id']);
					else
						$paramNode = $statusPlotNode->getParams()->getParamById($paramInfo['id']);
					$this->unmarshallStatusBar($paramData->{'param-drawing-object'}, $paramNode, $paramInfo['indexes']);
					break;

				case 'tick-bar':

					if (($plotNode->getName() == REQUESTOUTPUTPLOTELEMENTTICK_NAME) && !isset($tickPlotNode))
						$paramNode = $plotNode->getParams()->getParamById($paramInfo['id']);
					else
						$paramNode = $tickPlotNode->getParams()->getParamById($paramInfo['id']);

					$this->unmarshallTickBar($paramData->{'param-drawing-object'}, $paramNode, $paramInfo['indexes']);
					break;

				case 'iserie':

					$paramNode = $plotNode->getParams()->getParamById($paramInfo['id']);
					$this->unmarshallInstantSerie($paramData->{'param-drawing-object'}, $plotNode, $paramNode);
					break;

				case 'ispectro':

					$paramNode = $plotNode->getParams()->getParamById($paramInfo['id']);
					$this->unmarshallInstantSpectro($paramData->{'param-drawing-object'}, $plotNode, $paramNode, $paramInfo['indexes']);

					break;

				case 'intervals':

					$paramNode = $plotNode->getParams()->getParamById($paramInfo['id']);
					$this->unmarshallIntervals($paramData->{'param-drawing-object'}, $paramNode);
					break;

				default:

					throw new Exception('Drawing type not implemented.');
			}
			++$drawingEltIndex;
		}

		//Colored parameter
		$drawingEltIndex = 0;

		foreach ($paramsData as $paramData) {
			if (empty($paramData->{'param-drawing-object'}->{'serie-colored-param'})) {

				++$drawingEltIndex;
				continue;
			}

			$paramColoredInfo = $this->paramManager->addExistingParam($paramData->{'param-drawing-object'}->{'serie-colored-param'}, $this->paramsData);

			if ($paramColoredInfo['id'] == '')
				throw new Exception('Cannot retrieve colored parameter.');
			$requestParamsNode->addParam($paramColoredInfo['id']);
			$coloredParamNode = $plotNode->getParams()->getParamById($paramColoredInfo['id']);

			$colorSerieId = $drawingEltIndex;

			switch ($paramData->{'param-drawing-type'}) {
				case 'serie':
				case 'orbit-serie':

					//Unmarshall colored serie
					if (count($paramColoredInfo['indexes']) == 0)
						$coloredParamNode->addColorSerie($colorSerieId, -1);
					else if (count($paramColoredInfo['indexes']) == 1)
						$coloredParamNode->addColorSerie($colorSerieId, $paramColoredInfo['indexes'][0]);
					else
						throw new Exception('Colored parameter for serie must be a component.');
					break;

				default:

					throw new Exception('Colored parameter not allowed for this drawing type. ');
			}
			++$drawingEltIndex;
		}
	}