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.Comparator;

    28 import java.util.Enumeration;

    29 import java.util.Hashtable;

    30 import java.util.Vector;

    31 

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

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

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

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

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

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

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

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

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

    41 import org.eclipse.swt.SWT;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    60 

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

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

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

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

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

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

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

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

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

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

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

    72 import com.nokia.carbide.cpp.pi.util.SourceLookup;

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

    74 

    75 

    76 public class AddrFunctionTable extends GenericAddrTable

    77 {

    78 	// local copy of profiled binaries, which we can sort

    79 	// without affecting the original

    80 	Vector<ProfiledGeneric> profiledFunctions = new Vector<ProfiledGeneric>();

    81 

    82 	public AddrFunctionTable(GppTraceGraph myGraph, Composite parent)

    83 	{

    84 		this.myGraph = myGraph;

    85 		this.parent  = parent;

    86 	}

    87 

    88 	public void createTableViewer(int drawMode)

    89 	{

    90 		if (this.parent == null)

    91 			return;

    92 

    93 		// Function table:

    94 		//		checkbox + colored or white background

    95 		//  	percent load

    96 		//  	function name

    97 		//		function start address

    98 		//		binary containing function

    99 		//		path of binary containing function

   100 		//		sample count

   101 

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

   103 		// or the number of samples

   104 		switch (drawMode)

   105 		{

   106 			case Defines.FUNCTIONS:

   107 			case Defines.THREADS_BINARIES_FUNCTIONS:

   108 			case Defines.BINARIES_FUNCTIONS:

   109 			case Defines.THREADS_FUNCTIONS:

   110 			case Defines.BINARIES_THREADS_FUNCTIONS:

   111 			case Defines.THREADS_FUNCTIONS_BINARIES:

   112 			case Defines.BINARIES_FUNCTIONS_THREADS:

   113 			case Defines.FUNCTIONS_THREADS:

   114 			case Defines.FUNCTIONS_THREADS_BINARIES:

   115 			case Defines.FUNCTIONS_BINARIES:

   116 			case Defines.FUNCTIONS_BINARIES_THREADS:

   117 			{

   118 				break;

   119 			}

   120 			default:

   121 				// no function table in this draw mode

   122 				return;

   123 		}

   124 

   125 		// create the table viewer

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

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

   128 

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

   130 		tableViewer.addCheckStateListener(new SharedCheckHandler());

   131 		tableViewer.setLabelProvider(new shownFunctionsLabelProvider());

   132 		tableViewer.setContentProvider(new shownFunctionsContentProvider());

   133 		tableViewer.addSelectionChangedListener(new ISelectionChangedListener() {

   134 			public void selectionChanged(SelectionChangedEvent arg0) {

   135 				if (copyAction == null)

   136 					return;

   137 

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

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

   140 				PIPageEditor.getActionBars().updateActionBars();

   141 			}

   142 		});

   143 

   144 		createDefaultActions();

   145 

   146 		// make sure the table viewer has a sorter

   147 		if (this.sorter == null)

   148 			this.sorter = new GppTableSorter();

   149 

   150 		this.table = tableViewer.getTable();

   151 		this.table.setRedraw(false);

   152 

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

   154 		this.table.setData(Messages.getString("AddrFunctionTable.functions")); //$NON-NLS-1$

   155 		

   156 		// create the columns

   157 		TableColumn column;

   158 

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

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

   161 		boolean[] isHex = {false, false, false, true, false, false, false};

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

   163 

   164 		// select/deselect column

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

   166 		column.setText(COLUMN_HEAD_SHOW);

   167 		column.setWidth(COLUMN_WIDTH_SHOW);

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

   169 		column.setMoveable(true);

   170 		column.setResizable(true);

   171 		column.addSelectionListener(new ColumnSelectionHandler());

   172 

   173 		// percent load column

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

   175 		column.setText(COLUMN_HEAD_PERCENT_LOAD);

   176 		column.setWidth(COLUMN_WIDTH_PERCENT_LOAD);

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

   178 		column.setMoveable(true);

   179 		column.setResizable(true);

   180 		column.addSelectionListener(new ColumnSelectionHandler());

   181 

   182 		// function name column

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

   184 		column.setText(COLUMN_HEAD_FUNCTION);

   185 		column.setWidth(COLUMN_WIDTH_FUNCTION_NAME);

   186 		column.setData(new Integer(COLUMN_ID_FUNCTION));

   187 		column.setMoveable(true);

   188 		column.setResizable(true);

   189 		column.addSelectionListener(new ColumnSelectionHandler());

   190 

   191 		// function start address column

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

   193 		column.setText(COLUMN_HEAD_START_ADDR);

   194 		column.setWidth(COLUMN_WIDTH_START_ADDRESS);

   195 		column.setData(new Integer(COLUMN_ID_START_ADDR));

   196 		column.setMoveable(true);

   197 		column.setResizable(true);

   198 		column.addSelectionListener(new ColumnSelectionHandler());

   199 

   200 		// binary containing function column

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

   202 		column.setText(COLUMN_HEAD_IN_BINARY);

   203 		column.setWidth(COLUMN_WIDTH_IN_BINARY);

   204 		column.setData(new Integer(COLUMN_ID_IN_BINARY));

   205 		column.setMoveable(true);

   206 		column.setResizable(true);

   207 		column.addSelectionListener(new ColumnSelectionHandler());

   208 

   209 		// path to binary containing function column

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

   211 		column.setText(COLUMN_HEAD_IN_BINARY_PATH);

   212 		column.setWidth(COLUMN_WIDTH_IN_BINARY_PATH);

   213 		column.setData(new Integer(COLUMN_ID_IN_BINARY_PATH));

   214 		column.setMoveable(true);

   215 		column.setResizable(true);

   216 		column.addSelectionListener(new ColumnSelectionHandler());

   217 

   218 		// sample count column

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

   220 		column.setText(COLUMN_HEAD_SAMPLE_COUNT);

   221 		column.setWidth(COLUMN_WIDTH_SAMPLE_COUNT);

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

   223 		column.setMoveable(true);

   224 		column.setResizable(true);

   225 		column.addSelectionListener(new ColumnSelectionHandler());

   226 

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

   228 		table.addMouseListener(new TableMouseListener());

   229 

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

   231 		table.addKeyListener(new TableKeyListener());

   232 

   233 		table.addFocusListener(new AddrTableFocusListener());

   234 

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

   236 		FormData viewerData = new FormData();

   237 		viewerData.top    = new FormAttachment(0);

   238 		viewerData.bottom = new FormAttachment(100);

   239 		viewerData.left   = new FormAttachment(0);

   240 		viewerData.right  = new FormAttachment(100);

   241 		table.setLayoutData(viewerData);

   242 		table.setLayout(new FormLayout());

   243 

   244 		table.setHeaderVisible(true);

   245 		table.setLinesVisible(true);

   246 		table.setRedraw(true);

   247 	}

   248 

   249 	public void setTableViewer(CheckboxTableViewer tableViewer)

   250 	{

   251 		this.tableViewer = tableViewer;

   252 

   253 		if (tableViewer == null)

   254 			this.table = null;

   255 	}

   256 

   257 	public void setTableViewer(int drawMode)

   258 	{

   259 		if (this.parent == null)

   260 			return;

   261 

   262 		createTableViewer(drawMode);

   263 

   264 		// sort by sample count

   265 		this.sortColumn = COLUMN_ID_SAMPLE_COUNT;

   266 		this.sortAscending = false;

   267 

   268 		// profiledFunctions and tableItemData contain one entry per table row

   269 		updateProfiledAndItemData(false);

   270 		quickSort(sortColumn, profiledFunctions);

   271 

   272 		// initially, all rows are selected

   273 		this.tableViewer.setAllChecked(true);

   274 	}

   275 

   276 	public void refreshTableViewer()

   277 	{

   278 		if (this.tableViewer == null)

   279 			return;

   280 

   281 		this.tableViewer.setInput(tableItemData);

   282 		

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

   284 	}

   285 	

   286 	public void addColor(int drawMode)

   287 	{

   288 		if (this.tableViewer == null)

   289 			return;

   290 

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

   292 		if (   (drawMode != Defines.FUNCTIONS)

   293 			&& (drawMode != Defines.THREADS_FUNCTIONS)

   294 			&& (drawMode != Defines.THREADS_BINARIES_FUNCTIONS)

   295 			&& (drawMode != Defines.BINARIES_FUNCTIONS)

   296 			&& (drawMode != Defines.BINARIES_THREADS_FUNCTIONS))

   297 			return;

   298 

   299 		ProfiledGeneric pGeneric;

   300 

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

   302 

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

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

   305 //			Color color = ((GppTrace)this.myGraph.getTrace()).getFunctionColorPalette().getColor(pGeneric.getNameString());

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

   307 		}

   308 

   309 		table.redraw();

   310 	}

   311 	

   312 	public void removeColor(int drawMode)

   313 	{

   314 		if (this.tableViewer == null)

   315 			return;

   316 

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

   318 		if (   (drawMode == Defines.FUNCTIONS)

   319 			|| (drawMode == Defines.THREADS_FUNCTIONS)

   320 			|| (drawMode == Defines.THREADS_BINARIES_FUNCTIONS)

   321 			|| (drawMode == Defines.BINARIES_FUNCTIONS)

   322 			|| (drawMode == Defines.BINARIES_THREADS_FUNCTIONS))

   323 			return;

   324 

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

   326 

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

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

   329 		}

   330 

   331 		table.redraw();

   332 	}

   333 

   334 	private static class shownFunctionsContentProvider implements IStructuredContentProvider {

   335 

   336 		public shownFunctionsContentProvider() {

   337 			super();

   338 		}

   339 

   340 		public Object[] getElements(Object inputElement) {

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

   342 		}

   343 

   344 		public void dispose() {

   345 		}

   346 

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

   348 		}

   349 	}

   350 

   351 	private class shownFunctionsLabelProvider extends LabelProvider implements ITableLabelProvider {

   352 

   353 		public shownFunctionsLabelProvider() {

   354 			super();

   355 		}

   356 

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

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

   359 

   360 			if (element instanceof ProfiledThreshold) {

   361 				ProfiledThreshold pThreshold = (ProfiledThreshold) element;

   362 				switch (columnId)

   363 				{

   364 					case COLUMN_ID_SHOW:

   365 					{

   366 						return SHOW_ITEM_VALUE;

   367 					}

   368 					case COLUMN_ID_PERCENT_LOAD:

   369 					{

   370 						// Percent load string

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

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

   373 						if (   (startTime == -1)

   374 							|| (endTime   == -1)

   375 							|| (startTime == endTime)) {

   376 							pThreshold.setAverageLoadValueString(myGraph.getGraphIndex(), ""); //$NON-NLS-1$

   377 						} else {

   378 							float load = (float) (pThreshold.getSampleCount(myGraph.getGraphIndex())/(endTime - startTime)/10.0);

   379 							

   380 							if (load < 0.005)

   381 								pThreshold.setAverageLoadValueString(myGraph.getGraphIndex(), Messages.getString("AddrFunctionTable.zeroFormat")); //$NON-NLS-1$

   382 							else

   383 								pThreshold.setAverageLoadValueString(myGraph.getGraphIndex(), load);

   384 						}

   385 						return pThreshold.getAverageLoadValueString(myGraph.getGraphIndex());

   386 					}

   387 					case COLUMN_ID_FUNCTION:

   388 					{

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

   390 						int count = pThreshold.getItemCount(myGraph.getGraphIndex());

   391 

   392 						return count + (count > 1 ? Messages.getString("AddrFunctionTable.threshold1") : Messages.getString("AddrFunctionTable.threshold2"))   //$NON-NLS-1$ //$NON-NLS-2$

   393 								+ timeFormat.format((Double)NpiInstanceRepository.getInstance().activeUidGetPersistState("com.nokia.carbide.cpp.pi.address.thresholdLoadThread") * 100.0) + Messages.getString("AddrFunctionTable.threshold3")  //$NON-NLS-1$ //$NON-NLS-2$

   394 								+ (Integer)NpiInstanceRepository.getInstance().activeUidGetPersistState("com.nokia.carbide.cpp.pi.address.thresholdCountFunction") + Messages.getString("AddrFunctionTable.threshold4"); //$NON-NLS-1$ //$NON-NLS-2$	

   395 					}

   396 					case COLUMN_ID_SAMPLE_COUNT:

   397 					{

   398 						// Sample count

   399 						return String.valueOf(pThreshold.getSampleCount(myGraph.getGraphIndex()));

   400 					}

   401 					default:

   402 					{

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

   404 					}

   405 				}

   406 			}

   407 

   408 			if (!(element instanceof ProfiledFunction))

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

   410 

   411 			ProfiledFunction profiledItem = (ProfiledFunction) element;

   412 

   413 			switch (columnId)

   414 			{

   415 				case COLUMN_ID_SHOW:

   416 				{

   417 					return SHOW_ITEM_VALUE;

   418 				}

   419 				case COLUMN_ID_PERCENT_LOAD:

   420 				{

   421 					// Percent load string

   422 					return profiledItem.getAverageLoadValueString(myGraph.getGraphIndex());

   423 				}

   424 				case COLUMN_ID_FUNCTION:

   425 				{

   426 					// Function

   427 					return (profiledItem.getNameString());

   428 				}

   429 				case COLUMN_ID_START_ADDR:

   430 				{

   431 					// Function start

   432 					return (Long.toHexString(profiledItem.getFunctionAddress()));

   433 				}

   434 				case COLUMN_ID_IN_BINARY:

   435 				{

   436 					// Binary

   437 					String binary = profiledItem.getFunctionBinaryName();

   438 					int index = binary.lastIndexOf('\\');

   439 					if (index == -1)

   440 						return binary;

   441 					else

   442 						return binary.substring(index + 1);

   443 				}

   444 				case COLUMN_ID_IN_BINARY_PATH:

   445 				{

   446 					// Path

   447 					String binary = profiledItem.getFunctionBinaryName();

   448 					int index = binary.lastIndexOf('\\');

   449 					if (index == -1)

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

   451 					else

   452 						return binary.substring(0, index);

   453 				}

   454 				case COLUMN_ID_SAMPLE_COUNT:

   455 				{

   456 					// Sample count

   457 					return String.valueOf(profiledItem.getSampleCount(myGraph.getGraphIndex()));

   458 				}

   459 				default:

   460 				{

   461 					break;

   462 				}

   463 			}

   464 			// should never get here

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

   466 		}

   467 

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

   469 			return null;

   470 		}

   471 	}

   472 

   473     public void action(String actionString)

   474 	{

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

   476 

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

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

   479 	    {

   480 			actionAddRemove(actionString, graphIndex);

   481 			return;

   482 	    }

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

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

   485 	    {

   486 			actionAddRemoveAll(actionString, graphIndex);

   487 			return;

   488 	    }

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

   490 		{

   491 			actionRecolor();

   492 			return;

   493 		}

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

   495 	    {

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

   497 	        return;

   498 	    }

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

   500 	    {

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

   502 	        return;

   503 	    }

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

   505 	    {

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

   507 	        return;

   508 	    }

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

   510 	    {

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

   512 	        return;

   513 	    }

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

   515 	    {

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

   517 	        return;

   518 	    }

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

   520 	    {

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

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

   523 	        return;

   524 	    }

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

   526 	    {

   527 	    	actionSelectAll();

   528 	        return;

   529 	    }

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

   531 	    {

   532 	    	copyAction.setEnabled(false);

   533 			PIPageEditor.getActionBars().updateActionBars();

   534 	        return;

   535 	    }

   536 		else if (actionString.equals("sortinfullpath")) //$NON-NLS-1$

   537 		{

   538             if (this.sortColumn == COLUMN_ID_FULL_IN_PATH)

   539             	// sort in other order

   540             	sortAscending = !sortAscending;

   541             else

   542             	// sort in ascending order

   543             	sortAscending = true;

   544             sortColumn = COLUMN_ID_FULL_IN_PATH;

   545             quickSort(sortColumn, profiledFunctions);

   546 		}

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

   548 		{

   549 			actionFunction();

   550 			return;

   551 		}

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

   553 		{

   554 			actionFunctionThread();

   555 			return;

   556 		}

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

   558 		{

   559 			actionFunctionThreadBinary();

   560 			return;

   561 		}

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

   563 		{

   564 			actionFunctionBinary();

   565 			return;

   566 		}

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

   568 		{

   569 			actionFunctionBinaryThread();

   570 			return;

   571 		}

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

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

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

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

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

   577 		{

   578 			// let the thread page action handler handle it

   579 			this.myGraph.getThreadTable().action(actionString);

   580 			return;

   581 		}

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

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

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

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

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

   587 		{

   588 			// let the binary page action handler handle it

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

   590 			return;

   591 		}

   592 		else if (actionString.equals("changeThresholdFunction")) //$NON-NLS-1$

   593 		{

   594 			ProfiledThreshold threshold = this.myGraph.getThresholdFunction();

   595 			boolean enabled = threshold.isEnabled(graphIndex);

   596 

   597 			this.tableItemData.clear();

   598 			this.profiledFunctions.clear();

   599 			this.myGraph.getSortedFunctions().clear();

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

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

   602 			threshold.initAll();

   603 

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

   605 			myGraph.getSortedFunctions().add(threshold);

   606 

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

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

   609 				ProfiledGeneric nextElement = (ProfiledGeneric)this.myGraph.getGppTrace().getSortedFunctions().get(i);

   610 				if (nextElement.getTotalSampleCount() < functionThreshold) {

   611 					nextElement.setEnabled(graphIndex, enabled);

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

   613 				} else {

   614 					tableItemData.add(nextElement);

   615 					profiledFunctions.add(nextElement);

   616 					myGraph.getSortedFunctions().add(nextElement);

   617 				}

   618 			}

   619 

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

   621 				tableItemData.add(threshold);

   622 				profiledFunctions.add(threshold);

   623 			} else {

   624 				// remove the threshold item

   625 				myGraph.getSortedFunctions().remove(0);

   626 			}

   627 			

   628 			refreshTableViewer();

   629 			threshold.setEnabled(graphIndex, enabled);

   630 

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

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

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

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

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

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

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

   638 				}

   639 			}

   640 

   641 			this.myGraph.genericRefreshCumulativeThreadTable();

   642 		}

   643 		else if (actionString.equals("sourceLookup")) //$NON-NLS-1$

   644 		{

   645 			actionSourceLookup();

   646 			return;

   647 		}

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

   649 	    {

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

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

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

   653 	        String copyString = getString.getData();

   654 			StringSelection contents = new StringSelection(copyString);

   655 	        cb.setContents(contents, contents);

   656 	        return;

   657 	    }

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

   659 	    {

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

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

   662 	        Table[] tables = getDrillDownTables();

   663 	        

   664 	        int tableCount = 0;

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

   666 	        	tableCount++;

   667 

   668 	        SaveDrillDownString getString = new SaveDrillDownString(tableCount, tables, Messages.getString("AddrFunctionTable.comma")); //$NON-NLS-1$

   669 	        String copyString = getString.getData();

   670 			StringSelection contents = new StringSelection(copyString);

   671 	        cb.setContents(contents, contents);

   672 	        return;

   673 	    }

   674 	}

   675 

   676     private void actionAddRemove(String actionString, int graphIndex)

   677 	{

   678 		ProfiledGeneric pGeneric;

   679 		int totalSamples = 0;

   680 		

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

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

   683 

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

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

   686 		{

   687 			selectedItems[i].setChecked(addIt);

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

   689 			if (item instanceof ProfiledGeneric)

   690 			{

   691 				pGeneric = (ProfiledGeneric)item;

   692 				pGeneric.setEnabled(graphIndex, addIt);

   693 				totalSamples += pGeneric.getSampleCount(graphIndex);

   694    				

   695    				if (item instanceof ProfiledThreshold)

   696    				{

   697    					ProfiledThreshold pThreshold = (ProfiledThreshold)item;

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

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

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

   701    				}

   702 			}

   703 		}

   704 

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

   706 		// so propagate that information

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

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

   709 

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

   711 		{

   712    			if (selectedValues[i] instanceof ProfiledGeneric)

   713    			{

   714    				pGeneric = (ProfiledGeneric)selectedValues[i];

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

   716    			}

   717 		}

   718 

   719 		PIVisualSharedData shared = myGraph.getSharedDataInstance();

   720 		shared.GPP_SelectedFunctionNames = nameList;

   721 

   722   		if (   (totalSamples != 0)

   723       		|| (myGraph.getDrawMode() == Defines.FUNCTIONS))

   724       			selectionChangeNotify();

   725 

   726   		this.table.deselectAll();

   727 	}

   728 	

   729 	private void actionAddRemoveAll(String actionString, int graphIndex)

   730 	{

   731 		ProfiledGeneric pGeneric;

   732 

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

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

   735 

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

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

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

   739 		{

   740 			selectedItems[i].setChecked(addIt);

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

   742 			if (item instanceof ProfiledGeneric)

   743 			{

   744 				pGeneric = (ProfiledGeneric)item;

   745 				pGeneric.setEnabled(graphIndex, addIt);

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

   747    				

   748    				if (item instanceof ProfiledThreshold)

   749    				{

   750    					ProfiledThreshold pThreshold = (ProfiledThreshold)item;

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

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

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

   754    				}

   755 			}

   756 		}

   757 

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

   759 		// so propagate that information

   760 		PIVisualSharedData shared = myGraph.getSharedDataInstance();

   761 		shared.GPP_SelectedFunctionNames = nameList;

   762 

   763 			selectionChangeNotify();

   764   		this.table.deselectAll();

   765 	}

   766 	

   767 	private void actionRecolor()

   768 	{

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

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

   771 

   772 		// recolor selected items

   773 		boolean didRecolor = false;

   774 

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

   776 		TableColorPalette palette = ((GppTrace)this.myGraph.getTrace()).getFunctionColorPalette();

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

   778 		{

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

   780 			{

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

   782 				String nameKey = pGeneric.getNameString();

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

   784 				{

   785 					Color color = palette.getColor(nameKey);

   786 					Color oldColor = pGeneric.getColor();

   787 					

   788 					if (color.equals(oldColor))

   789 						continue;

   790 					

   791 					didRecolor = true;

   792 					

   793 					if (!(pGeneric instanceof ProfiledThreshold)){

   794 						PIPageEditor.currentPageEditor().setDirty();

   795 						pGeneric.setColor(color);

   796 					}

   797 					else {

   798 						// for the threshold item, we must change every graph's function threshold item

   799 						gppTrace.getGppGraph(PIPageEditor.THREADS_PAGE,   uid).getThresholdFunction().setColor(color);

   800 						gppTrace.getGppGraph(PIPageEditor.BINARIES_PAGE,  uid).getThresholdFunction().setColor(color);

   801 						gppTrace.getGppGraph(PIPageEditor.FUNCTIONS_PAGE, uid).getThresholdFunction().setColor(color);

   802 					}

   803 				}

   804 

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

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

   807 			}

   808 		}

   809 		

   810 		if (!didRecolor)

   811 			return;

   812 

   813 		table.redraw();

   814 		this.myGraph.repaint();

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

   816 		

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

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

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

   820 

   821 			if (graph == this.myGraph)

   822 				continue;

   823 

   824 			int drawMode = graph.getDrawMode();

   825 			

   826 			if (   (drawMode == Defines.FUNCTIONS)

   827 				|| (drawMode == Defines.THREADS_FUNCTIONS)

   828 				|| (drawMode == Defines.THREADS_BINARIES_FUNCTIONS)

   829 				|| (drawMode == Defines.BINARIES_FUNCTIONS)

   830 				|| (drawMode == Defines.BINARIES_THREADS_FUNCTIONS)) {

   831 				graph.getFunctionTable().addColor(drawMode);

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

   833 				graph.repaint();

   834 			}

   835 		}

   836 	}

   837 	

   838 	private void actionFunction()

   839 	{

   840 		// current drawMode should be FUNCTIONS, FUNCTIONS_THREADS, FUNCTIONS_THREADS_BINARIES,

   841 		// FUNCTIONS_BINARIES, or FUNCTIONS_BINARIES_THREADS

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

   843 

   844 		if (   (drawMode != Defines.FUNCTIONS_THREADS)

   845 			&& (drawMode != Defines.FUNCTIONS_THREADS_BINARIES)

   846 			&& (drawMode != Defines.FUNCTIONS_BINARIES)

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

   848 		{

   849 			// this case should be drawMode == Defines.FUNCTIONS

   850 			return;

   851 		}

   852 

   853 		setIsDrilldown(false);

   854 

   855 		// set the page's graph title

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

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

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

   859 

   860 		// get rid of any existing tables and sashes

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

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

   863 			this.myGraph.setLeftSash(null);

   864 

   865 			// detach the table from the sash

   866 			try {

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

   868 				formData.right = new FormAttachment(100);

   869 			} catch (ClassCastException e1) {

   870 			}

   871 		}

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

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

   874 			this.myGraph.setRightSash(null);

   875 		}

   876 		if (   (this.myGraph.getThreadTable() != null)

   877 			&& (this.myGraph.getThreadTable().getTable() != null)) {

   878 			this.myGraph.getThreadTable().getTableViewer().getTable().dispose();

   879 			this.myGraph.getThreadTable().setTableViewer(null);

   880 		}

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

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

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

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

   885 		}

   886 

   887 		// set the draw mode

   888 		this.myGraph.setDrawMode(Defines.FUNCTIONS);

   889 

   890 		// add colors to the rightmost table

   891 		addColor(Defines.FUNCTIONS);

   892 		

   893 		this.parent.layout();

   894 

   895  		this.myGraph.repaint();

   896 	}

   897 

   898 	private void actionFunctionBinary()

   899 	{

   900 		// current drawMode should be FUNCTIONS, FUNCTIONS_BINARIES, or FUNCTIONS_BINARIES_THREADS

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

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

   903 		

   904 		if (   drawMode != Defines.FUNCTIONS

   905 			&& drawMode != Defines.FUNCTIONS_BINARIES_THREADS) {

   906 			return;

   907 		}

   908 

   909 		setIsDrilldown(true);

   910 

   911 		if (drawMode == Defines.FUNCTIONS) {

   912 			// set the page's graph title

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

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

   915 			pV.getTitle2().setText(Messages.getString("AddrFunctionTable.functionTo"));  //$NON-NLS-1$

   916 

   917 			// set the draw mode

   918 			this.myGraph.setDrawMode(Defines.FUNCTIONS_BINARIES);

   919 

   920 			// create the binary graph table viewer

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

   922 			binaryTable.createTableViewer(Defines.FUNCTIONS_BINARIES);

   923 			binaryTable.setIsDrilldown(true);

   924 

   925 			// create a reduced set of binary entries based on enabled function entries

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

   927 			Vector<ProfiledGeneric> binaries = gppTrace.setFunctionBinary(graphIndex);

   928 			this.myGraph.setProfiledBinaries(binaries);

   929 

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

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

   932 			binaryTable.updateProfiledAndItemData(true);

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

   934 			binaryTable.getTableViewer().refresh();

   935 

   936 			// remove colors where appropriate

   937 			removeColor(Defines.FUNCTIONS_BINARIES);

   938 

   939 			// connect the tables with a sash

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

   941 

   942 			final FormData leftSashData = new FormData();

   943 			leftSashData.top    = new FormAttachment(0);

   944 			leftSashData.bottom = new FormAttachment(100);

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

   946 			leftSash.setLayoutData(leftSashData);

   947 

   948 			final Composite sashParent = this.parent;

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

   950 				public void handleEvent(Event event) {

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

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

   953 						sashParent.layout();

   954 					}

   955 				}

   956 			});

   957 

   958 			myGraph.setLeftSash(leftSash);

   959 

   960 			// attach the binary table to the sash

   961 			final FormData viewerData = new FormData();

   962 			viewerData.top    = new FormAttachment(0);

   963 			viewerData.bottom = new FormAttachment(100);

   964 			viewerData.left   = new FormAttachment(leftSash);

   965 			viewerData.right  = new FormAttachment(100);

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

   967 

   968 			// attach the function table to the sash

   969 			try {

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

   971 				formData.right = new FormAttachment(leftSash);

   972 			} catch (ClassCastException e1) {

   973 			}

   974 

   975 			this.parent.layout();

   976 

   977 			this.myGraph.repaint();

   978 

   979 		} else if (drawMode == Defines.FUNCTIONS_BINARIES_THREADS) {

   980 			// set the page's graph title

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

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

   983 			pV.getTitle2().setText(Messages.getString("AddrFunctionTable.functionTo"));  //$NON-NLS-1$

   984 

   985 			// get rid of the thread table and its sash

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

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

   988 				this.myGraph.setRightSash(null);

   989 			}

   990 			if (   (this.myGraph.getThreadTable() != null)

   991 				&& (this.myGraph.getThreadTable().getTable() != null)) {

   992 				this.myGraph.getThreadTable().getTableViewer().getTable().dispose();

   993 				this.myGraph.getThreadTable().setTableViewer(null);

   994 			}

   995 

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

   997 			try {

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

   999 				formData.right = new FormAttachment(100);

  1000 			} catch (ClassCastException e1) {

  1001 			}

  1002 

  1003 			// move the left sash to the middle

  1004 			try {

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

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

  1007 			} catch (ClassCastException e1) {

  1008 			}

  1009 

  1010 			// set the draw mode

  1011 			this.myGraph.setDrawMode(Defines.FUNCTIONS_BINARIES);

  1012 

  1013 			// show colors in the rightmost table

  1014 			this.myGraph.getBinaryTable().addColor(Defines.FUNCTIONS_BINARIES);

  1015 

  1016 			this.parent.layout();

  1017 

  1018 			this.myGraph.repaint();

  1019 		}

  1020 

  1021 		// this case should be drawMode == Defines.FUNCTIONS_BINARIES

  1022 		return;

  1023 	}

  1024 

  1025 	private void actionFunctionBinaryThread()

  1026 	{

  1027 		// current drawMode should be FUNCTIONS_BINARIES or FUNCTIONS_BINARIES_THREADS

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

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

  1030 

  1031 		if (drawMode != Defines.FUNCTIONS_BINARIES) {

  1032 			// this case should be drawMode == Defines.FUNCTIONS_BINARIES_THREADS

  1033 			return;

  1034 		}

  1035 

  1036 		setIsDrilldown(true);

  1037 

  1038 		// set the page's graph title

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

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

  1041 		pV.getTitle2().setText(Messages.getString("AddrFunctionTable.functionToBinaryTo"));  //$NON-NLS-1$

  1042 

  1043 		// set the draw mode

  1044 		this.myGraph.setDrawMode(Defines.FUNCTIONS_BINARIES_THREADS);

  1045 

  1046 		// create the thread graph table viewer

  1047 		AddrThreadTable threadTable = this.myGraph.getThreadTable();

  1048 		threadTable.createTableViewer(Defines.FUNCTIONS_BINARIES_THREADS);

  1049 		threadTable.setIsDrilldown(true);

  1050 

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

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

  1053 		Vector<ProfiledGeneric> threads = gppTrace.setFunctionBinaryThread(graphIndex);

  1054 		this.myGraph.setProfiledThreads(threads);

  1055 

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

  1057 		threadTable.quickSort(COLUMN_ID_SAMPLE_COUNT, this.myGraph.getProfiledThreads());

  1058 		threadTable.updateProfiledAndItemData(true);

  1059 		threadTable.getTableViewer().setAllChecked(true);

  1060 		threadTable.getTableViewer().refresh();

  1061 

  1062 		// remove colors where appropriate

  1063 		this.myGraph.getBinaryTable().removeColor(Defines.FUNCTIONS_BINARIES_THREADS);

  1064 

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

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

  1067 

  1068 		final FormData rightSashData = new FormData();

  1069 		rightSashData.top    = new FormAttachment(0);

  1070 		rightSashData.bottom = new FormAttachment(100);

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

  1072 		rightSash.setLayoutData(rightSashData);

  1073 

  1074 		final Composite sashParent = this.parent;

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

  1076 			public void handleEvent(Event event) {

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

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

  1079 					sashParent.layout();

  1080 				}

  1081 			}

  1082 		});

  1083 

  1084 		myGraph.setRightSash(rightSash);

  1085 

  1086 		// attach the thread table to the sash

  1087 		final FormData viewerData = new FormData();

  1088 		viewerData.top    = new FormAttachment(0);

  1089 		viewerData.bottom = new FormAttachment(100);

  1090 		viewerData.left   = new FormAttachment(rightSash);

  1091 		viewerData.right  = new FormAttachment(100);

  1092 		threadTable.getTable().setLayoutData(viewerData);

  1093 

  1094 		// attach the binary table to the sash

  1095 		try {

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

  1097 			formData.right = new FormAttachment(rightSash);

  1098 		} catch (ClassCastException e1) {

  1099 		}

  1100 

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

  1102 		try {

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

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

  1105 		} catch (ClassCastException e1) {

  1106 		}

  1107 

  1108 		this.parent.layout();

  1109 

  1110 		this.myGraph.repaint();

  1111 	}

  1112 

  1113 	private void actionFunctionThread()

  1114 	{

  1115 		// current drawMode should be FUNCTIONS, FUNCTIONS_THREADS, or FUNCTIONS_THREADS_BINARIES

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

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

  1118 

  1119 		if (   drawMode != Defines.FUNCTIONS

  1120 			&& drawMode != Defines.FUNCTIONS_THREADS_BINARIES) {

  1121 			return;

  1122 		}

  1123 

  1124 		setIsDrilldown(true);

  1125 

  1126 		if (drawMode == Defines.FUNCTIONS) {

  1127 			// set the page's graph title

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

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

  1130 			pV.getTitle2().setText(Messages.getString("AddrFunctionTable.functionTo"));  //$NON-NLS-1$

  1131 

  1132 			// set the draw mode

  1133 			this.myGraph.setDrawMode(Defines.FUNCTIONS_THREADS);

  1134