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

equal deleted inserted replaced

-:bb339882c6e9
+:0367d2db2c06
 					return notBuild;
 				}
 				// module not belong to selected project
 				return outside;
 			}
 			return element;
 		}
 		/**
 		 * Gets current tree view object name.
 	/** Tree parent object which not shown to user. */
 	private TreeParent invisibleRoot;
 	/** Double click action. */
 	private Action doubleClickAction;
 	/** Click action. */
 	private Action clickAction;
 	/** Change detail level action. */
 	public Action changeDetails;
 	/** Select S60 log file action. */
 	private Action s60LogTargetAction;
 	/** Select TraceViewer connection action. */
-	private Action externalLogTargetAction;
+	// private Action externalLogTargetAction;
 	/** Select fast data gathering mode */
 	private Action externalFastLogTargetAction;
 	/** Select Ask always action. */
 	private Action askLogTargetAction;
 	/** Save report file action. */
 	private Action saveReportAction;
 	/** Save test run action. */
 	private Action saveDataFileAction;
 	/** AnalyzeTool results action. */
 	private Action analyzeResults;
 	/** Activate AnalyzeTool build action. */
 	public Action buildWithAtool;
 	/** Clean AnalyzeTool changes action. */
 	private Action cleanAtoolChanges;
 	/** Start/Stop trace action. */
 	public Action traceAction;
 	/** Start subtest action. */
 	private Action startSubtest;
 	/** Stop subtest action. */
 	private Action stopSubtest;
 	/** Refresh(re-creates) project results */
 	private Action refreshResults;
 	/** Copies selected memory leak item info to the clipboard. */
 	private Action copyAction;
 	/** Action to open AnalyzeTool preference page. */
 	private Action openPrefs;
 	/**
 	 * Clears selected project results without removing temporary files
 	 */
 	private Action clearProjectResults;
 			if (bUtil.isNatureEnabled(project)) {
 				bUtil.disableNatures(project);
 			} else {
 				bUtil.enableNatures(project);
 			}
+		}
-		}
 		// update build state
 		updateBuildState(project);
 	}
 	/*
 	 * (non-Javadoc)
 	 *
 		if (datafile != null && runView != null) {
 			// need to check is data file available in the disk
 			FileInputStream fis = null;
 			try {
 				// get existing file stream
 				fis = new FileInputStream(datafile);
 				// if file is empty => do nothing
 				if (fis.available() == 0) {
 						analyzeDataFile(Constants.ANALYZE_USE_DATA_FILE,
 								datafile, false);
 					}
 				});
 			}
 		}
 	}
 	/**
 	 * Opens file dialog and analyzing data file for given location.
 			AbstractList<MMPInfo> modules = Util
 					.loadProjectTargetsInfo(project);
 			projectModules.put(project, modules);
 			boolean xmlFile = Util.isFileXML(selectedFile);
-			// if file is xml file
+			// if file is XML file
 			// no need to analyze data file
-			// => just create results from xml file
+			// => just create results from XML file
 			if (xmlFile) {
 				Job analyzingXMLJob = new Job(Constants.ANALYZE_TOOL_TITLE) {
 					@Override
 					protected IStatus run(IProgressMonitor monitor) {
 				|| analyzeJob.getResult().getCode() == IStatus.CANCEL
 				|| analyzeJob.getResult().getCode() == IStatus.ERROR) {
 			analyzeJob = new Job(Constants.ANALYZE_TOOL_TITLE) {
 				@Override
 				protected IStatus run(IProgressMonitor monitor) {
-					// inform progressdialog that task execution starts
+					// inform progress dialog that task execution starts
-					// this make progressdialog visible on the UI
+					// this make progress dialog 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
+					// create XML file
 					Constants.COMMAND_LINE_ERROR_CODE errorCode = atool
-							.createXMLFileToCarbide(monitor, projectRef,
+							.createXmlAndCleanDatFilesToCarbide(monitor,
-									usedFile, "-a");
+									projectRef, usedFile, "-a");
-					String xmlFileLocation = null;
-					xmlFileLocation = atool.getDataFileName();
+					String xmlFileLocation = atool.getXmlFilePath();
+					String cleanDatFileLocation = atool.getCleanDatFilePath();
 					// if some error occurs display it to user.
 					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
+						// Parse the XML file
 						ParseXMLFileSAX dataFileParser = new ParseXMLFileSAX(
 								project, xmlFileLocation, projectResults);
 						boolean error = dataFileParser.parse();
 						if (showErrorInfo && !error) {
 							fileOpenHistory.removeFileName(usedFile);
 						refreshView();
 					}
 					updateChangeDetailState(projectRef);
-					// //this only generates statistics and this feature is
-					// currently disabled
-					// if( !monitor.isCanceled() ) {
-					//
-					// IPreferenceStore store = Activator.getPreferences();
-					// boolean generateStatistic =
-					// store.getBoolean(Constants.CREATE_STATISTIC);
-					// //used file data file create statistic also
-					// if( generateStatistic && UseAtool.checkFileType(usedFile)
-					// == Constants.DATAFILE_TRACE )
-					// {
-					// monitor.setTaskName(Constants.STATISTICS_GENERATING_PROG_TITLE);
-					//
-					// ReadFile fileReader = new ReadFile();
-					// boolean error = fileReader.readFile(usedFile);
-					// if( error && statisticView != null) {
-					// AbstractList<ProcessInfo> processes =
-					// fileReader.getStatistic();
-					// statisticView.setData( project, processes);
-					// fileReader.finish();
-					// }
-					//
-					// }
-					// }
 					if (!monitor.isCanceled()) {
 						// create the job for loading the graph model
 						// but only schedule it when the user gets to the graph
 						// tab
-						graphLoadJob = new GraphLoadJob(usedFile);
+						graphLoadJob = new GraphLoadJob(cleanDatFileLocation);
 						graphLoadJob.setUser(true);// set progress bar
 						graphLoadJob.setPriority(Job.LONG);
 						// run the following in UI thread, since widgets get
 						// accessed
 						PlatformUI.getWorkbench().getDisplay().syncExec(
 								new Runnable() {
 									public void run() {
 										if (((CTabFolder) chart.getParent())
-												.getSelection() != null && ((CTabFolder) chart.getParent())
+												.getSelection() != null
-												.getSelection().getControl() == chart) {
+												&& ((CTabFolder) chart
+														.getParent())
+														.getSelection()
+														.getControl() == chart) {
 											// chart tab is currently selected
 											// so we can run the load job
 											// straight away
 											graphLoadJob.schedule();
 										}
 					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
+		} else {
+			// if existing job is running display info to user
 			showMessage(Constants.INFO_ALLREADY_RUNNING);
 		}
 	}
 	/**
 					} else {
 						// set selection to correct item
 						runView.setSelection(new StructuredSelection(
 								activeTreeItem), true);
 					}
 				}
 				if (callstackView != null) {
 					// update view callstack view content
 					callstackView.setInput(getCallStack(activeTreeItem));
 					// expand all the trees on call stack view
 					callstackView.expandAll();
 				}
 				// change tooltip
 				changeReportActionTooltip();
 			}
 		});
 	}
 	/**
 	 * Change logging mode.
 	 *
 		// get preference store
 		IPreferenceStore store = Activator.getPreferences();
 		String usedLoggingMode = "";
-		// if no loggingmode given get it from the AnalyzeTool preferences
+		// if no logging mode given get it from the AnalyzeTool preferences
 		if (loggingMode == null) {
 			usedLoggingMode = store.getString(Constants.LOGGING_MODE);
 		}
 		// logging mode is given => so start to use it
 		else {
 			store.setValue(Constants.LOGGING_MODE, loggingMode);
 			usedLoggingMode = loggingMode;
 		}
-		// current logging mode is external change it to external
+		if (Constants.LOGGING_S60.equals(usedLoggingMode)) {
-		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) {
-				externalLogTargetAction.setChecked(true);
-				s60LogTargetAction.setChecked(false);
-				externalFastLogTargetAction.setChecked(false);
-				askLogTargetAction.setChecked(false);
-			}
-		}
-		// current logging mode is s60 change it to s60
-		else if (Constants.LOGGING_S60.equals(usedLoggingMode)) {
 			logTargetMenu.setImageDescriptor(Activator
 					.getImageDescriptor(Constants.BUTTON_CELLURAR));
 			logTargetMenu
 					.setToolTipText(Constants.ACTION_CHANGE_LOGGING_MODE_TOOLTIP_S60);
 			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);
 			if (loggingMode == null) {
-				externalLogTargetAction.setChecked(false);
 				s60LogTargetAction.setChecked(false);
 				externalFastLogTargetAction.setChecked(true);
 				askLogTargetAction.setChecked(false);
 			}
 		}
 			logTargetMenu.setImageDescriptor(Activator
 					.getImageDescriptor(Constants.BUTTON_ASK));
 			logTargetMenu
 					.setToolTipText(Constants.ACTION_CHANGE_LOGGING_MODE_TOOLTIP_ASK);
 			if (loggingMode == null) {
-				externalLogTargetAction.setChecked(false);
 				s60LogTargetAction.setChecked(false);
 				externalFastLogTargetAction.setChecked(false);
 				askLogTargetAction.setChecked(true);
 			}
 		}
 			changeDetails.setImageDescriptor(Activator
 					.getImageDescriptor(Constants.BUTTON_DETAILS_TOPMOST));
 			changeDetails
 					.setToolTipText(Constants.ACTION_CHANGE_REPORT_LEVEL_TOPMOST);
 		}
 	}
 	/**
 	 * Change view title.
 	 *
 		if (clearProjectResults != null && clearProjectResults != null) {
 			clearProjectResults.setEnabled(false);
 		} else if (clearProjectResults != null) {
 			updateChangeDetailState(projectRef);
 		}
 	}
 	/**
 	 * Clears callstack view contents.
 	 */
 				if (callstackView != null) {
 					callstackView.setInput(null);
 				}
 			}
 		});
 	}
 	/**
 	 * Contributes action bar.
 	 */
 	 * it.
 	 */
 	@Override
 	public void createPartControl(Composite parent) {
-		// create new Tab
+		// create a new Tab
 		final CTabFolder mainFolder = new CTabFolder(parent, SWT.TOP);
 		// create main view and add it tab
 		createMainView(mainFolder);
-		// create new statistic view
-		// createMemoryView( mainFolder );
 		// create graph
 		createGraphView(mainFolder);
 		// set initial selection
 		mainFolder.setSelection(mainTab);
 			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
+				// 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(){
+		mainFolder.addDisposeListener(new DisposeListener() {
 			public void widgetDisposed(DisposeEvent e) {
-				if (graphLoadJob != null){
+				if (graphLoadJob != null) {
 					graphLoadJob.cancel();
 					graphLoadJob = null;
 				}
-				if (analyzeJob != null){
+				if (analyzeJob != null) {
 					analyzeJob.cancel();
 					analyzeJob = null;
 				}
 			}
 		});
 	}
 	/**
 	 * Creates graph view and add it to graph tab
 	 *
 	 * Clears the graph by setting an empty model and causing paint events
 	 */
 	private void resetGraphView() {
 		if (chart != null) {
 			chart.setInput(project, AnalyzeFactory.getEmptyModel());
-			// chart.update();
 		}
 	}
 	/**
 	 * Creates new statistic view and add it to memory tab
 		SashForm callstackForm = new SashForm(sashForm, SWT.VERTICAL);
 		// set content and label providers
 		runView.setContentProvider(new ViewContentProvider());
 		runView.setLabelProvider(new ViewLabelProvider());
-		// runView.addFilter( new ATFilter() );
 		// get init content
 		runView.setInput(getStartupContent());
 		// add listener to provide selection change events
 		runView.addTreeListener(this);
 				AnalyzeToolHelpContextIDs.ANALYZE_MAIN);
 		ResourcesPlugin.getWorkspace().addResourceChangeListener(
 				new ATResourceListener());
-		// get used command line engine version
-		String version = Util.getAtoolVersionNumber(Util
-				.getAtoolInstallFolder());
-		// 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
+		store.setValue(Constants.LOGGING_FAST_ENABLED, true);
-		// flag to true
-		if (comp == Constants.VERSION_NUMBERS_EQUALS
-				|| comp == Constants.VERSION_NUMBERS_SECOND) {
-			store.setValue(Constants.LOGGING_FAST_ENABLED, true);
-		} else {
-			store.setValue(Constants.LOGGING_FAST_ENABLED, false);
-		}
 		// get default value for logging mode
 		preferenceChanged();
 	}
 	 *
 	 * @param disable
 	 *            Boolean state of trace action
 	 */
 	public void disableTraceActions(final boolean disable) {
 		if (traceAction != null && disable) {
 			// enable trace action
 			traceAction.setToolTipText(Constants.ACTION_START_TRACE);
 			traceAction.setEnabled(disable);
 		} else if (traceAction != null && !disable) {
 			// disable trace action
 			traceAction.setToolTipText(Constants.TRACE_NOT_FOUND);
 			traceAction.setEnabled(disable);
 		}
 		traceActive = false;
 	}
 	/**
 	 * Fills context menu.
 	 *
 	 * @param manager
 	 *            Menu manager
 	 */
 	private void fillContextMenu(IMenuManager manager) {
 		manager.add(buildWithAtool);
 		manager.add(new Separator());
 		manager.add(traceAction);
 		manager.add(startSubtest);
 		manager.add(stopSubtest);
 	private void fillLocalToolBar(IToolBarManager manager) {
 		logTargetMenu = new DropDownMenu(Constants.ACTION_SAVE, this, false,
 				false);
 		makeLogTargetActions();
+		logTargetMenu.addAction(externalFastLogTargetAction);
 		logTargetMenu.addAction(s60LogTargetAction);
-		logTargetMenu.addAction(externalLogTargetAction);
-		logTargetMenu.addAction(externalFastLogTargetAction);
 		logTargetMenu.addAction(askLogTargetAction);
 		manager.add(logTargetMenu);
 		manager.add(buildWithAtool);
 		manager.add(new Separator());
 					IProject tempProject = projects[i];
 					if (tempProject.isOpen()) {
 						tempProject.accept(visitor);
 					}
 				}
 			} else { // project is selected
 				// if project is open => accept resource visitor
 				if (projectRef.isOpen()) {
 					projectRef.accept(visitor);
 				}
 			}
 		} catch (CoreException e) {
 			e.printStackTrace();
 		}
 	}
 	/**
 	 * Gets project results.
 	 * @return Object memory leak analysis results
 	 */
 	private Object getResults(final boolean showErrorInfo) {
 		try {
-			// create new tree paretn
+			// create a new tree parent
 			TreeParent testRuns = new TreeParent(Constants.TEST_RUNS_TREE_TITLE);
 			invisibleRoot = null;
 			invisibleRoot = new TreeParent(Constants.TREE_TITLE);
 			invisibleRoot.addChild(testRuns);
 				// display info to user
 				if (showErrorInfo) {
 					showErrorMessage(Constants.INFO_FILE_INVALID);
 				}
 				return getStartupContent();
 			}
 			IPreferenceStore store = Activator.getPreferences();
 				// get active item
 				// active must ask from the TreeHelper class
 				// because it can be filtered out when creating new tree model
 				activeTreeItem = helper.getActiveItem();
 				testRuns.addChild(oneRunTree);
+			}
-			}
 		} catch (java.lang.NullPointerException npe) {
 			npe.printStackTrace();
 			return null;
 		}
 		// expand to runs level
 		runView.setAutoExpandLevel(2);
 		return invisibleRoot;
 	}
 		Menu menu = menuMgr.createContextMenu(runView.getControl());
 		runView.getControl().setMenu(menu);
 		if (getSite() != null) {
 			getSite().registerContextMenu(menuMgr, runView);
 		}
 	}
 	/**
 	 * Hook double click actions.
 	 */
 			ActiveSubtests oneSubtest = subTestIter.next();
 			if (oneSubtest.getName().equals(subTestName)
 					&& oneSubtest.getTargetName().equals(target)) {
 				return true;
 			}
 		}
 		return false;
 	}
 	/**
 						copyAction.setEnabled(false);
 					} else {
 						callstackView.setInput(resultObject);
 						copyAction.setEnabled(true);
 					}
 				}
 				// expand all the trees on call stack view
 				callstackView.expandAll();
 		s60LogTargetAction
 				.setToolTipText(Constants.ACTION_CHANGE_LOGGING_MODE_TOOLTIP_S60);
 		s60LogTargetAction.setImageDescriptor(Activator
 				.getImageDescriptor(Constants.BUTTON_CELLURAR));
-		externalLogTargetAction = new Action(Constants.LOGGING_EXT,
-				IAction.AS_RADIO_BUTTON) {
-			@Override
-			public void run() {
-				changeLogTarget(Constants.LOGGING_EXT);
-			}
-		};
-		externalLogTargetAction.setText(Constants.PREFS_EXT);
-		externalLogTargetAction
-				.setToolTipText(Constants.ACTION_CHANGE_LOGGING_MODE_TOOLTIP_EXT);
-		externalLogTargetAction.setImageDescriptor(Activator
-				.getImageDescriptor(Constants.BUTTON_COMPUTER));
 		externalFastLogTargetAction = new Action(Constants.LOGGING_EXT_FAST,
 				IAction.AS_RADIO_BUTTON) {
 			@Override
 			public void run() {
 				changeLogTarget(Constants.LOGGING_EXT_FAST);
 			@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));
 	}
 	/**
 	 * Displays selected callstack item location on default file editor.
 	 *
 					clearProjectResults.setEnabled(true);
 				} else {
 					clearProjectResults.setEnabled(false);
 				}
 				updateChangeDetailState(project);
 			}
 		});
 	}
 	/**
 	/**
 	 * 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
+	 *            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) {
 				usedFile = targetPath;
 			} else {
 				Util.showMessage(Constants.INFO_NO_RESULTS_FILE);
 				return success;
 			}
 		}
 		// save data file
 		else {
 			String dataFile = Util.isDataFileAvailable(project);
 			// check is there data file which can be used
 			names[0] = "*.dat";
 			names[1] = "*.*";
 			Shell shell = null;
-			// get shell from teh active view
+			// get shell from the active view
 			if (runView != null) {
 				shell = runView.getControl().getShell();
 			}
 			// if for some reason shell is null => leave
 			if (shell == null) {
 				return success;
 			}
-			// ask user where to save xml report file
+			// ask user where to save XML report file
 			folder = Util.fileSaveDialog(Constants.DIALOG_SAVE_TRACE, names,
 					shell);
 		}
 		// no folder selected
 			// resource found => get resource project
 			if (resource != null) {
 				selectedProject = resource.getProject();
 			}
 		}
 		// first item is null => update build state
 		else if (element == null) {
 			updateBuildState(null);
 		}
 	 * Passing the focus request to the viewer's control.
 	 */
 	@Override
 	public void setFocus() {
 		runView.getControl().setFocus();
 	}
 	/**
 	 * Sets text to information label.
 	 */
 						+ " \nEnd time: FAILED");
 			} else {
 				buffer.append("\nStart time: " + oneRunResults.getStartTime()
 						+ " \nEnd time: " + oneRunResults.getEndTime());
 			}
 			updateInformationLabel(buffer.toString());
