FCL/sftools/ana/dynaanaapps: comparison sysperfana/perfinvestigator/com.nokia.carbide.cpp.pi.address/src/com/nokia/carbide/cpp/pi/address/AddrFunctionTable.java

equal deleted inserted replaced

-:615035072f7e
+:844b047e260d
 import java.text.DecimalFormat;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Comparator;
 import java.util.Enumeration;
-import java.util.Hashtable;
 import java.util.Vector;
 import org.eclipse.jface.viewers.CheckStateChangedEvent;
 import org.eclipse.jface.viewers.CheckboxTableViewer;
 import org.eclipse.jface.viewers.ICheckStateListener;
 import org.eclipse.swt.widgets.Sash;
 import org.eclipse.swt.widgets.Table;
 import org.eclipse.swt.widgets.TableColumn;
 import org.eclipse.swt.widgets.TableItem;
+import com.nokia.carbide.cpp.internal.pi.address.GppModelAdapter;
 import com.nokia.carbide.cpp.internal.pi.analyser.NpiInstanceRepository;
 import com.nokia.carbide.cpp.internal.pi.analyser.ProfileVisualiser;
-import com.nokia.carbide.cpp.internal.pi.model.ProfiledBinary;
 import com.nokia.carbide.cpp.internal.pi.model.ProfiledFunction;
 import com.nokia.carbide.cpp.internal.pi.model.ProfiledGeneric;
-import com.nokia.carbide.cpp.internal.pi.model.ProfiledThread;
 import com.nokia.carbide.cpp.internal.pi.model.ProfiledThreshold;
 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.PIVisualSharedData;
 import com.nokia.carbide.cpp.pi.editors.PIPageEditor;
 {
 	// local copy of profiled binaries, which we can sort
 	// without affecting the original
 	Vector<ProfiledGeneric> profiledFunctions = new Vector<ProfiledGeneric>();
-	public AddrFunctionTable(GppTraceGraph myGraph, Composite parent)
+	public AddrFunctionTable(GppTraceGraph myGraph, Composite parent, GppModelAdapter adapter)
 	{
-		this.myGraph = myGraph;
+		super(myGraph, parent, adapter);
-		this.parent  = parent;
 	}
 	public void createTableViewer(int drawMode)
 	{
 		if (this.parent == null)
 		// select/deselect column
 		column = new TableColumn(table, SWT.CENTER);
 		column.setText(COLUMN_HEAD_SHOW);
 		column.setWidth(COLUMN_WIDTH_SHOW);
-		column.setData(new Integer(COLUMN_ID_SHOW));
+		column.setData(Integer.valueOf(COLUMN_ID_SHOW));
 		column.setMoveable(true);
 		column.setResizable(true);
 		column.addSelectionListener(new ColumnSelectionHandler());
 		// percent load column
 		column = new TableColumn(table, SWT.RIGHT);
 		column.setText(COLUMN_HEAD_PERCENT_LOAD);
 		column.setWidth(COLUMN_WIDTH_PERCENT_LOAD);
-		column.setData(new Integer(COLUMN_ID_PERCENT_LOAD));
+		column.setData(Integer.valueOf(COLUMN_ID_PERCENT_LOAD));
 		column.setMoveable(true);
 		column.setResizable(true);
 		column.addSelectionListener(new ColumnSelectionHandler());
 		// function name column
 		column = new TableColumn(table, SWT.LEFT);
 		column.setText(COLUMN_HEAD_FUNCTION);
 		column.setWidth(COLUMN_WIDTH_FUNCTION_NAME);
-		column.setData(new Integer(COLUMN_ID_FUNCTION));
+		column.setData(Integer.valueOf(COLUMN_ID_FUNCTION));
 		column.setMoveable(true);
 		column.setResizable(true);
 		column.addSelectionListener(new ColumnSelectionHandler());
 		// function start address column
 		column = new TableColumn(table, SWT.CENTER);
 		column.setText(COLUMN_HEAD_START_ADDR);
 		column.setWidth(COLUMN_WIDTH_START_ADDRESS);
-		column.setData(new Integer(COLUMN_ID_START_ADDR));
+		column.setData(Integer.valueOf(COLUMN_ID_START_ADDR));
 		column.setMoveable(true);
 		column.setResizable(true);
 		column.addSelectionListener(new ColumnSelectionHandler());
 		// binary containing function column
 		column = new TableColumn(table, SWT.LEFT);
 		column.setText(COLUMN_HEAD_IN_BINARY);
 		column.setWidth(COLUMN_WIDTH_IN_BINARY);
-		column.setData(new Integer(COLUMN_ID_IN_BINARY));
+		column.setData(Integer.valueOf(COLUMN_ID_IN_BINARY));
 		column.setMoveable(true);
 		column.setResizable(true);
 		column.addSelectionListener(new ColumnSelectionHandler());
 		// path to binary containing function column
 		column = new TableColumn(table, SWT.LEFT);
 		column.setText(COLUMN_HEAD_IN_BINARY_PATH);
 		column.setWidth(COLUMN_WIDTH_IN_BINARY_PATH);
-		column.setData(new Integer(COLUMN_ID_IN_BINARY_PATH));
+		column.setData(Integer.valueOf(COLUMN_ID_IN_BINARY_PATH));
 		column.setMoveable(true);
 		column.setResizable(true);
 		column.addSelectionListener(new ColumnSelectionHandler());
 		// sample count column
 		column = new TableColumn(table, SWT.CENTER);
 		column.setText(COLUMN_HEAD_SAMPLE_COUNT);
 		column.setWidth(COLUMN_WIDTH_SAMPLE_COUNT);
-		column.setData(new Integer(COLUMN_ID_SAMPLE_COUNT));
+		column.setData(Integer.valueOf(COLUMN_ID_SAMPLE_COUNT));
 		column.setMoveable(true);
 		column.setResizable(true);
 		column.addSelectionListener(new ColumnSelectionHandler());
 		// listen for mouse clicks: to select a row, pop up a menu, etc.
 		public shownFunctionsContentProvider() {
 			super();
 		}
 		public Object[] getElements(Object inputElement) {
-			return ((Vector) inputElement).toArray();
+			return ((Vector<?>) inputElement).toArray();
 		}
 		public void dispose() {
 		}
 		public shownFunctionsLabelProvider() {
 			super();
 		}
+		/* (non-Javadoc)
+		 * @see org.eclipse.jface.viewers.ITableLabelProvider#getColumnText(java.lang.Object, int)
+		 */
 		public String getColumnText(Object element, int columnIndex) {
 			int columnId = ((Integer) table.getColumn(columnIndex).getData()).intValue();
 			if (element instanceof ProfiledThreshold) {
 				ProfiledThreshold pThreshold = (ProfiledThreshold) element;
 						return pThreshold.getAverageLoadValueString(myGraph.getGraphIndex());
 					}
 					case COLUMN_ID_FUNCTION:
 					{
 						DecimalFormat timeFormat = new DecimalFormat(Messages.getString("AddrFunctionTable.decimalFormat")); //$NON-NLS-1$
-						int count = pThreshold.getItemCount(myGraph.getGraphIndex());
+						int count = pThreshold.getItemCount();
 						return count + (count > 1 ? Messages.getString("AddrFunctionTable.threshold1") : Messages.getString("AddrFunctionTable.threshold2"))   //$NON-NLS-1$ //$NON-NLS-2$
 								+ timeFormat.format((Double)NpiInstanceRepository.getInstance().activeUidGetPersistState("com.nokia.carbide.cpp.pi.address.thresholdLoadThread") * 100.0) + Messages.getString("AddrFunctionTable.threshold3")  //$NON-NLS-1$ //$NON-NLS-2$
 								+ (Integer)NpiInstanceRepository.getInstance().activeUidGetPersistState("com.nokia.carbide.cpp.pi.address.thresholdCountFunction") + Messages.getString("AddrFunctionTable.threshold4"); //$NON-NLS-1$ //$NON-NLS-2$
 					}
 		public Image getColumnImage(Object element, int columnIndex) {
 			return null;
 		}
 	}
-public void action(String actionString)
+@Override
+	public void action(String actionString)
 	{
 		int graphIndex = this.myGraph.getGraphIndex();
 		if (   actionString.equals("add") //$NON-NLS-1$
 			|| actionString.equals("remove")) //$NON-NLS-1$
 			boolean enabled = threshold.isEnabled(graphIndex);
 			this.tableItemData.clear();
 			this.profiledFunctions.clear();
 			this.myGraph.getSortedFunctions().clear();
-			if (threshold.getItems(graphIndex) != null)
+			if (threshold.getItems() != null)
-				threshold.getItems(graphIndex).clear();
+				threshold.getItems().clear();
-			threshold.initAll();
+			adapter.init(threshold, graphIndex);
 			// if this appears, it needs to be the first item, so that it is drawn at the bottom
 			myGraph.getSortedFunctions().add(threshold);
 			int functionThreshold = (Integer)NpiInstanceRepository.getInstance().activeUidGetPersistState("com.nokia.carbide.cpp.pi.address.thresholdCountFunction"); //$NON-NLS-1$
 			for (int i = 0; i < this.myGraph.getGppTrace().getSortedFunctions().size(); i++) {
 				ProfiledGeneric nextElement = (ProfiledGeneric)this.myGraph.getGppTrace().getSortedFunctions().get(i);
-				if (nextElement.getTotalSampleCount() < functionThreshold) {
+				if (adapter.getTotalSampleCount(nextElement) < functionThreshold) {
 					nextElement.setEnabled(graphIndex, enabled);
-					threshold.addItem(graphIndex, nextElement, 0);
+					adapter.addItem(threshold, graphIndex, nextElement, 0);
 				} else {
 					tableItemData.add(nextElement);
 					profiledFunctions.add(nextElement);
 					myGraph.getSortedFunctions().add(nextElement);
 				}
 			}
-			if (threshold.getItemCount(graphIndex) != 0) {
+			if (threshold.getItemCount() != 0) {
 				tableItemData.add(threshold);
 				profiledFunctions.add(threshold);
 			} else {
 				// remove the threshold item
 				myGraph.getSortedFunctions().remove(0);
 				totalSamples += pGeneric.getSampleCount(graphIndex);
 				if (item instanceof ProfiledThreshold)
 				{
 					ProfiledThreshold pThreshold = (ProfiledThreshold)item;
-					ArrayList<ProfiledGeneric> items = pThreshold.getItems(graphIndex);
+					for (ProfiledGeneric p : pThreshold.getItems())
-					for (int j = 0; j < items.size(); j++)
+						p.setEnabled(graphIndex, addIt);
-						items.get(j).setEnabled(graphIndex, addIt);
 				}
 			}
 		}
 // this table's set of checkbox-selected rows has changed,
 				nameList[i] = pGeneric.getNameString();
 				if (item instanceof ProfiledThreshold)
 				{
 					ProfiledThreshold pThreshold = (ProfiledThreshold)item;
-					ArrayList<ProfiledGeneric> items = pThreshold.getItems(graphIndex);
+					for (ProfiledGeneric p : pThreshold.getItems())
-					for (int j = 0; j < items.size(); j++)
+						p.setEnabled(graphIndex, addIt);
-						items.get(j).setEnabled(graphIndex, addIt);
 				}
 			}
 		}
 // this table's set of checkbox-selected rows has changed,
 					if (!(pGeneric instanceof ProfiledThreshold)){
 						PIPageEditor.currentPageEditor().setDirty();
 						pGeneric.setColor(color);
 					}
 					else {
-						// for the threshold item, we must change every graph's function threshold item
+						// for the threshold item, we must change every graph's thread threshold item
-						gppTrace.getGppGraph(PIPageEditor.THREADS_PAGE,   uid).getThresholdFunction().setColor(color);
+						// CH: refactor! This could be done via an observer pattern. This class should not have knowledge of all other graphs
-						gppTrace.getGppGraph(PIPageEditor.BINARIES_PAGE,  uid).getThresholdFunction().setColor(color);
+						gppTrace.getGppGraph(PIPageEditor.THREADS_PAGE,   uid).getThresholdThread().setColor(color);
-						gppTrace.getGppGraph(PIPageEditor.FUNCTIONS_PAGE, uid).getThresholdFunction().setColor(color);
+						gppTrace.getGppGraph(PIPageEditor.BINARIES_PAGE,  uid).getThresholdThread().setColor(color);
+						gppTrace.getGppGraph(PIPageEditor.FUNCTIONS_PAGE, uid).getThresholdThread().setColor(color);
+//						if (gppTrace.getCPUCount() > 1){ //SMP CH: comment this out once we have SMP graphs on the functions page
+//							for (int cpu = 0; cpu < gppTrace.getCPUCount(); cpu++) {
+//								gppTrace.getGppGraph(11 + cpu, uid).getThresholdThread().setColor(color);
+//							}
+//						}
 					}
 				}
 				// recoloring should only be done in a draw mode that displays this table's colors
 				selectedItems[i].setBackground(COLOR_COLUMN_INDEX, palette.getColor(nameKey));
 		this.myGraph.repaint();
 		this.myGraph.setGraphImageChanged(true);	// any selection change to drill down will change graph
 		// if any other tabs are displaying this type of graph, they need to be scheduled for redrawing
 		for (int i = 0; i < 3; i++) {
-			GppTraceGraph graph = gppTrace.getGppGraph(i, uid);
+			IGppTraceGraph graph = gppTrace.getGppGraph(i, uid);
 			if (graph == this.myGraph)
 				continue;
 			int drawMode = graph.getDrawMode();
 			return;
 		}
 		setIsDrilldown(false);
-		// set the page's graph title
-		ProfileVisualiser pV =  NpiInstanceRepository.getInstance().getProfilePage(this.myGraph.getUid(), this.myGraph.getGraphIndex());
-		pV.getTitle().setText(Messages.getString("AddrFunctionTable.functionLoad"));  //$NON-NLS-1$
-		pV.getTitle2().setText(""); //$NON-NLS-1$
 		// get rid of any existing tables and sashes
 		if (this.myGraph.getLeftSash() != null) {
 			this.myGraph.getLeftSash().dispose();
 			this.myGraph.setLeftSash(null);
 		}
 		setIsDrilldown(true);
 		if (drawMode == Defines.FUNCTIONS) {
-			// set the page's graph title
-			ProfileVisualiser pV =  NpiInstanceRepository.getInstance().getProfilePage(this.myGraph.getUid(), this.myGraph.getGraphIndex());
-			pV.getTitle().setText(Messages.getString("AddrFunctionTable.binaryLoad"));  //$NON-NLS-1$
-			pV.getTitle2().setText(Messages.getString("AddrFunctionTable.functionTo"));  //$NON-NLS-1$
 			// set the draw mode
 			this.myGraph.setDrawMode(Defines.FUNCTIONS_BINARIES);
 			// create the binary graph table viewer
 			binaryTable.createTableViewer(Defines.FUNCTIONS_BINARIES);
 			binaryTable.setIsDrilldown(true);
 			// create a reduced set of binary entries based on enabled function entries
 			GppTrace gppTrace = (GppTrace) this.myGraph.getTrace();
-			Vector<ProfiledGeneric> binaries = gppTrace.setFunctionBinary(graphIndex);
+			gppTrace.setFunctionBinary(graphIndex, adapter, this.myGraph.getProfiledBinaries());
-			this.myGraph.setProfiledBinaries(binaries);
 			// put check marks on all rows, and sort by sample count
 			binaryTable.quickSort(COLUMN_ID_SAMPLE_COUNT, this.myGraph.getProfiledBinaries());
 			binaryTable.updateProfiledAndItemData(true);
 			binaryTable.getTableViewer().setAllChecked(true);
 			binaryTable.getTableViewer().refresh();
+			// put check marks on all enabled binary rows
+			for (int i = 0; i < this.table.getItemCount(); i++) {
+				ProfiledGeneric pFunction = (ProfiledGeneric) this.table.getItem(i).getData();
+				if (pFunction.isEnabled(graphIndex))
+					this.table.getItem(i).setChecked(true);
+			}
 			// remove colors where appropriate
 			removeColor(Defines.FUNCTIONS_BINARIES);
 			// connect the tables with a sash
 			this.parent.layout();
 			this.myGraph.repaint();
 		} else if (drawMode == Defines.FUNCTIONS_BINARIES_THREADS) {
-			// set the page's graph title
-			ProfileVisualiser pV =  NpiInstanceRepository.getInstance().getProfilePage(this.myGraph.getUid(), this.myGraph.getGraphIndex());
-			pV.getTitle().setText(Messages.getString("AddrFunctionTable.binaryLoad"));  //$NON-NLS-1$
-			pV.getTitle2().setText(Messages.getString("AddrFunctionTable.functionTo"));  //$NON-NLS-1$
 			// get rid of the thread table and its sash
 			if (this.myGraph.getRightSash() != null) {
 				this.myGraph.getRightSash().dispose();
 				this.myGraph.setRightSash(null);
 			return;
 		}
 		setIsDrilldown(true);
-		// set the page's graph title
-		ProfileVisualiser pV =  NpiInstanceRepository.getInstance().getProfilePage(this.myGraph.getUid(), this.myGraph.getGraphIndex());
-		pV.getTitle().setText(Messages.getString("AddrFunctionTable.threadLoad"));  //$NON-NLS-1$
-		pV.getTitle2().setText(Messages.getString("AddrFunctionTable.functionToBinaryTo"));  //$NON-NLS-1$
 		// set the draw mode
 		this.myGraph.setDrawMode(Defines.FUNCTIONS_BINARIES_THREADS);
 		// create the thread graph table viewer
 		AddrThreadTable threadTable = this.myGraph.getThreadTable();
 		threadTable.createTableViewer(Defines.FUNCTIONS_BINARIES_THREADS);
 		threadTable.setIsDrilldown(true);
 		// create a reduced set of thread entries based on enabled binary and function entries
 		GppTrace gppTrace = (GppTrace) this.myGraph.getTrace();
-		Vector<ProfiledGeneric> threads = gppTrace.setFunctionBinaryThread(graphIndex);
+		gppTrace.setFunctionBinaryThread(graphIndex, adapter, this.myGraph.getProfiledThreads());
-		this.myGraph.setProfiledThreads(threads);
 		// put check marks on all rows, and sort by sample count
 		threadTable.quickSort(COLUMN_ID_SAMPLE_COUNT, this.myGraph.getProfiledThreads());
 		threadTable.updateProfiledAndItemData(true);
 		threadTable.getTableViewer().setAllChecked(true);
 		}
 		setIsDrilldown(true);
 		if (drawMode == Defines.FUNCTIONS) {
-			// set the page's graph title
-			ProfileVisualiser pV =  NpiInstanceRepository.getInstance().getProfilePage(this.myGraph.getUid(), this.myGraph.getGraphIndex());
-			pV.getTitle().setText(Messages.getString("AddrFunctionTable.threadLoad"));  //$NON-NLS-1$
-			pV.getTitle2().setText(Messages.getString("AddrFunctionTable.functionTo"));  //$NON-NLS-1$
 			// set the draw mode
 			this.myGraph.setDrawMode(Defines.FUNCTIONS_THREADS);
 			// create the thread graph table viewer
 			threadTable.createTableViewer(Defines.FUNCTIONS_THREADS);
 			threadTable.setIsDrilldown(true);
 			// create a reduced set of thread entries based on enabled function entries
 			GppTrace gppTrace = (GppTrace) this.myGraph.getTrace();
-			Vector<ProfiledGeneric> threads = gppTrace.setFunctionThread(graphIndex);
+			gppTrace.setFunctionThread(graphIndex, adapter, this.myGraph.getProfiledThreads());
-			this.myGraph.setProfiledThreads(threads);
 			// put check marks on all rows, and sort by sample count
 			threadTable.quickSort(COLUMN_ID_SAMPLE_COUNT, this.myGraph.getProfiledThreads());
 			threadTable.updateProfiledAndItemData(true);
 			threadTable.getTableViewer().setAllChecked(true);
 			this.parent.layout();
 			this.myGraph.repaint();
 		} else if (drawMode == Defines.FUNCTIONS_THREADS_BINARIES) {
-			// set the page's graph title
-			ProfileVisualiser pV =  NpiInstanceRepository.getInstance().getProfilePage(this.myGraph.getUid(), this.myGraph.getGraphIndex());
-			pV.getTitle().setText(Messages.getString("AddrFunctionTable.threadLoad"));  //$NON-NLS-1$
-			pV.getTitle2().setText(Messages.getString("AddrFunctionTable.functionTo"));  //$NON-NLS-1$
 			// get rid of the binary table and its sash
 			if (this.myGraph.getRightSash() != null) {
 				this.myGraph.getRightSash().dispose();
 				this.myGraph.setRightSash(null);
 			return;
 		}
 		setIsDrilldown(true);
-		// set the page's graph title
-		ProfileVisualiser pV =  NpiInstanceRepository.getInstance().getProfilePage(this.myGraph.getUid(), this.myGraph.getGraphIndex());
-		pV.getTitle().setText(Messages.getString("AddrFunctionTable.binaryLoad"));  //$NON-NLS-1$
-		pV.getTitle2().setText(Messages.getString("AddrFunctionTable.functionToThreadTo"));  //$NON-NLS-1$
 		// set the draw mode
 		this.myGraph.setDrawMode(Defines.FUNCTIONS_THREADS_BINARIES);
 		// create the binary graph table viewer
 		AddrBinaryTable binaryTable = this.myGraph.getBinaryTable();
 		binaryTable.createTableViewer(Defines.FUNCTIONS_THREADS_BINARIES);
 		binaryTable.setIsDrilldown(true);
 		// create a reduced set of binary entries based on enabled thread entries
 		GppTrace gppTrace = (GppTrace) this.myGraph.getTrace();
-		Vector<ProfiledGeneric> binaries = gppTrace.setFunctionThreadBinary(graphIndex);
+		gppTrace.setFunctionThreadBinary(graphIndex, adapter, this.myGraph.getProfiledBinaries());
-		this.myGraph.setProfiledBinaries(binaries);
 		// put check marks on all rows, and sort by sample count
 		binaryTable.quickSort(COLUMN_ID_SAMPLE_COUNT, this.myGraph.getProfiledBinaries());
 		binaryTable.updateProfiledAndItemData(true);
 		binaryTable.getTableViewer().setAllChecked(true);
 				int thresholdCount = (Integer)NpiInstanceRepository.getInstance().activeUidGetPersistState("com.nokia.carbide.cpp.pi.address.thresholdCountFunction"); //$NON-NLS-1$
 				if (thresholdCount > 0) {
 					Vector<ProfiledGeneric> pGeneric = this.myGraph.getProfiledFunctions();
 					int sampleCount = 0;
 					for (int i = 0; i < pGeneric.size(); i++)
-						if (pGeneric.elementAt(i).getTotalSampleCount() < thresholdCount)
+						if (adapter.getTotalSampleCount(pGeneric.elementAt(i)) < thresholdCount)
 							sampleCount += pGeneric.elementAt(i).getSampleCount(graphIndex);
 					this.myGraph.getThresholdFunction().setSampleCount(graphIndex, sampleCount);
 				}
 			}
 			int drawMode = this.myGraph.getDrawMode();
 			if (drawMode == Defines.FUNCTIONS)
 				return;
 			GppTrace trace = (GppTrace)(this.myGraph.getTrace());
-			Vector<ProfiledGeneric> traceFunctions = trace.getIndexedFunctions();
-			int startSampleIndex = trace.getStartSampleIndex();
-			int endSampleIndex   = trace.getEndSampleIndex();
-			double percentPerSample;
-			if (startSampleIndex == endSampleIndex)
-				percentPerSample = 0.0;
-			else
-				percentPerSample = 100.0 / ((double)(endSampleIndex - startSampleIndex));
 			PIEvent be3 = new PIEvent(be.getValueObject(), PIEvent.SELECTION_AREA_CHANGED3);
 			switch (drawMode) {
 				case Defines.FUNCTIONS_THREADS:
 				{
-					// get new thread counts and loads
+					trace.setFunctionThread(graphIndex, adapter, this.myGraph.getProfiledThreads());
-					Vector<ProfiledGeneric> traceThreads  = trace.getIndexedThreads();
-					Vector<ProfiledGeneric> graphThreads  = this.myGraph.getProfiledThreads();
-					Hashtable<String,String> foundThreads = new Hashtable<String,String>();
-					// previous threads are not necessarily graphed this time
-					Enumeration<ProfiledGeneric> enu = graphThreads.elements();
-					while (enu.hasMoreElements()) {
-						ProfiledThread pThread = (ProfiledThread) enu.nextElement();
-						pThread.setEnabled(graphIndex, false);
-					}
-					graphThreads.clear();
-					ProfiledThreshold thresholdThread = this.myGraph.getThresholdThread();
-					if (thresholdThread.isEnabled(graphIndex)) {
-						ArrayList<ProfiledGeneric> items = thresholdThread.getItems(graphIndex);
-						// disable all items below the threshold
-						for (int i = 0; i < items.size(); i++) {
-							items.get(i).setEnabled(graphIndex, false);
-						}
-					}
-					GppSample[] sortedSamples = trace.getSortedGppSamples();
-					// set up in case we find threads below the threshold
-					boolean lowThread;
-					thresholdThread.init(graphIndex);
-					int threadThreshold = (Integer) NpiInstanceRepository.getInstance().activeUidGetPersistState("com.nokia.carbide.cpp.pi.address.thresholdCountThread"); //$NON-NLS-1$
-					for (int i = startSampleIndex; i < endSampleIndex; i++) {
-						GppSample sample = sortedSamples[i];
-						ProfiledFunction pFunction = (ProfiledFunction) traceFunctions.elementAt(sample.functionIndex);
-						if (pFunction.isEnabled(graphIndex)) {
-							// thread list is based on functions
-							ProfiledThread pThread = (ProfiledThread) traceThreads.elementAt(sample.threadIndex);
-							String threadName = pThread.getNameString();
-							lowThread = pThread.getTotalSampleCount() < threadThreshold;
-							if (!foundThreads.containsKey(threadName)) {
-								foundThreads.put(threadName, threadName);
-								if (lowThread) {
-									thresholdThread.addItem(graphIndex, pThread, 1);
-								} else {
-									pThread.setEnabled(graphIndex, true);
-									pThread.setSampleCount(graphIndex, 1);
-									graphThreads.add(pThread);
-								}
-							} else {
-								if (lowThread)
-									thresholdThread.incSampleCount(graphIndex);
-								else
-									pThread.incSampleCount(graphIndex);
-							}
-						}
-					}
-					// set the % load
-					for (int i = 0; i < graphThreads.size(); i++) {
-						ProfiledThread pThread = (ProfiledThread) graphThreads.elementAt(i);
-						pThread.setLoadAndString(graphIndex, (float)(pThread.getSampleCount(graphIndex)*percentPerSample));
-					}
-					thresholdThread.setLoadAndString(graphIndex,
-							(float)(thresholdThread.getSampleCount(graphIndex)*percentPerSample));
 					// update the table items and redraw the table
 					this.myGraph.getThreadTable().piEventReceived(be3);
 					break;
 				}
 				case Defines.FUNCTIONS_THREADS_BINARIES:
 				{
-					// get new thread and binary counts and loads
+					// previous threads are not necessarily graphed this time - reset
-					Vector<ProfiledGeneric> traceThreads   = trace.getIndexedThreads();
+					trace.setFunctionThread(graphIndex, adapter, this.myGraph.getProfiledThreads());
-					Vector<ProfiledGeneric> traceBinaries  = trace.getIndexedBinaries();
+					// previous binaries are not necessarily graphed this time - reset
-					Vector<ProfiledGeneric> graphThreads   = this.myGraph.getProfiledThreads();
+					trace.setFunctionThreadBinary(graphIndex, adapter, this.myGraph.getProfiledBinaries());
-					Vector<ProfiledGeneric> graphBinaries  = this.myGraph.getProfiledBinaries();
-					Hashtable<String,String> foundThreads  = new Hashtable<String,String>();
-					Hashtable<String,String> foundBinaries = new Hashtable<String,String>();
-					// previous binaries are not necessarily graphed this time
-					Enumeration<ProfiledGeneric> enuBinary = graphBinaries.elements();
-					while (enuBinary.hasMoreElements()) {
-						ProfiledBinary pBinary = (ProfiledBinary) enuBinary.nextElement();
-						pBinary.setEnabled(graphIndex, false);
-					}
-					graphBinaries.clear();
-					ProfiledThreshold thresholdBinary = this.myGraph.getThresholdBinary();
-					if (thresholdBinary.isEnabled(graphIndex)) {
-						ArrayList<ProfiledGeneric> items = thresholdBinary.getItems(graphIndex);
-						// disable all items below the threshold
-						for (int i = 0; i < items.size(); i++) {
-							items.get(i).setEnabled(graphIndex, false);
-						}
-					}
-					// previous threads are not necessarily graphed this time
-					Enumeration<ProfiledGeneric> enuThread = graphThreads.elements();
-					while (enuThread.hasMoreElements()) {
-						ProfiledThread pThread = (ProfiledThread) enuThread.nextElement();
-						pThread.setEnabled(graphIndex, false);
-					}
-					graphThreads.clear();
-					ProfiledThreshold thresholdThread = this.myGraph.getThresholdThread();
-					if (thresholdThread.isEnabled(graphIndex)) {
-						ArrayList<ProfiledGeneric> items = thresholdThread.getItems(graphIndex);
-						// disable all items below the threshold
-						for (int i = 0; i < items.size(); i++) {
-							items.get(i).setEnabled(graphIndex, false);
-						}
-					}
-					GppSample[] sortedSamples = trace.getSortedGppSamples();
-					// set up in case we find binaries below the threshold
-					boolean lowBinary;
-					thresholdBinary.init(graphIndex);
-					// set up in case we find threads below the threshold
-					boolean lowThread;
-					thresholdThread.init(graphIndex);
-					int threadThreshold = (Integer) NpiInstanceRepository.getInstance().activeUidGetPersistState("com.nokia.carbide.cpp.pi.address.thresholdCountThread"); //$NON-NLS-1$
-					for (int i = startSampleIndex; i < endSampleIndex; i++) {
-						GppSample sample = sortedSamples[i];
-						ProfiledFunction pFunction = (ProfiledFunction) traceFunctions.elementAt(sample.functionIndex);
-						if (pFunction.isEnabled(graphIndex)) {
-							// thread list is based on functions
-							ProfiledThread pThread = (ProfiledThread) traceThreads.elementAt(sample.threadIndex);
-							String threadName = pThread.getNameString();
-							lowThread = pThread.getTotalSampleCount() < threadThreshold;
-							if (!foundThreads.containsKey(threadName)) {
-								foundThreads.put(threadName, threadName);
-								if (lowThread) {
-									thresholdThread.addItem(graphIndex, pThread, 1);
-								} else {
-									pThread.setEnabled(graphIndex, true);
-									pThread.setSampleCount(graphIndex, 1);
-									graphThreads.add(pThread);
-								}
-							} else {
-								if (lowThread)
-									thresholdThread.incSampleCount(graphIndex);
-								else
-									pThread.incSampleCount(graphIndex);
-							}
-							// binary list is based on functions and threads
-							ProfiledBinary pBinary = (ProfiledBinary) traceBinaries.elementAt(sample.binaryIndex);
-							String binaryName = pBinary.getNameString();
-							lowBinary = pBinary.getTotalSampleCount() < (Integer)NpiInstanceRepository.getInstance().activeUidGetPersistState("com.nokia.carbide.cpp.pi.address.thresholdCountBinary"); //$NON-NLS-1$
-							if (!foundBinaries.containsKey(binaryName)) {
-								foundBinaries.put(binaryName, binaryName);
-								if (lowBinary) {
-									thresholdBinary.addItem(graphIndex, pBinary, 1);
-								} else {
-									pBinary.setEnabled(graphIndex, true);
-									pBinary.setSampleCount(graphIndex, 1);
-									graphBinaries.add(pBinary);
-								}
-							} else {
-								if (lowBinary)
-									thresholdBinary.incSampleCount(graphIndex);
-								else
-									pBinary.incSampleCount(graphIndex);
-							}
-						}
-					}
-					// set the % load
-					for (int i = 0; i < graphThreads.size(); i++) {
-						ProfiledThread pThread = (ProfiledThread) graphThreads.elementAt(i);
-						pThread.setLoadAndString(graphIndex, (float)(pThread.getSampleCount(graphIndex)*percentPerSample));
-					}
-					thresholdThread.setLoadAndString(graphIndex,
-							(float)(thresholdThread.getSampleCount(graphIndex)*percentPerSample));
-					for (int i = 0; i < graphBinaries.size(); i++) {
-						ProfiledBinary pBinary = (ProfiledBinary) graphBinaries.elementAt(i);
-						pBinary.setLoadAndString(graphIndex, (float)(pBinary.getSampleCount(graphIndex)*percentPerSample));
-					}
-					thresholdBinary.setLoadAndString(graphIndex,
-							(float)(thresholdBinary.getSampleCount(graphIndex)*percentPerSample));
 					// update the table items and redraw the table
 					this.myGraph.getThreadTable().piEventReceived(be3);
 					this.myGraph.getBinaryTable().piEventReceived(be3);
 					break;
 				}
 				case Defines.FUNCTIONS_BINARIES:
 				{
-					// get new counts and loads
+					trace.setFunctionBinary(graphIndex, adapter, this.myGraph.getProfiledBinaries());
-					Vector<ProfiledGeneric> traceBinaries  = trace.getIndexedBinaries();
-					Vector<ProfiledGeneric> graphBinaries  = this.myGraph.getProfiledBinaries();
-					Hashtable<String,String> foundBinaries = new Hashtable<String,String>();
-					// previous binaries are not necessarily graphed this time
-					Enumeration<ProfiledGeneric> enu = graphBinaries.elements();
-					while (enu.hasMoreElements()) {
-						ProfiledBinary pBinary = (ProfiledBinary) enu.nextElement();
-						pBinary.setEnabled(graphIndex, false);
-					}
-					graphBinaries.clear();
-					ProfiledThreshold thresholdBinary = this.myGraph.getThresholdBinary();
-					if (thresholdBinary.isEnabled(graphIndex)) {
-						ArrayList<ProfiledGeneric> items = thresholdBinary.getItems(graphIndex);
-						// disable all items below the threshold
-						for (int i = 0; i < items.size(); i++) {
-							items.get(i).setEnabled(graphIndex, false);
-						}
-					}
-					GppSample[] sortedSamples = trace.getSortedGppSamples();
-					// set up in case we find binaries below the threshold
-					boolean lowBinary;
-					thresholdBinary.init(graphIndex);
-					int binaryThreshold = (Integer) NpiInstanceRepository.getInstance().activeUidGetPersistState("com.nokia.carbide.cpp.pi.address.thresholdCountBinary"); //$NON-NLS-1$
-					for (int i = startSampleIndex; i < endSampleIndex; i++) {
-						GppSample sample = sortedSamples[i];
-						ProfiledFunction pFunction = (ProfiledFunction) traceFunctions.elementAt(sample.functionIndex);
-						if (pFunction.isEnabled(graphIndex)) {
-							// binary list is based on functions
-							ProfiledBinary pBinary = (ProfiledBinary) traceBinaries.elementAt(sample.binaryIndex);
-							String binaryName = pBinary.getNameString();
-							lowBinary = pBinary.getTotalSampleCount() < binaryThreshold;
-							if (!foundBinaries.containsKey(binaryName)) {
-								foundBinaries.put(binaryName, binaryName);
-								if (lowBinary) {
-									thresholdBinary.addItem(graphIndex, pBinary, 1);
-								} else {
-									pBinary.setEnabled(graphIndex, true);
-									pBinary.setSampleCount(graphIndex, 1);
-									graphBinaries.add(pBinary);
-								}
-							} else {
-								if (lowBinary)
-									thresholdBinary.incSampleCount(graphIndex);
-								else
-									pBinary.incSampleCount(graphIndex);
-							}
-						}
-					}
-					// set the % load
-					for (int i = 0; i < graphBinaries.size(); i++) {
-						ProfiledBinary pBinary = (ProfiledBinary) graphBinaries.elementAt(i);
-						pBinary.setLoadAndString(graphIndex, (float)(pBinary.getSampleCount(graphIndex)*percentPerSample));
-					}
-					thresholdBinary.setLoadAndString(graphIndex,
-							(float)(thresholdBinary.getSampleCount(graphIndex)*percentPerSample));
 					// update the table items and redraw the table
 					this.myGraph.getBinaryTable().piEventReceived(be3);
 					break;
 				}
 				case Defines.FUNCTIONS_BINARIES_THREADS:
 				{
-					// get new binary and thread counts and loads
+					// previous binaries are not necessarily graphed this time - reset
-					Vector<ProfiledGeneric> traceThreads    = trace.getIndexedThreads();
+					trace.setFunctionBinary(graphIndex, adapter, this.myGraph.getProfiledBinaries());
-					Vector<ProfiledGeneric> traceBinaries   = trace.getIndexedBinaries();
+					// previous threads are not necessarily graphed this time - reset
-					Vector<ProfiledGeneric> graphThreads    = this.myGraph.getProfiledThreads();
+					trace.setFunctionBinaryThread(graphIndex, adapter, this.myGraph.getProfiledThreads());
-					Vector<ProfiledGeneric> graphBinaries   = this.myGraph.getProfiledBinaries();
-					Hashtable<String,String> foundThreads   = new Hashtable<String,String>();
-					Hashtable<String,String> foundBinaries  = new Hashtable<String,String>();
-					// previous threads are not necessarily graphed this time
-					Enumeration<ProfiledGeneric> enuThreads = graphThreads.elements();
-					while (enuThreads.hasMoreElements()) {
-						ProfiledThread pThread = (ProfiledThread) enuThreads.nextElement();
-						pThread.setEnabled(graphIndex, false);
-					}
-					graphThreads.clear();
-					ProfiledThreshold thresholdThread = this.myGraph.getThresholdThread();
-					if (thresholdThread.isEnabled(graphIndex)) {
-						ArrayList<ProfiledGeneric> items = thresholdThread.getItems(graphIndex);
-						// disable all items below the threshold
-						for (int i = 0; i < items.size(); i++) {
-							items.get(i).setEnabled(graphIndex, false);
-						}
-					}
-					// previous binaries are not necessarily graphed this time
-					Enumeration<ProfiledGeneric> enuBinary = graphBinaries.elements();
-					while (enuBinary.hasMoreElements()) {
-						ProfiledBinary pBinary = (ProfiledBinary) enuBinary.nextElement();
-						pBinary.setEnabled(graphIndex, false);
-					}
-					graphBinaries.clear();
-					ProfiledThreshold thresholdBinary = this.myGraph.getThresholdBinary();
-					if (thresholdBinary.isEnabled(graphIndex)) {
-						ArrayList<ProfiledGeneric> items = thresholdBinary.getItems(graphIndex);
-						// disable all items below the threshold
-						for (int i = 0; i < items.size(); i++) {
-							items.get(i).setEnabled(graphIndex, false);
-						}
-					}
-					GppSample[] sortedSamples = trace.getSortedGppSamples();
-					// set up in case we find threads below the threshold
-					boolean lowThread;
-					thresholdThread.init(graphIndex);
-					// set up in case we find binaries below the threshold
-					boolean lowBinary;
-					thresholdBinary.init(graphIndex);
-					int binaryThreshold = (Integer) NpiInstanceRepository.getInstance().activeUidGetPersistState("com.nokia.carbide.cpp.pi.address.thresholdCountBinary"); //$NON-NLS-1$
-					for (int i = startSampleIndex; i < endSampleIndex; i++) {
-						GppSample sample = sortedSamples[i];
-						ProfiledFunction pFunction = (ProfiledFunction) traceFunctions.elementAt(sample.functionIndex);
-						if (pFunction.isEnabled(graphIndex)) {
-							// binary list is based on
-							ProfiledBinary pBinary = (ProfiledBinary) traceBinaries.elementAt(sample.binaryIndex);
-							String binaryName = pBinary.getNameString();
-							lowBinary = pBinary.getTotalSampleCount() < binaryThreshold;
-							if (!foundBinaries.containsKey(binaryName)) {
-								foundBinaries.put(binaryName, binaryName);
-								if (lowBinary) {
-									thresholdBinary.addItem(graphIndex, pBinary, 1);
-								} else {
-									pBinary.setEnabled(graphIndex, true);
-									pBinary.setSampleCount(graphIndex, 1);
-									graphBinaries.add(pBinary);
-								}
-							} else {
-								if (lowBinary)
-									thresholdBinary.incSampleCount(graphIndex);
-								else
-									pBinary.incSampleCount(graphIndex);
-							}
-							// thread list is based on functions and binaries
-							ProfiledThread pThread = (ProfiledThread) traceThreads.elementAt(sample.threadIndex);
-							String threadName = pThread.getNameString();
-							lowThread = pThread.getTotalSampleCount() < (Integer)NpiInstanceRepository.getInstance().activeUidGetPersistState("com.nokia.carbide.cpp.pi.address.thresholdCountThread"); //$NON-NLS-1$
-							if (!foundThreads.containsKey(threadName)) {
-								foundThreads.put(threadName, threadName);
-								if (lowThread) {
-									thresholdThread.addItem(graphIndex, pThread, 1);
-								} else {
-									pThread.setEnabled(graphIndex, true);
-									pThread.setSampleCount(graphIndex, 1);
-									graphThreads.add(pThread);
-								}
-							} else {
-								if (lowThread)
-									thresholdThread.incSampleCount(graphIndex);
-								else
-									pThread.incSampleCount(graphIndex);
-							}
-						}
-					}
-					// set the % load
-					for (int i = 0; i < graphThreads.size(); i++) {
-						ProfiledThread pThread = (ProfiledThread) graphThreads.elementAt(i);
-						pThread.setLoadAndString(graphIndex, (float)(pThread.getSampleCount(graphIndex)*percentPerSample));
-					}
-					thresholdThread.setLoadAndString(graphIndex,
-							(float)(thresholdThread.getSampleCount(graphIndex)*percentPerSample));
-					for (int i = 0; i < graphBinaries.size(); i++) {
-						ProfiledBinary pBinary = (ProfiledBinary) graphBinaries.elementAt(i);
-						pBinary.setLoadAndString(graphIndex, (float)(pBinary.getSampleCount(graphIndex)*percentPerSample));
-					}
-					thresholdBinary.setLoadAndString(graphIndex,
-							(float)(thresholdBinary.getSampleCount(graphIndex)*percentPerSample));
 					// update the table items and redraw the table
 					this.myGraph.getThreadTable().piEventReceived(be3);
 					this.myGraph.getBinaryTable().piEventReceived(be3);
 					break;
 			if (drawMode != Defines.FUNCTIONS_THREADS_BINARIES)
 				return;
 			// we don't need to redraw the function table, since it has not changed
+			PIEvent be3 = new PIEvent(be.getValueObject(), PIEvent.SELECTION_AREA_CHANGED3);
 			GppTrace trace = (GppTrace)(this.myGraph.getTrace());
-			Vector<ProfiledGeneric> traceThreads = trace.getIndexedThreads();
 			int graphIndex = this.myGraph.getGraphIndex();
-			int startSampleIndex = trace.getStartSampleIndex();
+			trace.setFunctionThreadBinary(graphIndex, adapter, this.myGraph.getProfiledBinaries());
-			int endSampleIndex   = trace.getEndSampleIndex();
-			double percentPerSample;
-			if (startSampleIndex == endSampleIndex)
-				percentPerSample = 0.0;
-			else
-				percentPerSample = 100.0 / ((double)(endSampleIndex - startSampleIndex));
-			PIEvent be3 = new PIEvent(be.getValueObject(), PIEvent.SELECTION_AREA_CHANGED3);
-			// get new binary counts and loads
-			Vector<ProfiledGeneric> traceBinaries  = trace.getIndexedBinaries();
-			Vector<ProfiledGeneric> graphBinaries  = this.myGraph.getProfiledBinaries();
-			Hashtable<String,String> foundBinaries = new Hashtable<String,String>();
-			// previous binaries are not necessarily graphed this time
-			Enumeration<ProfiledGeneric> enu = graphBinaries.elements();
-			while (enu.hasMoreElements()) {
-				ProfiledBinary pBinary = (ProfiledBinary) enu.nextElement();
-				pBinary.setEnabled(graphIndex, false);
-			}
-			graphBinaries.clear();
-			ProfiledThreshold thresholdBinary = this.myGraph.getThresholdBinary();
-			if (thresholdBinary.isEnabled(graphIndex)) {
-				ArrayList<ProfiledGeneric> items = thresholdBinary.getItems(graphIndex);
-				// disable all items below the threshold
-				for (int i = 0; i < items.size(); i++) {
-					items.get(i).setEnabled(graphIndex, false);
-				}
-			}
-			GppSample[] sortedSamples = trace.getSortedGppSamples();
-			// set up in case we find binaries below the threshold
-			boolean lowBinary;
-			thresholdBinary.init(graphIndex);
-			int binaryThreshold = (Integer) NpiInstanceRepository.getInstance().activeUidGetPersistState("com.nokia.carbide.cpp.pi.address.thresholdCountBinary"); //$NON-NLS-1$
-			for (int i = startSampleIndex; i < endSampleIndex; i++) {
-				GppSample sample = sortedSamples[i];
-				ProfiledThread pThread = (ProfiledThread) traceThreads.elementAt(sample.threadIndex);
-				if (pThread.isEnabled(graphIndex)) {
-					// binary list is based on threads
-					ProfiledBinary pBinary = (ProfiledBinary) traceBinaries.elementAt(sample.binaryIndex);
-					String binaryName = pBinary.getNameString();
-					lowBinary = pBinary.getTotalSampleCount() < binaryThreshold;
-					if (!foundBinaries.containsKey(binaryName)) {
-						foundBinaries.put(binaryName, binaryName);
-						if (lowBinary) {
-							thresholdBinary.addItem(graphIndex, pBinary, 1);
-						} else {
-							pBinary.setEnabled(graphIndex, true);
-							pBinary.setSampleCount(graphIndex, 1);
-							graphBinaries.add(pBinary);
-						}
-					} else {
-						if (lowBinary)
-							thresholdBinary.incSampleCount(graphIndex);
-						else
-							pBinary.incSampleCount(graphIndex);
-					}
-				}
-			}
-			// set the % load
-			for (int i = 0; i < graphBinaries.size(); i++) {
-				ProfiledBinary pBinary = (ProfiledBinary) graphBinaries.elementAt(i);
-				pBinary.setLoadAndString(graphIndex, (float)(pBinary.getSampleCount(graphIndex)*percentPerSample));
-			}
-			thresholdBinary.setLoadAndString(graphIndex,
-					(float)(thresholdBinary.getSampleCount(graphIndex)*percentPerSample));
 			// update the table items and redraw the table
 			this.myGraph.getBinaryTable().piEventReceived(be3);
 		}
 		else if (be.getType() == PIEvent.CHANGED_BINARY_TABLE)
 			if (drawMode != Defines.FUNCTIONS_BINARIES_THREADS)
 				return;
 			// we don't need to redraw the function table, since it has not changed
+			PIEvent be3 = new PIEvent(be.getValueObject(), PIEvent.SELECTION_AREA_CHANGED3);
 			GppTrace trace = (GppTrace)(this.myGraph.getTrace());
-			Vector<ProfiledGeneric> traceBinaries  = trace.getIndexedBinaries();
 			int graphIndex = this.myGraph.getGraphIndex();
-			int startSampleIndex = trace.getStartSampleIndex();
+			trace.setFunctionBinaryThread(graphIndex, adapter, this.myGraph.getProfiledThreads());
-			int endSampleIndex   = trace.getEndSampleIndex();
-			double percentPerSample;
-			if (startSampleIndex == endSampleIndex)
-				percentPerSample = 0.0;
-			else
-				percentPerSample = 100.0 / ((double)(endSampleIndex - startSampleIndex));
-			PIEvent be3 = new PIEvent(be.getValueObject(), PIEvent.SELECTION_AREA_CHANGED3);
-			// get new thread counts and loads
-			Vector<ProfiledGeneric> traceThreads  = trace.getIndexedThreads();
-			Vector<ProfiledGeneric> graphThreads  = this.myGraph.getProfiledThreads();
-			Hashtable<String,String> foundThreads = new Hashtable<String,String>();
-			// previous threads are not necessarily graphed this time
-			Enumeration<ProfiledGeneric> enu = graphThreads.elements();
-			while (enu.hasMoreElements()) {
-				ProfiledThread pThread = (ProfiledThread) enu.nextElement();
-				pThread.setEnabled(graphIndex, false);
-			}
-			graphThreads.clear();
-			ProfiledThreshold thresholdThread = this.myGraph.getThresholdThread();
-			if (thresholdThread.isEnabled(graphIndex)) {
-				ArrayList<ProfiledGeneric> items = thresholdThread.getItems(graphIndex);
-				// disable all items below the threshold
-				for (int i = 0; i < items.size(); i++) {
-					items.get(i).setEnabled(graphIndex, false);
-				}
-			}
-			GppSample[] sortedSamples = trace.getSortedGppSamples();
-			// set up in case we find threads below the threshold
-			boolean lowThread;
-			thresholdThread.init(graphIndex);
-			int threadThreshold = (Integer) NpiInstanceRepository.getInstance().activeUidGetPersistState("com.nokia.carbide.cpp.pi.address.thresholdCountThread"); //$NON-NLS-1$
-			for (int i = startSampleIndex; i < endSampleIndex; i++) {
-				GppSample sample = sortedSamples[i];
-				ProfiledBinary pBinary = (ProfiledBinary) traceBinaries.elementAt(sample.binaryIndex);
-				if (pBinary.isEnabled(graphIndex)) {
-					// thread list is based on binaries
-					ProfiledThread pThread = (ProfiledThread) traceThreads.elementAt(sample.threadIndex);
-					String threadName = pThread.getNameString();
-					lowThread = pThread.getTotalSampleCount() < threadThreshold;
-					if (!foundThreads.containsKey(threadName)) {
-						foundThreads.put(threadName, threadName);
-						if (lowThread) {
-							thresholdThread.addItem(graphIndex, pThread, 1);
-						} else {
-							pThread.setEnabled(graphIndex, true);
-							pThread.setSampleCount(graphIndex, 1);
-							graphThreads.add(pThread);
-						}
-					} else {
-						if (lowThread)
-							thresholdThread.incSampleCount(graphIndex);
-						else
-							pThread.incSampleCount(graphIndex);
-					}
-				}
-			}
-			// set the % load
-			for (int i = 0; i < graphThreads.size(); i++) {
-				ProfiledThread pThread = (ProfiledThread) graphThreads.elementAt(i);
-				pThread.setLoadAndString(graphIndex, (float)(pThread.getSampleCount(graphIndex)*percentPerSample));
-			}
-			thresholdThread.setLoadAndString(graphIndex,
-					(float)(thresholdThread.getSampleCount(graphIndex)*percentPerSample));
 			// update the table items and redraw the table
 			this.myGraph.getThreadTable().piEventReceived(be3);
 		}
 	}
 		if (!(event.getElement() instanceof ProfiledGeneric))
 			return;
 		// set the stored value to the checkbox value
 		ProfiledGeneric pg = (ProfiledGeneric)event.getElement();
