40 import org.eclipse.jface.viewers.CheckboxTableViewer;

    37 import org.eclipse.jface.action.Action;

    50 import org.eclipse.swt.widgets.Label;

    49 import org.eclipse.swt.widgets.Menu;

    50 import org.eclipse.swt.widgets.MenuItem;

    70 

    71 import com.nokia.carbide.cpp.pi.visual.IGenericTraceGraph;

    71 

    72 

    72 public class GppTraceGraph extends GenericTraceGraph implements ActionListener, 

    73 /**

    73 																FocusListener, 

    74  * Each instance of this class represents one trace graph for profiling

    74 																PIEventListener,

    75  * CPU activity. 

    75 																MouseMotionListener,

    76  *

    76 																MouseListener,

    77  */

    77 																MouseMoveListener

    78 public class GppTraceGraph extends GenericTraceGraph implements IGppTraceGraph,

    78 {

    79 		ActionListener, FocusListener, MouseMotionListener, MouseListener,

    79 	private GppTraceGraph thisTraceGraph;

    80 		MouseMoveListener, ITitleBarMenu, IContextMenu {

    81 

    82 	/**

    83 	 * amount of space at bottom of graph to contain things like x-axis units

    84 	 * and button icons

    85 	 */

    86 	public static final int X_LEGEND_HEIGHT = 50;

    87 

    88 	/**

    89 	 * When the graph is drawn, this is the finest granularity drawn. E.g.,

    90 	 * assume a granularity of 100, and a sample every ms. If the 1st function

    91 	 * draw appears in 5 samples from 101ms to 200ms and 10 samples from 200ms

    92 	 * to 300ms then the graph will show a point at height 5 at time 200

    93 	 * connected by a line to a point at height 10 at time 300.

    94 	 */

    95 	static final int GRANULARITY_VALUE = 100;

    81 	// amount of space at bottom of graph to contain things like x-axis units and button icons

    97 	/** constant to indicate graph is a bar graph */

    82 	public static final int xLegendHeight = 50;

    98 	public static final int BAR_MODE_ON = 3;

    99 	/** constant to indicate graph is stacked-area graph */

   100 	public static final int BAR_MODE_OFF = 4;

   101 

   102 	private static final String EMPTY_STRING = "";//$NON-NLS-1$ 

   103 

   104 	protected GppVisualiserPanel vPanel;

   105 	protected String title;

   106 	protected String shortTitle;

   107 

   108 	/*

   109 	 * Depending on this trace graph's graphIndex, one of these will be the base

   110 	 * table, and others will be derived from its selections. The other tables

   111 	 * will appear and disappear based on drawMode.

   112 	 * 

   113 	 * E.g., say that for graphIndex = 0, the base table is threadTable. Then

   114 	 * this graph can represent the draw modes of: THREADS THREADS_BINARIES

   115 	 * THREADS_BINARIES_FUNCTIONS THREADS_FUNCTIONS THREADS_FUNCTIONS_BINARIES

   116 	 */

   117 	protected AddrThreadTable threadTable;

   118 	protected AddrBinaryTable binaryTable;

   119 	protected AddrFunctionTable functionTable;

    94 	 *  Depending on this trace graph's graphIndex, one of these will be

   122 	 * Depending on this trace graph's graphIndex, one of these will match the

    95 	 *  the base table, and others will be derived from its selections.

   123 	 * entire trace's profiled vector, while the others will be derived from

    96 	 *  The other tables will appear and disappear based on drawMode.

   124 	 * drilldown selections. The other vectors will only be meaningful depending

    97 	 *  

   125 	 * on the drawMode.

    98 	 *  E.g., say that for graphIndex = 0, the base table is threadTable.

   126 	 */

    99 	 *  Then this graph can represent the draw modes of:

   127 	protected Vector<ProfiledGeneric> profiledThreads = new Vector<ProfiledGeneric>();

   100 	 *  	THREADS

   128 	protected Vector<ProfiledGeneric> profiledBinaries = new Vector<ProfiledGeneric>();

   101 	 *  	THREADS_BINARIES

   129 	protected Vector<ProfiledGeneric> profiledFunctions = new Vector<ProfiledGeneric>();

   102 	 *  	THREADS_BINARIES_FUNCTIONS

   130 

   103 	 *  	THREADS_FUNCTIONS

   131 	private Vector<ProfiledGeneric> sortedProfiledThreads = new Vector<ProfiledGeneric>();

   104 	 *  	THREADS_FUNCTIONS_BINARIES

   132 	private Vector<ProfiledGeneric> sortedProfiledBinaries = new Vector<ProfiledGeneric>();

   105 	 */

   106 	private AddrThreadTable   threadTable;

   107 	private AddrBinaryTable   binaryTable;

   108 	private AddrFunctionTable functionTable;

   109 

   110 	/*

   111 	 *	Depending on this trace graph's graphIndex, one of these will match

   112 	 *	the entire trace's profiled vector, while the others will be derived

   113 	 *	from drilldown selections. The other vectors will only be meaningful

   114 	 *  depending on the drawMode.

   115 	 */

   116 	private Vector<ProfiledGeneric> profiledThreads   = new Vector<ProfiledGeneric>();

   117 	private Vector<ProfiledGeneric> profiledBinaries  = new Vector<ProfiledGeneric>();

   118 	private Vector<ProfiledGeneric> profiledFunctions = new Vector<ProfiledGeneric>();

   119 	

   120 	private Vector<ProfiledGeneric> sortedProfiledThreads   = new Vector<ProfiledGeneric>();

   121 	private Vector<ProfiledGeneric> sortedProfiledBinaries  = new Vector<ProfiledGeneric>();

   123 	

   134 

   124 	private ProfiledThreshold thresholdThread   = new ProfiledThreshold("dummy[0]::dummy_0"); //$NON-NLS-1$

   135 	protected ProfiledThreshold thresholdThread;

   125 	private ProfiledThreshold thresholdBinary   = new ProfiledThreshold("\\dummy"); //$NON-NLS-1$

   136 	private ProfiledThreshold thresholdBinary;

   126 	private ProfiledThreshold thresholdFunction = new ProfiledThreshold("dummy::dummy()"); //$NON-NLS-1$

   137 	private ProfiledThreshold thresholdFunction;

   132 	public static final int NOFILL       = 0;

   143 	protected int drawMode = Defines.THREADS;

   133 	public static final int FILLSELECTED = 1;

   134 	public static final int FILLALL      = 2;

   135 	public static final int BAR_MODE_ON  = 3;

   136 	public static final int BAR_MODE_OFF = 4;

   137 		

   138 	private int drawMode = Defines.THREADS;

   139 	public int barMode   = BAR_MODE_OFF;

   141 	private int uid;

   145 	/** current graph drawing mode: either bar or stacked-area graph */

   142 	

   146 	public int barMode = BAR_MODE_OFF;

   143 	private static class BarGraphData

   147 

   144 	{

   148 	protected int uid;

   149 

   150 	private static class BarGraphData {

   148 	

   154 

   150 	

   156 

   151 	public GppTraceGraph(int graphIndex, GppTrace trace, int uid)

   157 	/**

   152 	{

   158 	 * The model adapter hides some of the SMP specifics. It must be created

   153 		super((GenericSampledTrace)trace);

   159 	 * during initialisation of this graph.

   154 		

   160 	 */

   155 		int granularityValue = trace.samples.size() > GppTraceGraph.granularityValue ? GppTraceGraph.granularityValue : trace.samples.size();  

   161 	protected GppModelAdapter adapter;

   156 		

   162 

   157 		this.thisTraceGraph = this;

   163 	/** main Composite of legend view */

   158 		this.graphIndex     = graphIndex;

   164 	private Composite holdTablesComposite;

   159 		

   165 

   166 

   167 	/**

   168 	 * Constructor

   169 	 * 

   170 	 * @param graphIndex

   171 	 *            the unique index of this graph

   172 	 * @param trace

   173 	 *            the trace data model to use

   174 	 * @param uid

   175 	 *            the Uid of the editor session

   176 	 */

   177 	public GppTraceGraph(int graphIndex, GppTrace trace, int uid) {

   178 		super(trace);

   179 		this.graphIndex = graphIndex;

   180 		this.uid = uid;

   181 

   182 	}

   183 

   184 	/**

   185 	 * Initialises the graph.

   186 	 * 

   187 	 * @param pageIndex

   188 	 *            page index of the page which displays the graph

   189 	 * @param trace

   190 	 *            the trace model

   191 	 */

   192 	public void init(int pageIndex, GppTrace trace) {

   193 		doCreateAdapter();

   194 		doSetTitle();

   195 		int granularityValue = trace.samples.size() > GppTraceGraph.GRANULARITY_VALUE ? GppTraceGraph.GRANULARITY_VALUE

   196 				: trace.samples.size();

   197 

   161 		ProfileVisualiser pV = NpiInstanceRepository.getInstance().getProfilePage(uid, graphIndex);

   199 		ProfileVisualiser pV = NpiInstanceRepository.getInstance()

   162 		Composite holdTables = new Composite(pV.getBottomComposite(), SWT.NONE);

   200 				.getProfilePage(uid, pageIndex);

   163 		holdTables.setLayout(new FormLayout());

   201 		holdTablesComposite = trace.createLegendComposite(pageIndex, graphIndex, pV.getBottomComposite(), getShortTitle());

   164 

   202 		holdTablesComposite.setLayout(new FormLayout());

   165 		this.threadTable   = new AddrThreadTable(this, holdTables);

   203 

   166 		this.binaryTable   = new AddrBinaryTable(this, holdTables);

   204 		createLegendTables(holdTablesComposite);

   167 		this.functionTable = new AddrFunctionTable(this, holdTables);

   168 		

   169 		this.uid = uid;

   170 

   171 		Label graphTitle = pV.getTitle();

   172 		Label graphTitle2 = pV.getTitle2();

   173 		if 	(graphTitle2 != null)

   174 			graphTitle2.setText(""); //$NON-NLS-1$

   178 		NpiInstanceRepository.getInstance().setPersistState(uid, "com.nokia.carbide.cpp.pi.address.thresholdCountThread", new Integer(new Double(totalSampleCount * (Double)NpiInstanceRepository.getInstance().getPersistState(uid, "com.nokia.carbide.cpp.pi.address.thresholdLoadThread") + 0.5).intValue())); //$NON-NLS-1$ //$NON-NLS-2$

   208 

   179 		NpiInstanceRepository.getInstance().setPersistState(uid, "com.nokia.carbide.cpp.pi.address.thresholdCountBinary", new Integer(new Double(totalSampleCount * (Double)NpiInstanceRepository.getInstance().getPersistState(uid, "com.nokia.carbide.cpp.pi.address.thresholdLoadBinary") + 0.5).intValue())); //$NON-NLS-1$ //$NON-NLS-2$

   209 		// CH: this is called too many times (those values are global for the

   180 		NpiInstanceRepository.getInstance().setPersistState(uid, "com.nokia.carbide.cpp.pi.address.thresholdCountFunction", new Integer(new Double(totalSampleCount * (Double)NpiInstanceRepository.getInstance().getPersistState(uid, "com.nokia.carbide.cpp.pi.address.thresholdLoadFunction") + 0.5).intValue())); //$NON-NLS-1$ //$NON-NLS-2$

   210 		// whole trace) -> can we move it to GppTrace?

   181 		

   211 		NpiInstanceRepository

   182 		int samplingInterval = (Integer) NpiInstanceRepository.getInstance().activeUidGetPersistState("com.nokia.carbide.cpp.pi.address.samplingInterval"); //$NON-NLS-1$

   212 				.getInstance()

   213 				.setPersistState(

   214 						uid,

   215 						"com.nokia.carbide.cpp.pi.address.thresholdCountThread", Integer.valueOf(new Double(totalSampleCount * (Double) NpiInstanceRepository.getInstance().getPersistState(uid, "com.nokia.carbide.cpp.pi.address.thresholdLoadThread") + 0.5).intValue())); //$NON-NLS-1$ //$NON-NLS-2$

   216 		NpiInstanceRepository

   217 				.getInstance()

   218 				.setPersistState(

   219 						uid,

   220 						"com.nokia.carbide.cpp.pi.address.thresholdCountBinary", Integer.valueOf(new Double(totalSampleCount * (Double) NpiInstanceRepository.getInstance().getPersistState(uid, "com.nokia.carbide.cpp.pi.address.thresholdLoadBinary") + 0.5).intValue())); //$NON-NLS-1$ //$NON-NLS-2$

   221 		NpiInstanceRepository

   222 				.getInstance()

   223 				.setPersistState(

   224 						uid,

   225 						"com.nokia.carbide.cpp.pi.address.thresholdCountFunction", Integer.valueOf(new Double(totalSampleCount * (Double) NpiInstanceRepository.getInstance().getPersistState(uid, "com.nokia.carbide.cpp.pi.address.thresholdLoadFunction") + 0.5).intValue())); //$NON-NLS-1$ //$NON-NLS-2$

   226 

   227 		int samplingInterval = (Integer) NpiInstanceRepository.getInstance()

   228 				.activeUidGetPersistState(

   229 						"com.nokia.carbide.cpp.pi.address.samplingInterval"); //$NON-NLS-1$

   185 		thresholdThread.setColor(trace.getThreadColorPalette().getColor(thresholdThread.getNameString()));

   232 		int bucketDuration = granularityValue * samplingInterval;

   186 		thresholdThread.setActivityMarkCount((trace.samples.size() + granularityValue) / granularityValue + 1);

   233 		int numberOfBuckets = GppTraceUtil.calculateNumberOfBuckets(trace

   187 		for (int i = 0; i < trace.samples.size() + granularityValue; i += granularityValue)

   234 				.getLastSampleTime(), granularityValue);

   188 		{

   235 

   189 			thresholdThread.zeroActivityMarkValues(i * samplingInterval);

   236 		thresholdThread = new ProfiledThreshold(

   190 		}

   237 				"dummy[0]::dummy_0", trace.getCPUCount(), trace.getGraphCount()); //$NON-NLS-1$

   191 		thresholdBinary.setColor(trace.getBinaryColorPalette().getColor(thresholdBinary.getNameString()));

   238 		thresholdBinary = new ProfiledThreshold(

   192 		thresholdBinary.setActivityMarkCount((trace.samples.size() + granularityValue) / granularityValue + 1);

   239 				"\\dummy", trace.getCPUCount(), trace.getGraphCount()); //$NON-NLS-1$

   193 		for (int i = 0; i < trace.samples.size() + granularityValue; i += granularityValue)

   240 		thresholdFunction = new ProfiledThreshold(

   194 		{

   241 				"dummy::dummy()", trace.getCPUCount(), trace.getGraphCount()); //$NON-NLS-1$

   195 			thresholdBinary.zeroActivityMarkValues(i * samplingInterval);

   242 		thresholdThread.setColor(trace.getThreadColorPalette().getColor(

   196 		}

   243 				thresholdThread.getNameString()));

   197 		thresholdFunction.setColor(trace.getFunctionColorPalette().getColor(thresholdFunction.getNameString()));

   244 		thresholdThread.createBuckets(numberOfBuckets);

   198 		thresholdFunction.setActivityMarkCount((trace.samples.size() + granularityValue) / granularityValue + 1);

   245 		thresholdThread.initialiseBuckets(bucketDuration);

   199 		for (int i = 0; i < trace.samples.size() + granularityValue; i += granularityValue)

   246 		thresholdBinary.setColor(trace.getBinaryColorPalette().getColor(

   200 		{

   247 				thresholdBinary.getNameString()));

   201 			thresholdFunction.zeroActivityMarkValues(i * samplingInterval);

   248 		thresholdBinary.createBuckets(numberOfBuckets);

   202 		}

   249 		thresholdBinary.initialiseBuckets(bucketDuration);

   203 

   250 		thresholdFunction.setColor(trace.getFunctionColorPalette().getColor(

   204 		// all the trace data is known, and you have it sorted 3 different ways

   251 				thresholdFunction.getNameString()));

   205 		// so set the drawmode, create the page's base table, and set the graph title

   252 		thresholdFunction.createBuckets(numberOfBuckets);

   206 		if (graphIndex == PIPageEditor.THREADS_PAGE) {

   253 		thresholdFunction.initialiseBuckets(bucketDuration);

   254 

   255 		int graphType = adapter.getGraphType();

   256 

   257 		if (graphType == PIPageEditor.THREADS_PAGE) {

   208 

   259 			int threshold = (Integer)NpiInstanceRepository.getInstance().getPersistState(uid, "com.nokia.carbide.cpp.pi.address.thresholdCountThread"); //$NON-NLS-1$

   209 			// tables will show threads in decreasing total sample order, but

   260 

   210 			// then put them back in increasing sample order so that the graph

   261 			for (ProfiledGeneric profiled : trace.getSortedThreads()) {

   211 			// shows most common (e.g., EKern) threads on top

   262 				if (adapter.getTotalSampleCount(profiled) > 0){

   212 			this.profiledThreads.clear();

   263 					if (adapter.getTotalSampleCount(profiled) < threshold){//check below threshold

   213 			for (int i = trace.getSortedThreads().size() - 1; i >= 0; i--)

   264 						adapter.addItem(thresholdThread, graphIndex, profiled, adapter.getTotalSampleCount(profiled));

   214 				this.profiledThreads.add(trace.getSortedThreads().get(i));

   265 					} else {

   215 			filterSortedByThreshold(graphIndex, 

   266 						profiledThreads.add(profiled);

   216 									(Integer)NpiInstanceRepository.getInstance().getPersistState(uid, "com.nokia.carbide.cpp.pi.address.thresholdCountThread"), //$NON-NLS-1$

   267 					}

   217 									thresholdThread, this.profiledThreads);

   268 				}

   269 			}

   270 

   221 			graphTitle.setText(Messages.getString("GppTraceGraph.threadLoad"));  //$NON-NLS-1$

   273 		} else if (graphType == PIPageEditor.BINARIES_PAGE) {

   222 		} else

   223 		if (graphIndex == PIPageEditor.BINARIES_PAGE) {

   225 

   275 			int threshold = (Integer)NpiInstanceRepository.getInstance().getPersistState(uid, "com.nokia.carbide.cpp.pi.address.thresholdCountBinary"); //$NON-NLS-1$

   226 			// tables will show binaries in decreasing total sample order, but

   276 

   227 			// then put them back in increasing sample order so that the graph

   277 			for (ProfiledGeneric profiled : trace.getSortedBinaries()) {

   228 			// shows most common (e.g., EKern) binaries on top

   278 				if (adapter.getTotalSampleCount(profiled) > 0){

   229 			this.profiledBinaries.clear();

   279 					if (adapter.getTotalSampleCount(profiled) < threshold){//check below threshold

   230 			for (int i = trace.getSortedBinaries().size() - 1; i >= 0; i--)

   280 						adapter.addItem(thresholdBinary, graphIndex, profiled, adapter.getTotalSampleCount(profiled));

   231 				this.profiledBinaries.add(trace.getSortedBinaries().get(i));

   281 					} else {

   232 			filterSortedByThreshold(graphIndex, (Integer)NpiInstanceRepository.getInstance().getPersistState(uid, "com.nokia.carbide.cpp.pi.address.thresholdCountBinary"), //$NON-NLS-1$

   282 						profiledBinaries.add(profiled);

   233 								thresholdBinary, this.profiledBinaries);

   283 					}

   284 					

   285 				}

   286 			}

   287 

   237 			graphTitle.setText(Messages.getString("GppTraceGraph.binaryLoad"));  //$NON-NLS-1$

   291 		} else if (graphType == PIPageEditor.FUNCTIONS_PAGE) {

   238 		} else

   239 		if (graphIndex == PIPageEditor.FUNCTIONS_PAGE) {

   241 

   293 			int threshold = (Integer)NpiInstanceRepository.getInstance().getPersistState(uid, "com.nokia.carbide.cpp.pi.address.thresholdCountFunction"); //$NON-NLS-1$

   242 			// tables will show functions in decreasing total sample order, but

   294 

   243 			// then put them back in increasing sample order so that the graph

   295 			for (ProfiledGeneric profiled : trace.getSortedFunctions()) {

   244 			// shows most common (e.g., EKern) functions on top

   296 				if (adapter.getTotalSampleCount(profiled) > 0){

   245 			this.profiledFunctions.clear();

   297 					if (adapter.getTotalSampleCount(profiled) < threshold){//check below threshold

   246 			for (int i = trace.getSortedFunctions().size() - 1; i >= 0; i--)

   298 						adapter.addItem(thresholdFunction, graphIndex, profiled, adapter.getTotalSampleCount(profiled));

   247 				this.profiledFunctions.add(trace.getSortedFunctions().get(i));

   299 					} else {

   248 			filterSortedByThreshold(graphIndex, (Integer)NpiInstanceRepository.getInstance().getPersistState(uid, "com.nokia.carbide.cpp.pi.address.thresholdCountFunction"), //$NON-NLS-1$

   300 						profiledFunctions.add(profiled);

   249 								thresholdFunction, this.profiledFunctions);

   301 					}

   302 				}

   303 			}

   253 			graphTitle.setText(Messages.getString("GppTraceGraph.FunctionLoad"));  //$NON-NLS-1$

   307 		} else {

   254 		} else

   308 			throw new IllegalStateException(Messages

   255 		{

   309 					.getString("GppTraceGraph.traceGraphInternalErrorIn")); //$NON-NLS-1$

   310 		}

   311 

   312 

   313 		// since the trace can be shown any of 3 ways (by thread, by binary, or

   314 		// by function), make sure that all 3 are ready for display

   315 		// Sse sorted vector to be consistent with other call to

   316 		// genericRefreshCumulativeThreadTable()

   317 		// fix issue with wrong color on newly opened npi file before a change

   318 		// in the table

   319 		if (this.profiledThreads.size() > 0) {

   320 			genericRefreshCumulativeThreadTable(this.profiledThreads.elements());

   321 			genericRefreshCumulativeThreadTable(this.sortedProfiledThreads

   322 					.elements());

   323 		}

   324 		if (this.profiledBinaries.size() > 0) {

   325 			genericRefreshCumulativeThreadTable(this.profiledBinaries

   326 					.elements());

   327 			genericRefreshCumulativeThreadTable(this.sortedProfiledBinaries

   328 					.elements());

   329 		}

   330 		if (this.profiledFunctions.size() > 0) {

   331 			genericRefreshCumulativeThreadTable(this.profiledFunctions

   332 					.elements());

   333 			genericRefreshCumulativeThreadTable(this.sortedProfiledFunctions

   334 					.elements());

   335 		}

   336 

   337 		if (this.profiledThreads.size() <= 0

   338 				&& this.profiledBinaries.size() <= 0

   339 				&& this.profiledFunctions.size() <= 0) {

   257 				throw new Exception(Messages.getString("GppTraceGraph.traceGraphInternalErrorIn"));  //$NON-NLS-1$

   341 				throw new Exception(Messages

   342 						.getString("GppTraceGraph.traceGraphInternalErrorAt")); //$NON-NLS-1$

   291 	}

   349 

   292 	

   350 	}

   351 

   352 	/**

   353 	 * Sets the graph-specific title

   354 	 */

   355 	protected void doSetTitle() {

   356 		title = Messages.getString("GppTraceGraph.1");		 //$NON-NLS-1$

   357 		shortTitle = Messages.getString("GppTraceGraph.0"); //$NON-NLS-1$

   358 	}

   359 

   360 	/**

   361 	 * Creates a GppModelAdapter

   362 	 */

   363 	protected void doCreateAdapter() {

   364 		adapter = new GppModelAdapter(this.graphIndex);

   365 	}

   366 

   367 	/**

   368 	 * Creates the three legend tables for this graph (for threads, binaries,

   369 	 * functions)

   370 	 * 

   371 	 * @param holdTablesComposite

   372 	 */

   373 	protected void createLegendTables(Composite holdTablesComposite) {

   374 		this.threadTable = new AddrThreadTable(this, holdTablesComposite, adapter);

   375 		this.binaryTable = new AddrBinaryTable(this, holdTablesComposite, adapter);

   376 		this.functionTable = new AddrFunctionTable(this, holdTablesComposite, adapter);

   377 	}

   378 

   294 	 * Combine all vectors elements that are below the threshold into a single

   380 	 * (non-Javadoc)

   295 	 * vector element. Assumes that the input vector is sorted by decreasing sample count.

   381 	 * 

   296 	 */

   382 	 * @see com.nokia.carbide.cpp.pi.address.IGppTraceGraph#getGppTrace()

   297 	private void filterSortedByThreshold(int graphIndex, int thresholdCount, ProfiledThreshold pThreshold, Vector<ProfiledGeneric> pGenerics)

   383 	 */

   298 	{

   299 		// count and remove items below the threshold 

   300 		for (int i = pGenerics.size() - 1; i >= 0; i--) {

   301 			if (pGenerics.elementAt(i).getTotalSampleCount() < thresholdCount) {

   302 				pThreshold.addItem(graphIndex, pGenerics.elementAt(i), 0);

   303 				pGenerics.removeElementAt(i);

   304 			} else {

   305 				break;

   306 			}

   307 		}

   308 	}

   309 

   311 		return (GppTrace)this.getTrace();

   385 		return (GppTrace) this.getTrace();

   312 	}

   386 	}

   313 

   387 

   314 	public int getGraphIndex()

   388 	/*

   315 	{

   389 	 * (non-Javadoc)

   316 		return this.graphIndex;

   390 	 * 

   317 	}

   391 	 * @see

   318 

   392 	 * com.nokia.carbide.cpp.internal.pi.visual.PIEventListener#piEventReceived

   319 	public void piEventReceived(PIEvent be)

   393 	 * (com.nokia.carbide.cpp.internal.pi.visual.PIEvent)

   320 	{

   394 	 */

   321 		switch (be.getType())

   395 	public void piEventReceived(PIEvent be) {

   322 		{

   396 		switch (be.getType()) {

   323 			// determine the threads that can be shown, and get rid of all drilldowns

   397 		// determine the threads that can be shown, and get rid of all

   324 			case PIEvent.THRESHOLD_THREAD_CHANGED:

   398 		// drilldowns

   325 				if (this.getGraphIndex() == PIPageEditor.THREADS_PAGE)

   399 		case PIEvent.THRESHOLD_THREAD_CHANGED:

   326 					this.getThreadTable().action("changeThresholdThread"); //$NON-NLS-1$

   400 			if (this.getGraphIndex() == PIPageEditor.THREADS_PAGE)

   327 				switch (this.drawMode) {

   401 				this.getThreadTable().action("changeThresholdThread"); //$NON-NLS-1$

   328 				case Defines.THREADS:

   402 			switch (this.drawMode) {

   329 				case Defines.THREADS_FUNCTIONS:

   403 			case Defines.THREADS:

   330 				case Defines.THREADS_FUNCTIONS_BINARIES:

   404 			case Defines.THREADS_FUNCTIONS:

   331 				case Defines.THREADS_BINARIES:

   405 			case Defines.THREADS_FUNCTIONS_BINARIES:

   332 				case Defines.THREADS_BINARIES_FUNCTIONS:

   406 			case Defines.THREADS_BINARIES:

   333 				case Defines.BINARIES_THREADS:

   407 			case Defines.THREADS_BINARIES_FUNCTIONS:

   334 				case Defines.BINARIES_THREADS_FUNCTIONS:

   408 			case Defines.BINARIES_THREADS:

   335 				case Defines.BINARIES_FUNCTIONS_THREADS:

   409 			case Defines.BINARIES_THREADS_FUNCTIONS:

   336 				case Defines.FUNCTIONS_THREADS:

   410 			case Defines.BINARIES_FUNCTIONS_THREADS:

   337 				case Defines.FUNCTIONS_THREADS_BINARIES:

   411 			case Defines.FUNCTIONS_THREADS:

   338 				case Defines.FUNCTIONS_BINARIES_THREADS:

   412 			case Defines.FUNCTIONS_THREADS_BINARIES:

   339 					this.setGraphImageChanged(true);

   413 			case Defines.FUNCTIONS_BINARIES_THREADS:

   340 				default:

   414 				this.setGraphImageChanged(true);

   341 					break;

   342 			}

   343 				break;

   344 			case PIEvent.THRESHOLD_BINARY_CHANGED:

   345 				if (this.getGraphIndex() == PIPageEditor.BINARIES_PAGE)

   346 					this.getBinaryTable().action("changeThresholdBinary"); //$NON-NLS-1$

   347 				switch (this.drawMode) {

   348 				case Defines.THREADS_FUNCTIONS_BINARIES:

   349 				case Defines.THREADS_BINARIES:

   350 				case Defines.THREADS_BINARIES_FUNCTIONS:

   351 				case Defines.BINARIES:

   352 				case Defines.BINARIES_THREADS:

   353 				case Defines.BINARIES_THREADS_FUNCTIONS:

   354 				case Defines.BINARIES_FUNCTIONS:

   355 				case Defines.BINARIES_FUNCTIONS_THREADS:

   356 				case Defines.FUNCTIONS_THREADS_BINARIES:

   357 				case Defines.FUNCTIONS_BINARIES:

   358 				case Defines.FUNCTIONS_BINARIES_THREADS:

   359 					this.setGraphImageChanged(true);

   360 				default:

   361 					break;

   362 			}

   363 				break;

   364 			case PIEvent.THRESHOLD_FUNCTION_CHANGED:

   365 				if (this.getGraphIndex() == PIPageEditor.FUNCTIONS_PAGE)

   366 					this.getFunctionTable().action("changeThresholdFunction"); //$NON-NLS-1$

   367 				switch (this.drawMode) {

   368 				case Defines.THREADS_FUNCTIONS:

   369 				case Defines.THREADS_FUNCTIONS_BINARIES:

   370 				case Defines.THREADS_BINARIES_FUNCTIONS:

   371 				case Defines.BINARIES_THREADS_FUNCTIONS:

   372 				case Defines.BINARIES_FUNCTIONS:

   373 				case Defines.BINARIES_FUNCTIONS_THREADS:

   374 				case Defines.FUNCTIONS:

   375 				case Defines.FUNCTIONS_THREADS:

   376 				case Defines.FUNCTIONS_THREADS_BINARIES:

   377 				case Defines.FUNCTIONS_BINARIES:

   378 				case Defines.FUNCTIONS_BINARIES_THREADS:

   379 					this.setGraphImageChanged(true);

   380 				default:

   381 					break;

   382 			}

   383 				break;

   384 			// when the selection area changes, change the percent loads

   385 			// and the sample counts in all tables of this GPP graph

   386 			case PIEvent.SELECTION_AREA_CHANGED:

   387 				// this is the first GPP graph to be told of the selection area change,

   388 				// so it gathers the overall trace information

   389 				GppTrace trace = (GppTrace)this.getTrace();

   390 				trace.setSelectedArea();

   391 				

   392 				// take care of the threshold members

   393 				int sampleCount = 0;

   394 				int thresholdCount;

   395 				

   396 				if (graphIndex == PIPageEditor.THREADS_PAGE) {

   397 					thresholdCount = (Integer)NpiInstanceRepository.getInstance().getPersistState(uid, "com.nokia.carbide.cpp.pi.address.thresholdCountThread"); //$NON-NLS-1$

   398 					if (thresholdCount > 0) {

   399 						for (int i = 0; i < profiledThreads.size(); i++)

   400 							if (profiledThreads.elementAt(i).getTotalSampleCount() < thresholdCount)

   401 								sampleCount += profiledThreads.elementAt(i).getSampleCount(graphIndex);

   402 						thresholdThread.setSampleCount(this.graphIndex, sampleCount);

   403 					}

   404 				} else if (graphIndex == PIPageEditor.BINARIES_PAGE) {

   405 					thresholdCount = (Integer)NpiInstanceRepository.getInstance().getPersistState(uid, "com.nokia.carbide.cpp.pi.address.thresholdCountBinary"); //$NON-NLS-1$

   406 					if (thresholdCount > 0) {

   407 						for (int i = 0; i < profiledBinaries.size(); i++)

   408 							if (profiledBinaries.elementAt(i).getTotalSampleCount() < thresholdCount)

   409 								sampleCount += profiledBinaries.elementAt(i).getSampleCount(graphIndex);

   410 						thresholdBinary.setSampleCount(this.graphIndex, sampleCount);

   411 					}

   412 				} else if (graphIndex == PIPageEditor.FUNCTIONS_PAGE) {

   413 					thresholdCount = (Integer)NpiInstanceRepository.getInstance().getPersistState(uid, "com.nokia.carbide.cpp.pi.address.thresholdCountFunction"); //$NON-NLS-1$

   414 					if (thresholdCount > 0) {

   415 						for (int i = 0; i < profiledFunctions.size(); i++)

   416 							if (profiledFunctions.elementAt(i).getTotalSampleCount() < thresholdCount)

   417 								sampleCount += profiledFunctions.elementAt(i).getSampleCount(graphIndex);

   418 						thresholdFunction.setSampleCount(this.graphIndex, sampleCount);

   419 					}

   420 				}

   421 

   422 				double startTime = PIPageEditor.currentPageEditor().getStartTime();

   423 				double endTime   = PIPageEditor.currentPageEditor().getEndTime();

   424 				

   425 				// send this message to the 2 other GPP graphs

   426 				PIEvent be2 = new PIEvent(be.getValueObject(),

   427 						PIEvent.SELECTION_AREA_CHANGED2);

   428 				

   429 				// update the selection area shown

   430 				for (int i = 0; i < 3; i++)

   431 				{

   432 					GppTraceGraph graph = trace.getGppGraph(i, getUid());

   433 

   434 					if (graph != this) {

   435 						graph.piEventReceived(be2);

   436 						// once per graph, update the selection interval shown

   437 						graph.getCompositePanel().getVisualiser().getTimeString().setText(ProfileVisualiser.getTimeInterval(startTime, endTime));

   438 					}

   439 					

   440 					// change the graph's selected time interval

   441 					graph.setSelectionStart((double) startTime * 1000);

   442 					graph.setSelectionEnd((double) endTime * 1000);

   443 					graph.parentComponent.setSelectionFields((int)(startTime * 1000), (int)(endTime * 1000));

   444 				}

   445 

   446 				this.parentComponent.getSashForm().redraw();

   447 				be = be2;

   448 				// FALL THROUGH

   449 			case PIEvent.SELECTION_AREA_CHANGED2:

   450 			{

   451 				// this code lets each graph's base thread/binary/function table update the other tables

   452 				switch (drawMode)

   453 				{

   454 					case Defines.THREADS:

   455 					case Defines.THREADS_FUNCTIONS:

   456 					case Defines.THREADS_FUNCTIONS_BINARIES:

   457 					case Defines.THREADS_BINARIES:

   458 					case Defines.THREADS_BINARIES_FUNCTIONS:

   459 				    {

   460 				        this.threadTable.piEventReceived(be);

   461 				        break;

   462 				    }

   463 					case Defines.BINARIES:

   464 					case Defines.BINARIES_THREADS:

   465 					case Defines.BINARIES_THREADS_FUNCTIONS:

   466 					case Defines.BINARIES_FUNCTIONS:

   467 					case Defines.BINARIES_FUNCTIONS_THREADS:

   468 					{

   469 				        this.binaryTable.piEventReceived(be);

   470 						break;

   471 					}

   472 					case Defines.FUNCTIONS:

   473 					case Defines.FUNCTIONS_THREADS:

   474 					case Defines.FUNCTIONS_THREADS_BINARIES:

   475 					case Defines.FUNCTIONS_BINARIES:

   476 					case Defines.FUNCTIONS_BINARIES_THREADS:

   477 					{

   478 				        this.functionTable.piEventReceived(be);

   479 						break;

   480 					}

   481 				}

   482 

   483 				this.vPanel.refreshCumulativeThreadTable();

   484 				this.setGraphImageChanged(true);	// any selection change to drill down will change graph

   485 				this.repaint();

   486 				break;

   487 			}

   488 			

   489 			// in the graph, show all values from the rightmost table

   490 			case PIEvent.SET_FILL_ALL_THREADS:

   491 				this.setGraphImageChanged(true);	// any selection change to drill down will change graph

   492 				this.vPanel.piEventReceived(be);

   493 				break;

   494 

   495 			// in the graph, don't fill between the lines will the color of

   496 			// the line above

   497 			case PIEvent.SET_FILL_OFF:

   498 				this.setGraphImageChanged(true);	// any selection change to drill down will change graph

   499 				this.vPanel.piEventReceived(be);

   500 				break;

   501 

   502 			// in the graph, show bars

   503 			case PIEvent.GPP_SET_BAR_GRAPH_ON:

   504 				this.vPanel.piEventReceived(be);

   505 				break;

   506 

   507 			// in the graph, show polylines 

   508 			case PIEvent.GPP_SET_BAR_GRAPH_OFF:

   509 				this.vPanel.piEventReceived(be);

   510 				break;

   511 

   512 			// in the graph, show only the values from selected rows in the

   513 			// rightmost table

   514 			case PIEvent.SET_FILL_SELECTED_THREAD:

   515 				this.setGraphImageChanged(true);	// any selection change to drill down will change graph

   516 				this.vPanel.piEventReceived(be);

   517 				break;

   518 

   519 			// Redraw the graph because the thread table's selected values have changed.

   520 			// The thread table is handled (setting of array of selected threads

   521 			// and table redraw) by the table selection listener or mouse listener.

   522 			case PIEvent.CHANGED_THREAD_TABLE:

   523 				switch (drawMode)

   524 				{

   525 					case Defines.THREADS_BINARIES:

   526 					case Defines.THREADS_BINARIES_FUNCTIONS:

   527 					case Defines.THREADS_FUNCTIONS:

   528 					case Defines.THREADS_FUNCTIONS_BINARIES:

   529 					{

   530 						this.threadTable.piEventReceived(be);

   531 						break;

   532 					}

   533 					case Defines.BINARIES_THREADS_FUNCTIONS:

   534 					{

   535 						this.binaryTable.piEventReceived(be);

   536 						break;

   537 					}

   538 					case Defines.FUNCTIONS_THREADS_BINARIES:

   539 					{

   540 						this.functionTable.piEventReceived(be);

   541 						break;

   542 					}

   543 					case Defines.THREADS:

   544 					case Defines.BINARIES:

   545 					case Defines.BINARIES_THREADS:

   546 					case Defines.BINARIES_FUNCTIONS:

   547 					case Defines.BINARIES_FUNCTIONS_THREADS:

   548 					case Defines.FUNCTIONS:

   549 					case Defines.FUNCTIONS_THREADS:

   550 					case Defines.FUNCTIONS_BINARIES:

   551 					case Defines.FUNCTIONS_BINARIES_THREADS:

   552 					default:

   553 						break;

   554 				}

   555 

   556 				this.vPanel.refreshCumulativeThreadTable();

   557 				this.repaint();

   558 			    //if fill selected, the graph is drawn again

   559 				this.vPanel.piEventReceived(be);

   560 				break;

   561 

   562 			// Redraw the graph because the binary table's selected values have changed.

   563 			// The binary table is handled (setting of array of selected binaries

   564 			// and table redraw) by the table selection listener or mouse listener.

   565 			case PIEvent.CHANGED_BINARY_TABLE:

   566 				switch(drawMode)

   567 				{

   568 					case Defines.BINARIES_THREADS:

   569 					case Defines.BINARIES_THREADS_FUNCTIONS:

   570 					case Defines.BINARIES_FUNCTIONS:

   571 					case Defines.BINARIES_FUNCTIONS_THREADS:

   572 					{

   573 						this.binaryTable.piEventReceived(be);

   574 						break;

   575 					}

   576 					case Defines.THREADS_BINARIES_FUNCTIONS:

   577 					{

   578 						this.threadTable.piEventReceived(be);

   579 						break;

   580 					}

   581 					case Defines.FUNCTIONS_BINARIES_THREADS:

   582 					{

   583 						this.functionTable.piEventReceived(be);

   584 						break;

   585 					}

   586 					case Defines.THREADS:

   587 					case Defines.THREADS_BINARIES:

   588 					case Defines.THREADS_FUNCTIONS:

   589 					case Defines.THREADS_FUNCTIONS_BINARIES:

   590 					case Defines.BINARIES:

   591 					case Defines.FUNCTIONS:

   592 					case Defines.FUNCTIONS_THREADS:

   593 					case Defines.FUNCTIONS_THREADS_BINARIES:

   594 					case Defines.FUNCTIONS_BINARIES:

   595 					default:

   596 						break;

   597 				}

   598 

   599 				this.vPanel.refreshCumulativeThreadTable();

   600 				this.repaint();

   601 			    //if fill selected, the graph is drawn again

   602 				this.vPanel.piEventReceived(be);

   603 				break;

   604 

   605 			// Redraw the graph because the function table's selected values have changed.

   606 			// The function table is handled (setting of array of selected functions

   607 			// and table redraw) by the table selection listener or mouse listener.

   608 			case PIEvent.CHANGED_FUNCTION_TABLE:

   609 				switch(drawMode)

   610 				{

   611 					case Defines.FUNCTIONS_THREADS:

   612 					case Defines.FUNCTIONS_THREADS_BINARIES:

   613 					case Defines.FUNCTIONS_BINARIES:

   614 					case Defines.FUNCTIONS_BINARIES_THREADS:

   615 					{

   616 						this.functionTable.piEventReceived(be);

   617 						break;

   618 					}

   619 					case Defines.THREADS_FUNCTIONS_BINARIES:

   620 					{

   621 						this.threadTable.piEventReceived(be);

   622 						break;

   623 					}

   624 					case Defines.BINARIES_FUNCTIONS_THREADS:

   625 					{

   626 						this.binaryTable.piEventReceived(be);

   627 						break;

   628 					}

   629 					case Defines.THREADS:

   630 					case Defines.THREADS_BINARIES:

   631 					case Defines.THREADS_BINARIES_FUNCTIONS:

   632 					case Defines.THREADS_FUNCTIONS:

   633 					case Defines.BINARIES:

   634 					case Defines.BINARIES_THREADS:

   635 					case Defines.BINARIES_THREADS_FUNCTIONS:

   636 					case Defines.BINARIES_FUNCTIONS:

   637 					case Defines.FUNCTIONS:

   638 					default:

   639 						break;

   640 				}

   641 

   642 				this.vPanel.refreshCumulativeThreadTable();

   643 				this.repaint();

   644 				this.vPanel.piEventReceived(be);

   645 				break;

   646 

   647 			case PIEvent.MOUSE_PRESSED:

   648 				switch (drawMode) {

   649 					case Defines.THREADS:

   650 					{

   651 						break;

   652 					}

   653 					case Defines.BINARIES:

   654 					{

   655 						break;

   656 					}

   657 					case Defines.FUNCTIONS:

   658 					{

   659 						break;

   660 					}

   661 					default:

   662 					{

   663 						break;

   664 					}

   665 				}

   666 			    this.parentComponent.setActive(this);

   667 				break;

   668 				

   671 		}

   417 			}

   672 	}

   418 			break;

   673 	

   419 		case PIEvent.THRESHOLD_BINARY_CHANGED:

   674 	public void actionPerformed(ActionEvent ae)

   420 			if (this.getGraphIndex() == PIPageEditor.BINARIES_PAGE)

   675 	{

   421 				this.getBinaryTable().action("changeThresholdBinary"); //$NON-NLS-1$

   676 	}

   422 			switch (this.drawMode) {

   677 	

   423 			case Defines.THREADS_FUNCTIONS_BINARIES:

   678 	public void action(String actionString)

   424 			case Defines.THREADS_BINARIES:

   679 	{

   425 			case Defines.THREADS_BINARIES_FUNCTIONS:

   680 	    System.out.println(Messages.getString("GppTraceGraph.actionString")+actionString);  //$NON-NLS-1$

   426 			case Defines.BINARIES:

   681 	    

   682 	    if (actionString.equals("resetToCurrentMode")) //$NON-NLS-1$

   683 	    {

   684 	        if (drawMode == Defines.THREADS_FUNCTIONS)

   685 	            this.setDrawMode(Defines.THREADS);

   686 	        else if (drawMode == Defines.BINARIES_FUNCTIONS)

   687 	            this.setDrawMode(Defines.BINARIES);

   688 	        else

   689 	            System.out.println(Messages.getString("GppTraceGraph.drawMode") + drawMode); //should not print this ever  //$NON-NLS-1$

   690 	    }

   691 	    else

   692 	    {

   693 			switch (drawMode)

   694 			{

   695 				case Defines.THREADS:

   696 				case Defines.THREADS_FUNCTIONS:

   697 				case Defines.THREADS_FUNCTIONS_BINARIES:

   698 				case Defines.THREADS_BINARIES:

   699 				case Defines.THREADS_BINARIES_FUNCTIONS:

   700 			    {

   701 					this.threadTable.action(actionString);

   702 			        break;

   703 			    }

   704 				case Defines.BINARIES:

   705 				case Defines.BINARIES_THREADS:

   706 				case Defines.BINARIES_THREADS_FUNCTIONS:

   707 				case Defines.BINARIES_FUNCTIONS:

   708 				case Defines.BINARIES_FUNCTIONS_THREADS:

   709 				{

   710 					this.binaryTable.action(actionString);

   711 					break;

   712 				}

   713 				case Defines.FUNCTIONS:

   714 				case Defines.FUNCTIONS_THREADS:

   715 				case Defines.FUNCTIONS_THREADS_BINARIES:

   716 				case Defines.FUNCTIONS_BINARIES:

   717 				case Defines.FUNCTIONS_BINARIES_THREADS:

   718 				{

   719 					this.functionTable.action(actionString);

   720 					break;

   721 				}

   722 			}

   723 	    }

   724 	}

   725 	

   726 	public void focusGained(FocusEvent fe)

   727 	{

   728 	}

   729 

   730 	public void focusLost(FocusEvent fe)

   731 	{

   732 	}

   733 

   734 	public void mouseDragged(MouseEvent me) {

   735 	}

   736 

   737 	public void mouseEntered(MouseEvent me) {

   738 	}

   739 

   740 	public void mouseExited(MouseEvent me) {

   741 	}

   742 

   743 	public void mouseHover(MouseEvent me) {

   744 	}

   745 

   746 	public void mousePressed(MouseEvent me) {

   747 	}

   748 

   749 	public void mouseReleased(MouseEvent me) {

   750 	}

   751 

   752 	public void mouseDoubleClicked(MouseEvent me)

   753 	{

   754 	    Object[] result = this.getProfiledGenericUnderMouse(me);

   755 		if ((result == null)) 

   756 		{

   757 			return;

   758 		}

   759 		

   760 		ProfiledGeneric pg = (ProfiledGeneric)result[0];

   761 		GenericTable gtu = null;

   762 

   763 		switch (drawMode)

   764 		{

   765 			case Defines.THREADS:

   767 			case Defines.FUNCTIONS_THREADS:

   428 			case Defines.BINARIES_THREADS_FUNCTIONS:

   429 			case Defines.BINARIES_FUNCTIONS:

   770 			{

   434 				this.setGraphImageChanged(true);

   771 			    gtu = this.threadTable;

   435 			default:

   772 			    break;

   436 				break;

   773 			}

   437 			}

   774 			case Defines.BINARIES:

   438 			break;

   775 			case Defines.THREADS_BINARIES:

   439 		case PIEvent.THRESHOLD_FUNCTION_CHANGED:

   440 			if (this.getGraphIndex() == PIPageEditor.FUNCTIONS_PAGE)

   441 				this.getFunctionTable().action("changeThresholdFunction"); //$NON-NLS-1$

   442 			switch (this.drawMode) {

   443 			case Defines.THREADS_FUNCTIONS:

   788 			{

   447 			case Defines.BINARIES_FUNCTIONS:

   789 			    gtu = this.functionTable;

   448 			case Defines.BINARIES_FUNCTIONS_THREADS:

   790 			    break;

   449 			case Defines.FUNCTIONS:

   791 			}

   450 			case Defines.FUNCTIONS_THREADS:

   451 			case Defines.FUNCTIONS_THREADS_BINARIES:

   452 			case Defines.FUNCTIONS_BINARIES:

   453 			case Defines.FUNCTIONS_BINARIES_THREADS:

   454 				this.setGraphImageChanged(true);

   794 		}

   457 			}

   795 

   458 			break;

   796 		if (pg != null)

   459 		// when the selection area changes, change the percent loads

   460 		// and the sample counts in all tables of this GPP graph

   461 		case PIEvent.SELECTION_AREA_CHANGED:

   462 			// this is the first GPP graph to be told of the selection area

   463 			// change,

   464 			// so it gathers the overall trace information

   465 			double doubleStartTime = PIPageEditor.currentPageEditor()

   466 					.getStartTime();

   467 			double doubleEndTime = PIPageEditor.currentPageEditor()

   468 					.getEndTime();

   469 			GppTrace trace = (GppTrace) this.getTrace();

   470 			trace.setSelectedArea(doubleStartTime, doubleEndTime);

   471 

   472 			// take care of the threshold members

   473 			int sampleCount = 0;

   474 			int thresholdCount;

   475 

   476 			if (graphIndex == PIPageEditor.THREADS_PAGE) {

   477 				thresholdCount = (Integer) NpiInstanceRepository

   478 						.getInstance()

   479 						.getPersistState(uid,

   480 								"com.nokia.carbide.cpp.pi.address.thresholdCountThread"); //$NON-NLS-1$

   481 				if (thresholdCount > 0) {

   482 					for (int i = 0; i < profiledThreads.size(); i++)

   483 						if (profiledThreads.elementAt(i).getTotalSampleCount() < thresholdCount)

   484 							sampleCount += profiledThreads.elementAt(i)

   485 									.getSampleCount(graphIndex);

   486 					thresholdThread

   487 							.setSampleCount(this.graphIndex, sampleCount);

   488 				}

   489 			} else if (graphIndex == PIPageEditor.BINARIES_PAGE) {

   490 				thresholdCount = (Integer) NpiInstanceRepository

   491 						.getInstance()

   492 						.getPersistState(uid,

   493 								"com.nokia.carbide.cpp.pi.address.thresholdCountBinary"); //$NON-NLS-1$

   494 				if (thresholdCount > 0) {

   495 					for (int i = 0; i < profiledBinaries.size(); i++)

   496 						if (profiledBinaries.elementAt(i).getTotalSampleCount() < thresholdCount)

   497 							sampleCount += profiledBinaries.elementAt(i)

   498 									.getSampleCount(graphIndex);

   499 					thresholdBinary

   500 							.setSampleCount(this.graphIndex, sampleCount);

   501 				}

   502 			} else if (graphIndex == PIPageEditor.FUNCTIONS_PAGE) {

   503 				thresholdCount = (Integer) NpiInstanceRepository

   504 						.getInstance()

   505 						.getPersistState(uid,

   506 								"com.nokia.carbide.cpp.pi.address.thresholdCountFunction"); //$NON-NLS-1$

   507 				if (thresholdCount > 0) {

   508 					for (int i = 0; i < profiledFunctions.size(); i++)

   509 						if (profiledFunctions.elementAt(i)

   510 								.getTotalSampleCount() < thresholdCount)

   511 							sampleCount += profiledFunctions.elementAt(i)

   512 									.getSampleCount(graphIndex);

   513 					thresholdFunction.setSampleCount(this.graphIndex,

   514 							sampleCount);

   515 				}

   516 			}

   517 

   518 			double startTime = PIPageEditor.currentPageEditor().getStartTime();

   519 			double endTime = PIPageEditor.currentPageEditor().getEndTime();

   520 

   521 			// send this message to the other GPP graphs

   522 			PIEvent be2 = new PIEvent(be.getValueObject(),

   523 					PIEvent.SELECTION_AREA_CHANGED2);

   524 

   525 			// update the selection area shown

   526 			for (int i = 0; i < trace.getGraphCount(); i++) {

   527 				IGppTraceGraph graph = trace.getGppGraph(i, getUid());

   528 

   529 				if (graph != this) {

   530 					graph.piEventReceived(be2);

   531 					// once per graph, update the selection interval shown

   532 					graph.getCompositePanel().getVisualiser().updateStatusBarTimeInterval(startTime, endTime);

   533 				}

   534 

   535 				// change the graph's selected time interval

   536 				graph.setSelectionStart(startTime * 1000);

   537 				graph.setSelectionEnd(endTime * 1000);

   538 				graph.getCompositePanel().setSelectionFields(

   539 						(int) (startTime * 1000), (int) (endTime * 1000));

   540 			}

   541 

   542 			this.parentComponent.getSashForm().redraw();

   543 			be = be2;

   544 			// FALL THROUGH

   545 		case PIEvent.SELECTION_AREA_CHANGED2: {

   546 			// this code lets each graph's base thread/binary/function table

   547 			// update the other tables

   548 			switch (drawMode) {

   549 			case Defines.THREADS:

   550 			case Defines.THREADS_FUNCTIONS:

   551 			case Defines.THREADS_FUNCTIONS_BINARIES:

   552 			case Defines.THREADS_BINARIES:

   553 			case Defines.THREADS_BINARIES_FUNCTIONS: {

   554 				this.threadTable.piEventReceived(be);

   555 				break;

   556 			}

   557 			case Defines.BINARIES:

   558 			case Defines.BINARIES_THREADS:

   559 			case Defines.BINARIES_THREADS_FUNCTIONS:

   560 			case Defines.BINARIES_FUNCTIONS:

   561 			case Defines.BINARIES_FUNCTIONS_THREADS: {

   562 				this.binaryTable.piEventReceived(be);

   563 				break;

   564 			}

   565 			case Defines.FUNCTIONS:

   566 			case Defines.FUNCTIONS_THREADS:

   567 			case Defines.FUNCTIONS_THREADS_BINARIES:

   568 			case Defines.FUNCTIONS_BINARIES:

   569 			case Defines.FUNCTIONS_BINARIES_THREADS: {

   570 				this.functionTable.piEventReceived(be);

   571 				break;

   572 			}

   573 			}

   574 

   575 			this.vPanel.refreshCumulativeThreadTable();

   576 			this.setGraphImageChanged(true); // any selection change to drill

   577 			// down will change graph

   578 			this.repaint();

   579 			break;

   580 		}

   581 

   582 			// in the graph, show all values from the rightmost table

   583 		case PIEvent.SET_FILL_ALL_THREADS:

   584 			this.setGraphImageChanged(true); // any selection change to drill

   585 			// down will change graph

   586 			this.vPanel.piEventReceived(be);

   587 			break;

   588 

   589 		// in the graph, don't fill between the lines will the color of

   590 		// the line above

   591 		case PIEvent.SET_FILL_OFF:

   592 			this.setGraphImageChanged(true); // any selection change to drill

   593 			// down will change graph

   594 			this.vPanel.piEventReceived(be);

   595 			break;

   596 

   597 		// in the graph, show bars

   598 		case PIEvent.GPP_SET_BAR_GRAPH_ON:

   599 			this.vPanel.piEventReceived(be);

   600 			break;

   601 

   602 		// in the graph, show polylines

   603 		case PIEvent.GPP_SET_BAR_GRAPH_OFF:

   604 			this.vPanel.piEventReceived(be);

   605 			break;

   606 

   607 		// in the graph, show only the values from selected rows in the

   608 		// rightmost table

   609 		case PIEvent.SET_FILL_SELECTED_THREAD:

   610 			this.setGraphImageChanged(true); // any selection change to drill

   611 			// down will change graph

   612 			this.vPanel.piEventReceived(be);

   613 			break;

   614 

   615 		// Redraw the graph because the thread table's selected values have

   616 		// changed.

   617 		// The thread table is handled (setting of array of selected threads

   618 		// and table redraw) by the table selection listener or mouse listener.

   619 		case PIEvent.CHANGED_THREAD_TABLE:

   620 			switch (drawMode) {

   621 			case Defines.THREADS_BINARIES:

   622 			case Defines.THREADS_BINARIES_FUNCTIONS:

   623 			case Defines.THREADS_FUNCTIONS:

   624 			case Defines.THREADS_FUNCTIONS_BINARIES: {

   625 				this.threadTable.piEventReceived(be);

   626 				break;

   627 			}

   628 			case Defines.BINARIES_THREADS_FUNCTIONS: {

   629 				this.binaryTable.piEventReceived(be);

   630 				break;

   631 			}

   632 			case Defines.FUNCTIONS_THREADS_BINARIES: {

   633 				this.functionTable.piEventReceived(be);

   634 				break;

   635 			}

   636 			case Defines.THREADS:

   637 			case Defines.BINARIES:

   638 			case Defines.BINARIES_THREADS:

   639 			case Defines.BINARIES_FUNCTIONS:

   640 			case Defines.BINARIES_FUNCTIONS_THREADS:

   641 			case Defines.FUNCTIONS:

   642 			case Defines.FUNCTIONS_THREADS: