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

equal deleted inserted replaced

-:615035072f7e
+:844b047e260d
 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.interfaces.ISaveSamples;
-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;
 	// changes made to support priority plugin
 	private boolean priorityAdded = false;
 	private Hashtable<Integer,String> priorityTable;
 	private Hashtable<Integer,Integer> priorityValues;
-	public AddrThreadTable(GppTraceGraph myGraph, Composite parent)
+	public AddrThreadTable(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)
 		this.tableViewer = CheckboxTableViewer.newCheckList(this.parent,
 				SWT.BORDER | SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL | SWT.FULL_SELECTION);
 		// add the check state handler, label provider and content provider
 		tableViewer.addCheckStateListener(new SharedCheckHandler());
-		tableViewer.setLabelProvider(new shownThreadsLabelProvider());
+		tableViewer.setLabelProvider(new ShownThreadsLabelProvider());
-		tableViewer.setContentProvider(new shownThreadsContentProvider());
+		tableViewer.setContentProvider(new ShownThreadsContentProvider());
 		tableViewer.addSelectionChangedListener(new ISelectionChangedListener() {
 			public void selectionChanged(SelectionChangedEvent arg0) {
 				if (copyAction == null)
 					return;
 		// 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());
 		// thread name column
 		column = new TableColumn(table, SWT.LEFT);
 		column.setText(COLUMN_HEAD_THREAD);
 		column.setWidth(COLUMN_WIDTH_THREAD_NAME);
-		column.setData(new Integer(COLUMN_ID_THREAD));
+		column.setData(Integer.valueOf(COLUMN_ID_THREAD));
 		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());
 		// priority column
 		}
 		table.redraw();
 	}