-	        pg.setEnabled(myGraph.getGraphIndex(), event.getChecked());
+		pg.setEnabled(myGraph.getGraphIndex(), event.getChecked());
 	        // this table's set of checkbox-selected rows has changed, so propagate that information
 		setSelectedNames();
 		if (   (pg.getSampleCount(myGraph.getGraphIndex()) != 0)
 		quickSort(sortColumn, profiledFunctions);
 	}
 	private class ColumnSelectionHandler extends SelectionAdapter
 	{
+		@Override
 		public void widgetSelected(SelectionEvent e)
 {
 	// wait for the previous sort to finish
 	if (sorting || !(e.widget instanceof TableColumn))
 		return;
 	sortOnColumnSelection((TableColumn) e.widget);
 }
 	}
+	/**
+	 * Adds ProfiledGenerics and threshold items to the table data
+	 * (this.tableItemData and this.profiledThreads). Sorts the ProfiledGenerics
+	 * according to load; and sets the graph's sorted list accordingly. Refreshes
+	 * the TableViewer if parameter setInput is true.
+	 *
+	 * @param setInput
+	 *            if true, reset the TableViewer
+	 */
 	public void updateProfiledAndItemData(boolean setInput)
 	{
 		tableItemData.clear();
 		profiledFunctions.clear();
 			ProfiledFunction nextElement = (ProfiledFunction)enu.nextElement();
 			tableItemData.add(nextElement);
 			profiledFunctions.add(nextElement);
 		}