+		}
-		}
 	}
 	/**
 	 * Shows error message.
 	 *
 	/**
 	 * Starts traceviewer connection.
 	 */
 	private void start() {
-		// check is project selected and open
+		// check if the project is selected and open
 		if (!checkProjectValidity()) {
 			return;
 		}
 		// get project file infos
 						IStatus.OK, "Trace started", null);
 			}
 		};
 		activateTrace.setUser(true);
 		activateTrace.schedule();
 	}
 	/**
 	 * Starts subtests.
 	 */
 				processID);
 		startedSubtest.add(subtes);
 		// start subtest
 		parser.parse(Constants.PREFIX + " " + subtes.getProcessID()
-				+ " TEST_START 0000 " + subTestName);
+				+ " TSS 0000 " + subTestName);
 		updateSubtestInfoText(Constants.SUBTEST_STARTED + target
 				+ Constants.ENRULE + subTestName);
 		stopSubtest.setEnabled(true);
 	}
 			ite.printStackTrace();
 		} catch (InstantiationException iv) {
 			iv.printStackTrace();
 		}
 	}
 	/**
 	 * Updates button states and creates results for project.
 	 */
 		// close any active subtests
 		if (!startedSubtest.isEmpty()) {
 			for (int j = 0; j < startedSubtest.size(); j++) {
 				ActiveSubtests oneSubtest = startedSubtest.get(j);
 				parser.parse(Constants.PREFIX + " " + oneSubtest.getProcessID()
-						+ " TEST_END" + " 0000 " + oneSubtest.getName());
+						+ " TSE 0000 " + oneSubtest.getName());
 			}
 			startedSubtest.clear();
 		}
 		// tell parser to finish => write data to file
 		} else {
 			// only one subtest no need to ask for users
 			if (startedSubtest.size() == 1) {
 				ActiveSubtests oneSubtest = startedSubtest.get(0);
 				parser.parse(Constants.PREFIX + " " + oneSubtest.getProcessID()
-						+ " TEST_END" + " 0000 " + oneSubtest.getName());
+						+ " TSE 0000 " + oneSubtest.getName());
 				updateSubtestInfoText(Constants.SUBTEST_ENDED
 						+ oneSubtest.getTargetName() + Constants.ENRULE
 						+ oneSubtest.getName());
 				startedSubtest.remove(0);
 				stopSubtest.setEnabled(false);
 					// if user selected subtest name and current subtest equals
 					if (splittedText[2].equals(oneSubtest.getName())) {
 						// write subtest end tag to data file
 						parser.parse(Constants.PREFIX + " "
-								+ oneSubtest.getProcessID() + " TEST_END"
+								+ oneSubtest.getProcessID() + " TSE 0000 "
-								+ " 0000 " + oneSubtest.getName());
+								+ oneSubtest.getName());
 						updateSubtestInfoText(Constants.SUBTEST_ENDED
 								+ oneSubtest.getTargetName() + Constants.ENRULE
 								+ oneSubtest.getName());
 						// remove current subtest from active subtest
 						// AbstractList
 						startedSubtest.remove(k);
 						break;
 					}
 				}
 				if (startedSubtest.isEmpty()) {
 					stopSubtest.setEnabled(false);
 				}
 			}
 		}
 	public final void updateAllocNumber() {
 		runView.getControl().getDisplay().syncExec(new Runnable() {
 			public void run() {
-				// if lable is created
+				// if label is created
 				if (informationLabel != null) {
 					// get existing label text
 					String tmpText = informationLabel.getText();
 					// split existing text
 					} else {
 						informationLabel.setText(tmpText + lineFeed
 								+ Constants.INFO_ALLOCATED_MEM
 								+ parser.getAllocationsSize());
 					}
+				}
-				}
 			}
 		});
 	}
 	/**
 	 * Update build action icon and tooltip text.
 	 *
 		} else {
 			buildWithAtool.setText(Constants.ACTION_AT_BUILD_DEACTIVE);
 			buildWithAtool.setToolTipText(Constants.ACTION_AT_BUILD_DEACTIVE);
 			buildWithAtool.setChecked(false);
 		}
 	}
 	/**
 	 * Indicates the target (emulator/device) by inspecting the given projects
 	 * build configuration.
 		String dataFile = projectResults.getDataFileName(projectRef);
 		if (dataFile != null) {
 			int fileType = UseAtool.checkFileType(dataFile);
 			if (fileType == Constants.DATAFILE_TRACE
-					|| fileType == Constants.DATAFILE_LOG) {
+					|| fileType == Constants.DATAFILE_LOG
+					|| fileType == Constants.DATAFILE_BINARY) {
 				refreshResults.setEnabled(true);
 			} else {
 				refreshResults.setEnabled(false);
 			}
 		} else {
 			public void run() {
 				// if informationlabel exists set text
 				if (informationLabel != null) {
 					informationLabel.setText(oneLine);
 				}
 			}
 		});
 	}
 	/**
 	 * Updates Subtest info to the information label.
 	 *
 						// set new text to information label
 						informationLabel.setText(tmpBuffer.toString());
 					} else {
 						informationLabel.setText(origText + newText);
 					}
+				}
-				}
 			}
 		});
 	}
 	/**
 		// if ctrl and c key pressed => run copy action
 		if (ctrlPressed & cPressed) {
 			// Triggering copy action
 			copyAction.run();
 		}
 	}
 	/**
 	 * (non-Javadoc)
 	 *
 							DeferredCallstackManager callstackManager = new DeferredCallstackManager(
 									datFileLocation);
 							callstackManager.setProcesses(processes);
 							model.setCallstackManager(callstackManager);
 						} else {
-							model.setCallstackManager(new SimpleCallstackManager());
+							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.");
 						"Error while generating graph model", e);
 			}
 			graphLoadJob = null;
 			return Status.OK_STATUS;
 		}
 	}
 }

changeset 15	0367d2db2c06
parent 6	f65f740e69f9