/*

 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). 

 * All rights reserved.

 * This component and the accompanying materials are made available

 * under the terms of the License "Eclipse Public License v1.0"

 * which accompanies this distribution, and is available

 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

 *

 * Initial Contributors:

 * Nokia Corporation - initial contribution.

 *

 * Contributors:

 *

 * Description: 

 *

 */

/*

 * GppVisualiserPanel.java

 */

package com.nokia.carbide.cpp.pi.address;

import java.util.Enumeration;

import java.util.Vector;

import org.eclipse.draw2d.Graphics;

import org.eclipse.draw2d.Panel;

import com.nokia.carbide.cpp.internal.pi.model.ProfiledGeneric;

import com.nokia.carbide.cpp.internal.pi.visual.Defines;

import com.nokia.carbide.cpp.internal.pi.visual.PIEvent;

import com.nokia.carbide.cpp.internal.pi.visual.PIEventListener;

import com.nokia.carbide.cpp.pi.core.SessionPreferences;

public class GppVisualiserPanel implements PIEventListener 

{

	private static final long serialVersionUID = 8984025640418406715L;

	public GppTraceGraph myGppGraph;

	public GppVisualiserPanel myGppVisualiser;

	public GppVisualiserPanel(GppTraceGraph myGppGraphIn)

	{  	

		this.myGppGraph = myGppGraphIn;

	     //sets the percentage scale for y-coordinates

	    this.myGppGraph.setScale(0,100);

	    this.myGppGraph.fillFlag = SessionPreferences.getInstance().getFillAllEnabled();

	  	this.myGppVisualiser = myGppGraphIn.getVisualiserPanel();

	} //constructor

	public void refreshCumulativeThreadTable()

	{	

		this.myGppGraph.genericRefreshCumulativeThreadTable();

	}

	public void piEventReceived(PIEvent be)

	{

		switch (be.getType())

		{

			case PIEvent.SET_FILL_ALL_THREADS:

				this.myGppGraph.fillSelected = false;

				this.myGppGraph.fillFlag     = true;

				this.myGppGraph.repaint();

				break;

			case PIEvent.SET_FILL_OFF:

				this.myGppGraph.fillSelected = false;

				this.myGppGraph.fillFlag     = false;

				this.myGppGraph.repaint();

				break;

			case PIEvent.SET_FILL_SELECTED_THREAD:

				this.myGppGraph.fillSelected = true;

				this.myGppGraph.fillFlag     = true;

				this.myGppGraph.repaint();

				break;

			case PIEvent.GPP_SET_BAR_GRAPH_ON:

				this.myGppGraph.barMode = GppTraceGraph.BAR_MODE_ON;

				this.myGppGraph.repaint();

				break;

			case PIEvent.GPP_SET_BAR_GRAPH_OFF:

				this.myGppGraph.barMode = GppTraceGraph.BAR_MODE_OFF;

				this.myGppGraph.repaint();

				break;

			case PIEvent.CHANGED_THREAD_TABLE:

				this.myGppGraph.setGraphImageChanged(true);

				if (this.myGppGraph.fillFlag && this.myGppGraph.fillSelected)

				{

				    this.myGppGraph.repaint();

				}

				break;

			case PIEvent.CHANGED_BINARY_TABLE:

				this.myGppGraph.setGraphImageChanged(true);

			    if (this.myGppGraph.fillFlag)

			    {

			        this.myGppGraph.repaint();

			    }

			    break;

			case PIEvent.CHANGED_FUNCTION_TABLE:

				this.myGppGraph.setGraphImageChanged(true);

			    if (this.myGppGraph.fillFlag)

			    {

			        this.myGppGraph.repaint();

			    }

			    break;

			default:

				break;

		}

	}

	private Vector getItemsInVector(int drawMode)

	{

		Vector v = null;

		if (   (drawMode == Defines.THREADS)

			|| (drawMode == Defines.BINARIES_THREADS)

			|| (drawMode == Defines.BINARIES_FUNCTIONS_THREADS)

			|| (drawMode == Defines.FUNCTIONS_THREADS)

			|| (drawMode == Defines.FUNCTIONS_BINARIES_THREADS))

		{

		    v = this.myGppGraph.getSortedThreads();

		}

		else if ((drawMode == Defines.BINARIES)

			  || (drawMode == Defines.THREADS_BINARIES)

			  || (drawMode == Defines.THREADS_FUNCTIONS_BINARIES)

			  || (drawMode == Defines.FUNCTIONS_BINARIES)

			  || (drawMode == Defines.FUNCTIONS_THREADS_BINARIES))

		{

		    v = this.myGppGraph.getSortedBinaries();

		}

		else if ((drawMode == Defines.FUNCTIONS)

			  || (drawMode == Defines.THREADS_FUNCTIONS)

			  || (drawMode == Defines.THREADS_BINARIES_FUNCTIONS)

			  || (drawMode == Defines.BINARIES_FUNCTIONS)

			  || (drawMode == Defines.BINARIES_THREADS_FUNCTIONS))

		{

			v = this.myGppGraph.getSortedFunctions();

		}

		return v;

	}