-		if (myGraph.getThresholdFunction().getItemCount(myGraph.getGraphIndex()) != 0) {
+		if (myGraph.getThresholdFunction().getItemCount() != 0) {
 			tableItemData.add(myGraph.getThresholdFunction());
 			profiledFunctions.add(myGraph.getThresholdFunction());
 		}
 		// now sort the items in increasing total sample count, so that they graph correctly
 		Arrays.sort(sorted, new Comparator<Object>() {
 			public int compare(Object arg0, Object arg1)
 			{
 				if (arg0 instanceof ProfiledGeneric && arg1 instanceof ProfiledGeneric)
-					return ((ProfiledGeneric)arg0).getTotalSampleCount() -
+					return (adapter.getTotalSampleCount((ProfiledGeneric)arg0)) -
-							((ProfiledGeneric)arg1).getTotalSampleCount();
+					adapter.getTotalSampleCount(((ProfiledGeneric)arg1));
-				else
+				return 0;
-					return 0;
 			}
 		});
 		// now create the sorted list used to draw the graph
 		myGraph.getSortedFunctions().clear();
-		if (myGraph.getThresholdFunction().getItemCount(myGraph.getGraphIndex()) != 0)
+		if (myGraph.getThresholdFunction().getItemCount() != 0)
 			myGraph.getSortedFunctions().add(myGraph.getThresholdFunction());
 		for (int i = 0; i < sorted.length; i++)
 			myGraph.getSortedFunctions().add((ProfiledGeneric) sorted[i]);
 		refreshTableViewer();
 		this.sorting = false;
 	}
-	protected Menu getTableMenu(Decorations parent, int graphIndex, int drawMode) {
+	@Override
+	protected Menu getTableMenu(Decorations aParent, int graphIndex, int drawMode) {
 		// get rid of last Menu created so we don't have double menu
 		// in on click
 		if (contextMenu != null) {
 			contextMenu.dispose();
 		}
-		contextMenu = new Menu(parent, SWT.POP_UP);
+		contextMenu = new Menu(aParent, SWT.POP_UP);
 		// Use drawMode to determine the drill down items and
 		// whether to show a color column
 		addDrillDownItems(contextMenu, drawMode);
 		contextMenu.setVisible(true);
 		return contextMenu;
 	}
-	public Vector getTableItemData() {
+	public Vector<ProfiledGeneric> getTableItemData() {
 		return this.tableItemData;
 	}
 }

changeset 5	844b047e260d
parent 2	b9ab3b238396
child 12	ae255c9aa552