FCL/sftools/ana/dynaanaapps: comparison sysperfana/analyzetoolext/com.nokia.s60tools.analyzetool/src/com/nokia/s60tools/analyzetool/ui/MainView.java

equal deleted inserted replaced

-:844b047e260d
+:f65f740e69f9
 /*
-* Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
+* Copyright (c) 2008-2010 Nokia Corporation and/or its subsidiary(-ies).
 * All rights reserved.
 * This component and the accompanying materials are made available
 * under the terms of "Eclipse Public License v1.0"
 * which accompanies this distribution, and is available
 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
 import org.eclipse.core.runtime.IStatus;
 import org.eclipse.core.runtime.Path;
 import org.eclipse.core.runtime.Status;
 import org.eclipse.core.runtime.jobs.Job;
 import org.eclipse.jface.action.Action;
+import org.eclipse.jface.action.IAction;
 import org.eclipse.jface.action.IMenuListener;
 import org.eclipse.jface.action.IMenuManager;
 import org.eclipse.jface.action.IToolBarManager;
 import org.eclipse.jface.action.MenuManager;
 import org.eclipse.jface.action.Separator;
 import org.eclipse.jface.viewers.StructuredSelection;
 import org.eclipse.jface.viewers.TreeExpansionEvent;
 import org.eclipse.jface.viewers.TreeViewer;
 import org.eclipse.jface.viewers.Viewer;
 import org.eclipse.jface.viewers.ViewerSorter;
+import org.eclipse.jface.window.Window;
 import org.eclipse.swt.SWT;
 import org.eclipse.swt.custom.CTabFolder;
 import org.eclipse.swt.custom.CTabItem;
 import org.eclipse.swt.custom.SashForm;
 import org.eclipse.swt.dnd.Clipboard;
 import org.eclipse.swt.dnd.TextTransfer;
 import org.eclipse.swt.dnd.Transfer;
+import org.eclipse.swt.events.DisposeEvent;
+import org.eclipse.swt.events.DisposeListener;
 import org.eclipse.swt.events.KeyEvent;
 import org.eclipse.swt.events.KeyListener;
+import org.eclipse.swt.events.SelectionEvent;
+import org.eclipse.swt.events.SelectionListener;
 import org.eclipse.swt.graphics.Image;
 import org.eclipse.swt.layout.GridData;
 import org.eclipse.swt.widgets.Composite;
 import org.eclipse.swt.widgets.Label;
 import org.eclipse.swt.widgets.Menu;
 import org.eclipse.ui.IWorkbenchPage;
 import org.eclipse.ui.IWorkbenchPart;
 import org.eclipse.ui.PlatformUI;
 import org.eclipse.ui.dialogs.PreferencesUtil;
 import org.eclipse.ui.ide.IDE;
+import org.eclipse.ui.navigator.CommonNavigator;
 import org.eclipse.ui.part.ViewPart;
+import org.eclipse.ui.views.navigator.ResourceNavigator;
 import com.nokia.carbide.cdt.builder.CarbideBuilderPlugin;
 import com.nokia.carbide.cdt.builder.project.ICarbideBuildConfiguration;
 import com.nokia.carbide.cdt.builder.project.ICarbideProjectInfo;
+import com.nokia.carbide.cpp.internal.project.ui.views.SymbianProjectNavigatorView;
 import com.nokia.s60tools.analyzetool.Activator;
 import com.nokia.s60tools.analyzetool.AnalyzeToolHelpContextIDs;
 import com.nokia.s60tools.analyzetool.builder.BuilderUtil;
 import com.nokia.s60tools.analyzetool.engine.AnalysisItem;
 import com.nokia.s60tools.analyzetool.engine.AnalyzeFactory;
 import com.nokia.s60tools.analyzetool.engine.CallstackItem;
+import com.nokia.s60tools.analyzetool.engine.DeferredCallstackManager;
 import com.nokia.s60tools.analyzetool.engine.EpocReader;
 import com.nokia.s60tools.analyzetool.engine.IMemoryActivityModel;
 import com.nokia.s60tools.analyzetool.engine.MMPInfo;
 import com.nokia.s60tools.analyzetool.engine.ParseAnalyzeData;
 import com.nokia.s60tools.analyzetool.engine.ParseXMLFileSAX;
 import com.nokia.s60tools.analyzetool.engine.ProjectResults;
 import com.nokia.s60tools.analyzetool.engine.RunResults;
+import com.nokia.s60tools.analyzetool.engine.SimpleCallstackManager;
 import com.nokia.s60tools.analyzetool.engine.UseAtool;
 import com.nokia.s60tools.analyzetool.engine.statistic.ProcessInfo;
 import com.nokia.s60tools.analyzetool.engine.statistic.ReadFile;
 import com.nokia.s60tools.analyzetool.global.Constants;
 import com.nokia.s60tools.analyzetool.global.Util;
 import com.nokia.s60tools.analyzetool.ui.actions.DropDownMenu;
 import com.nokia.s60tools.analyzetool.ui.actions.FileActionHistory;
 import com.nokia.s60tools.analyzetool.ui.statistic.StatisticView;
 /**
-* Class to display memory analysis results also provides all the
+* AnalyzeTool main view which displays memory analysis results and provides
-* functionalities what AnalyzeTool has.
+* interface for all the functionalities what AnalyzeTool has.
 *
 * @author kihe
 *
 */
 public class MainView extends ViewPart implements ISelectionListener,