	// draw the graph based on the rightmost table displayed

  	private void drawCumulativeGraphLines(Graphics graphics)

	{	

		Vector v = getItemsInVector(this.myGppGraph.getDrawMode());

		if (v == null) 

		    return;

		this.myGppGraph.drawGraphsGeneric(v, graphics, myGppGraph.getTableUtils().getSelectedValues());	  	

	}

	private void drawBarGraph(Graphics graphics)

	{

		Vector v = getItemsInVector(this.myGppGraph.getDrawMode());

		if (v == null) 

		    return;

		this.myGppGraph.drawBarsGpp(v, graphics, myGppGraph.getTableUtils().getSelectedValues());	  			

	}

	//updates values in current profiled generic items

	public void updateThreadAverages()

	{

	    //System.out.println("Refreshing average values");

		Enumeration enumer = null;

		int drawMode   = this.myGppGraph.getDrawMode();

		int graphIndex = this.myGppGraph.getGraphIndex();

		if (   (drawMode == Defines.THREADS)

				|| (drawMode == Defines.BINARIES_THREADS)

				|| (drawMode == Defines.BINARIES_FUNCTIONS_THREADS)

				|| (drawMode == Defines.FUNCTIONS_THREADS)

				|| (drawMode == Defines.FUNCTIONS_BINARIES_THREADS))

		{

		    enumer = ((GppTrace) (this.myGppGraph.getTrace())).getSortedThreadsElements();

		}

		else if ((drawMode == Defines.BINARIES)

			  || (drawMode == Defines.THREADS_BINARIES)

			  || (drawMode == Defines.THREADS_FUNCTIONS_BINARIES)

			  || (drawMode == Defines.FUNCTIONS_BINARIES)

			  || (drawMode == Defines.FUNCTIONS_THREADS_BINARIES))

		{

		    enumer = ((GppTrace) (this.myGppGraph.getTrace())).getSortedBinariesElements();

		}

		else if ((drawMode == Defines.FUNCTIONS)

			  || (drawMode == Defines.THREADS_FUNCTIONS)

			  || (drawMode == Defines.THREADS_BINARIES_FUNCTIONS)

			  || (drawMode == Defines.BINARIES_FUNCTIONS)

			  || (drawMode == Defines.BINARIES_THREADS_FUNCTIONS))

		{

		    enumer = ((GppTrace) (this.myGppGraph.getTrace())).getSortedFunctionsElements();

		}

		if (enumer == null) 

		    return;

	  	// update the average load strings

		if (   (myGppGraph.getSelectionStart() == -1)

			|| (myGppGraph.getSelectionEnd()   == -1))

		{

		  	while(enumer.hasMoreElements())

		  		((ProfiledGeneric) enumer.nextElement()).

		  				setAverageLoadValueString(graphIndex, "  0.000"); //$NON-NLS-1$

		} else {

		  	while(enumer.hasMoreElements())

		  	{

		  	    updateThreadAverage(graphIndex, (ProfiledGeneric) enumer.nextElement());

		  	}

		}

	}

	private void updateThreadAverage(int graphIndex, ProfiledGeneric pg)

	{

        float averageLoad = pg.getAverageLoad(

				myGppGraph.getSelectionStart(),

				myGppGraph.getSelectionEnd());

		if (averageLoad >= 0.001)

		{

			pg.setAverageLoadValueString(graphIndex, averageLoad);

		}

	  	else

	  	{

			pg.setAverageLoadValueString(graphIndex, "  0.000"); //$NON-NLS-1$

	  	}

	}

	public void paintComponent(Panel panel, Graphics graphics)

	{		

		// lay down the cumulative graphs first, then grid, and last with selection

		// so the "effects" shows on the top layer

		if (this.myGppGraph.barMode == GppTraceGraph.BAR_MODE_OFF)

		{

			this.drawCumulativeGraphLines(graphics);

		}

		else

		{

			this.drawBarGraph(graphics);

		}

		this.myGppGraph.drawDottedLineBackground(graphics, GppTraceGraph.xLegendHeight);

		this.myGppGraph.drawSelectionSection(graphics, GppTraceGraph.xLegendHeight);

	}

} //class VisualiserPanel