1 /*

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

     3  * All rights reserved.

     4  * This component and the accompanying materials are made available

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

     6  * which accompanies this distribution, and is available

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

     8  *

     9  * Initial Contributors:

    10  * Nokia Corporation - initial contribution.

    11  *

    12  * Contributors:

    13  *

    14  * Description: 

    15  *

    16  */

    17 

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

    19 

    20 import java.awt.Toolkit;

    21 import java.awt.datatransfer.Clipboard;

    22 import java.awt.datatransfer.StringSelection;

    23 import java.awt.event.FocusEvent;

    24 import java.text.DecimalFormat;

    25 import java.util.ArrayList;

    26 import java.util.Arrays;

    27 import java.util.Collections;

    28 import java.util.Comparator;

    29 import java.util.Enumeration;

    30 import java.util.Hashtable;

    31 import java.util.Vector;

    32 

    33 import org.eclipse.jface.viewers.CheckStateChangedEvent;

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

    35 import org.eclipse.jface.viewers.ICheckStateListener;

    36 import org.eclipse.jface.viewers.ISelectionChangedListener;

    37 import org.eclipse.jface.viewers.IStructuredContentProvider;

    38 import org.eclipse.jface.viewers.ITableLabelProvider;

    39 import org.eclipse.jface.viewers.LabelProvider;

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

    41 import org.eclipse.jface.viewers.Viewer;

    42 import org.eclipse.swt.SWT;

    43 import org.eclipse.swt.events.SelectionAdapter;

    44 import org.eclipse.swt.events.SelectionEvent;

    45 import org.eclipse.swt.graphics.Color;

    46 import org.eclipse.swt.graphics.Image;

    47 import org.eclipse.swt.layout.FormAttachment;

    48 import org.eclipse.swt.layout.FormData;

    49 import org.eclipse.swt.layout.FormLayout;

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

    51 import org.eclipse.swt.widgets.Decorations;

    52 import org.eclipse.swt.widgets.Display;

    53 import org.eclipse.swt.widgets.Event;

    54 import org.eclipse.swt.widgets.Listener;

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

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

    57 import org.eclipse.swt.widgets.Sash;

    58 import org.eclipse.swt.widgets.Table;

    59 import org.eclipse.swt.widgets.TableColumn;

    60 import org.eclipse.swt.widgets.TableItem;

    61 

    62 import com.nokia.carbide.cpp.internal.pi.analyser.NpiInstanceRepository;

    63 import com.nokia.carbide.cpp.internal.pi.analyser.ProfileVisualiser;

    64 import com.nokia.carbide.cpp.internal.pi.interfaces.ISaveSamples;

    65 import com.nokia.carbide.cpp.internal.pi.model.ProfiledBinary;

    66 import com.nokia.carbide.cpp.internal.pi.model.ProfiledFunction;

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

    68 import com.nokia.carbide.cpp.internal.pi.model.ProfiledThread;

    69 import com.nokia.carbide.cpp.internal.pi.model.ProfiledThreshold;

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

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

    72 import com.nokia.carbide.cpp.internal.pi.visual.PIVisualSharedData;

    73 import com.nokia.carbide.cpp.pi.editors.PIPageEditor;

    74 import com.nokia.carbide.cpp.pi.util.TableColorPalette;

    75 

    76 

    77 public class AddrThreadTable extends GenericAddrTable

    78 {

    79 	// local copy of profiled threads, which we can sort

    80 	// without affecting the original

    81 	Vector<ProfiledGeneric> profiledThreads = new Vector<ProfiledGeneric>();

    82 

    83 	// changes made to support priority plugin

    84 	private boolean priorityAdded = false;

    85 	private Hashtable<Integer,String> priorityTable;

    86 	private Hashtable<Integer,Integer> priorityValues;

    87 

    88 	public AddrThreadTable(GppTraceGraph myGraph, Composite parent)

    89 	{

    90 		this.myGraph = myGraph;

    91 		this.parent  = parent;

    92 	}

    93 

    94 	public void createTableViewer(int drawMode)

    95 	{

    96 		if (this.parent == null)

    97 			return;

    98 

    99 		// Thread table:

   100 		//		checkbox + colored or white background

   101 		//  	percent load

   102 		//  	thread name

   103 		//		sample count

   104 		//		priority (optional)

   105 

   106 		// Check the drawMode, and use it to decide whether or not to show a color column

   107 		// or the number of samples

   108 		switch (drawMode)

   109 		{

   110 			case Defines.THREADS:

   111 			case Defines.BINARIES_THREADS:

   112 			case Defines.BINARIES_FUNCTIONS_THREADS:

   113 			case Defines.FUNCTIONS_THREADS:

   114 			case Defines.FUNCTIONS_BINARIES_THREADS:

   115 			case Defines.THREADS_FUNCTIONS:

   116 			case Defines.THREADS_FUNCTIONS_BINARIES:

   117 			case Defines.THREADS_BINARIES:

   118 			case Defines.THREADS_BINARIES_FUNCTIONS:

   119 			case Defines.BINARIES_THREADS_FUNCTIONS:

   120 			case Defines.FUNCTIONS_THREADS_BINARIES:

   121 			{

   122 				break;

   123 			}

   124 			default:

   125 				// no thread table in this draw mode

   126 				return;

   127 		}

   128 

   129 		// create the table viewer

   130 		this.tableViewer = CheckboxTableViewer.newCheckList(this.parent,

   131   				SWT.BORDER | SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL | SWT.FULL_SELECTION);

   132 

   133 		// add the check state handler, label provider and content provider

   134 		tableViewer.addCheckStateListener(new SharedCheckHandler());

   135 		tableViewer.setLabelProvider(new shownThreadsLabelProvider());

   136 		tableViewer.setContentProvider(new shownThreadsContentProvider());

   137 		tableViewer.addSelectionChangedListener(new ISelectionChangedListener() {

   138 			public void selectionChanged(SelectionChangedEvent arg0) {

   139 				if (copyAction == null)

   140 					return;

   141 

   142 				// when selection changes, the ability to copy may change

   143 				copyAction.setEnabled(table.getSelectionCount() > 0);

   144 				PIPageEditor.getActionBars().updateActionBars();

   145 			}

   146 		});

   147 

   148 		createDefaultActions();

   149 		

   150 		// make sure the table viewer has a sorter

   151 		if (this.sorter == null)

   152 			this.sorter = new GppTableSorter();

   153 

   154 		this.table = tableViewer.getTable();

   155 		this.table.setRedraw(false);

   156 

   157 		// give the table a heading for use in copying and exported

   158 		this.table.setData(Messages.getString("AddrThreadTable.threads")); //$NON-NLS-1$

   159 		

   160 		// create the columns

   161 		TableColumn column;

   162 

   163 		// data associated with the TableViewer will note which columns contain hex values

   164 		// Keep this in the order in which columns have been created

   165 		// Includes the priority column

   166 		boolean[] isHex = {false, false, false, false, false};

   167 		this.table.setData("isHex", isHex); //$NON-NLS-1$

   168 

   169 		// select/deselect column

   170 		column = new TableColumn(table, SWT.CENTER);

   171 		column.setText(COLUMN_HEAD_SHOW);

   172 		column.setWidth(COLUMN_WIDTH_SHOW);

   173 		column.setData(new Integer(COLUMN_ID_SHOW));

   174 		column.setMoveable(true);

   175 		column.setResizable(true);

   176 		column.addSelectionListener(new ColumnSelectionHandler());

   177 

   178 		// percent load column

   179 		column = new TableColumn(table, SWT.RIGHT);

   180 		column.setText(COLUMN_HEAD_PERCENT_LOAD);

   181 		column.setWidth(COLUMN_WIDTH_PERCENT_LOAD);

   182 		column.setData(new Integer(COLUMN_ID_PERCENT_LOAD));

   183 		column.setMoveable(true);

   184 		column.setResizable(true);

   185 		column.addSelectionListener(new ColumnSelectionHandler());

   186 

   187 		// thread name column

   188 		column = new TableColumn(table, SWT.LEFT);

   189 		column.setText(COLUMN_HEAD_THREAD);

   190 		column.setWidth(COLUMN_WIDTH_THREAD_NAME);

   191 		column.setData(new Integer(COLUMN_ID_THREAD));

   192 		column.setMoveable(true);

   193 		column.setResizable(true);

   194 		column.addSelectionListener(new ColumnSelectionHandler());

   195 

   196 		// sample count column

   197 		column = new TableColumn(table, SWT.CENTER);

   198 		column.setText(COLUMN_HEAD_SAMPLE_COUNT);

   199 		column.setWidth(COLUMN_WIDTH_SAMPLE_COUNT);

   200 		column.setData(new Integer(COLUMN_ID_SAMPLE_COUNT));

   201 		column.setMoveable(true);

   202 		column.setResizable(true);

   203 		column.addSelectionListener(new ColumnSelectionHandler());

   204 

   205 		// priority column

   206 		if (priorityAdded)

   207 			this.addPriorityColumn();

   208 

   209 		// listen for mouse clicks: to select a row, pop up a menu, etc.

   210 		table.addMouseListener(new TableMouseListener());

   211 

   212 		// listen for key sequences such as Ctrl-A and Ctrl-C

   213 		table.addKeyListener(new TableKeyListener());

   214 		

   215 		table.addFocusListener(new AddrTableFocusListener());

   216 		

   217 		// add form data in case later we add a sash to the right

   218 		FormData viewerData = new FormData();

   219 		viewerData.top    = new FormAttachment(0);

   220 		viewerData.bottom = new FormAttachment(100);

   221 		viewerData.left   = new FormAttachment(0);

   222 		viewerData.right  = new FormAttachment(100);

   223 		table.setLayoutData(viewerData);

   224 		table.setLayout(new FormLayout());

   225 

   226 		table.setHeaderVisible(true);

   227 		table.setLinesVisible(true);

   228 		table.setRedraw(true);

   229 	}

   230 

   231 	public void setTableViewer(CheckboxTableViewer tableViewer)

   232 	{

   233 		this.tableViewer = tableViewer;

   234 

   235 		if (tableViewer == null)

   236 			this.table = null;

   237 	}

   238 

   239 	public void setTableViewer(int drawMode)

   240 	{

   241 		if (this.parent == null)

   242 			return;

   243 

   244 		createTableViewer(drawMode);

   245 

   246 		// sort by percent load

   247 		this.sortColumn = COLUMN_ID_SAMPLE_COUNT;

   248 		this.sortAscending = false;

   249 

   250 		// profiledThreads and tableItemData contain one entry per table row

   251 		updateProfiledAndItemData(false);

   252 		quickSort(sortColumn, profiledThreads);

   253 

   254 		// initially, all rows are checked

   255 		this.tableViewer.setAllChecked(true);

   256 	}

   257 

   258 	public void refreshTableViewer()

   259 	{

   260 		if (this.tableViewer == null)

   261 			return;

   262 

   263 		this.tableViewer.setInput(tableItemData);

   264 		

   265 		addColor(this.myGraph.getDrawMode());

   266 	}

   267 	

   268 	public void addColor(int drawMode)

   269 	{

   270 		if (this.tableViewer == null)

   271 			return;

   272 

   273 		// make sure that this table's colors are being shown

   274 		if (   (drawMode != Defines.THREADS)

   275 			&& (drawMode != Defines.BINARIES_THREADS)

   276 			&& (drawMode != Defines.BINARIES_FUNCTIONS_THREADS)

   277 			&& (drawMode != Defines.FUNCTIONS_THREADS)

   278 			&& (drawMode != Defines.FUNCTIONS_BINARIES_THREADS))

   279 			return;

   280 

   281 		ProfiledGeneric pGeneric;

   282 

   283 		TableItem[] items = this.table.getItems();

   284 

   285 		for (int i = 0; i < items.length; i++) {

   286 			pGeneric = (ProfiledGeneric) items[i].getData();

   287 //			Color color = ((GppTrace)this.myGraph.getTrace()).getThreadColorPalette().getColor(pGeneric.getNameString());

   288 			items[i].setBackground(COLOR_COLUMN_INDEX, pGeneric.getColor());

   289 		}

   290 

   291 		table.redraw();

   292 	}

   293 	

   294 	public void removeColor(int drawMode)

   295 	{

   296 		if (this.tableViewer == null)

   297 			return;

   298 

   299 		// make sure that this table's colors should not be shown

   300 		if (   (drawMode == Defines.THREADS)

   301 			|| (drawMode == Defines.BINARIES_THREADS)

   302 			|| (drawMode == Defines.BINARIES_FUNCTIONS_THREADS)

   303 			|| (drawMode == Defines.FUNCTIONS_THREADS)

   304 			|| (drawMode == Defines.FUNCTIONS_BINARIES_THREADS))

   305 			return;

   306 

   307 		TableItem[] items = this.table.getItems();

   308 

   309 		for (int i = 0; i < items.length; i++) {

   310 			items[i].setBackground(COLOR_COLUMN_INDEX, this.parent.getDisplay().getSystemColor(SWT.COLOR_WHITE));

   311 		}

   312 

   313 		table.redraw();

   314 	}

   315 

   316 	private static class shownThreadsContentProvider implements IStructuredContentProvider {

   317 

   318 		public shownThreadsContentProvider() {

   319 			super();

   320 		}

   321 

   322 		public Object[] getElements(Object inputElement) {

   323 			return ((Vector) inputElement).toArray();

   324 		}

   325 

   326 		public void dispose() {

   327 		}

   328 

   329 		public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {

   330 		}

   331 	}

   332 

   333 	private class shownThreadsLabelProvider extends LabelProvider implements ITableLabelProvider {

   334 

   335         public shownThreadsLabelProvider() {

   336 			super();

   337 		}

   338 

   339 		public String getColumnText(Object element, int columnIndex) {

   340 

   341 			int graphIndex = myGraph.getGraphIndex();

   342 	        int columnId = ((Integer) table.getColumn(columnIndex).getData()).intValue();

   343 

   344 			if (element instanceof ProfiledThreshold) {

   345 				ProfiledThreshold pThreshold = (ProfiledThreshold) element;

   346 

   347 				switch (columnId)

   348 				{

   349 					case COLUMN_ID_SHOW:

   350 					{

   351 						return SHOW_ITEM_VALUE;

   352 					}

   353 					case COLUMN_ID_PERCENT_LOAD:

   354 					{

   355 						// Percent load string

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

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

   358 						if (   (startTime == -1)

   359 							|| (endTime   == -1)

   360 							|| (startTime == endTime)) {

   361 							pThreshold.setAverageLoadValueString(graphIndex, ""); //$NON-NLS-1$

   362 						} else {

   363 							float load = (float) (pThreshold.getSampleCount(graphIndex)/(endTime - startTime)/10.0);

   364 							

   365 							if (load < 0.005)

   366 								pThreshold.setAverageLoadValueString(graphIndex, Messages.getString("AddrThreadTable.zeroFormat")); //$NON-NLS-1$

   367 							else

   368 								pThreshold.setAverageLoadValueString(graphIndex, load);

   369 						}

   370 						return pThreshold.getAverageLoadValueString(graphIndex);

   371 					}

   372 					case COLUMN_ID_THREAD:

   373 					{

   374 						DecimalFormat timeFormat = new DecimalFormat(Messages.getString("AddrThreadTable.decimalFormat")); //$NON-NLS-1$

   375 

   376 						int count = pThreshold.getItemCount(graphIndex);

   377 

   378 						return count + (count > 1 ? Messages.getString("AddrThreadTable.thresholdMsg1") : Messages.getString("AddrThreadTable.thresholdMsg2"))   //$NON-NLS-1$ //$NON-NLS-2$

   379 								+ 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$ 

   380 								+ (Integer)NpiInstanceRepository.getInstance().activeUidGetPersistState("com.nokia.carbide.cpp.pi.address.thresholdCountThread") + Messages.getString("AddrThreadTable.thresholdMsg4"); //$NON-NLS-1$ //$NON-NLS-2$ 

   381 					}

   382 					case COLUMN_ID_SAMPLE_COUNT:

   383 					{

   384 						// Sample count

   385 						return String.valueOf(pThreshold.getSampleCount(graphIndex));

   386 					}

   387 					default:

   388 					{

   389 						return ""; //$NON-NLS-1$

   390 					}

   391 				}

   392 			}

   393 

   394 			if (!(element instanceof ProfiledThread))

   395 				return ""; //$NON-NLS-1$

   396 

   397 			ProfiledThread profiledItem = (ProfiledThread) element;

   398 

   399 			switch (columnId)

   400 			{

   401 				case COLUMN_ID_SHOW:

   402 				{

   403 					return SHOW_ITEM_VALUE;

   404 				}

   405 				case COLUMN_ID_PERCENT_LOAD:

   406 				{

   407 					// Percent load string

   408 					return profiledItem.getAverageLoadValueString(graphIndex);

   409 				}

   410 				case COLUMN_ID_THREAD:

   411 				{

   412 					// Thread

   413 					if (profiledItem.getNameString().startsWith("*Native*")) //$NON-NLS-1$

   414 						return Messages.getString("AddrThreadTable.NOSthreads"); //$NON-NLS-1$

   415 					else

   416 						return profiledItem.getNameString();

   417 				}

   418 				case COLUMN_ID_SAMPLE_COUNT:

   419 				{

   420 					// Sample count

   421 					return String.valueOf(profiledItem.getSampleCount(graphIndex));

   422 				}

   423 				case COLUMN_ID_PRIORITY:

   424 			    {

   425 					if (priorityAdded) {

   426 				        String priority = priorityTable.get(new Integer(profiledItem.getThreadId()));

   427 				        if (priority == null)

   428 				        	return Messages.getString("AddrThreadTable.unknownPriority"); //$NON-NLS-1$

   429 				        else

   430 				        	return priority;

   431 					}

   432 					return ""; //$NON-NLS-1$

   433 			    }

   434 				default:

   435 				{

   436 					break;

   437 				}

   438 			}

   439 			// should never get here

   440 			return ""; //$NON-NLS-1$

   441 		}

   442 

   443 		public Image getColumnImage(Object element, int columnIndex) {

   444 			return null;

   445 		}

   446 	}

   447 

   448     public void action(String actionString)

   449 	{

   450 		int graphIndex = this.myGraph.getGraphIndex();

   451 

   452 		if (   actionString.equals("add") //$NON-NLS-1$

   453 			|| actionString.equals("remove")) //$NON-NLS-1$

   454 	    {

   455 			actionAddRemove(actionString, graphIndex);

   456 			return;

   457 	    }

   458 		else if (   actionString.equals("addall") //$NON-NLS-1$

   459 				 || actionString.equals("removeall")) //$NON-NLS-1$

   460 	    {

   461 			actionAddRemoveAll(actionString, graphIndex);

   462 			return;

   463 	    }

   464 		else if (actionString.equals("recolor")) //$NON-NLS-1$

   465 		{

   466 			actionRecolor();

   467 			return;

   468 		}

   469 	    else if (actionString.equals("copy")) //$NON-NLS-1$

   470 	    {

   471 	    	actionCopyOrSave(true, this.table, CHECKBOX_NO_TEXT, false, "\t", "\n"); //$NON-NLS-1$ //$NON-NLS-2$

   472 	        return;

   473 	    }

   474 	    else if (actionString.equals("copyTable")) //$NON-NLS-1$

   475 	    {

   476 	    	actionCopyOrSave(true, this.table, CHECKBOX_NO_TEXT, true, "\t", "\n"); //$NON-NLS-1$ //$NON-NLS-2$

   477 	        return;

   478 	    }

   479 	    else if (actionString.equals("copyDrilldown")) //$NON-NLS-1$

   480 	    {

   481 	    	actionCopyOrSaveDrilldown(true, "\t"); //$NON-NLS-1$

   482 	        return;

   483 	    }

   484 	    else if (actionString.equals("saveTable")) //$NON-NLS-1$

   485 	    {

   486 	    	actionCopyOrSave(false, this.table, CHECKBOX_NO_TEXT, true, ",", "\n"); //$NON-NLS-1$ //$NON-NLS-2$

   487 	        return;

   488 	    }

   489 	    else if (actionString.equals("saveDrilldown")) //$NON-NLS-1$

   490 	    {

   491 	    	actionCopyOrSaveDrilldown(false, ","); //$NON-NLS-1$

   492 	        return;

   493 	    }

   494 	    else if (actionString.equals("saveSamples")) //$NON-NLS-1$

   495 	    {

   496 	    	SaveSampleString saveSampleString = new SaveSampleString(graphIndex, myGraph.getDrawMode());

   497 	    	actionSaveSamples(saveSampleString); //$NON-NLS-1$

   498 	        return;

   499 	    }

   500 	    else if (actionString.equals("savePrioritySamples")) //$NON-NLS-1$

   501 	    {

   502 	    	SavePrioritySampleString saveSampleString = new SavePrioritySampleString(graphIndex, myGraph.getDrawMode());

   503 	    	actionSaveSamples(saveSampleString); //$NON-NLS-1$

   504 	        return;

   505 	    }

   506 		else if (actionString.equals("selectAll")) //$NON-NLS-1$

   507 	    {

   508 	    	actionSelectAll();

   509 	        return;

   510 	    }

   511 		else if (actionString.equals("doubleClick")) //$NON-NLS-1$

   512 	    {

   513 	    	copyAction.setEnabled(false);

   514 			PIPageEditor.getActionBars().updateActionBars();

   515 	        return;

   516 	    }

   517 		else if (actionString.equals("thread-only")) //$NON-NLS-1$

   518 		{

   519 			actionThread();

   520 			return;

   521 		}

   522 		else if (actionString.equals("thread-binary")) //$NON-NLS-1$

   523 		{

   524 			actionThreadBinary();

   525 			return;

   526 		}

   527 		else if (actionString.equals("thread-binary-function")) //$NON-NLS-1$

   528 		{

   529 			actionThreadBinaryFunction();

   530 			return;

   531 		}

   532 		else if (actionString.equals("thread-function")) //$NON-NLS-1$

   533 		{

   534 			actionThreadFunction();

   535 			return;

   536 		}

   537 		else if (actionString.equals("thread-function-binary")) //$NON-NLS-1$

   538 		{

   539 			actionThreadFunctionBinary();

   540 			return;

   541 		}

   542 		else if (   (actionString.equals("binary-only")) //$NON-NLS-1$

   543 				 || (actionString.equals("binary-thread")) //$NON-NLS-1$

   544 				 || (actionString.equals("binary-thread-function")) //$NON-NLS-1$

   545 				 || (actionString.equals("binary-function")) //$NON-NLS-1$

   546 				 || (actionString.equals("binary-function-thread"))) //$NON-NLS-1$

   547 		{

   548 			// let the binary page action handler handle it

   549 			this.myGraph.getBinaryTable().action(actionString);

   550 			return;

   551 		}

   552 		else if (   (actionString.equals("function-only")) //$NON-NLS-1$

   553 				 || (actionString.equals("function-thread")) //$NON-NLS-1$

   554 				 || (actionString.equals("function-thread-binary")) //$NON-NLS-1$

   555 				 || (actionString.equals("function-binary")) //$NON-NLS-1$

   556 				 || (actionString.equals("function-binary-thread"))) //$NON-NLS-1$

   557 		{

   558 			// let the function page action handler handle it

   559 			this.myGraph.getFunctionTable().action(actionString);

   560 			return;

   561 		}

   562 		else if (actionString.equals("changeThresholdThread")) //$NON-NLS-1$

   563 		{

   564 			ProfiledThreshold threshold = this.myGraph.getThresholdThread();

   565 			boolean enabled = threshold.isEnabled(graphIndex);

   566 

   567 			this.tableItemData.clear();

   568 			this.profiledThreads.clear();

   569 			this.myGraph.getSortedThreads().clear();

   570 			if (threshold.getItems(graphIndex) != null)

   571 				threshold.getItems(graphIndex).clear();

   572 			threshold.initAll();

   573 

   574 			// if this appears, it needs to be the first item, so that it is drawn at the bottom

   575 			myGraph.getSortedThreads().add(threshold);

   576 

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

   578 			for (int i = 0; i < this.myGraph.getGppTrace().getSortedThreads().size(); i++) {

   579 				ProfiledGeneric nextElement = (ProfiledGeneric)this.myGraph.getGppTrace().getSortedThreads().get(i);

   580 				if (nextElement.getTotalSampleCount() < threadThreshold) {

   581 					nextElement.setEnabled(graphIndex, enabled);

   582 					threshold.addItem(graphIndex, nextElement, 0);

   583 				} else {

   584 					tableItemData.add(nextElement);

   585 					profiledThreads.add(nextElement);

   586 					myGraph.getSortedThreads().add(nextElement);

   587 				}

   588 			}

   589 

   590 			if (threshold.getItemCount(graphIndex) != 0) {

   591 				tableItemData.add(threshold);

   592 				profiledThreads.add(threshold);

   593 			} else {

   594 				// remove the threshold item

   595 				myGraph.getSortedThreads().remove(0);

   596 			}

   597 			

   598 			refreshTableViewer();

   599 			threshold.setEnabled(graphIndex, enabled);

   600 			

   601 			// make sure that checkboxes shown reflect the actual enabled values

   602 			TableItem[] tableItems = this.table.getItems();

   603 			for (int i = 0; i < tableItems.length; i++) {

   604 				if (tableItems[i].getData() instanceof ProfiledGeneric) {

   605 					ProfiledGeneric pGeneric = (ProfiledGeneric) tableItems[i].getData();

   606 					if (tableItems[i].getChecked() != pGeneric.isEnabled(graphIndex))

   607 						tableItems[i].setChecked(pGeneric.isEnabled(graphIndex));

   608 				}

   609 			}

   610 

   611 			this.myGraph.genericRefreshCumulativeThreadTable();

   612 		}

   613 	    else if (actionString.equals("saveTableTest")) //$NON-NLS-1$

   614 	    {

   615 			// copy save file contents to the clipboard for easy viewing

   616 	        Clipboard cb = Toolkit.getDefaultToolkit().getSystemClipboard();

   617 			SaveTableString getString = new SaveTableString(this.table, CHECKBOX_NO_TEXT, ",", "\n"); //$NON-NLS-1$ //$NON-NLS-2$

   618 	        String copyString = getString.getData();

   619 			StringSelection contents = new StringSelection(copyString);

   620 	        cb.setContents(contents, contents);

   621 	        return;

   622 	    }

   623 	    else if (actionString.equals("saveDrilldownTest")) //$NON-NLS-1$

   624 	    {

   625 			// copy save file contents to the clipboard for easy viewing

   626 	        Clipboard cb = Toolkit.getDefaultToolkit().getSystemClipboard();

   627 	        Table[] tables = getDrillDownTables();

   628 	        

   629 	        int tableCount = 0;

   630 	        while (tableCount < tables.length && tables[tableCount] != null)

   631 	        	tableCount++;

   632 

   633 	        SaveDrillDownString getString = new SaveDrillDownString(tableCount, tables, ","); //$NON-NLS-1$

   634 	        String copyString = getString.getData();

   635 			StringSelection contents = new StringSelection(copyString);

   636 	        cb.setContents(contents, contents);

   637 	        return;

   638 	    }

   639 	}

   640 

   641 	private void actionAddRemove(String actionString, int graphIndex)

   642 	{

   643 		ProfiledGeneric pGeneric;

   644 		int totalSamples = 0;

   645 		

   646 		// true for "add", false for "remove"

   647 		boolean addIt = actionString.equals("add"); //$NON-NLS-1$

   648 

   649 		TableItem[] selectedItems = this.table.getSelection();

   650 		for (int i = 0; i < selectedItems.length; i++)

   651 		{

   652 			selectedItems[i].setChecked(addIt);

   653 			Object item = ((TableItem)selectedItems[i]).getData();

   654 			if (item instanceof ProfiledGeneric)

   655 			{

   656 				pGeneric = (ProfiledGeneric)item;

   657 				pGeneric.setEnabled(graphIndex, addIt);

   658 				totalSamples += pGeneric.getSampleCount(graphIndex);

   659    				

   660    				if (item instanceof ProfiledThreshold)

   661    				{

   662    					ProfiledThreshold pThreshold = (ProfiledThreshold)item;

   663    					ArrayList<ProfiledGeneric> items = pThreshold.getItems(graphIndex);

   664    					for (int j = 0; j < items.size(); j++)

   665    						items.get(j).setEnabled(graphIndex, addIt);

   666    				}

   667 			}

   668 		}

   669 

   670         // this table's set of checkbox-selected rows has changed,

   671 		// so propagate that information

   672 		Object[] selectedValues = this.tableViewer.getCheckedElements();

   673 		String[] nameList = new String[selectedValues.length];

   674 

   675 		for (int i = 0; i < selectedValues.length; i++)

   676 		{

   677    			if (selectedValues[i] instanceof ProfiledGeneric)

   678    			{

   679    				pGeneric = (ProfiledGeneric)selectedValues[i];

   680    				nameList[i] = pGeneric.getNameString();

   681    			}

   682 		}

   683 

   684 		PIVisualSharedData shared = myGraph.getSharedDataInstance();

   685 		shared.GPP_SelectedThreadNames = nameList;

   686 

   687   		if (   (totalSamples != 0)

   688       		|| (myGraph.getDrawMode() == Defines.THREADS))

   689       			selectionChangeNotify();

   690 

   691   		this.table.deselectAll();

   692 	}

   693 	

   694 	private void actionAddRemoveAll(String actionString, int graphIndex)

   695 	{

   696 		ProfiledGeneric pGeneric;

   697 

   698 		// true for "add", false for "remove"

   699 		boolean addIt = actionString.equals("addall"); //$NON-NLS-1$

   700 

   701 		TableItem[] selectedItems = this.table.getItems();

   702 		String[] nameList = new String[selectedItems.length];

   703 		for (int i = 0; i < selectedItems.length; i++)

   704 		{

   705 			selectedItems[i].setChecked(addIt);

   706 			Object item = ((TableItem)selectedItems[i]).getData();

   707 			if (item instanceof ProfiledGeneric)

   708 			{

   709 				pGeneric = (ProfiledGeneric)item;

   710 				pGeneric.setEnabled(graphIndex, addIt);

   711    				nameList[i] = pGeneric.getNameString();

   712    				

   713    				if (item instanceof ProfiledThreshold)

   714    				{

   715    					ProfiledThreshold pThreshold = (ProfiledThreshold)item;

   716    					ArrayList<ProfiledGeneric> items = pThreshold.getItems(graphIndex);

   717    					for (int j = 0; j < items.size(); j++)

   718    						items.get(j).setEnabled(graphIndex, addIt);

   719    				}

   720 			}

   721 		}

   722 

   723         // this table's set of checkbox-selected rows has changed,

   724 		// so propagate that information

   725 		PIVisualSharedData shared = myGraph.getSharedDataInstance();

   726 		shared.GPP_SelectedThreadNames = nameList;

   727 

   728 			selectionChangeNotify();

   729   		this.table.deselectAll();

   730 	}

   731 	

   732 	private void actionRecolor()

   733 	{

   734 		int uid 			= this.myGraph.getUid();

   735 		GppTrace gppTrace = this.myGraph.getGppTrace();

   736 

   737 		// recolor selected items

   738 		boolean didRecolor = false;

   739 

   740 		TableItem[] selectedItems = table.getSelection();

   741 		for (int i = 0; i < selectedItems.length;i++)

   742 		{

   743 			if (selectedItems[i].getData() instanceof ProfiledGeneric)

   744 			{

   745 				ProfiledGeneric pGeneric = (ProfiledGeneric)selectedItems[i].getData();

   746 				TableColorPalette palette = ((GppTrace)this.myGraph.getTrace()).getThreadColorPalette();

   747 				String nameKey = pGeneric.getNameString();

   748 				if (palette.recolorEntryDialog(table.getShell(), nameKey))

   749 				{

   750 					Color color = palette.getColor(nameKey);

   751 					Color oldColor = pGeneric.getColor();

   752 					

   753 					if (color.equals(oldColor))

   754 						continue;

   755 					

   756 					didRecolor = true;

   757 					

   758 					if (!(pGeneric instanceof ProfiledThreshold)) {

   759 						PIPageEditor.currentPageEditor().setDirty();

   760 						pGeneric.setColor(color);

   761 					} else {

   762 						// for the threshold item, we must change every graph's thread threshold item

   763 						gppTrace.getGppGraph(PIPageEditor.THREADS_PAGE,   uid).getThresholdThread().setColor(color);

   764 						gppTrace.getGppGraph(PIPageEditor.BINARIES_PAGE,  uid).getThresholdThread().setColor(color);

   765 						gppTrace.getGppGraph(PIPageEditor.FUNCTIONS_PAGE, uid).getThresholdThread().setColor(color);

   766 					}

   767 				}

   768 

   769 				// recoloring should only be done in a draw mode that displays this table's colors

   770 				selectedItems[i].setBackground(COLOR_COLUMN_INDEX, palette.getColor(nameKey));

   771 			}

   772 		}

   773 		

   774 		if (!didRecolor)

   775 			return;

   776 

   777 		table.redraw();

   778 		this.myGraph.repaint();

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

   780 		

   781 		// if any other tabs are displaying this type of graph, they need to be scheduled for redrawing

   782 		for (int i = 0; i < 3; i++) {

   783 			GppTraceGraph graph = gppTrace.getGppGraph(i, uid);

   784 

   785 			if (graph == this.myGraph)

   786 				continue;

   787 

   788 			int drawMode = graph.getDrawMode();

   789 			

   790 			if (   (drawMode == Defines.THREADS)

   791 				|| (drawMode == Defines.BINARIES_THREADS)

   792 				|| (drawMode == Defines.BINARIES_FUNCTIONS_THREADS)

   793 				|| (drawMode == Defines.FUNCTIONS_THREADS)

   794 				|| (drawMode == Defines.FUNCTIONS_BINARIES_THREADS)) {

   795 				graph.getThreadTable().addColor(drawMode);

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

   797 				graph.repaint();

   798 			}

   799 		}

   800 	}

   801 

   802 	private void actionThread()

   803 	{

   804 		// current drawMode should be THREADS, THREADS_BINARIES, THREADS_BINARIES_FUNCTIONS,

   805 		// THREADS_FUNCTIONS, or THREADS_FUNCTIONS_BINARIES

   806 		int drawMode = this.myGraph.getDrawMode();

   807 

   808 		if (   (drawMode != Defines.THREADS_BINARIES)

   809 			&& (drawMode != Defines.THREADS_BINARIES_FUNCTIONS)

   810 			&& (drawMode != Defines.THREADS_FUNCTIONS)

   811 			&& (drawMode != Defines.THREADS_FUNCTIONS_BINARIES))

   812 		{

   813 			// this case should be drawMode == Defines.THREADS

   814 			return;

   815 		}

   816 		

   817 		setIsDrilldown(false);

   818 

   819 		// set the page's graph title

   820 		ProfileVisualiser pV =  NpiInstanceRepository.getInstance().getProfilePage(this.myGraph.getUid(), this.myGraph.getGraphIndex());

   821 		pV.getTitle().setText(Messages.getString("AddrThreadTable.threadLoad")); //$NON-NLS-1$

   822 		pV.getTitle2().setText(""); //$NON-NLS-1$

   823 

   824 		// get rid of any existing tables and sashes

   825 		if (this.myGraph.getLeftSash() != null) {

   826 			this.myGraph.getLeftSash().dispose();

   827 			this.myGraph.setLeftSash(null);

   828 

   829 			// detach the table from the sash

   830 			try {

   831 				FormData formData = (FormData) this.table.getLayoutData();

   832 				formData.right = new FormAttachment(100);

   833 			} catch (ClassCastException e1) {

   834 			}

   835 		}

   836 		if (this.myGraph.getRightSash() != null) {

   837 			this.myGraph.getRightSash().dispose();

   838 			this.myGraph.setRightSash(null);

   839 		}

   840 		if (   (this.myGraph.getBinaryTable() != null)

   841 			&& (this.myGraph.getBinaryTable().getTable() != null)) {

   842 			this.myGraph.getBinaryTable().getTableViewer().getTable().dispose();

   843 			this.myGraph.getBinaryTable().setTableViewer(null);

   844 		}

   845 		if (   (this.myGraph.getFunctionTable() != null)

   846 			&& (this.myGraph.getFunctionTable().getTable() != null)) {

   847 			this.myGraph.getFunctionTable().getTableViewer().getTable().dispose();

   848 			this.myGraph.getFunctionTable().setTableViewer(null);

   849 		}

   850 

   851 		// set the draw mode

   852 		this.myGraph.setDrawMode(Defines.THREADS);

   853 

   854 		// add colors to the rightmost table

   855 		addColor(Defines.THREADS);

   856 

   857 		this.parent.layout();

   858 

   859 		this.myGraph.repaint();

   860 	}

   861 

   862 	private void actionThreadBinary()

   863 	{

   864 		// current drawMode should be THREADS, THREADS_BINARIES, or THREADS_BINARIES_FUNCTIONS

   865 		int drawMode = this.myGraph.getDrawMode();

   866 		int graphIndex = this.myGraph.getGraphIndex();

   867 

   868 		if (   drawMode != Defines.THREADS

   869 			&& drawMode != Defines.THREADS_BINARIES_FUNCTIONS) {

   870 			return;

   871 		}

   872 		

   873 		setIsDrilldown(true);

   874 

   875 		if (drawMode == Defines.THREADS) {

   876 			// set the page's graph title

   877 			ProfileVisualiser pV =  NpiInstanceRepository.getInstance().getProfilePage(this.myGraph.getUid(), this.myGraph.getGraphIndex());

   878 			pV.getTitle().setText(Messages.getString("AddrThreadTable.binaryLoad")); //$NON-NLS-1$

   879 			pV.getTitle2().setText(Messages.getString("AddrThreadTable.threadTo")); //$NON-NLS-1$

   880 

   881 			// set the draw mode before populating table viewers, since the

   882 			// color column depends on the draw mode

   883 			this.myGraph.setDrawMode(Defines.THREADS_BINARIES);

   884 

   885 			// create the binary graph table viewer

   886 			AddrBinaryTable binaryTable = this.myGraph.getBinaryTable();

   887 			binaryTable.createTableViewer(Defines.THREADS_BINARIES);

   888 			binaryTable.setIsDrilldown(true);

   889 

   890 			// create a reduced set of binary entries based on enabled thread entries

   891 			GppTrace gppTrace = (GppTrace) this.myGraph.getTrace();

   892 			Vector<ProfiledGeneric> binaries = gppTrace.setThreadBinary(graphIndex);

   893 			this.myGraph.setProfiledBinaries(binaries);

   894 

   895 			// put check marks on all rows, and sort by sample count

   896 			binaryTable.quickSort(COLUMN_ID_SAMPLE_COUNT, this.myGraph.getProfiledBinaries());

   897 			binaryTable.updateProfiledAndItemData(true);

   898 			binaryTable.getTableViewer().setAllChecked(true);

   899 			binaryTable.getTableViewer().refresh();

   900 

   901 			// put check marks on all enabled thread rows

   902 			for (int i = 0; i < this.table.getItemCount(); i++) {

   903 				ProfiledGeneric pThread = (ProfiledGeneric) this.table.getItem(i).getData();

   904 				if (pThread.isEnabled(graphIndex))

   905 					this.table.getItem(i).setChecked(true);

   906 			}

   907 			

   908 			// remove colors where appropriate

   909 			removeColor(Defines.THREADS_BINARIES);

   910 

   911 			// connect the tables with a sash

   912 			Sash leftSash   = new Sash(this.parent, SWT.VERTICAL);

   913 

   914 			final FormData leftSashData = new FormData();

   915 			leftSashData.top    = new FormAttachment(0);

   916 			leftSashData.bottom = new FormAttachment(100);

   917 			leftSashData.left   = new FormAttachment(50); // middle

   918 			leftSash.setLayoutData(leftSashData);

   919 

   920 			final Composite sashParent = this.parent;

   921 			leftSash.addListener(SWT.Selection, new Listener() {

   922 				public void handleEvent(Event event) {

   923 					if (event.detail != SWT.DRAG) {

   924 						leftSashData.left = new FormAttachment(0, event.x);

   925 						sashParent.layout();

   926 					}

   927 				}

   928 			});

   929 

   930 			myGraph.setLeftSash(leftSash);

   931 

   932 			// attach the binary table to the sash

   933 			final FormData viewerData = new FormData();

   934 			viewerData.top    = new FormAttachment(0);

   935 			viewerData.bottom = new FormAttachment(100);

   936 			viewerData.left   = new FormAttachment(leftSash);

   937 			viewerData.right  = new FormAttachment(100);

   938 			binaryTable.getTable().setLayoutData(viewerData);

   939 

   940 			// attach the thread table to the sash

   941 			try {

   942 				FormData formData = (FormData) this.table.getLayoutData();

   943 				formData.right = new FormAttachment(leftSash);

   944 			} catch (ClassCastException e1) {

   945 			}

   946 

   947 			this.parent.layout();

   948 

   949 			this.myGraph.repaint();

   950 

   951 		} else if (drawMode == Defines.THREADS_BINARIES_FUNCTIONS) {

   952 			// set the page's graph title

   953 			ProfileVisualiser pV =  NpiInstanceRepository.getInstance().getProfilePage(this.myGraph.getUid(), this.myGraph.getGraphIndex());

   954 			pV.getTitle().setText(Messages.getString("AddrThreadTable.binaryLoad")); //$NON-NLS-1$

   955 			pV.getTitle2().setText(Messages.getString("AddrThreadTable.threadTo")); //$NON-NLS-1$

   956 

   957 			// get rid of the function table and its sash

   958 			if (this.myGraph.getRightSash() != null) {

   959 				this.myGraph.getRightSash().dispose();

   960 				this.myGraph.setRightSash(null);

   961 			}

   962 			if (   (this.myGraph.getFunctionTable() != null)

   963 				&& (this.myGraph.getFunctionTable().getTable() != null)) {

   964 				this.myGraph.getFunctionTable().getTableViewer().getTable().dispose();

   965 				this.myGraph.getFunctionTable().setTableViewer(null);

   966 			}

   967 

   968 			// get rid of the middle table's connection to the sash

   969 			try {

   970 				FormData formData = (FormData) this.myGraph.getBinaryTable().getTable().getLayoutData();

   971 				formData.right = new FormAttachment(100);

   972 			} catch (ClassCastException e1) {

   973 			}

   974 

   975 			// move the left sash to the middle

   976 			try {

   977 				FormData formData = (FormData) this.myGraph.getLeftSash().getLayoutData();

   978 				formData.left = new FormAttachment(50); // middle

   979 			} catch (ClassCastException e1) {

   980 			}

   981 

   982 			// set the draw mode

   983 			this.myGraph.setDrawMode(Defines.THREADS_BINARIES);

   984 

   985 			// show colors in the rightmost table

   986 			this.myGraph.getBinaryTable().addColor(Defines.THREADS_BINARIES);

   987 

   988 			this.parent.layout();

   989 

   990 			this.myGraph.repaint();

   991 		}

   992 

   993 		// this case should be drawMode == Defines.THREADS_BINARIES

   994 		return;

   995 	}

   996 

   997 	private void actionThreadBinaryFunction()

   998 	{

   999 		// current drawMode should be THREADS_BINARIES or THREADS_BINARIES_FUNCTIONS

  1000 		int drawMode = this.myGraph.getDrawMode();

  1001 		int graphIndex = this.myGraph.getGraphIndex();

  1002 

  1003 		if (drawMode != Defines.THREADS_BINARIES) {

  1004 			// this case should be drawMode == Defines.THREADS_BINARIES_FUNCTIONS

  1005 			return;

  1006 		}

  1007 

  1008 		setIsDrilldown(true);

  1009 

  1010 		// set the page's graph title

  1011 		ProfileVisualiser pV =  NpiInstanceRepository.getInstance().getProfilePage(this.myGraph.getUid(), this.myGraph.getGraphIndex());

  1012 		pV.getTitle().setText(Messages.getString("AddrThreadTable.functionLoad")); //$NON-NLS-1$

  1013 		pV.getTitle2().setText(Messages.getString("AddrThreadTable.threadToBinaryTo")); //$NON-NLS-1$

  1014 

  1015 		// set the draw mode before populating table viewers, since the

  1016 		// color column depends on the draw mode

  1017 		this.myGraph.setDrawMode(Defines.THREADS_BINARIES_FUNCTIONS);

  1018 

  1019 		// create the function graph table viewer

  1020 		AddrFunctionTable functionTable = this.myGraph.getFunctionTable();

  1021 		functionTable.createTableViewer(Defines.THREADS_BINARIES_FUNCTIONS);

  1022 		functionTable.setIsDrilldown(true);

  1023 

  1024 		// create a reduced set of function entries based on enabled thread and binary entries

  1025 		GppTrace gppTrace = (GppTrace) this.myGraph.getTrace();

  1026 		Vector<ProfiledGeneric> functions = gppTrace.setThreadBinaryFunction(graphIndex);

  1027 		this.myGraph.setProfiledFunctions(functions);

  1028 

  1029 		// put check marks on all rows, and sort by sample count

  1030 		functionTable.quickSort(COLUMN_ID_SAMPLE_COUNT, this.myGraph.getProfiledFunctions());

  1031 		functionTable.updateProfiledAndItemData(true);

  1032 		functionTable.getTableViewer().setAllChecked(true);

  1033 		functionTable.getTableViewer().refresh();

  1034 

  1035 		// remove colors where appropriate

  1036 		this.myGraph.getBinaryTable().removeColor(Defines.THREADS_BINARIES_FUNCTIONS);

  1037 

  1038 		// connect the 2nd and 3rd tables with a sash

  1039 		Sash rightSash   = new Sash(this.parent, SWT.VERTICAL);

  1040 

  1041 		final FormData rightSashData = new FormData();

  1042 		rightSashData.top    = new FormAttachment(0);

  1043 		rightSashData.bottom = new FormAttachment(100);

  1044 		rightSashData.left   = new FormAttachment(67); // two thirds

  1045 		rightSash.setLayoutData(rightSashData);

  1046 

  1047 		final Composite sashParent = this.parent;

  1048 		rightSash.addListener(SWT.Selection, new Listener() {

  1049 			public void handleEvent(Event event) {

  1050 				if (event.detail != SWT.DRAG) {

  1051 					rightSashData.left = new FormAttachment(0, event.x);

  1052 					sashParent.layout();

  1053 				}

  1054 			}

  1055 		});

  1056 

  1057 		myGraph.setRightSash(rightSash);

  1058 

  1059 		// attach the function table to the sash

  1060 		final FormData viewerData = new FormData();

  1061 		viewerData.top    = new FormAttachment(0);

  1062 		viewerData.bottom = new FormAttachment(100);

  1063 		viewerData.left   = new FormAttachment(rightSash);

  1064 		viewerData.right  = new FormAttachment(100);

  1065 		functionTable.getTable().setLayoutData(viewerData);

  1066 

  1067 		// attach the binary table to the sash

  1068 		try {

  1069 			FormData formData = (FormData) this.myGraph.getBinaryTable().getTable().getLayoutData();

  1070 			formData.right = new FormAttachment(rightSash);

  1071 		} catch (ClassCastException e1) {

  1072 		}

  1073 

  1074 		// move the left sash to 1/3 from the left

  1075 		try {

  1076 			FormData formData = (FormData) this.myGraph.getLeftSash().getLayoutData();

  1077 			formData.left = new FormAttachment(33); // one third

  1078 		} catch (ClassCastException e1) {

  1079 		}

  1080 

  1081 		this.parent.layout();

  1082 

  1083 		this.myGraph.repaint();

  1084 	}

  1085 

  1086 	private void actionThreadFunction()

  1087 	{

  1088 		// current drawMode should be THREADS, THREADS_FUNCTIONS, or THREADS_FUNCTIONS_BINARIES

  1089 		int drawMode = this.myGraph.getDrawMode();

  1090 		int graphIndex = this.myGraph.getGraphIndex();

  1091 

  1092 		if (   drawMode != Defines.THREADS

  1093 			&& drawMode != Defines.THREADS_FUNCTIONS_BINARIES) {

  1094 			return;

  1095 		}

  1096 

  1097 		setIsDrilldown(true);

  1098 

  1099 		if (drawMode == Defines.THREADS) {

  1100 			// set the page's graph title

  1101 			ProfileVisualiser pV =  NpiInstanceRepository.getInstance().getProfilePage(this.myGraph.getUid(), this.myGraph.getGraphIndex());

  1102 			pV.getTitle().setText(Messages.getString("AddrThreadTable.functionLoad")); //$NON-NLS-1$

  1103 			pV.getTitle2().setText(Messages.getString("AddrThreadTable.threadTo")); //$NON-NLS-1$

  1104 

  1105 			// set the draw mode

  1106 			this.myGraph.setDrawMode(Defines.THREADS_FUNCTIONS);

  1107 

  1108 			// create the function graph table viewer

  1109 			AddrFunctionTable functionTable = this.myGraph.getFunctionTable();

  1110 			functionTable.createTableViewer(Defines.THREADS_FUNCTIONS);

  1111 			functionTable.setIsDrilldown(true);

  1112 

  1113 			// create a reduced set of function entries based on enabled thread and binary entries

  1114 			GppTrace gppTrace = (GppTrace) this.myGraph.getTrace();

  1115 			Vector<ProfiledGeneric> functions = gppTrace.setThreadFunction(graphIndex);

  1116 			this.myGraph.setProfiledFunctions(functions);

  1117 

  1118 			// put check marks on all rows, and sort by sample count

  1119 			functionTable.quickSort(COLUMN_ID_SAMPLE_COUNT, this.myGraph.getProfiledFunctions());

  1120 			functionTable.updateProfiledAndItemData(true);

  1121 			functionTable.getTableViewer().setAllChecked(true);

  1122 			functionTable.getTableViewer().refresh();

  1123 

  1124 			// remove colors where appropriate

  1125 			removeColor(Defines.THREADS_FUNCTIONS);

  1126 

  1127 			// connect the tables with a sash

  1128 			Sash leftSash   = new Sash(this.parent, SWT.VERTICAL);

  1129 

  1130 			final FormData leftSashData = new FormData();

  1131 			leftSashData.top    = new FormAttachment(0);

  1132 			leftSashData.bottom = new FormAttachment(100);

  1133 			leftSashData.left   = new FormAttachment(50); // middle

  1134 			leftSash.setLayoutData(leftSashData);