-		ITreeViewerListener, IActionListener, ISelectionChangedListener, KeyListener {
+		ITreeViewerListener, IActionListener, ISelectionChangedListener,
+		KeyListener {
 	/**
 	 * Sorts tree view objects.
 	 *
 	 * @author kihe
 	 */
 	public static class NameSorter extends ViewerSorter {
 		/**
 		 * Compares view items.
 		 *
 		 * @see org.eclipse.jface.viewers.ViewerComparator#compare(org.eclipse.jface.viewers.Viewer,
 		 *      java.lang.Object, java.lang.Object)
 		 *
 		 * @param viewer
 		 *            Viewer
 		 * @param e1
 		 *            Object
 		 * @param e2
 	 * example).
 	 */
 	class ViewContentProvider implements ITreeContentProvider {
 		/**
 		 *
 		 * @see org.eclipse.jface.viewers.IContentProvider#dispose()
 		 */
 		public void dispose() {
 			// MethodDeclaration/Block[count(BlockStatement) = 0 and
 			// @containsComment = 'false']
 		}
 		/**
 		 *
 		 * @see org.eclipse.jface.viewers.ITreeContentProvider#getChildren(java.lang.Object)
 		 */
 		public Object[] getChildren(Object parent) {
 			if (parent instanceof TreeParent) {
 				return ((TreeParent) parent).getChildren();
 			return new Object[0];
 		}
 		/*
 		 * (non-Javadoc)
 		 *
-		 * @see org.eclipse.jface.viewers.IStructuredContentProvider#getElements(java.lang.Object)
+		 * @see
+		 * org.eclipse.jface.viewers.IStructuredContentProvider#getElements(
+		 * java.lang.Object)
 		 */
 		public Object[] getElements(Object parent) {
 			if (parent.equals(getViewSite())) {
 				if (invisibleRoot == null) {
 					getStartupContent();
 			return getChildren(parent);
 		}
 		/*
 		 * (non-Javadoc)
 		 *
-		 * @see org.eclipse.jface.viewers.ITreeContentProvider#getParent(java.lang.Object)
+		 * @see
+		 * org.eclipse.jface.viewers.ITreeContentProvider#getParent(java.lang
+		 * .Object)
 		 */
 		public Object getParent(Object child) {
 			if (child instanceof TreeObject) {
 				return ((TreeObject) child).getParent();
 			}
 			return null;
 		}
 		/*
 		 * (non-Javadoc)
 		 *
-		 * @see org.eclipse.jface.viewers.ITreeContentProvider#hasChildren(java.lang.Object)
+		 * @see
+		 * org.eclipse.jface.viewers.ITreeContentProvider#hasChildren(java.lang
+		 * .Object)
 		 */
 		public boolean hasChildren(Object parent) {
 			if (parent instanceof TreeParent) {
 				return ((TreeParent) parent).hasChildren();
 			}
 			return false;
 		}
 		/*
 		 * (non-Javadoc)
 		 *
-		 * @see org.eclipse.jface.viewers.IContentProvider#inputChanged(org.eclipse.jface.viewers.Viewer,
+		 * @see
-		 *      java.lang.Object, java.lang.Object)
+		 * org.eclipse.jface.viewers.IContentProvider#inputChanged(org.eclipse
+		 * .jface.viewers.Viewer, java.lang.Object, java.lang.Object)
 		 */
 		public void inputChanged(Viewer v, Object oldInput, Object newInput) {
 			// MethodDeclaration/Block[count(BlockStatement) = 0 and
 			// @containsComment = 'false']
 		}
 	}
 	/**
 	 * Provides elements of tree view.
 	 *
 	 * @author kihe
 	 *
 	 */
 	public class ViewLabelProvider extends LabelProvider {
 		/**
 		 * Used when tree model item is TreeParent.
 					.createImage();
 		}
 		/**
 		 * Gets current tree object image.
 		 *
 		 * @see org.eclipse.jface.viewers.LabelProvider#getImage(java.lang.Object)
 		 *
 		 * @param obj
 		 *            Current tree model item
 		 * @return Corresponding image of tree view object
 		 */
 		@Override
 			return element;
 		}
 		/**
 		 * Gets current tree view object name.
 		 *
 		 * @see org.eclipse.jface.viewers.LabelProvider#getText(java.lang.Object)
 		 *
 		 * @return Current tree view object name
 		 */
 		@Override
 		public final String getText(final Object obj) {
 			return obj.toString();
 	private Action clickAction;
 	/** Change detail level action. */
 	public Action changeDetails;
 	/** Select S60 log file action. */
 	private Action s60LogTargetAction;
-	/** Select Tracing utility connection action. */
+	/** Select TraceViewer connection action. */
 	private Action externalLogTargetAction;
 	/** Select fast data gathering mode */
 	private Action externalFastLogTargetAction;
 	/** Select Ask always action. */
 	private Action askLogTargetAction;
 	public Action traceAction;
 	/** Start subtest action. */
 	private Action startSubtest;
 	/** Stop subtest action. */
 	private Action stopSubtest;
-	/**Refresh(re-creates) project results*/
+	/** Refresh(re-creates) project results */
 	private Action refreshResults;
-	/**Copies selected memory leak item info to the clipboard.*/
+	/** Copies selected memory leak item info to the clipboard. */
 	private Action copyAction;
-	/** Action to open AnalyzeTool preference page.*/
+	/** Action to open AnalyzeTool preference page. */
 	private Action openPrefs;
 	/**
 	 * Clears selected project results without removing temporary files
 	 */
 	private Action clearProjectResults;
 	private final ProjectResults projectResults;
 	/** Job for analyzing data files. */
 	private Job analyzeJob;
+	/** Job for reading the data files for the graph. */
+	private GraphLoadJob graphLoadJob;
 	/** Last selected tree item. */
 	private Object lastSelectedObject;
-	/** Contains information of which files is opened. */
+	/** Contains information of which files were opened. */
 	public FileActionHistory fileOpenHistory;
 	/** File open drop down menu. */
 	private DropDownMenu fileOpenMenu;
 	private DropDownMenu saveFileMenu;
 	/** Tab item for the "Top allocation locations" tab */
 	CTabItem memoryTab;
-	/** Tab item for the memory results tab*/
+	/** Tab item for the memory results tab */
 	CTabItem mainTab;
 	/** StatisticView reference */
 	StatisticView statisticView;
 	/** Contains project related modules */
 	private final Hashtable<IProject, AbstractList<MMPInfo>> projectModules;
-	/**Reads epocwind.out file*/
+	/** Reads epocwind.out file */
 	EpocReader listeningJob;
 	/** The chart view composite */
 	protected ChartContainer chart;
 	/**
 	 * The constructor.
 	 */
 	public MainView() {
-		parser = new ParseAnalyzeData(true, false);
+		parser = new ParseAnalyzeData(true, false, true);
 		cppFileNames = new ArrayList<String>();
 		startedSubtest = new ArrayList<ActiveSubtests>();
 		projectResults = new ProjectResults();
 		fileOpenHistory = new FileActionHistory(Constants.HISTORY_LEVEL);
 		projectModules = new Hashtable<IProject, AbstractList<MMPInfo>>();
 	}
 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see com.nokia.s60tools.analyzetool.ui.IActionListener#allModulesBuilt()
 	 */
 	public final void buildStateChanged(final IProject projRef) {
-		//check validity
+		// check validity
-		if(!project.equals(projRef) || projectResults == null) {
+		if (!project.equals(projRef) || projectResults == null) {
 			return;
 		}
 		final String datafile = projectResults.getDataFileName(projRef);
 		// if trace is captured or data file is opened
 		if (datafile != null && runView != null) {
 				} catch (java.io.IOException ioe) {
 					ioe.printStackTrace();
 				}
 			}
+			// data file is available
-			//data file is available
 			int dataFileType = UseAtool.checkFileType(datafile);
-			if( dataFileType == Constants.DATAFILE_INVALID || dataFileType == Constants.DATAFILE_XML || dataFileType == Constants.DATAFILE_EMPTY ) {
+			if (dataFileType == Constants.DATAFILE_INVALID
+					|| dataFileType == Constants.DATAFILE_XML
+					|| dataFileType == Constants.DATAFILE_EMPTY) {
 				return;
 			}
-			boolean reGenerate = Util.openConfirmationDialog(Constants.BUILD_STATE_CHANGED);
+			boolean reGenerate = Util
+					.openConfirmationDialog(Constants.BUILD_STATE_CHANGED);
-			if( reGenerate ) {
+			if (reGenerate) {
 				// sync with UI thread
 				runView.getControl().getDisplay().asyncExec(new Runnable() {
 					public void run() {
-						analyzeDataFile(Constants.ANALYZE_USE_DATA_FILE, datafile,
+						analyzeDataFile(Constants.ANALYZE_USE_DATA_FILE,
-								false);
+								datafile, false);
 					}
 				});
 			}
 		}
 	}
 	/**
 	 * Opens file dialog and analyzing data file for given location.
 	 *
 	 * @param type
 	 *            Type to define is data file asked from the user or using the
 	 *            give data file
 	 * @param existingDataFile
 	 *            Data file path
 			clearCallstackViewContent();
 			updateInformationLabel("");
 			runView.setInput(getStartupContent());
 			changeViewTitle(viewTitle);
-			AbstractList<MMPInfo> modules = Util.loadProjectTargetsInfo(project);
+			AbstractList<MMPInfo> modules = Util
+					.loadProjectTargetsInfo(project);
 			projectModules.put(project, modules);
 			boolean xmlFile = Util.isFileXML(selectedFile);
 			// if file is xml file
 			// no need to analyze data file
 						// update progress monitor state
 						monitor.beginTask(Constants.PROGRESSDIALOG_TITLE,
 								IProgressMonitor.UNKNOWN);
 						// Parse the data file
-						ParseXMLFileSAX dataFileParser = new ParseXMLFileSAX(project, selectedFile, projectResults);
+						ParseXMLFileSAX dataFileParser = new ParseXMLFileSAX(
+								project, selectedFile, projectResults);
 						boolean ret = dataFileParser.parse();
 						// set used datafile name
 						usedDataFileName = selectedFile;
 						// if parsing success
 						// display memory leak results
 						if (ret) {
 							// update project results
-							projectResults.setProjectModules(project, projectModules.get(project), dataFileParser.getModules());
+							projectResults.setProjectModules(project,
+									projectModules.get(project), dataFileParser
+											.getModules());
 						} else {
 							fileOpenHistory.removeFileName(selectedFile);
 							if (showErrorInfo) {
 								showErrorMessage(Constants.INFO_FILE_INVALID);
 							}
 				};
 				analyzingXMLJob.setUser(true);
 				analyzingXMLJob.schedule();
 			} else {
-				try{
+				try {
 					analyzeWithAtool(project, selectedFile, showErrorInfo);
-				}
+				} catch (Exception e) {
-				catch( Exception e ) {
 					analyzeJob = null;
 				}
 			}
 		}
 	}
 	/**
 	 * Analyzing memory analysis results using atool.exe.
 	 *
 	 * @param projectRef
 	 *            Project reference
 	 * @param usedFile
 	 *            Data file which contains memory analyze data
 	 * @param showErrorInfo
 				protected IStatus run(IProgressMonitor monitor) {
 					// inform progressdialog that task execution starts
 					// this make progressdialog visible on the UI
 					monitor.beginTask(Constants.PROGRESSDIALOG_ATOOL,
 							IProgressMonitor.UNKNOWN);
 					fileOpenHistory.setFileName(usedFile);
 					// add2UserActionHistory( "File opened: " + usedFile );
 					// set used datafile name
 					usedDataFileName = usedFile;
+					if (chart != null) {
+						resetGraphView();// clear out the graph view
+					}
 					// create atool object and execute atool
 					UseAtool atool = new UseAtool();
 					// create xml file
-					Constants.COMMAND_LINE_ERROR_CODE errorCode = atool.createXMLFileToCarbide(
+					Constants.COMMAND_LINE_ERROR_CODE errorCode = atool
-							monitor, projectRef, usedFile, "-a");
+							.createXMLFileToCarbide(monitor, projectRef,
+									usedFile, "-a");
 					String xmlFileLocation = null;
 					xmlFileLocation = atool.getDataFileName();
 					// if some error occurs display it to user.
-					if( errorCode != Constants.COMMAND_LINE_ERROR_CODE.OK ) {
+					if (errorCode != Constants.COMMAND_LINE_ERROR_CODE.OK) {
 						fileOpenHistory.removeFileName(usedFile);
 						Util.displayCommandLineError(errorCode);
 					}
 					// if XML file generation failed => info to the user
 					else if (xmlFileLocation == null) {
 						fileOpenHistory.removeFileName(usedFile);
 						if (showErrorInfo) {
 							showErrorMessage(Constants.INFO_FILE_INVALID);
 						}
 					} else {
 						// Parse the xml file
-						ParseXMLFileSAX dataFileParser = new ParseXMLFileSAX(project,
+						ParseXMLFileSAX dataFileParser = new ParseXMLFileSAX(
-								xmlFileLocation, projectResults);
+								project, xmlFileLocation, projectResults);
 						boolean error = dataFileParser.parse();
 						if (showErrorInfo && !error) {
 							fileOpenHistory.removeFileName(usedFile);
 							showErrorMessage(Constants.INFO_FILE_INVALID);
 						}
-						projectResults.setProjectModules(project, projectModules.get(project), dataFileParser.getModules());
+						projectResults.setProjectModules(project,
-						projectResults.setDataFileName(projectRef, usedDataFileName);
+								projectModules.get(project), dataFileParser
+										.getModules());
+						projectResults.setDataFileName(projectRef,
+								usedDataFileName);
 						// update display
 						refreshView();
 					}
 					updateChangeDetailState(projectRef);
-//					//this only generates statistics and this feature is currently disabled
+					// //this only generates statistics and this feature is
-//					if( !monitor.isCanceled() ) {
+					// currently disabled
-//
+					// if( !monitor.isCanceled() ) {
-//						IPreferenceStore store = Activator.getPreferences();
+					//
-//						boolean generateStatistic = store.getBoolean(Constants.CREATE_STATISTIC);
+					// IPreferenceStore store = Activator.getPreferences();
-//						//used file data file create statistic also
+					// boolean generateStatistic =
-//						if( generateStatistic && UseAtool.checkFileType(usedFile) == Constants.DATAFILE_TRACE )
+					// store.getBoolean(Constants.CREATE_STATISTIC);
-//						{
+					// //used file data file create statistic also
-//							monitor.setTaskName(Constants.STATISTICS_GENERATING_PROG_TITLE);
+					// if( generateStatistic && UseAtool.checkFileType(usedFile)
-//
+					// == Constants.DATAFILE_TRACE )
-//							ReadFile fileReader = new ReadFile();
+					// {
-//							boolean error = fileReader.readFile(usedFile);
+					// monitor.setTaskName(Constants.STATISTICS_GENERATING_PROG_TITLE);
-//							if( error && statisticView != null) {
+					//
-//								AbstractList<ProcessInfo> processes = fileReader.getStatistic();
+					// ReadFile fileReader = new ReadFile();
-//								statisticView.setData( project, processes);
+					// boolean error = fileReader.readFile(usedFile);
-//								fileReader.finish();
+					// if( error && statisticView != null) {
-//							}
+					// AbstractList<ProcessInfo> processes =
-//
+					// fileReader.getStatistic();
-//						}
+					// statisticView.setData( project, processes);
-//					}
+					// fileReader.finish();
+					// }
+					//
+					// }
+					// }
 					if (!monitor.isCanceled()) {
-						monitor.setTaskName(Constants.GRAPH_GENERATING_PROG_TITLE);
+						// create the job for loading the graph model
-						try {
+						// but only schedule it when the user gets to the graph
-							ReadFile fileReader = new ReadFile();
+						// tab
-							boolean success = fileReader.readFile(usedFile);
+						graphLoadJob = new GraphLoadJob(usedFile);
-							if (success) {
+						graphLoadJob.setUser(true);// set progress bar
-								if (chart != null){
+						graphLoadJob.setPriority(Job.LONG);
-									resetGraphView();
-								}
+						// run the following in UI thread, since widgets get
-								AbstractList<ProcessInfo> processes = fileReader.getStatistic();
+						// accessed
-								IMemoryActivityModel model = new AnalyzeFactory().createModel(processes.size() == 0);
+						PlatformUI.getWorkbench().getDisplay().syncExec(
-								chart.setInput(project, model);
+								new Runnable() {
-								model.addProcesses(processes);
+									public void run() {
-								fileReader.finish();
+										if (((CTabFolder) chart.getParent())
-							}
+												.getSelection() != null && ((CTabFolder) chart.getParent())
-						}catch( OutOfMemoryError oome ) {
+												.getSelection().getControl() == chart) {
-							Activator.getDefault().logInfo(IStatus.ERROR, IStatus.ERROR, "Can not allocate enough memory for the memory usage graph model.");
+											// chart tab is currently selected
-							analyzeJob = null;
+											// so we can run the load job
-						}catch (Exception e ) {
+											// straight away
-							Activator.getDefault().log(IStatus.ERROR, "Error while generating graph model", e);
+											graphLoadJob.schedule();
-							analyzeJob = null;
+										}
-						}
+									}
+								});
 					}
 					analyzeJob = null;
 					return new Status(IStatus.OK, Constants.ANALYZE_CONSOLE_ID,
 							IStatus.OK,
 							Constants.PROGRESSDIALOG_ANALYZE_COMPLETE, null);
 				}
 			};
+			if (graphLoadJob != null && graphLoadJob.getState() == Job.RUNNING) {
+				graphLoadJob.cancel();
+			}
+			graphLoadJob = null;
 			analyzeJob.setUser(true);
 			analyzeJob.setPriority(Job.LONG);
 			analyzeJob.schedule();
 		} else { // if existing job is running display info to user
 			showMessage(Constants.INFO_ALLREADY_RUNNING);
 		}
 	}
 	/**
 	 * Change report detail level.
 	 */
 	public final void changeDetailLevel() {
 	}
 	/**
 	 * Change logging mode.
 	 *
 	 * @param loggingMode
 	 *            Used logging mode
 	 */
 	public final void changeLogTarget(final String loggingMode) {
 		if (Constants.LOGGING_EXT.equals(usedLoggingMode)) {
 			logTargetMenu.setImageDescriptor(Activator
 					.getImageDescriptor(Constants.BUTTON_COMPUTER));
 			logTargetMenu
 					.setToolTipText(Constants.ACTION_CHANGE_LOGGING_MODE_TOOLTIP_EXT);
-			if (loggingMode == null){
+			if (loggingMode == null) {
 				externalLogTargetAction.setChecked(true);
 				s60LogTargetAction.setChecked(false);
 				externalFastLogTargetAction.setChecked(false);
 				askLogTargetAction.setChecked(false);
 			}
 			logTargetMenu.setImageDescriptor(Activator
 					.getImageDescriptor(Constants.BUTTON_CELLURAR));
 			logTargetMenu
 					.setToolTipText(Constants.ACTION_CHANGE_LOGGING_MODE_TOOLTIP_S60);
-			if (loggingMode == null){
+			if (loggingMode == null) {
 				externalLogTargetAction.setChecked(false);
 				s60LogTargetAction.setChecked(true);
 				externalFastLogTargetAction.setChecked(false);
 				askLogTargetAction.setChecked(false);
 			}
 		}
-		else if( Constants.LOGGING_EXT_FAST.equals(usedLoggingMode)) {
+		else if (Constants.LOGGING_EXT_FAST.equals(usedLoggingMode)) {
 			logTargetMenu.setImageDescriptor(Activator
 					.getImageDescriptor(Constants.BUTTON_COMPUTER_FAST));
-			logTargetMenu.setToolTipText(Constants.ACTION_CHANGE_LOGGING_MODE_TOOLTIP_FAST);
+			logTargetMenu
-			if( loggingMode == null) {
+					.setToolTipText(Constants.ACTION_CHANGE_LOGGING_MODE_TOOLTIP_FAST);
+			if (loggingMode == null) {
 				externalLogTargetAction.setChecked(false);
 				s60LogTargetAction.setChecked(false);
 				externalFastLogTargetAction.setChecked(true);
 				askLogTargetAction.setChecked(false);
 			}
 		else {
 			logTargetMenu.setImageDescriptor(Activator
 					.getImageDescriptor(Constants.BUTTON_ASK));
 			logTargetMenu
 					.setToolTipText(Constants.ACTION_CHANGE_LOGGING_MODE_TOOLTIP_ASK);
-			if (loggingMode == null){
+			if (loggingMode == null) {
 				externalLogTargetAction.setChecked(false);
 				s60LogTargetAction.setChecked(false);
 				externalFastLogTargetAction.setChecked(false);
 				askLogTargetAction.setChecked(true);
 			}
 		}
-		// if the fast data gathering mode is enabled by the preference page => enable also toolbar option
+		// if the fast data gathering mode is enabled by the preference page =>
+		// enable also toolbar option
 		// else disable fast data gathering mode
-		externalFastLogTargetAction.setEnabled(store.getBoolean(Constants.LOGGING_FAST_ENABLED));
+		externalFastLogTargetAction.setEnabled(store
+				.getBoolean(Constants.LOGGING_FAST_ENABLED));
 	}
 	/**
 	 * Changes "Change report detail level" action tooltip.
 	 */
 	}
 	/**
 	 * Change view title.
 	 *
 	 * @param newTitle
 	 *            New title text
 	 */
 	private void changeViewTitle(final String newTitle) {
 			super.setContentDescription(newTitle);
 		}
 	}
 	/**
-	 * Check project validity that is project is selected.
+	 * Check that selected project is open and project information can be read.
 	 *
 	 * @return True if project is open and accessible otherwise False
 	 */
 	public final boolean checkProjectValidity() {
 		// project is not selected show info to user
 		if (project == null || !project.isOpen()) {
 		boolean ret = Util.openConfirmationDialog(Constants.CONFIRM_DELETE_ALL);
 		// if user confirms
 		if (ret) {
 			// clear AnalyzeTool made changes
-			Util util = new Util();
+			Util.clearAtoolChanges(project);
-			util.clearAtoolChanges(project);
 			cleanAnalyzeData(null);
+			resetGraphView();
 			updateChangeDetailState(project);
 		}
-		if( statisticView != null ) {
+		if (statisticView != null) {
 			statisticView.clean(null);
 		}
-		if (chart != null){
-			resetGraphView();
-		}
 	}
 	/**
 	 * Cleans all the saved data.
 	 */
 		// clean all data if project not specified
 		if (projectRef == null) {
 			// clean all the project related info and data
 			projectResults.clear();
 			projectModules.clear();
-		}
+		} else {
-		else {
 			// clear only one project results
 			if (projectResults.contains(projectRef)) {
 				projectResults.clearProjectData(projectRef);
 			}
-			if( projectModules.contains(projectRef)) {
+			if (projectModules.contains(projectRef)) {
 				projectModules.remove(projectRef);
 			}
 		}
 		cppFileNames.clear();
 		// update variables
 		activeTreeItem = null;
 		usedDataFileName = "";
 		// set default view contents
 		if (runView != null) {
 			runView.getControl().getDisplay().syncExec(new Runnable() {
 				public void run() {
 					if (informationLabel != null) {
 						updateInformationLabel("");
 					}
 					changeViewTitle(viewTitle);
-					if( statisticView != null ) {
+					if (statisticView != null) {
 						statisticView.clean(projectRef);
 					}
 				}
 			});
 		}
 		clearCallstackViewContent();
-		if( clearProjectResults != null && clearProjectResults != null ) {
+		if (clearProjectResults != null && clearProjectResults != null) {
 			clearProjectResults.setEnabled(false);
-		}else if( clearProjectResults != null ) {
+		} else if (clearProjectResults != null) {
 			updateChangeDetailState(projectRef);
 		}
 	}
 		IActionBars bars = getViewSite().getActionBars();
 		fillLocalPullDown(bars.getMenuManager());
 		fillLocalToolBar(bars.getToolBarManager());
 	}
+	/**
-	/**
+	 * This is a callback that will allow us to create the viewer and initialize
-	* This is a callback that will allow us
+	 * it.
-	* to create the viewer and initialize it.
+	 */
-	*/
 	@Override
-	public void createPartControl( Composite parent ){
+	public void createPartControl(Composite parent) {
-		//create new Tab
+		// create new Tab
-		CTabFolder mainFolder = new CTabFolder( parent, SWT.TOP );
+		final CTabFolder mainFolder = new CTabFolder(parent, SWT.TOP);
-		//create main view and add it tab
+		// create main view and add it tab
-		createMainView( mainFolder );
+		createMainView(mainFolder);
-		//create new statistic view
+		// create new statistic view
-		//createMemoryView( mainFolder );
+		// createMemoryView( mainFolder );
-		//create graph
+		// create graph
 		createGraphView(mainFolder);
-		//set initial selection
+		// set initial selection
-		mainFolder.setSelection( mainTab );
+		mainFolder.setSelection(mainTab);
+		mainFolder.addSelectionListener(new SelectionListener() {
+			public void widgetDefaultSelected(SelectionEvent e) {
+				widgetSelected(e);
+			}
+			public void widgetSelected(SelectionEvent e) {
+				// if we changed to the graph tab and the graph load job isn't already running
+				// schedule it now
+				if (graphLoadJob != null
+						&& graphLoadJob.getState() != Job.RUNNING
+						&& mainFolder.getSelection() != null
+						&& mainFolder.getSelection().getControl() == chart) {
+					graphLoadJob.schedule();
+				}
+				if (mainFolder.getSelectionIndex() == 1) {
+					changeDetails.setEnabled(false);
+				} else {
+					changeDetails.setEnabled(true);
+				}
+			}
+		});
+		// stop any jobs that may be scheduled
+		mainFolder.addDisposeListener(new DisposeListener(){
+			public void widgetDisposed(DisposeEvent e) {
+				if (graphLoadJob != null){
+					graphLoadJob.cancel();
+					graphLoadJob = null;
+				}
+				if (analyzeJob != null){
+					analyzeJob.cancel();
+					analyzeJob = null;
+				}
+			}
+		});
 	}
 	/**
 	 * Creates graph view and add it to graph tab
-	 * @param parent CTabFolder parent of the view
+	 *
+	 * @param mainFolder
+	 *            CTabFolder parent of the view
 	 */
 	private void createGraphView(CTabFolder mainFolder) {
 		final CTabItem chartTabItem = new CTabItem(mainFolder, SWT.NONE);
 		chartTabItem.setText("Graph");
 		chartTabItem.setToolTipText("AnalyzeTool graph per process");
 		chart = new ChartContainer(mainFolder, SWT.NONE);
 		chartTabItem.setControl(chart);
 		IMemoryActivityModel model = AnalyzeFactory.getEmptyModel();
 		chart.setInput(project, model);
-		model.addProcesses(model.getProcesses());//charts should get notified via listeners on the model
+		model.addProcesses(model.getProcesses());// charts should get notified
-	}
+		// via listeners on the
+		// model
+	}
 	/**
 	 * Clears the graph by setting an empty model and causing paint events
 	 */
-	private void resetGraphView(){
+	private void resetGraphView() {
-		if (chart != null){
+		if (chart != null) {
 			chart.setInput(project, AnalyzeFactory.getEmptyModel());
-			//chart.update();
+			// chart.update();
 		}
 	}
 	/**
 	 * Creates new statistic view and add it to memory tab
-	 * @param parent Statistic view parent( CTabFolder )
+	 *
-	 */
+	 * @param parent
-	public void createMemoryView( CTabFolder parent )
+	 *            Statistic view parent( CTabFolder )
-	{
+	 */
+	public void createMemoryView(CTabFolder parent) {
 		statisticView = new StatisticView();
-		memoryTab = statisticView.createView( parent );
+		memoryTab = statisticView.createView(parent);
 	}
 	/**
 	 * Creates memory results view
-	 * @param parent View parent ( CTabFolder )
+	 *
+	 * @param parent
+	 *            View parent ( CTabFolder )
 	 */
 	public void createMainView(CTabFolder parent) {
 		// Create SashForm this form includes all the current view components
 		SashForm sashForm = new SashForm(parent, SWT.HORIZONTAL);
-		mainTab = new CTabItem( parent, SWT.NONE );
+		mainTab = new CTabItem(parent, SWT.NONE);
-		mainTab.setControl( sashForm );
+		mainTab.setControl(sashForm);
 		mainTab.setText(Constants.MAIN_TAB_TITLE);
 		// create new treeviewer to shown memory analysis runs and leaks
 		runView = new TreeViewer(sashForm, SWT.VIRTUAL);
 		hookDoubleClickAction();
 		hookClicks();
 		contributeToActionBars();
 		// set view title
-		viewTitle = String.format(Constants.ANALYZE_TOOL_TITLE_WITH_VERSION, Util.getAToolFeatureVersionNumber());
+		viewTitle = String.format(Constants.ANALYZE_TOOL_TITLE_WITH_VERSION,
+				Util.getAToolFeatureVersionNumber());
 		this.setContentDescription(viewTitle);
 		// add selection listener
 		if (getSite() != null) {
 			getSite().getPage().addSelectionListener(this);
 				callstackView.getControl(),
 				AnalyzeToolHelpContextIDs.ANALYZE_MAIN);
 		PlatformUI.getWorkbench().getHelpSystem().setHelp(runView.getControl(),
 				AnalyzeToolHelpContextIDs.ANALYZE_MAIN);
-		ResourcesPlugin.getWorkspace().addResourceChangeListener(new ATResourceListener());
+		ResourcesPlugin.getWorkspace().addResourceChangeListener(
+				new ATResourceListener());
-		//get used command line engine version
-		String version = Util.getAtoolVersionNumber(Util.getAtoolInstallFolder());
+		// get used command line engine version
+		String version = Util.getAtoolVersionNumber(Util
-		//compare current version to min version
+				.getAtoolInstallFolder());
-		int comp = Util.compareVersionNumber(Constants.CS_SUPPORT_MIN_VERSION, version);
+		// compare current version to min version
+		int comp = Util.compareVersionNumber(Constants.CS_SUPPORT_MIN_VERSION,
+				version);
 		IPreferenceStore store = Activator.getPreferences();
-		//if current version is same or higher than required version => set flag to true
+		// if current version is same or higher than required version => set
-		if( comp == Constants.VERSION_NUMBERS_EQUALS || comp == Constants.VERSION_NUMBERS_SECOND ) {
+		// flag to true
+		if (comp == Constants.VERSION_NUMBERS_EQUALS
+				|| comp == Constants.VERSION_NUMBERS_SECOND) {
 			store.setValue(Constants.LOGGING_FAST_ENABLED, true);
-		}
+		} else {
-		else {
 			store.setValue(Constants.LOGGING_FAST_ENABLED, false);
 		}
 		// get default value for logging mode
 		preferenceChanged();
 	}
 	/**
-	 * When AnalyzeTool view is activated and Tracing utility plug-in is not
+	 * When AnalyzeTool view is activated and TraceViewer plug-in is not
 	 * available disable AnalyzeTool trace actions.
 	 *
 	 * @see com.nokia.s60tools.analyzetool.ui.IActionListener#disableTraceActions(boolean)
 	 *
 	 * @param disable
 	 *            Boolean state of trace action
 	 */
 	public void disableTraceActions(final boolean disable) {
 		traceActive = false;
 	}
 	/**
 	 * Fills context menu.
 	 *
 	 * @param manager
 	 *            Menu manager
 	 */
 	private void fillContextMenu(IMenuManager manager) {
 		manager.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS));
 	}
 	/**
 	 * Fills local pull down menu.
 	 *
 	 * @param manager
 	 *            Menu manager
 	 */
 	private void fillLocalPullDown(IMenuManager manager) {
 		manager.add(buildWithAtool);
 		manager.add(openPrefs);
 	}
 	/**
 	 * Fills local toolbar.
 	 *
 	 * @param manager
 	 *            Menu manager
 	 */
 	private void fillLocalToolBar(IToolBarManager manager) {
 		manager.add(openPrefs);
 	}
 	/**
 	 * Gets call stack information of current leak.
 	 *
 	 * @param treeObject
 	 *            Tree object
 	 * @return Object
 	 */
 	Object getCallStack(final TreeObject treeObject) {
 		TreeParent parent = helper.getCallstack(item, modules);
 		return parent;
 	}
 	/**
 	 * Gets callstack item name.
 	 *
 	 * @param callstackItem
 	 *            One callstack item
 	 * @return Callstack name if found otherwise null
 	 */
 	public final String getCallstackItemName(final CallstackItem callstackItem) {
 		}
 		// check that project contains cpp file which is parsed from call stack
 		// list
 		Iterator<String> iterCppFiles = cppFileNames.iterator();
-		while( iterCppFiles.hasNext() ) {
+		while (iterCppFiles.hasNext()) {
 			String cppFileLocation = iterCppFiles.next();
-			//parse file name from the source path
+			// parse file name from the source path
 			int slash = Util.getLastSlashIndex(cppFileLocation);
-			if( slash != -1 ) {
+			if (slash != -1) {
-				String cppFile = cppFileLocation.substring(slash+1, cppFileLocation.length());
+				String cppFile = cppFileLocation.substring(slash + 1,
-				if( cppFile.equalsIgnoreCase(fileName)) {
+						cppFileLocation.length());
+				if (cppFile.equalsIgnoreCase(fileName)) {
 					cppFileName = cppFileLocation;
 					break;
 				}
 			}
 		}
 		return cppFileName;
 	}
 	/**
 	 * Gets file info for current project.
 	 *
 	 * @param projectRef
 	 *            Project reference
 	 */
 	private void getFileInfos(final IProject projectRef) {
 		ResourceVisitor visitor = new ResourceVisitor(this);
 		}
 	}
 	/**
 	 * Gets project results.
 	 *
 	 * @param projectRef
 	 *            Project reference
 	 */
 	public void getProjectResults(final IProject projectRef) {
 		// if project reference is null => leave
 				updateBuildState(lastProjectRef);
 				updateChangeDetailState(lastProjectRef);
 			}
 		}
-		//update clear project results action state
+		// update clear project results action state
-		if( projectResults.contains(projectRef) ) {
+		if (projectResults.contains(projectRef)) {
 			clearProjectResults.setEnabled(true);
-		}
+		} else {
-		else {
 			clearProjectResults.setEnabled(false);
 		}
 	}
 	/**
 	 * Gets memory leak analysis results.
 	 *
 	 * @param showErrorInfo
 	 *            Display error info or not
 	 * @return Object memory leak analysis results
 	 */
 	private Object getResults(final boolean showErrorInfo) {
 				changeViewTitle(viewTitle);
 				updateInformationLabel(Constants.INFO_NO_DATA);
 				return getStartupContent();
 			}
-			if( !projectModules.containsKey(project) )
+			if (!projectModules.containsKey(project)) {
-			{
+				AbstractList<MMPInfo> modules = Util
-				AbstractList<MMPInfo> modules = Util.loadProjectTargetsInfo(project);
+						.loadProjectTargetsInfo(project);
 				projectModules.put(project, modules);
 			}
 			// get run results
 			AbstractList<RunResults> runs = projectResults.getResults(project);
 			IPreferenceStore store = Activator.getPreferences();
 			// create TreeHelper object
 			// TreeHelper class creates tree model to this view.
-			TreeHelper helper = new TreeHelper(lastSelectedObject,
+			TreeHelper helper = new TreeHelper(lastSelectedObject, store);
-					store);
 			// clear active item
 			activeTreeItem = null;
 			// update used data file name
 			usedDataFileName = projectResults.getDataFileName(project);
 			// change view title
-			changeViewTitle(viewTitle
+			changeViewTitle(viewTitle + " results from file: "
-					+ " results from file: " + usedDataFileName);
+					+ usedDataFileName);
 			// thru runs
 			Iterator<RunResults> runIterator = runs.iterator();
 			while (runIterator.hasNext()) {
 				// get one run info
 				RunResults oneRunResults = runIterator.next();
 				// creates one run information at the time
-				TreeParent oneRunTree = helper.createRunResults(oneRunResults, modules);
+				TreeParent oneRunTree = helper.createRunResults(oneRunResults,
+						modules);
 				// get active item
 				// active must ask from the TreeHelper class
 				// because it can be filtered out when creating new tree model
 				activeTreeItem = helper.getActiveItem();
 		return invisibleRoot;
 	}
 	/**
 	 * Sets startup contents for view.
 	 *
 	 * @return Object which can be displayd
 	 */
 	public TreeParent getStartupContent() {
 		// create default treeviewer content
 		invisibleRoot = new TreeParent(Constants.ANALYZE_TOOL_TITLE);
 			}
 		});
 	}
 	/**
-	 * Check that if subtest by given name allready exists.
+	 * Check that if subtest by given name already exists.
 	 *
 	 * @param subTestName
 	 *            Subtest name
 	 * @param target
 	 *            Testing target
-	 * @return True if allready exists otherwise False
+	 * @return True if already exists otherwise False
 	 */
 	public final boolean isSubtestExists(final String subTestName,
 			final String target) {
 		Iterator<ActiveSubtests> subTestIter = startedSubtest.iterator();
 		while (subTestIter.hasNext()) {
 		}
 		return false;
 	}
 	/**
 	 * Go thru the project files and stores mmp files.
 	 *
 	 * @param resource
 	 *            One resource file of project
 	 */
 	public final void loadFileInfo(IResource resource) {
 		// get all the cpp file info which are imported to workspace
 				// get call stack addresses to view
 				if (obj instanceof TreeObject) {
 					lastSelectedObject = obj;
-					//get callstack items
+					// get callstack items
 					Object resultObject = getCallStack((TreeObject) obj);
 					// if results not found
-					if( resultObject == null ) {
+					if (resultObject == null) {
 						copyAction.setEnabled(false);
-					}
+					} else {
-					else {
 						callstackView.setInput(resultObject);
 						copyAction.setEnabled(true);
 					}
 				}
 		clearProjectResults = new Action() {
 			@Override
 			public void run() {
 				cleanAnalyzeData(project);
-				if(statisticView != null ) {
+				if (statisticView != null) {
 					statisticView.clean(project);
 				}
 				updateChangeDetailState(project);
 			}
 		};
 		clearProjectResults.setToolTipText(Constants.ACTION_CLEAR_RESULTS);
 		refreshResults = new Action() {
 			@Override
 			public void run() {
-				if( project != null && project.isOpen() && projectResults != null ) {
+				if (project != null && project.isOpen()
+						&& projectResults != null) {
 					String dataFile = projectResults.getDataFileName(project);
-					if( dataFile != null || !("").equals(dataFile) ) {
+					if (dataFile != null || !("").equals(dataFile)) {
-						analyzeDataFile(Constants.ANALYZE_USE_DATA_FILE, dataFile, true);
+						analyzeDataFile(Constants.ANALYZE_USE_DATA_FILE,
-					}
+								dataFile, true);
-					else {
+					} else {
-						//some internal error occurred => disable this action
+						// some internal error occurred => disable this action
 						refreshResults.setEnabled(false);
 					}
 				}
 			}
 		};
 		refreshResults.setText(Constants.ACTION_RE_ANALYZE);
 		refreshResults.setToolTipText(Constants.ACTION_RE_ANALYZE_TOOLTIP);
 		refreshResults.setEnabled(false);
-		//copy active item contents to clipboard
+		// copy active item contents to clipboard
-		copyAction = new Action(){
+		copyAction = new Action() {
 			@Override
 			public void run() {
-				//copy active item contents to clipboard
+				// copy active item contents to clipboard
-				//Create new clipboard object
+				// Create new clipboard object
 				Clipboard cp = new Clipboard(runView.getControl().getDisplay());
-				//Create new TextTransfer object
+				// Create new TextTransfer object
-				//TextTransfer converts plain text represented as a java String to a platform specific representation of the data and vice versa
+				// TextTransfer converts plain text represented as a java String
+				// to a platform specific representation of the data and vice
+				// versa
 				TextTransfer tt = TextTransfer.getInstance();
-				//new StringBuffer which contains the copied text
+				// new StringBuffer which contains the copied text
 				StringBuffer sb = new StringBuffer(64);
 				// chech that project contains results
-				if( projectResults == null || !projectResults.contains(project) || activeTreeItem == null ) {
+				if (projectResults == null || !projectResults.contains(project)
+						|| activeTreeItem == null) {
 					return;
 				}
-				//get active item info (also callstack info)
+				// get active item info (also callstack info)
 				AnalysisItem item = null;
 				// if selected item is subtest
-				if( activeTreeItem.isSubTest() ) {
+				if (activeTreeItem.isSubTest()) {
 					item = projectResults.getSubtestItem(project,
-							activeTreeItem.getRunID(), activeTreeItem.getMemLeakID(),
+							activeTreeItem.getRunID(), activeTreeItem
-							activeTreeItem.getSubtestID());
+									.getMemLeakID(), activeTreeItem
-				}
+									.getSubtestID());
-				else {
+				} else {
-					item = projectResults.getSpecific(project, activeTreeItem.getRunID(), activeTreeItem.getMemLeakID());
+					item = projectResults.getSpecific(project, activeTreeItem
+							.getRunID(), activeTreeItem.getMemLeakID());
 				}
 				// check that item found
-				if( item == null ) {
+				if (item == null) {
 					return;
 				}
 				sb.append(activeTreeItem.getName());
-				String separator = System.getProperty ( "line.separator" );
+				String separator = System.getProperty("line.separator");
 				sb.append(separator);
 				char space = ' ';
-				AbstractList<CallstackItem> callstackItems = item.getCallstackItems();
+				AbstractList<CallstackItem> callstackItems = item
-				Iterator<CallstackItem> iterCallstack = callstackItems.iterator();
+						.getCallstackItems();
-				while( iterCallstack.hasNext() ) {
+				Iterator<CallstackItem> iterCallstack = callstackItems
+						.iterator();
+				while (iterCallstack.hasNext()) {
 					CallstackItem oneItem = iterCallstack.next();
 					sb.append("      ");
 					sb.append(oneItem.getMemoryAddress());
 					sb.append(space);
 					sb.append(oneItem.getModuleName());
 					sb.append(oneItem.getFunctionName());
 					sb.append(space);
 					sb.append(oneItem.getFileName());
 					sb.append(space);
 					int lineNbr = oneItem.getLeakLineNumber();
-					if( lineNbr > 0 ) {
+					if (lineNbr > 0) {
 						sb.append(lineNbr);
 					}
 					sb.append(separator);
 				}
-				//info is ready => now copy info to clipboard
+				// info is ready => now copy info to clipboard
 				cp.setContents(new Object[] { sb.toString() },
-			            new Transfer[] { tt });
+						new Transfer[] { tt });
 			}
 		};
 		copyAction.setText(Constants.ACTION_COPY);
 		copyAction.setEnabled(false);
 		// open preferences action
 		openPrefs = new Action() {
 			@Override
 			public void run() {
-				PreferenceDialog dialog = PreferencesUtil.createPreferenceDialogOn(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(),
+				PreferenceDialog dialog = PreferencesUtil
-						Constants.ANALYZE_TOOL_PREFS_ID, null, null);
+						.createPreferenceDialogOn(PlatformUI.getWorkbench()
+								.getActiveWorkbenchWindow().getShell(),
-				if( dialog != null ) {
+								Constants.ANALYZE_TOOL_PREFS_ID, null, null);
+				if (dialog != null) {
 					dialog.open();
 				}
 			}
 		};
 		openPrefs.setText(Constants.ACTION_OPEN_PREFS);
 		openPrefs.setToolTipText(Constants.ACTION_OPEN_PREFS_TOOLTIP);
-		openPrefs.setImageDescriptor(Activator.getImageDescriptor(Constants.BUTTON_OPEN_PREFS));
+		openPrefs.setImageDescriptor(Activator
+				.getImageDescriptor(Constants.BUTTON_OPEN_PREFS));
 		changeReportActionTooltip();
 		updateChangeDetailState(project);
 		updateBuildState(project);
 	}
 		fileOpenMenu.setImageDescriptor(Activator
 				.getImageDescriptor(Constants.BUTTON_OPEN));
 	}
 	/**
-	 * Creates file open actions.
+	 * Creates data gathering actions.
 	 */
 	private void makeLogTargetActions() {
-		s60LogTargetAction = new Action(Constants.LOGGING_S60, Action.AS_RADIO_BUTTON) {
+		s60LogTargetAction = new Action(Constants.LOGGING_S60,
+				IAction.AS_RADIO_BUTTON) {
 			@Override
 			public void run() {
 				changeLogTarget(Constants.LOGGING_S60);
 			}
 		};
 		s60LogTargetAction
 				.setToolTipText(Constants.ACTION_CHANGE_LOGGING_MODE_TOOLTIP_S60);
 		s60LogTargetAction.setImageDescriptor(Activator
 				.getImageDescriptor(Constants.BUTTON_CELLURAR));
-		externalLogTargetAction = new Action(Constants.LOGGING_EXT, Action.AS_RADIO_BUTTON) {
+		externalLogTargetAction = new Action(Constants.LOGGING_EXT,
+				IAction.AS_RADIO_BUTTON) {
 			@Override
 			public void run() {
 				changeLogTarget(Constants.LOGGING_EXT);
 			}
 		};
 		externalLogTargetAction
 				.setToolTipText(Constants.ACTION_CHANGE_LOGGING_MODE_TOOLTIP_EXT);
 		externalLogTargetAction.setImageDescriptor(Activator
 				.getImageDescriptor(Constants.BUTTON_COMPUTER));
-		externalFastLogTargetAction = new Action(Constants.LOGGING_EXT_FAST, Action.AS_RADIO_BUTTON) {
+		externalFastLogTargetAction = new Action(Constants.LOGGING_EXT_FAST,
+				IAction.AS_RADIO_BUTTON) {
 			@Override
 			public void run() {
 				changeLogTarget(Constants.LOGGING_EXT_FAST);
 			}
 		};
 		externalFastLogTargetAction.setText(Constants.PREFS_EXT_FAST);
-		externalFastLogTargetAction.setToolTipText(Constants.PREFS_EXT_FAST_TOOLTIP);
+		externalFastLogTargetAction
+				.setToolTipText(Constants.PREFS_EXT_FAST_TOOLTIP);
 		externalFastLogTargetAction.setImageDescriptor(Activator
 				.getImageDescriptor(Constants.BUTTON_COMPUTER_FAST));
-		askLogTargetAction = new Action(Constants.LOGGING_ASK_ALLWAYS, Action.AS_RADIO_BUTTON) {
+		askLogTargetAction = new Action(Constants.LOGGING_ASK_ALLWAYS,
+				IAction.AS_RADIO_BUTTON) {
 			@Override
 			public void run() {
 				changeLogTarget(Constants.LOGGING_ASK_ALLWAYS);
 			}
 		};
 		askLogTargetAction.setText(Constants.PREFS_ASK_ALWAYS);
 		askLogTargetAction
 				.setToolTipText(Constants.ACTION_CHANGE_LOGGING_MODE_TOOLTIP_ASK);
 		askLogTargetAction.setImageDescriptor(Activator
 				.getImageDescriptor(Constants.BUTTON_ASK));
 	}
 	/**
-	 * Opens current callstack item on default editor and pinpoints memory leak.
+	 * Displays selected callstack item location on default file editor.
-	 * line
+	 *
-	 *
 	 * @param treeObject
 	 *            Tree object
 	 */
 	public final void openEditor(final TreeObject treeObject) {
 		// get file info for all projects
 		}
 	}
 	/**
 	 * Updates log target action and report action tooltips.
 	 *
 	 * @see com.nokia.s60tools.analyzetool.ui.IActionListener#preferenceChanged()
 	 */
 	public void preferenceChanged() {
 		// get active logging mode
 		changeLogTarget(null);
 				// refresh view
 				runView.setInput(getResults(false));
 				// refresh callstack view
 				getCallStack(activeTreeItem);
-				if( project != null && project.isOpen() && projectResults.contains(project)) {
+				if (project != null && project.isOpen()
+						&& projectResults.contains(project)) {
 					clearProjectResults.setEnabled(true);
-				}
+				} else {
-				else {
 					clearProjectResults.setEnabled(false);
 				}
 				updateChangeDetailState(project);
 			}
 		});
 	}
 	/**
 	 * Runs user selected AnalyzeTool action.
 	 *
-	 * @see com.nokia.s60tools.analyzetool.ui.IActionListener#runAction(IProject, com.nokia.s60tools.analyzetool.global.Constants.ACTIONS)
+	 * @see com.nokia.s60tools.analyzetool.ui.IActionListener#runAction(IProject,
-	 *
+	 *      com.nokia.s60tools.analyzetool.global.Constants.ACTIONS)
+	 *
 	 * @param projectRef
 	 *            Project reference
 	 *
 	 * @param action
 	 *            Which action to execute
 	 */
 	public void runAction(IProject projectRef, Constants.ACTIONS action) {
 		project = projectRef;
 			break;
 		}
 	}
 	/**
-	 * Saves existing report or data file asks user where to save.
+	 * Copies existing report or data file to the new location. Asks from user
-	 *
+	 * new location where to copy the file.
+	 *
 	 * @param type
 	 *            Which kind of type the file is. Possible types xml or data
 	 *            file
 	 *
 	 * @return True if saving successfully otherwise false
 	 */
 	public final boolean saveReportFile(final int type) {
 		// copy success?
 		boolean success = false;
 	}
 	/**
 	 * Notifies this action delegate that the selection in the workbench has
 	 * changed.
 	 *
 	 * @param part
 	 *            Workbench part
 	 *
 	 * @param selection
 	 *            User selection
 	 */
 	@SuppressWarnings("restriction")
 	public void selectionChanged(IWorkbenchPart part, ISelection selection) {
 		// project reference
 		IProject selectedProject = null;
-		// check where the selection comes
+		// Check where the selection comes from
-		// supported views: CommonNavigator and SymbianProjectNavigator
+		// Supported views: CommonNavigator, SymbianProjectNavigatorView and
-		if (!(part instanceof org.eclipse.ui.navigator.CommonNavigator) ) {
+		// ResourceNavigator
+		if (!(part instanceof CommonNavigator
+				|| part instanceof SymbianProjectNavigatorView || part instanceof ResourceNavigator)) {
 			return;
 		}
 		// get selection
 		IStructuredSelection structuredSelection = (IStructuredSelection) selection;
 						.getCProject().getProject();
 			} else if (adaptable instanceof org.eclipse.cdt.core.model.ICProject) {
 				selectedProject = ((org.eclipse.cdt.core.model.ICProject) adaptable)
 						.getProject();
 			} else {
-				resource = (IResource) adaptable
+				resource = (IResource) adaptable.getAdapter(IResource.class);
-						.getAdapter(IResource.class);
 			}
 			// resource found => get resource project
 			if (resource != null) {
 				selectedProject = resource.getProject();
 		// if project found and it is open => get project results
 		if (selectedProject != null && selectedProject.isOpen()) {
 			project = selectedProject;
 			getProjectResults(selectedProject);
 			updateBuildState(project);
-			if( statisticView != null ) {
+			if (statisticView != null) {
 				statisticView.handleProjectChange(project);
 			}
 		}
 	}
+	/**
-	/**
+	 * Executes clickAction when user selects item in the AnalyzeTool view.
-	 * Executes clicAction when user selects item in the AnalyzeTool view.
+	 *
-	 *
 	 * @see org.eclipse.jface.viewers.ISelectionChangedListener#selectionChanged(org.eclipse.jface.viewers.SelectionChangedEvent)
 	 *
 	 * @param event
 	 *            Selection changed event
 	 */
 	public void selectionChanged(SelectionChangedEvent event) {
 		clickAction.run();
 	}
 	/**
 	 * Shows error message.
 	 *
 	 * @param message
 	 *            Error message to show
 	 */
 	public final void showErrorMessage(final String message) {
 		runView.getControl().getDisplay().syncExec(new Runnable() {
 		});
 	}
 	/**
 	 * Shows message.
 	 *
 	 * @param message
 	 *            Message to show
 	 */
 	public final void showMessage(final String message) {
 		runView.getControl().getDisplay().syncExec(new Runnable() {
 			// delete existing data file
 			Util.deleteDataFile(project);
 		}
-		ICarbideProjectInfo info = CarbideBuilderPlugin.getBuildManager().getProjectInfo(project);
+		ICarbideProjectInfo info = CarbideBuilderPlugin.getBuildManager()
+				.getProjectInfo(project);
 		ICarbideBuildConfiguration config = info.getDefaultConfiguration();
-		//start listening emulator output
+		// start listening emulator output
-		if( config.getPlatformString().equals(Constants.BUILD_TARGET_WINSCW) ) {
+		if (config.getPlatformString().equals(Constants.BUILD_TARGET_WINSCW)) {
+			String dbghelpDllVersionInfo = Util.getDbghelpDllVersionInfo(Util
+					.getAtoolInstallFolder());
+			if (dbghelpDllVersionInfo != Constants.DBGHELPDLL_IS_UP_TO_DATE) {
+				DbghelpDllVersionInfoDialog dialog = new DbghelpDllVersionInfoDialog(
+						getSite().getShell(), dbghelpDllVersionInfo);
+				if (dialog.open() == Window.CANCEL)
+					return;
+			}
 			listeningJob = new EpocReader(project, this);
 			listeningJob.start();
 			traceStarted();
 			return;
 		}
-		// else start trace capturing using Tracing utility connection
+		// else start trace capturing using TraceViewer connection
 		// main view class instance
 		// this instance if passed to the TraceWrapper class
 		final MainView selfInstance = this;
 		Job activateTrace = new Job(Constants.STARTING_TRACE) {
 		} else {
 			target = Util.openSelectionDialog(Constants.SUBTEST_SELECT_TARGET,
 					Constants.SUBTEST_RUNNING_PROCESSES_INFO, targets);
 		}
-		if (target == null || ("").equals(target) ) {
+		if (target == null || ("").equals(target)) {
 			return;
 		}
 		// ask for subtest name
 		CustomInputDialog dialog = new CustomInputDialog(
 		}
 		// get process id for selected target
 		int processID = startedPros.get(target);
-		// if subtest allready exists
+		// if subtest already exists
 		if (isSubtestExists(subTestName, target)) {
 			Util.showMessage(Constants.SUBTEST_ALLREADY_RUNNING);
 			return;
 		}
 		ActiveSubtests subtes = new ActiveSubtests(subTestName, target,
 				processID);
 		startedSubtest.add(subtes);
 		// start subtest
-		parser.parse(Constants.PREFIX + " " + processID + " TEST_START 0000 "
+		parser.parse(Constants.PREFIX + " " + subtes.getProcessID()
-				+ subTestName);
+				+ " TEST_START 0000 " + subTestName);
 		updateSubtestInfoText(Constants.SUBTEST_STARTED + target
 				+ Constants.ENRULE + subTestName);
 		stopSubtest.setEnabled(true);
 	}
 	/**
 	 * Stop external message tracing.
 	 */
 	public final void stop(boolean analyze) {
-		ICarbideProjectInfo info = CarbideBuilderPlugin.getBuildManager().getProjectInfo(project);
+		ICarbideProjectInfo info = CarbideBuilderPlugin.getBuildManager()
+				.getProjectInfo(project);
 		ICarbideBuildConfiguration config = info.getDefaultConfiguration();
-		if( config.getPlatformString().equalsIgnoreCase(Constants.BUILD_TARGET_WINSCW) ) {
+		if (config.getPlatformString().equalsIgnoreCase(
+				Constants.BUILD_TARGET_WINSCW)) {
 			listeningJob.stop();
 			traceStopped(analyze);
 			return;
 		}
-		//else stop Tracing utility connection
+		// else stop TraceViewer connection
 		try {
 			Class<?> buildManagerClass = Class
 					.forName("com.nokia.s60tools.analyzetool.trace.TraceWrapper");
 			java.lang.reflect.Method[] methods = buildManagerClass.getMethods();
 					String returnValue = (String) oneMethod.invoke(
 							buildManagerClass.newInstance(), new Object[] {});
 					if (("").equals(returnValue)) {
 						traceStopped(analyze);
 					} else {
-						showErrorMessage("Error while disconnecting Tracing utility");
+						showErrorMessage("Error while disconnecting TraceViewer");
 						traceAction.setImageDescriptor(Activator
 								.getImageDescriptor((Constants.BUTTON_STOP)));
 						traceActive = true;
 					}
 				}
 	private void traceStopped(boolean analyze) {
 		// update icon and information text
 		traceAction.setImageDescriptor(Activator
 				.getImageDescriptor((Constants.BUTTON_RUN)));
 		traceAction.setText(Constants.ACTION_START_TRACE);
-		traceAction
+		traceAction.setToolTipText(Constants.ACTION_START_TRACE);
-				.setToolTipText(Constants.ACTION_START_TRACE);
 		traceActive = false;
 		// close any active subtests
 		if (!startedSubtest.isEmpty()) {
 			for (int j = 0; j < startedSubtest.size(); j++) {
-				ActiveSubtests oneSubtest = startedSubtest
+				ActiveSubtests oneSubtest = startedSubtest.get(j);
-						.get(j);
+				parser.parse(Constants.PREFIX + " " + oneSubtest.getProcessID()
-				parser.parse(Constants.PREFIX + " "
+						+ " TEST_END" + " 0000 " + oneSubtest.getName());
-						+ oneSubtest.getProcessID()
-						+ " TEST_END" + " 0000 "
-						+ oneSubtest.getName());
 			}
 			startedSubtest.clear();
 		}
 		// tell parser to finish => write data to file
 		cleanAtoolChanges.setEnabled(true);
 		project = traceStartedProjectRef;
 		// parse and analyze saved data file
-		if( analyze ) {
+		if (analyze) {
-			analyzeDataFile(Constants.ANALYZE_USE_DATA_FILE, null,
+			analyzeDataFile(Constants.ANALYZE_USE_DATA_FILE, null, true);
-					true);
+		}
-		}
+	}
-	}
+	/**
-	/**
+	 * Stop one subtest. If there is multiple subtests running ask for user to
-	 * Stop one subtest If there multiple subtest running ask for user to which
+	 * which one to stop.
-	 * one to stop.
 	 */
 	public final void stopSubTest() {
 		// no processes show info
 		if (startedSubtest.isEmpty()) {
 			Util.showMessage(Constants.SUBTEST_NO_SUBTESTS);
 		}
 	}
 	/**
 	 * When AnalyzeTool view tree model is collapsed.
 	 *
 	 * @see org.eclipse.jface.viewers.ITreeViewerListener#treeCollapsed(org.eclipse.jface.viewers.TreeExpansionEvent)
 	 *
 	 * @param event
 	 *            Tree expansion event
 	 */
 	public void treeCollapsed(TreeExpansionEvent event) {
 		// MethodDeclaration/Block[count(BlockStatement) = 0 and
 		// @containsComment = 'false']
 	}
 	/**
 	 * When AnalyzeTool view tree model is expanded.
 	 *
 	 * @see org.eclipse.jface.viewers.ITreeViewerListener#treeExpanded(org.eclipse.jface.viewers.TreeExpansionEvent)
 	 *
 	 * @param event
 	 *            Tree expansion event
 	 */
 	public void treeExpanded(TreeExpansionEvent event) {
 		// MethodDeclaration/Block[count(BlockStatement) = 0 and
 		// @containsComment = 'false']
 	}
 	/**
 	 * Updates allocation count in the information label.
 	 *
 	 * The information layout is hard to modify so we need to manage information
 	 * label text
 	 */
 	public final void updateAllocNumber() {
 	}
 	/**
 	 * Update build action icon and tooltip text.
 	 *
 	 * @param projectRef
 	 *            Project reference
 	 */
 	public final void updateBuildState(final IProject projectRef) {
 		if (buildWithAtool == null) {
 		}
 	}
 	/**
-	 * Indicates the target (emulator/device) by inspecting the given projects build configuration.
+	 * Indicates the target (emulator/device) by inspecting the given projects
-	 * @param selectedProject the currently active project
+	 * build configuration.
-	 * @return "emulator" if the build configuration is WINSCW, "device" otherwise
+	 *
+	 * @param selectedProject
+	 *            the currently active project
+	 * @return "emulator" if the build configuration is WINSCW, "device"
+	 *         otherwise
 	 */
 	private static String getTraceTarget(final IProject selectedProject) {
 		String target = "";
 		if (selectedProject != null && selectedProject.isOpen()) {
-			ICarbideProjectInfo info = CarbideBuilderPlugin.getBuildManager().getProjectInfo(selectedProject);
+			ICarbideProjectInfo info = CarbideBuilderPlugin.getBuildManager()
+					.getProjectInfo(selectedProject);
 			if (info != null) {
-				ICarbideBuildConfiguration config = info.getDefaultConfiguration();
+				ICarbideBuildConfiguration config = info
+						.getDefaultConfiguration();
 				target = config.getPlatformString().equals(
-						Constants.BUILD_TARGET_WINSCW) ? Constants.INFO_TRACE_FROM_EMULATOR : Constants.INFO_TRACE_FROM_DEVICE;
+						Constants.BUILD_TARGET_WINSCW) ? Constants.INFO_TRACE_FROM_EMULATOR
+						: Constants.INFO_TRACE_FROM_DEVICE;
 			}
 		}
 		return target;
 	}
 	/**
 	 * Update change detail action state.
 	 *
 	 * @param projectRef
 	 *            Current project
 	 */
 	public final void updateChangeDetailState(final IProject projectRef) {
 		if (changeDetails == null) {
 		} else {
 			changeDetails.setEnabled(false);
 		}
 		String dataFile = projectResults.getDataFileName(projectRef);
-		if( dataFile != null ) {
+		if (dataFile != null) {
 			int fileType = UseAtool.checkFileType(dataFile);
-			if( fileType == Constants.DATAFILE_TRACE || fileType == Constants.DATAFILE_LOG ) {
+			if (fileType == Constants.DATAFILE_TRACE
+					|| fileType == Constants.DATAFILE_LOG) {
 				refreshResults.setEnabled(true);
-			}
+			} else {
-			else {
 				refreshResults.setEnabled(false);
 			}
-		}
+		} else {
-		else {
 			refreshResults.setEnabled(false);
 		}
 	}
 	/**
 	 * Sets information to the information label.
 	 *
 	 * @param infoText
 	 *            Info text
 	 */
 	private void updateInformationLabel(final String infoText) {
 		// trace is active => do not update information label
 		});
 	}
 	/**
 	 * Updates label by given string.
 	 *
 	 * @param line
 	 *            String to display
 	 */
 	public final void updateLabel(final String line) {
 	}
 	/**
 	 * Updates Subtest info to the information label.
 	 *
 	 * The information layout is hard to modify so we need to manage information
 	 * label text
 	 *
 	 * @param text
 	 *            New label text
 	 */
 	private void updateSubtestInfoText(final String text) {
 		final String newText = text;
 		cleanAnalyzeData(project);
 		clearCallstackViewContent();
 		traceStartedProjectRef = project;
 		// change icon and information text
-		traceAction
+		traceAction.setImageDescriptor(Activator
-				.setImageDescriptor(Activator
+				.getImageDescriptor((Constants.BUTTON_STOP)));
-						.getImageDescriptor((Constants.BUTTON_STOP)));
+		traceAction.setText(Constants.ACTION_STOP_TRACE);
-		traceAction
+		traceAction.setToolTipText(Constants.ACTION_STOP_TRACE);
-				.setText(Constants.ACTION_STOP_TRACE);
-		traceAction
-				.setToolTipText(Constants.ACTION_STOP_TRACE);
 		traceActive = true;
 		String fromTarget = getTraceTarget(traceStartedProjectRef);
-		updateLabel(fromTarget.length()==0 ? Constants.INFO_TRACE_START : String.format(Constants.INFO_TRACE_FROM_TARGET_START, fromTarget));
+		updateLabel(fromTarget.length() == 0 ? Constants.INFO_TRACE_START
+				: String.format(Constants.INFO_TRACE_FROM_TARGET_START,
+						fromTarget));
 		// add2UserActionHistory( "Trace started for
 		// project: "
 		// +project.getName() +" at "+ Util.getTime() );
 		// set start and stop subtest visible
 		updateAllocNumber();
 	}
 	/**
 	 * Overrided method to capture keyevents.
 	 *
 	 * @see org.eclipse.swt.events.KeyListener#keyPressed(org.eclipse.swt.events.KeyEvent)
 	 */
 	public void keyPressed(KeyEvent e) {
 		// C key address(hex)
 		boolean cPressed = (charValue == CTRL_C); // This should be enough
 		// ctrl key pressed
 		boolean ctrlPressed = (e.stateMask & SWT.CTRL) != 0;
-		//if ctrl and c key pressed => run copy action
+		// if ctrl and c key pressed => run copy action
-		if(ctrlPressed & cPressed){
+		if (ctrlPressed & cPressed) {
 			// Triggering copy action
 			copyAction.run();
 		}
 	}
 	/**
 	 * (non-Javadoc)
+	 *
 	 * @see org.eclipse.swt.events.KeyListener#keyReleased(org.eclipse.swt.events.KeyEvent)
 	 */
 	public void keyReleased(KeyEvent e) {
 		// This method is overrided
 	}
+	/**
+	 * This job parses the .dat file and loads the graph
+	 *
+	 */
+	class GraphLoadJob extends Job {
+		/** Location of file to parse for graph model */
+		private String datFileLocation;
+		/**
+		 * Constructor
+		 *
+		 * @param aDatFileLocation
+		 *            Location of file to parse for graph model
+		 */
+		public GraphLoadJob(String aDatFileLocation) {
+			super(Constants.GRAPH_LOAD_JOB_TITLE);
+			this.datFileLocation = aDatFileLocation;
+		}
+		@Override
+		protected IStatus run(IProgressMonitor monitor) {
+			monitor.beginTask(Constants.GRAPH_GENERATING_PROG_TITLE,
+					IProgressMonitor.UNKNOWN);
+			try {
+				ReadFile fileReader = new ReadFile();
+				boolean success = fileReader.readFile(datFileLocation);
+				if (success) {
+					AbstractList<ProcessInfo> processes = fileReader
+							.getStatistic();
+					IMemoryActivityModel model = new AnalyzeFactory()
+							.createModel(processes.size() == 0);
+					if (processes.size() > 0) {
+						model.setDeferredCallstackReading(fileReader
+								.hasDeferredCallstacks());
+						if (model.isDeferredCallstackReading()) {
+							DeferredCallstackManager callstackManager = new DeferredCallstackManager(
+									datFileLocation);
+							callstackManager.setProcesses(processes);
+							model.setCallstackManager(callstackManager);
+						} else {
+							model.setCallstackManager(new SimpleCallstackManager());
+						}
+					}
+					if (!monitor.isCanceled()) {
+						chart.setInput(project, model);
+						model.addProcesses(processes);
+					}
+					fileReader.finish();
+				}
+			} catch (OutOfMemoryError oome) {
+				Activator
+						.getDefault()
+						.logInfo(IStatus.ERROR, IStatus.ERROR,
+								"Can not allocate enough memory for the memory usage graph model.");
+			} catch (Exception e) {
+				Activator.getDefault().log(IStatus.ERROR,
+						"Error while generating graph model", e);
+			}
+			graphLoadJob = null;
+			return Status.OK_STATUS;
+		}
+	}
 }

changeset 6	f65f740e69f9
parent 1	1050670c6980
child 15	0367d2db2c06