-	private static class shownThreadsContentProvider implements IStructuredContentProvider {
+	private static class ShownThreadsContentProvider implements IStructuredContentProvider {
-		public shownThreadsContentProvider() {
+		public ShownThreadsContentProvider() {
 			super();
 		}
 		public Object[] getElements(Object inputElement) {
 			return ((Vector) inputElement).toArray();
 		public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
 		}
 	}
-	private class shownThreadsLabelProvider extends LabelProvider implements ITableLabelProvider {
+	private class ShownThreadsLabelProvider extends LabelProvider implements ITableLabelProvider {
-public shownThreadsLabelProvider() {
+public ShownThreadsLabelProvider() {
 			super();
 		}
+		/* (non-Javadoc)
+		 * @see org.eclipse.jface.viewers.ITableLabelProvider#getColumnText(java.lang.Object, int)
+		 */
 		public String getColumnText(Object element, int columnIndex) {
 			int graphIndex = myGraph.getGraphIndex();
 	        int columnId = ((Integer) table.getColumn(columnIndex).getData()).intValue();
 					}
 					case COLUMN_ID_THREAD:
 					{
 						DecimalFormat timeFormat = new DecimalFormat(Messages.getString("AddrThreadTable.decimalFormat")); //$NON-NLS-1$
-						int count = pThreshold.getItemCount(graphIndex);
+						int count = pThreshold.getItemCount();
 						return count + (count > 1 ? Messages.getString("AddrThreadTable.thresholdMsg1") : Messages.getString("AddrThreadTable.thresholdMsg2"))   //$NON-NLS-1$ //$NON-NLS-2$
 								+ timeFormat.format((Double)NpiInstanceRepository.getInstance().activeUidGetPersistState("com.nokia.carbide.cpp.pi.address.thresholdLoadThread") * 100.0) + Messages.getString("AddrThreadTable.thresholdMsg3") //$NON-NLS-1$ //$NON-NLS-2$
 								+ (Integer)NpiInstanceRepository.getInstance().activeUidGetPersistState("com.nokia.carbide.cpp.pi.address.thresholdCountThread") + Messages.getString("AddrThreadTable.thresholdMsg4"); //$NON-NLS-1$ //$NON-NLS-2$
 					}
 					return String.valueOf(profiledItem.getSampleCount(graphIndex));
 				}
 				case COLUMN_ID_PRIORITY:
 			    {
 					if (priorityAdded) {
-				        String priority = priorityTable.get(new Integer(profiledItem.getThreadId()));
+				        String priority = priorityTable.get(Integer.valueOf(profiledItem.getThreadId()));
 				        if (priority == null)
 				        	return Messages.getString("AddrThreadTable.unknownPriority"); //$NON-NLS-1$
 				        else
 				        	return priority;
 					}
 		{
 			// let the function page action handler handle it
 			this.myGraph.getFunctionTable().action(actionString);
 			return;
 		}
-		else if (actionString.equals("changeThresholdThread")) //$NON-NLS-1$
+		else if (actionString.equals(IGppTraceGraph.ACTION_CHANGE_THRESHOLD_THREAD))
 		{
 			ProfiledThreshold threshold = this.myGraph.getThresholdThread();
 			boolean enabled = threshold.isEnabled(graphIndex);
 			this.tableItemData.clear();
 			this.profiledThreads.clear();
 			this.myGraph.getSortedThreads().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.getSortedThreads().add(threshold);
 			int threadThreshold = (Integer) NpiInstanceRepository.getInstance().activeUidGetPersistState("com.nokia.carbide.cpp.pi.address.thresholdCountThread"); //$NON-NLS-1$
 			for (int i = 0; i < this.myGraph.getGppTrace().getSortedThreads().size(); i++) {
 				ProfiledGeneric nextElement = (ProfiledGeneric)this.myGraph.getGppTrace().getSortedThreads().get(i);
-				if (nextElement.getTotalSampleCount() < threadThreshold) {
+				if (adapter.getTotalSampleCount(nextElement) < threadThreshold) {
 					nextElement.setEnabled(graphIndex, enabled);
-					threshold.addItem(graphIndex, nextElement, 0);
+					adapter.addItem(threshold, graphIndex, nextElement, 0);
 				} else {
 					tableItemData.add(nextElement);
 					profiledThreads.add(nextElement);
 					myGraph.getSortedThreads().add(nextElement);
 				}
 			}
-			if (threshold.getItemCount(graphIndex) != 0) {
+			if (threshold.getItemCount() != 0) {
 				tableItemData.add(threshold);
 				profiledThreads.add(threshold);
 			} else {
 				// remove the threshold item
 				myGraph.getSortedThreads().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 thread threshold item
+						// CH: refactor! This could be done via an observer pattern. This class should not have knowledge of all other graphs
 						gppTrace.getGppGraph(PIPageEditor.THREADS_PAGE,   uid).getThresholdThread().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
+							for (int cpu = 0; cpu < gppTrace.getCPUCount(); cpu++) {
+								gppTrace.getGppGraph(3 + 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("AddrThreadTable.threadLoad")); //$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.THREADS) {
-			// set the page's graph title
-			ProfileVisualiser pV =  NpiInstanceRepository.getInstance().getProfilePage(this.myGraph.getUid(), this.myGraph.getGraphIndex());
-			pV.getTitle().setText(Messages.getString("AddrThreadTable.binaryLoad")); //$NON-NLS-1$
-			pV.getTitle2().setText(Messages.getString("AddrThreadTable.threadTo")); //$NON-NLS-1$
 			// set the draw mode before populating table viewers, since the
 			// color column depends on the draw mode
 			this.myGraph.setDrawMode(Defines.THREADS_BINARIES);
 			binaryTable.createTableViewer(Defines.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.setThreadBinary(graphIndex);
+			gppTrace.setThreadBinary(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);
 			this.parent.layout();
 			this.myGraph.repaint();
 		} else if (drawMode == Defines.THREADS_BINARIES_FUNCTIONS) {
-			// set the page's graph title
-			ProfileVisualiser pV =  NpiInstanceRepository.getInstance().getProfilePage(this.myGraph.getUid(), this.myGraph.getGraphIndex());
-			pV.getTitle().setText(Messages.getString("AddrThreadTable.binaryLoad")); //$NON-NLS-1$
-			pV.getTitle2().setText(Messages.getString("AddrThreadTable.threadTo")); //$NON-NLS-1$
 			// get rid of the function table and its sash
 			if (this.myGraph.getRightSash() != null) {
 				this.myGraph.getRightSash().dispose();
 				this.myGraph.setRightSash(null);
 			// get rid of the middle table's connection to the sash
 			try {
 				FormData formData = (FormData) this.myGraph.getBinaryTable().getTable().getLayoutData();
 				formData.right = new FormAttachment(100);
-			} catch (ClassCastException e1) {
+			} catch (ClassCastException e1) { //CH: refactor!  Runtime exceptions should not be caught!
 			}
 			// move the left sash to the middle
 			try {
 				FormData formData = (FormData) this.myGraph.getLeftSash().getLayoutData();
 				formData.left = new FormAttachment(50); // middle
-			} catch (ClassCastException e1) {
+			} catch (ClassCastException e1) { //CH: refactor!  Runtime exceptions should not be caught!
 			}
 			// set the draw mode
 			this.myGraph.setDrawMode(Defines.THREADS_BINARIES);
 			// this case should be drawMode == Defines.THREADS_BINARIES_FUNCTIONS
 			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("AddrThreadTable.functionLoad")); //$NON-NLS-1$
-		pV.getTitle2().setText(Messages.getString("AddrThreadTable.threadToBinaryTo")); //$NON-NLS-1$
 		// set the draw mode before populating table viewers, since the
 		// color column depends on the draw mode
 		this.myGraph.setDrawMode(Defines.THREADS_BINARIES_FUNCTIONS);
 		functionTable.createTableViewer(Defines.THREADS_BINARIES_FUNCTIONS);
 		functionTable.setIsDrilldown(true);
 		// create a reduced set of function entries based on enabled thread and binary entries
 		GppTrace gppTrace = (GppTrace) this.myGraph.getTrace();
-		Vector<ProfiledGeneric> functions = gppTrace.setThreadBinaryFunction(graphIndex);
+		gppTrace.setThreadBinaryFunction(graphIndex, adapter, this.myGraph.getProfiledFunctions());
-		this.myGraph.setProfiledFunctions(functions);
 		// put check marks on all rows, and sort by sample count
 		functionTable.quickSort(COLUMN_ID_SAMPLE_COUNT, this.myGraph.getProfiledFunctions());
 		functionTable.updateProfiledAndItemData(true);
 		functionTable.getTableViewer().setAllChecked(true);
 		}
 		setIsDrilldown(true);
 		if (drawMode == Defines.THREADS) {
-			// set the page's graph title
-			ProfileVisualiser pV =  NpiInstanceRepository.getInstance().getProfilePage(this.myGraph.getUid(), this.myGraph.getGraphIndex());
-			pV.getTitle().setText(Messages.getString("AddrThreadTable.functionLoad")); //$NON-NLS-1$
-			pV.getTitle2().setText(Messages.getString("AddrThreadTable.threadTo")); //$NON-NLS-1$
 			// set the draw mode
 			this.myGraph.setDrawMode(Defines.THREADS_FUNCTIONS);
 			// create the function graph table viewer
 			functionTable.createTableViewer(Defines.THREADS_FUNCTIONS);
 			functionTable.setIsDrilldown(true);
 			// create a reduced set of function entries based on enabled thread and binary entries
 			GppTrace gppTrace = (GppTrace) this.myGraph.getTrace();
-			Vector<ProfiledGeneric> functions = gppTrace.setThreadFunction(graphIndex);
+			gppTrace.setThreadFunction(graphIndex, adapter, this.myGraph.getProfiledFunctions());
-			this.myGraph.setProfiledFunctions(functions);
 			// put check marks on all rows, and sort by sample count
 			functionTable.quickSort(COLUMN_ID_SAMPLE_COUNT, this.myGraph.getProfiledFunctions());
 			functionTable.updateProfiledAndItemData(true);
 			functionTable.getTableViewer().setAllChecked(true);
 			this.parent.layout();
 			this.myGraph.repaint();
 		} else if (drawMode == Defines.THREADS_FUNCTIONS_BINARIES) {
-			// set the page's graph title
-			ProfileVisualiser pV =  NpiInstanceRepository.getInstance().getProfilePage(this.myGraph.getUid(), this.myGraph.getGraphIndex());
-			pV.getTitle().setText(Messages.getString("AddrThreadTable.functionLoad")); //$NON-NLS-1$
-			pV.getTitle2().setText(Messages.getString("AddrThreadTable.threadTo")); //$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("AddrThreadTable.binaryLoad")); //$NON-NLS-1$
-		pV.getTitle2().setText(Messages.getString("AddrThreadTable.threadToFunctionTo")); //$NON-NLS-1$
 		// set the draw mode
 		this.myGraph.setDrawMode(Defines.THREADS_FUNCTIONS_BINARIES);
 		// create the binary graph table viewer
 		AddrBinaryTable binaryTable = this.myGraph.getBinaryTable();
 		binaryTable.createTableViewer(Defines.THREADS_FUNCTIONS_BINARIES);
 		binaryTable.setIsDrilldown(true);
 		// create a reduced set of binary entries based on enabled thread and function entries
 		GppTrace gppTrace = (GppTrace) this.myGraph.getTrace();
-		Vector<ProfiledGeneric> binaries = gppTrace.setThreadFunctionBinary(graphIndex);
+		gppTrace.setThreadFunctionBinary(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.thresholdCountThread"); //$NON-NLS-1$
 				if (thresholdCount > 0) {
 					Vector<ProfiledGeneric> pGeneric = this.myGraph.getProfiledThreads();
 					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.getThresholdThread().setSampleCount(graphIndex, sampleCount);
 				}
 			}
 			int drawMode = this.myGraph.getDrawMode();
 			if (drawMode == Defines.THREADS)
 				return;
 			GppTrace trace = (GppTrace)(this.myGraph.getTrace());
-			Vector<ProfiledGeneric> traceThreads = trace.getIndexedThreads();
-			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.THREADS_BINARIES:
 				{
-					// get new binary counts and loads
+					trace.setThreadBinary(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];
-						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);
 					break;
 				}
 				case Defines.THREADS_BINARIES_FUNCTIONS:
 				{
-					// get new binary and function counts and loads
+					// previous binaries are not necessarily graphed this time - reset
-					Vector<ProfiledGeneric> traceBinaries   = trace.getIndexedBinaries();
+					trace.setThreadBinary(graphIndex, adapter, this.myGraph.getProfiledBinaries());
-					Vector<ProfiledGeneric> traceFunctions  = trace.getIndexedFunctions();
+					// previous functions are not necessarily graphed this time - reset
-					Vector<ProfiledGeneric> graphBinaries   = this.myGraph.getProfiledBinaries();
+					trace.setThreadBinaryFunction(graphIndex, adapter, this.myGraph.getProfiledFunctions());
-					Vector<ProfiledGeneric> graphFunctions  = this.myGraph.getProfiledFunctions();
-					Hashtable<String,String> foundBinaries  = new Hashtable<String,String>();
-					Hashtable<String,String> foundFunctions = new Hashtable<String,String>();
-					// previous functions are not necessarily graphed this time
-					Enumeration<ProfiledGeneric> enuFunctions = graphFunctions.elements();
-					while (enuFunctions.hasMoreElements()) {
-						ProfiledFunction pFunction = (ProfiledFunction) enuFunctions.nextElement();
-						pFunction.setEnabled(graphIndex, false);
-					}
-					graphFunctions.clear();
-					ProfiledThreshold thresholdFunction = this.myGraph.getThresholdFunction();
-					if (thresholdFunction.isEnabled(graphIndex)) {
-						ArrayList<ProfiledGeneric> items = thresholdFunction.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 functions below the threshold
-					boolean lowFunction;
-					thresholdFunction.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];
-						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);
-							}
-							// function list is based on threads and binaries
-							ProfiledFunction pFunction = (ProfiledFunction) traceFunctions.elementAt(sample.functionIndex);
-							String functionName = pFunction.getNameString();
-							lowFunction = pFunction.getTotalSampleCount() < (Integer)NpiInstanceRepository.getInstance().activeUidGetPersistState("com.nokia.carbide.cpp.pi.address.thresholdCountFunction"); //$NON-NLS-1$
-							if (!foundFunctions.containsKey(functionName)) {
-								foundFunctions.put(functionName, functionName);
-								if (lowFunction) {
-									thresholdFunction.addItem(graphIndex, pFunction, 1);
-								} else {
-									pFunction.setEnabled(graphIndex, true);
-									pFunction.setSampleCount(graphIndex, 1);
-									graphFunctions.add(pFunction);
-								}
-							} else {
-								if (lowFunction)
-									thresholdFunction.incSampleCount(graphIndex);
-								else
-									pFunction.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));
-					for (int i = 0; i < graphFunctions.size(); i++) {
-						ProfiledFunction pFunction = (ProfiledFunction) graphFunctions.elementAt(i);
-						pFunction.setLoadAndString(graphIndex, (float)(pFunction.getSampleCount(graphIndex)*percentPerSample));
-					}
-					thresholdFunction.setLoadAndString(graphIndex,
-							(float)(thresholdFunction.getSampleCount(graphIndex)*percentPerSample));
 					// update the table items and redraw the table
 					this.myGraph.getBinaryTable().piEventReceived(be3);
 					this.myGraph.getFunctionTable().piEventReceived(be3);
 					break;
 				}
 				case Defines.THREADS_FUNCTIONS:
 				{
-					// get new function counts and loads
-					Vector<ProfiledGeneric> traceFunctions  = trace.getIndexedFunctions();
-					Vector<ProfiledGeneric> graphFunctions  = this.myGraph.getProfiledFunctions();
-					Hashtable<String,String> foundFunctions = new Hashtable<String,String>();
 					// previous functions are not necessarily graphed this time
-					Enumeration<ProfiledGeneric> enu = graphFunctions.elements();
+					trace.setThreadFunction(graphIndex, adapter, this.myGraph.getProfiledFunctions());
-					while (enu.hasMoreElements()) {
-						ProfiledFunction pFunction = (ProfiledFunction) enu.nextElement();
-						pFunction.setEnabled(graphIndex, false);
-					}
-					graphFunctions.clear();
-					ProfiledThreshold thresholdFunction = this.myGraph.getThresholdFunction();
-					if (thresholdFunction.isEnabled(graphIndex)) {
-						ArrayList<ProfiledGeneric> items = thresholdFunction.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 functions below the threshold
-					boolean lowFunction;
-					thresholdFunction.init(graphIndex);
-					int functionThreshold = (Integer) NpiInstanceRepository.getInstance().activeUidGetPersistState("com.nokia.carbide.cpp.pi.address.thresholdCountFunction"); //$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)) {
-							// function list is based on threads
-							ProfiledFunction pFunction = (ProfiledFunction) traceFunctions.elementAt(sample.functionIndex);
-							String functionName = pFunction.getNameString();
-							lowFunction = pFunction.getTotalSampleCount() < functionThreshold;
-							if (!foundFunctions.containsKey(functionName)) {
-								foundFunctions.put(functionName, functionName);
-								if (lowFunction) {
-									thresholdFunction.addItem(graphIndex, pFunction, 1);
-								} else {
-									pFunction.setEnabled(graphIndex, true);
-									pFunction.setSampleCount(graphIndex, 1);
-									graphFunctions.add(pFunction);
-								}
-							} else {
-								if (lowFunction)
-									thresholdFunction.incSampleCount(graphIndex);
-								else
-									pFunction.incSampleCount(graphIndex);
-							}
-						}
-					}
-					// set the % load
-					for (int i = 0; i < graphFunctions.size(); i++) {
-						ProfiledFunction pFunction = (ProfiledFunction) graphFunctions.elementAt(i);
-						pFunction.setLoadAndString(graphIndex, (float)(pFunction.getSampleCount(graphIndex)*percentPerSample));
-					}
-					thresholdFunction.setLoadAndString(graphIndex,
-							(float)(thresholdFunction.getSampleCount(graphIndex)*percentPerSample));
 					// update the table items and redraw the table
 					this.myGraph.getFunctionTable().piEventReceived(be3);
 					break;
 				}
 				case Defines.THREADS_FUNCTIONS_BINARIES:
 				{
-					// get new function and binary counts and loads
+					// previous functions and binaries are not necessarily graphed this time
-					Vector<ProfiledGeneric> traceBinaries   = trace.getIndexedBinaries();
+					trace.setThreadFunction(graphIndex, adapter, this.myGraph.getProfiledFunctions());
-					Vector<ProfiledGeneric> traceFunctions  = trace.getIndexedFunctions();
+					trace.setThreadFunctionBinary(graphIndex, adapter, this.myGraph.getProfiledBinaries());
-					Vector<ProfiledGeneric> graphBinaries   = this.myGraph.getProfiledBinaries();
-					Vector<ProfiledGeneric> graphFunctions  = this.myGraph.getProfiledFunctions();
-					Hashtable<String,String> foundBinaries  = new Hashtable<String,String>();
-					Hashtable<String,String> foundFunctions = new Hashtable<String,String>();
-					// previous binaries are not necessarily graphed this time
-					Enumeration<ProfiledGeneric> enuBinaries = graphBinaries.elements();
-					while (enuBinaries.hasMoreElements()) {
-						ProfiledBinary pBinary = (ProfiledBinary) enuBinaries.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 functions are not necessarily graphed this time
-					Enumeration<ProfiledGeneric> enuFunctions = graphFunctions.elements();
-					while (enuFunctions.hasMoreElements()) {
-						ProfiledFunction pFunction = (ProfiledFunction) enuFunctions.nextElement();
-						pFunction.setEnabled(graphIndex, false);
-					}
-					graphFunctions.clear();
-					ProfiledThreshold thresholdFunction = this.myGraph.getThresholdFunction();
-					if (thresholdFunction.isEnabled(graphIndex)) {
-						ArrayList<ProfiledGeneric> items = thresholdFunction.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 functions below the threshold
-					boolean lowFunction;
-					thresholdFunction.init(graphIndex);
-					int functionThreshold = (Integer) NpiInstanceRepository.getInstance().activeUidGetPersistState("com.nokia.carbide.cpp.pi.address.thresholdCountFunction"); //$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)) {
-							// function list is based on threads
-							ProfiledFunction pFunction = (ProfiledFunction) traceFunctions.elementAt(sample.functionIndex);
-							String functionName = pFunction.getNameString();
-							lowFunction = pFunction.getTotalSampleCount() < functionThreshold;
-							if (!foundFunctions.containsKey(functionName)) {
-								foundFunctions.put(functionName, functionName);
-								if (lowFunction) {
-									thresholdFunction.addItem(graphIndex, pFunction, 1);
-								} else {
-									pFunction.setEnabled(graphIndex, true);
-									pFunction.setSampleCount(graphIndex, 1);
-									graphFunctions.add(pFunction);
-								}
-							} else {
-								if (lowFunction)
-									thresholdFunction.incSampleCount(graphIndex);
-								else
-									pFunction.incSampleCount(graphIndex);
-							}
-							// binary list is based on threads and functions
-							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 < 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));
-					for (int i = 0; i < graphFunctions.size(); i++) {
-						ProfiledFunction pFunction = (ProfiledFunction) graphFunctions.elementAt(i);
-						pFunction.setLoadAndString(graphIndex, (float)(pFunction.getSampleCount(graphIndex)*percentPerSample));
-					}
-					thresholdFunction.setLoadAndString(graphIndex,
-							(float)(thresholdFunction.getSampleCount(graphIndex)*percentPerSample));
 					// update the table items and redraw the table
 					this.myGraph.getBinaryTable().piEventReceived(be3);
 					this.myGraph.getFunctionTable().piEventReceived(be3);
 					break;
 			// This routine enables all entries in the next table
 			int drawMode = this.myGraph.getDrawMode();
 			if (drawMode != Defines.THREADS_BINARIES_FUNCTIONS)
 				return;
 			// we don't need to redraw the thread 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.setThreadBinaryFunction(graphIndex, adapter, this.myGraph.getProfiledFunctions());
-			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 function counts and loads
-			Vector<ProfiledGeneric> traceFunctions = trace.getIndexedFunctions();
-			Vector<ProfiledGeneric> graphFunctions = this.myGraph.getProfiledFunctions();
-			Hashtable<String,String> foundFunctions = new Hashtable<String,String>();
-			// previous functions are not necessarily graphed this time
-			Enumeration<ProfiledGeneric> enu = graphFunctions.elements();
-			while (enu.hasMoreElements()) {
-				ProfiledFunction pFunction = (ProfiledFunction) enu.nextElement();
-				pFunction.setEnabled(graphIndex, false);
-			}
-			graphFunctions.clear();
-			ProfiledThreshold thresholdFunction = this.myGraph.getThresholdFunction();
-			if (thresholdFunction.isEnabled(graphIndex)) {
-				ArrayList<ProfiledGeneric> items = thresholdFunction.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 functions below the threshold
-			boolean lowFunction;
-			thresholdFunction.init(graphIndex);
-			for (int i = startSampleIndex; i < endSampleIndex; i++) {
-				GppSample sample = sortedSamples[i];
-				ProfiledBinary pBinary = (ProfiledBinary) traceBinaries.elementAt(sample.binaryIndex);
-				if (pBinary.isEnabled(graphIndex)) {
-					// function list is based on binaries
-					ProfiledFunction pFunction = (ProfiledFunction) traceFunctions.elementAt(sample.functionIndex);
-					String functionName = pFunction.getNameString();
-					lowFunction = pFunction.getTotalSampleCount() < (Integer)NpiInstanceRepository.getInstance().activeUidGetPersistState("com.nokia.carbide.cpp.pi.address.thresholdCountFunction"); //$NON-NLS-1$
-					if (!foundFunctions.containsKey(functionName)) {
-						foundFunctions.put(functionName, functionName);
-						if (lowFunction) {
-							thresholdFunction.addItem(graphIndex, pFunction, 1);
-						} else {
-							pFunction.setEnabled(graphIndex, true);
-							pFunction.setSampleCount(graphIndex, 1);
-							graphFunctions.add(pFunction);
-						}
-					} else {
-						if (lowFunction)
-							thresholdFunction.incSampleCount(graphIndex);
-						else
-							pFunction.incSampleCount(graphIndex);
-					}
-				}
-			}
-			// set the % load
-			for (int i = 0; i < graphFunctions.size(); i++) {
-				ProfiledFunction pFunction = (ProfiledFunction) graphFunctions.elementAt(i);
-				pFunction.setLoadAndString(graphIndex, (float)(pFunction.getSampleCount(graphIndex)*percentPerSample));
-			}
-			thresholdFunction.setLoadAndString(graphIndex,
-					(float)(thresholdFunction.getSampleCount(graphIndex)*percentPerSample));
 			// update the table items and redraw the table
 			this.myGraph.getFunctionTable().piEventReceived(be3);
 		}
 		else if (be.getType() == PIEvent.CHANGED_FUNCTION_TABLE)
 			int drawMode = this.myGraph.getDrawMode();
 			if (drawMode != Defines.THREADS_FUNCTIONS_BINARIES)
 				return;
 			// we don't need to redraw the thread table, since it has not changed
+			PIEvent be3 = new PIEvent(be.getValueObject(), PIEvent.SELECTION_AREA_CHANGED3);
 			GppTrace trace = (GppTrace)(this.myGraph.getTrace());
-			Vector<ProfiledGeneric> traceFunctions = trace.getIndexedFunctions();
 			int graphIndex = this.myGraph.getGraphIndex();
-			int startSampleIndex = trace.getStartSampleIndex();
+			trace.setThreadFunctionBinary(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 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];
-				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);
 		}
 	}
-	public void setSelectedNames()
+	/**
+	 * this table's set of checkbox-selected rows has changed, so propagate that information
+	 */
+	private void setSelectedNames()
 	{
 		Object[] selectedValues = this.tableViewer.getCheckedElements();
 String[] threadNames = new String[selectedValues.length];
 for (int i = 0; i < selectedValues.length; i++)
 			quickSort(sortColumn, profiledThreads);
 	}
 	private class ColumnSelectionHandler extends SelectionAdapter
 	{
+		/* (non-Javadoc)
+		 * @see org.eclipse.swt.events.SelectionAdapter#widgetSelected(org.eclipse.swt.events.SelectionEvent)
+		 */
+		@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();
 		profiledThreads.clear();
 			ProfiledThread nextElement = (ProfiledThread)enu.nextElement();
 			tableItemData.add(nextElement);
 			profiledThreads.add(nextElement);
 		}
-		if (myGraph.getThresholdThread().getItemCount(myGraph.getGraphIndex()) != 0) {
+		if (myGraph.getThresholdThread().getItemCount() != 0) {
 			tableItemData.add(myGraph.getThresholdThread());
 			profiledThreads.add(myGraph.getThresholdThread());
 		}
 		// 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.getSortedThreads().clear();
-		if (myGraph.getThresholdThread().getItemCount(myGraph.getGraphIndex()) != 0)
+		if (myGraph.getThresholdThread().getItemCount() != 0)
 			myGraph.getSortedThreads().add(myGraph.getThresholdThread());
 		for (int i = 0; i < sorted.length; i++)
 			myGraph.getSortedThreads().add((ProfiledGeneric) sorted[i]);
 		if (profiled.size() == 0)
 			return;
 		this.sorting = true;
+		//if the last element is a threshold element - remove it
 		ProfiledGeneric pGeneric = profiled.elementAt(profiled.size() - 1);
 		if (pGeneric instanceof ProfiledThreshold) {
 			profiled.removeElementAt(profiled.size() - 1);
 		}
 		saveSamplesItem.setText(Messages.getString("AddrThreadTable.savePrioritySamples")); //$NON-NLS-1$
 		saveSamplesItem.setEnabled(enabled);
 		if (enabled) {
 			saveSamplesItem.addSelectionListener(new SelectionAdapter() {
+				@Override
 				public void widgetSelected(SelectionEvent e) {
 					action("savePrioritySamples"); //$NON-NLS-1$
 				}
 			});
 		}
 		return saveSamplesItem;
 	}
+	@Override
 	protected Menu getTableMenu(Decorations parent, int graphIndex, int drawMode) {
 		// get rid of last Menu created so we don't have double menu
 		// in on click
 		if (contextMenu != null) {
 	{
 		TableColumn column;
 		column = new TableColumn(tableViewer.getTable(), SWT.LEFT);
 		column.setText(COLUMN_HEAD_PRIORITY);
 		column.setWidth(COLUMN_WIDTH_PRIORITY);
-		column.setData(new Integer(COLUMN_ID_PRIORITY));
+		column.setData(Integer.valueOf(COLUMN_ID_PRIORITY));
 		column.setMoveable(true);
 		column.setResizable(true);
 		column.addSelectionListener(new ColumnSelectionHandler());
 	}
 	private Integer parsePriorityValue(String priorityString)
 	{
 		if (priorityString == null || priorityString.equals(Messages.getString("AddrThreadTable.unsolvedPriority"))) //$NON-NLS-1$
-			return new Integer(Integer.MIN_VALUE);
+			return Integer.MIN_VALUE;
 		else
 		{
 			int endIndex = priorityString.indexOf(Messages.getString("AddrThreadTable.priorityStringEnding")); //$NON-NLS-1$
 			int beginIndex = priorityString.indexOf(Messages.getString("AddrThreadTable.priorityStringStart")); //$NON-NLS-1$
 			String value = priorityString.substring(beginIndex+2, endIndex);
-			return new Integer(Integer.parseInt(value));
+			return Integer.parseInt(value);
 		}
 	}
-// class to pass sample data to the save wizard
+/** class to pass sample data to the save wizard */
 public class SavePrioritySampleString implements ISaveSamples {
 	int graphIndex;
 	int drawMode;
 	boolean done = false;
+	/**
+	 * Constructor
+	 * @param graphIndex
+	 * @param drawMode
+	 */
 	public SavePrioritySampleString(int graphIndex, int drawMode) {
 		this.graphIndex = graphIndex;
 		this.drawMode   = drawMode;
 		}
+	/* (non-Javadoc)
+	 * @see com.nokia.carbide.cpp.internal.pi.interfaces.ISaveSamples#getData()
+	 */
 	public String getData() {
 		if (done)
 			return null;
 			String returnString = getPrioritySampleString(graphIndex, drawMode);
 		public String getData(int size) {
 			return getData();
 		}
+		/* (non-Javadoc)
+		 * @see com.nokia.carbide.cpp.internal.pi.interfaces.ISaveSamples#getIndex()
+		 */
 		public int getIndex() {
 			return done ? 1 : 0;
 		}
+		/* (non-Javadoc)
+		 * @see com.nokia.carbide.cpp.internal.pi.interfaces.ISaveSamples#clear()
+		 */
 		public void clear() {
 			done = false;
 		}
 }
 }
 protected void createPrioritySample(ArrayList<PrioritySample> prioritySamples, int graphIndex, ProfiledThread pt, int startTime, int endTime) {
 	PrioritySample localSample = null;
 	boolean addedLocalSample = false;
-	String priority = priorityTable.get(new Integer(pt.getThreadId()));
+	String priority = priorityTable.get(Integer.valueOf(pt.getThreadId()));
 		if (priority == null) {
 			prioritySamples.add(new PrioritySample(0, pt, Messages.getString("AddrThreadTable.unknownPriority"))); //$NON-NLS-1$
 			return;
 		}
 				pt = (ProfiledThread) profiledThreads.get(i);
 				createPrioritySample(prioritySamples, graphIndex, pt, startIndex, endIndex);
 			} else if (profiledThreads.get(i) instanceof ProfiledThreshold) {
 				ProfiledThreshold pth = (ProfiledThreshold) profiledThreads.get(i);
-				for (int j = 0; j < pth.getItems(graphIndex).size(); j++) {
+				for (int j = 0; j < pth.getItems().size(); j++) {
-					pt = (ProfiledThread) pth.getItems(graphIndex).get(j);
+					pt = (ProfiledThread) pth.getItems().get(j);
 					if (pt.isEnabled(graphIndex) && pt.getSampleCount(graphIndex) > 0)
 						createPrioritySample(prioritySamples, graphIndex, pt, startIndex, endIndex);
 				}
 			}
 								+ sample.priorityString + "\n";  //$NON-NLS-1$ //$NON-NLS-2$
 			}
 		return returnString;
 	}
 }

changeset 5	844b047e260d
parent 2	b9ab3b238396
child 12	ae255c9aa552