--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/sysperfana/analyzetoolext/com.nokia.s60tools.analyzetool/src/com/nokia/s60tools/analyzetool/preferences/AnalyzeToolPreferencePage.java	Thu Feb 11 15:22:14 2010 +0200
@@ -0,0 +1,795 @@
+/*
+ * Copyright (c) 2008-2009 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".
+ *
+ * Initial Contributors:
+ * Nokia Corporation - initial contribution.
+ *
+ * Contributors:
+ *
+ * Description:  Definitions for the class AnalyzeToolPreferencePage
+ *
+ */
+
+package com.nokia.s60tools.analyzetool.preferences;
+
+import org.eclipse.core.runtime.IPath;
+import org.eclipse.core.runtime.Path;
+import org.eclipse.jface.preference.FieldEditorPreferencePage;
+import org.eclipse.jface.preference.IPreferenceStore;
+import org.eclipse.jface.preference.RadioGroupFieldEditor;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.layout.GridData;
+import org.eclipse.swt.layout.GridLayout;
+import org.eclipse.swt.widgets.Button;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.DirectoryDialog;
+import org.eclipse.swt.widgets.Event;
+import org.eclipse.swt.widgets.Group;
+import org.eclipse.swt.widgets.Label;
+import org.eclipse.swt.widgets.Listener;
+import org.eclipse.swt.widgets.Spinner;
+import org.eclipse.swt.widgets.Text;
+import org.eclipse.ui.IWorkbench;
+import org.eclipse.ui.IWorkbenchPreferencePage;
+import org.eclipse.ui.PlatformUI;
+
+import com.nokia.s60tools.analyzetool.Activator;
+import com.nokia.s60tools.analyzetool.AnalyzeToolHelpContextIDs;
+import com.nokia.s60tools.analyzetool.global.Constants;
+import com.nokia.s60tools.analyzetool.global.Util;
+import com.nokia.s60tools.analyzetool.ui.IActionListener;
+
+/**
+ * This class represents a preference page that is contributed to the
+ * Preferences dialog. By subclassing <samp>FieldEditorPreferencePage</samp>,
+ * we can use the field support built into JFace that allows us to create a page
+ * that is small and knows how to save, restore and apply itself.
+ * <p>
+ * This page is used to modify preferences only. They are stored in the
+ * preference store that belongs to the main plug-in class. That way,
+ * preferences can be accessed directly via the preference store.
+ */
+
+public class AnalyzeToolPreferencePage extends FieldEditorPreferencePage
+		implements IWorkbenchPreferencePage, Listener{
+
+	/** Button to ask always. */
+	Button askButton = null;
+
+	/** Atool.exe path field. */
+	Text atooDirText = null;
+
+	/** User specified atool.exe path. */
+	Label atoolDir = null;
+
+	/** Atool.exe version field. */
+	Label atoolVerLabel;
+
+	/** Browse button to active file selection dialog. */
+	Button browseButton = null;
+
+	/** Button to activate/deactivate statistic generation */
+	//Button generateStatistic = null;
+
+	/** Group for callstack size buttons. */
+	Group csSizeGroup;
+
+	/** Custom items button */
+	Button customButton;
+
+	/** Forty items button */
+	Button fortyButton;
+
+	/** Hundred items button */
+	Button hundredButton;
+
+	/** Button to use process data. */
+	Button processButton = null;
+
+	/** Button to refresh atool.exe version. */
+	Button refeshAtoolVersion = null;
+
+	/** Radio group for report level. */
+	RadioGroupFieldEditor reportLevels = null;
+
+	/** Button to use S60 file mode. */
+	Button s60Button = null;
+
+	/**
+	 * Spinner to define custom size of callstack, this item is visible only
+	 * when custom button is selected.
+	 */
+	Spinner spinner;
+
+	/**
+	 * Button to use default atool.exe location this means that atool.exe is
+	 * executed inside AnalyzeTool jar.
+	 */
+	Button useDefaultLocation = null;
+
+	/** Button to use user specified data file name. */
+	Button userButton = null;
+
+	/** Use user specified location. */
+	Button useUserSpecified = null;
+
+	/** Button to verbose atool.exe output. */
+	Button verboseButton = null;
+
+	/** Button to select Tracing utility connection. */
+	Button externalButton = null;
+
+	/** Button to select fast external data gathering mode */
+	Button externalFastButton = null;
+
+	/** No items button. */
+	Button zeroButton;
+
+	/**
+	 * Constructor.
+	 */
+	public AnalyzeToolPreferencePage() {
+		super(GRID);
+		setPreferenceStore(Activator.getDefault().getPreferenceStore());
+		setDescription(Constants.ATOOL_DESC);
+	}
+
+	/**
+	 * Checks preferences initial values if logging mode is not set to S60
+	 * disables S60 data file name selections.
+	 */
+	public final void chechInitValues() {
+		IPreferenceStore store = Activator.getPreferences();
+		
+		// get stored atool folder
+		String atoolFolder = store.getString(Constants.ATOOL_FOLDER);
+		atoolVerLabel.setText(Constants.PREFS_ATOOL_VER_NOT_FOUND);
+
+		// if atool folder is set to point default atool location
+		if (atoolFolder.equals(Constants.DEFAULT_ATOOL_FOLDER)) {
+
+			// check stored atool location exists
+			java.io.File file = new java.io.File(atoolFolder);
+			if (file.exists()) { // if exists use this location and update
+				// preference page buttons
+				useDefaultLocation.setSelection(false);
+				store.setValue(Constants.USE_INTERNAL, false);
+
+			} else { // location could not found => use internal atool
+				useDefaultLocation.setSelection(true);
+				store.setValue(Constants.USE_INTERNAL, true);
+
+			}
+		} else {
+			boolean useDef = store.getBoolean(Constants.USE_INTERNAL);
+			useDefaultLocation.setSelection(useDef);
+
+		}
+
+		// get atool.exe path and set it atool.exe path field
+		String atoolPath = store.getString(Constants.USER_SELECTED_FOLDER);
+		atooDirText.setText(atoolPath);
+
+		// update preference page buttons
+		handleDefaultLocationChange();
+
+		// update atool.exe version number
+		if (useDefaultLocation.getSelection()) {
+			updateAtoolVersion(null);
+		} else {
+			updateAtoolVersion(atooDirText.getText());
+		}
+
+		// get logging mode and update buttons
+		String fileMode = store.getString(Constants.LOGGING_MODE);
+		setGroupButtons(fileMode);
+
+		String loggingMode = store.getString(Constants.S60_LOG_FILE_MODE);
+		if (loggingMode.equals(Constants.LOGGING_S60_USER_SPECIFIED)) {
+			processButton.setSelection(false);
+			userButton.setSelection(true);
+		} else {
+			processButton.setSelection(true);
+			userButton.setSelection(false);
+		}
+
+		verboseButton.setSelection(store.getBoolean(Constants.ATOOL_VERBOSE));
+		//generateStatistic.setSelection(store.getBoolean(Constants.CREATE_STATISTIC));
+
+		// get stored callstack size
+		int callstackSize = store.getInt(Constants.CALLSTACK_SIZE);
+		if (callstackSize == 0) {
+			zeroButton.setSelection(true);
+			spinner.setEnabled(false);
+		} else if (callstackSize == 40) {
+			fortyButton.setSelection(true);
+			spinner.setEnabled(false);
+		} else if (callstackSize == 100) {
+			hundredButton.setSelection(true);
+			spinner.setEnabled(false);
+		} else {
+			// if callstack size is set to custom area
+			// enable spinner and set stored callstack size
+			customButton.setSelection(true);
+			spinner.setEnabled(true);
+			spinner.setSelection(callstackSize);
+		}
+
+	}
+
+	/**
+	 * Check if user entered folder location is available.
+	 *
+	 * @param folderLocation
+	 *            User entered folder location
+	 * @return True if folder exists otherwise False
+	 */
+	public final boolean checkIfFolderExists(final String folderLocation) {
+		if (folderLocation.length() > 0) {
+			StringBuffer tmpFolderLoc = new StringBuffer();
+			tmpFolderLoc.append(folderLocation);
+			// folder is not end with backslash => add it
+			if (!folderLocation.endsWith("\\")) {
+				// folderLocation += "\\";
+				tmpFolderLoc.append('\\');
+			}
+			tmpFolderLoc.append("atool.exe");
+			IPath atoolPath = new Path(tmpFolderLoc.toString());
+
+			// if folder does not exists
+			if (atoolPath.toFile().exists()) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	/**
+	 * Creates callstack size group items.
+	 */
+	private void createCallstackSizeGroup() {
+		// create new button group for callstack size
+		csSizeGroup = new Group(getFieldEditorParent(), SWT.NULL);
+		csSizeGroup.setText("Stored callstack size");
+
+		// set group layout
+		final GridLayout layoutCsSize = new GridLayout();
+		layoutCsSize.numColumns = 1;
+		csSizeGroup.setLayout(layoutCsSize);
+
+		GridData gridData = new GridData(GridData.HORIZONTAL_ALIGN_FILL);
+		gridData.horizontalSpan = 1;
+		csSizeGroup.setLayoutData(gridData);
+
+		// zero size button
+		zeroButton = new Button(csSizeGroup, SWT.RADIO);
+		zeroButton.setText(Constants.PREFS_ZERO_BUTTON);
+		zeroButton.addListener(SWT.Selection, this);
+
+		// forty items button
+		fortyButton = new Button(csSizeGroup, SWT.RADIO);
+		fortyButton.setText(Constants.PREFS_FORTY_BUTTON);
+		fortyButton.addListener(SWT.Selection, this);
+
+		// hundred items button
+		hundredButton = new Button(csSizeGroup, SWT.RADIO);
+		hundredButton.setText(Constants.PREFS_HUNDRED_BUTTON);
+		hundredButton.addListener(SWT.Selection, this);
+
+		// button for define custom size of callstack
+		customButton = new Button(csSizeGroup, SWT.RADIO);
+		customButton.setText(Constants.PREFS_CUSTOM_BUTTON);
+		customButton.addListener(SWT.Selection, this);
+
+		// new composite for spinner item
+		Composite customComp = new Composite(csSizeGroup, SWT.NULL);
+		final GridLayout customGrid = new GridLayout();
+		customGrid.marginLeft = 15;
+		customGrid.numColumns = 1;
+		customComp.setLayout(customGrid);
+
+		spinner = new Spinner(customComp, SWT.BORDER);
+		spinner.setMaximum(255);
+	}
+
+	/**
+	 * Creates data gathering group items
+	 */
+	private void createGatheringGroup()
+	{
+		// create new button group for logging mode
+		Group groupGatheringMode = new Group(getFieldEditorParent(), SWT.NULL);
+		groupGatheringMode.setText(Constants.PREFS_LOGGING_MODE_TITLE);
+
+		// set group layout
+		final GridLayout layoutLogMode = new GridLayout();
+		layoutLogMode.numColumns = 1;
+		groupGatheringMode.setLayout(layoutLogMode);
+
+		GridData gridData = new GridData(GridData.HORIZONTAL_ALIGN_FILL);
+		gridData.horizontalSpan = 1;
+		groupGatheringMode.setLayoutData(gridData);
+
+		// External mode button
+		externalButton = new Button(groupGatheringMode, SWT.RADIO);
+		externalButton.setToolTipText(Constants.PREFS_EXT_TOOLTIP);
+		externalButton.setText(Constants.PREFS_EXT);
+		externalButton.addListener(SWT.Selection, this);
+
+		// External fast mode button
+		externalFastButton = new Button(groupGatheringMode, SWT.RADIO);
+		externalFastButton.setToolTipText(Constants.PREFS_EXT_FAST_TOOLTIP);
+		externalFastButton.setText(Constants.PREFS_EXT_FAST);
+		externalFastButton.addListener(SWT.Selection, this);
+
+		// S60 mode button
+		s60Button = new Button(groupGatheringMode, SWT.RADIO);
+		s60Button.setToolTipText(Constants.PREFS_S60_TOOLTIP);
+		s60Button.setText(Constants.PREFS_S60);
+		s60Button.addListener(SWT.Selection, this);
+
+		Composite compStoreMode = new Composite(groupGatheringMode, SWT.NULL);
+
+		final GridLayout layoutStoreMode = new GridLayout();
+		layoutStoreMode.marginLeft = 15;
+		layoutStoreMode.numColumns = 1;
+		compStoreMode.setLayout(layoutStoreMode);
+
+		// use process name button
+		processButton = new Button(compStoreMode, SWT.RADIO);
+		processButton.setToolTipText(Constants.PREFS_USE_PROCESS_NAME_TOOLTIP);
+		processButton.setText(Constants.PREFS_USE_PROCESS_NAME);
+		processButton.addListener(SWT.Selection, this);
+
+		// user specified button
+		userButton = new Button(compStoreMode, SWT.RADIO);
+		userButton.setToolTipText(Constants.PREFS_USER_SPEC_TOOLTIP);
+		userButton.setText(Constants.PREFS_USER_SPEC);
+		userButton.addListener(SWT.Selection, this);
+
+		// ask always button
+		askButton = new Button(groupGatheringMode, SWT.RADIO);
+		askButton.setToolTipText(Constants.PREFS_ASK_ALWAYS_TOOLTIP);
+		askButton.setText(Constants.PREFS_ASK_ALWAYS);
+		askButton.addListener(SWT.Selection, this);
+
+	}
+	/**
+	 * Creates the field editors. Field editors are abstractions of the common
+	 * GUI blocks needed to manipulate various types of preferences. Each field
+	 * editor knows how to save and restore itself.
+	 */
+	@Override
+	public final void createFieldEditors() {
+		
+		Composite composite = new Composite(getFieldEditorParent(), SWT.NULL);
+		final GridLayout gridLayout = new GridLayout();
+		gridLayout.numColumns = 3;
+
+		// set layoyt of this view
+		composite.setLayout(gridLayout);
+
+		// new group for atool.exe specific settings
+		Group groupAtool = new Group(getFieldEditorParent(), SWT.NULL);
+		groupAtool.setText(Constants.PREFS_ATOOL_GROUP_TITLE);
+
+		// set group layout
+		final GridLayout layoutAtool = new GridLayout();
+		layoutAtool.numColumns = 1;
+		groupAtool.setLayout(layoutAtool);
+
+		// grid data for the atool.exe group
+		GridData gridDataAtool = new GridData(GridData.HORIZONTAL_ALIGN_FILL);
+		gridDataAtool.horizontalSpan = 1;
+		groupAtool.setLayoutData(gridDataAtool);
+
+		// create default location button and add listener to it
+		useDefaultLocation = new Button(groupAtool, SWT.RADIO);
+		useDefaultLocation.setText(Constants.PREFS_USE_INTERNAL_TITLE);
+		useDefaultLocation.setToolTipText(Constants.PREFS_USE_INTERNAL_TITLE);
+		useDefaultLocation.addListener(SWT.Selection, this);
+
+		// create user specified location button and add listener to it
+		useUserSpecified = new Button(groupAtool, SWT.RADIO);
+		useUserSpecified.setText(Constants.PREFS_USE_EXTERNAL_TITLE);
+		useUserSpecified.setToolTipText(Constants.PREFS_USE_EXTERNAL_TITLE);
+		useUserSpecified.addListener(SWT.Selection, this);
+
+		Composite compAtool = new Composite(groupAtool, SWT.NULL);
+
+		final GridLayout layoutAtoolDir = new GridLayout();
+		layoutAtoolDir.marginLeft = 15;
+		layoutAtoolDir.numColumns = 3;
+		compAtool.setLayout(layoutAtoolDir);
+
+		// directory label
+		atoolDir = new Label(compAtool, SWT.NONE);
+		atoolDir.setToolTipText(Constants.PREFS_SELECT_FOLDER);
+		atoolDir.setText(Constants.PREFS_ATOOL_PATH);
+
+		// directory field
+		atooDirText = new Text(compAtool, SWT.BORDER);
+		atooDirText.setLayoutData(new GridData(200, SWT.DEFAULT));
+
+		// button which opens the folder selection dialog
+		browseButton = new Button(compAtool, SWT.NONE);
+		browseButton.setToolTipText(Constants.PREFS_SELECT_FOLDER);
+		browseButton.setText(Constants.PREFS_BROWSE);
+		browseButton.addListener(SWT.Selection, this);
+
+		// generate statistics for the test run
+		/*
+		generateStatistic = new Button(groupAtool, SWT.CHECK);
+		generateStatistic.setText("Generate statistics");
+		generateStatistic.setToolTipText("Generate statistics");
+		*/
+		// verbose atool.exe output
+		verboseButton = new Button(groupAtool, SWT.CHECK);
+		verboseButton.setText(Constants.PREFS_VERBOSE);
+		verboseButton.setToolTipText(Constants.PREFS_VERBOSE_TOOLTIP);
+
+		// create new group for the atool.exe version
+		Group groupVersion = new Group(groupAtool, SWT.NONE);
+
+		// set atool.exe version group layout
+		GridData gridDataVersion = new GridData(GridData.HORIZONTAL_ALIGN_FILL);
+		gridDataVersion.horizontalSpan = 1;
+		groupVersion.setLayoutData(gridDataVersion);
+
+		// set group layout
+		final GridLayout layoutVersion = new GridLayout(4, false);
+		groupVersion.setLayout(layoutVersion);
+
+		// atool.exe version label title
+		Label versionTextLabel = new Label(groupVersion, SWT.NONE);
+		versionTextLabel.setText(Constants.PREFS_ENGINE_VERSION);
+
+		// create atool.exe version field and set layout
+		atoolVerLabel = new Label(groupVersion, SWT.NONE);
+		GridData vergd13 = new GridData(GridData.FILL_HORIZONTAL);
+		vergd13.horizontalSpan = 2;
+		atoolVerLabel.setLayoutData(vergd13);
+
+		// create button to refresh atool.exe version
+		refeshAtoolVersion = new Button(groupVersion, SWT.NONE);
+		refeshAtoolVersion.setText(Constants.PREFS_REFRESH_VERSION);
+		refeshAtoolVersion.addListener(SWT.Selection, this);
+
+		// create data gathering group
+		createGatheringGroup();
+
+		// create callstack size group
+		createCallstackSizeGroup();
+
+		// report level related settings
+		reportLevels = new RadioGroupFieldEditor(Constants.REPORT_LEVEL,
+				Constants.PREFS_REPORT_LEVEL, 1, new String[][] {
+						{ Constants.PREFS_SHOW_EVERY, Constants.REPORT_EVERY },
+						{ Constants.PREFS_SHOW_KNOWN, Constants.REPORT_KNOWN },
+						{ Constants.PREFS_SHOW_TOPMOST,
+								Constants.REPORT_TOPMOST } },
+				getFieldEditorParent(), true);
+
+		addField(reportLevels);
+		chechInitValues();
+		PlatformUI.getWorkbench().getHelpSystem().setHelp(super.getControl(),
+				AnalyzeToolHelpContextIDs.ANALYZE_TOOL_VIEW_MEM_LEAKS);
+
+	}
+
+	/**
+	 * Handles atool.exe location selection changes Update corresponding buttons
+	 * states.
+	 */
+	public final void handleDefaultLocationChange() {
+		if (useDefaultLocation.getSelection()) {
+			atooDirText.setEnabled(false);
+			browseButton.setEnabled(false);
+			atoolDir.setEnabled(false);
+			useUserSpecified.setSelection(false);
+		} else {
+			atooDirText.setEnabled(true);
+			browseButton.setEnabled(true);
+			atoolDir.setEnabled(true);
+			useUserSpecified.setSelection(true);
+		}
+	}
+
+	/**
+	 * Handles events.
+	 *
+	 * @param event
+	 *            Preference page event
+	 */
+	public final void handleEvent(final Event event) {
+		if (event.widget == browseButton) {
+			openFolderDialog();
+		} else if (event.widget == externalButton || event.widget == externalFastButton || event.widget == askButton ) {
+			userButton.setEnabled(false);
+			processButton.setEnabled(false);
+		} else if (event.widget == s60Button) {
+			userButton.setEnabled(true);
+			processButton.setEnabled(true);
+		} else if (event.widget == useDefaultLocation
+				|| event.widget == atoolDir) {
+			handleDefaultLocationChange();
+		} else if (event.widget == refeshAtoolVersion) {
+			if (useDefaultLocation.getSelection()) {
+				updateAtoolVersion(null);
+			} else {
+				updateAtoolVersion(atooDirText.getText());
+			}
+		} else if (event.widget == zeroButton || event.widget == fortyButton
+				|| event.widget == hundredButton) {
+			spinner.setEnabled(false);
+		} else if (event.widget == customButton) {
+			spinner.setEnabled(true);
+		}
+	}
+
+	/*
+	 * (non-Javadoc)
+	 *
+	 * @see org.eclipse.ui.IWorkbenchPreferencePage#init(org.eclipse.ui.IWorkbench)
+	 */
+	public void init(final IWorkbench workbench) {
+		// MethodDeclaration/Block[count(BlockStatement) = 0 and
+		// @containsComment = 'false']
+	}
+
+	/**
+	 * Opens folder selection dialog.
+	 */
+	public final void openFolderDialog() {
+		DirectoryDialog folderDialog = new DirectoryDialog(atooDirText
+				.getShell(), SWT.OPEN);
+		folderDialog.setText(Constants.PREFS_SELECT_DIR);
+		folderDialog.setFilterPath(atooDirText.getText());
+		String folderPath = folderDialog.open();
+		if (folderPath != null) {
+			atooDirText.setText(folderPath);
+		}
+	}
+
+	/**
+	 * Perform defaults for AnalyzeTool preferences.
+	 */
+	@Override
+	public final void performDefaults() {
+		//check that AT prefs page is displayed
+		//if( getControl() != null && getControl().isVisible() ) {
+
+			processButton.setSelection(true);
+			userButton.setSelection(false);
+			setGroupButtons(Constants.LOGGING_EXT);
+
+			atooDirText.setText(Constants.DEFAULT_ATOOL_FOLDER);
+			useDefaultLocation.setSelection(true);
+			handleDefaultLocationChange();
+			verboseButton.setSelection(false);
+			zeroButton.setSelection(false);
+			fortyButton.setSelection(true);
+			hundredButton.setSelection(false);
+			customButton.setSelection(false);
+			spinner.setEnabled(false);
+			//generateStatistic.setSelection(false);
+			super.performDefaults();	
+		//}
+	}
+
+	/**
+	 * Stores selected values When user press "Ok" or "apply" button this method
+	 * is called
+	 */
+	@Override
+	public final boolean performOk() {
+		
+		//check that AT prefs page is displayed
+		//if( getControl() != null && getControl().isVisible() ) {
+			IPreferenceStore store = Activator.getPreferences();
+			String atoolFolder = atooDirText.getText();
+
+			// use default location is selected
+			if (useDefaultLocation.getSelection()) {
+				store.setValue(Constants.ATOOL_FOLDER, Util
+						.getDefaultAtoolLocation());
+				store.setValue(Constants.USE_INTERNAL, true);
+			}
+			// using user specified atool.exe location and the folder contains
+			// atool.exe
+			else if (checkIfFolderExists(atoolFolder)) {
+				store.setValue(Constants.ATOOL_FOLDER, atoolFolder);
+				store.setValue(Constants.USER_SELECTED_FOLDER, atoolFolder);
+				store.setValue(Constants.USE_INTERNAL, false);
+			}
+			// user selected folder does not contain atool.exe
+			// ask confirmation to use this folder anyway
+			else {
+				boolean ret = Util
+						.openConfirmationDialog(Constants.CONFIRM_DIR_DOES_NOT_CONTAIN_ATOOL);
+				if (ret) {
+
+					store.setValue(Constants.ATOOL_FOLDER, atoolFolder);
+					store.setValue(Constants.USER_SELECTED_FOLDER, atoolFolder);
+					store.setValue(Constants.USE_INTERNAL, false);
+				} else {
+					return false;
+				}
+			}
+
+			// store logging mode
+			if (askButton.getSelection()) {
+				store.setValue(Constants.LOGGING_MODE,
+						Constants.LOGGING_ASK_ALLWAYS);
+			} else if (s60Button.getSelection()) {
+				store.setValue(Constants.LOGGING_MODE, Constants.LOGGING_S60);
+			} else if( externalFastButton.getSelection() ) {
+				store.setValue(Constants.LOGGING_MODE, Constants.LOGGING_EXT_FAST);
+			} else {
+				store.setValue(Constants.LOGGING_MODE, Constants.LOGGING_EXT);
+			}
+
+			// store log file option
+			if (userButton.getSelection()) {
+				store.setValue(Constants.S60_LOG_FILE_MODE,
+						Constants.LOGGING_S60_USER_SPECIFIED);
+			} else {
+				store.setValue(Constants.S60_LOG_FILE_MODE,
+						Constants.LOGGING_S60_PROCESS_NAME);
+			}
+
+			// store value of verbose atool.exe output
+			store.setValue(Constants.ATOOL_VERBOSE, verboseButton.getSelection());
+
+			// update preference value
+			// this values is used later when UI creates/update toolbar options and when building project with "ask always" option
+			if( externalFastButton.isEnabled() ) {
+				store.setValue(Constants.LOGGING_FAST_ENABLED, true);
+			}
+			else {
+				store.setValue(Constants.LOGGING_FAST_ENABLED, false);
+			}
+			// store.setValue(Constants.CREATE_STATISTIC,
+			// generateStatistic.getSelection());
+
+			// get callstack size
+			int size = 0;
+			boolean userDefinedCSSize = false;
+			if (zeroButton.getSelection() && zeroButton.isEnabled()) {
+				userDefinedCSSize = true;
+			} else if (fortyButton.getSelection() && fortyButton.isEnabled()) {
+				size = 40;
+				userDefinedCSSize = true;
+			} else if (hundredButton.getSelection() && hundredButton.isEnabled()) {
+				size = 100;
+				userDefinedCSSize = true;
+			} else if (customButton.getSelection() && customButton.isEnabled()) {
+				size = spinner.getSelection();
+				userDefinedCSSize = true;
+			}
+
+			// store callstack size
+			store.setValue(Constants.USE_CALLSTACK_SIZE, userDefinedCSSize);
+			store.setValue(Constants.CALLSTACK_SIZE, size);
+
+			// update view with new settings
+			IActionListener listener = Activator.getActionListener();
+			if (listener != null) {
+				listener.preferenceChanged();
+			}
+		//}
+		
+		// store report detail level prefs
+		return super.performOk();
+	}
+
+	/**
+	 * Sets S60 file options visible.
+	 *
+	 * @param enabled
+	 *            Is buttons enabled.
+	 */
+	private void setFileModeEnabled(final boolean enabled) {
+		processButton.setEnabled(enabled);
+		userButton.setEnabled(enabled);
+	}
+
+	/**
+	 * Changes logging mode buttons.
+	 *
+	 * @param mode
+	 *            Which mode is used
+	 */
+	private void setGroupButtons(final String mode) {
+		if (mode.equals(Constants.LOGGING_S60)) {
+			externalButton.setSelection(false);
+			externalFastButton.setSelection(false);
+			s60Button.setSelection(true);
+			askButton.setSelection(false);
+			setFileModeEnabled(true);
+		} else if (mode.equals(Constants.LOGGING_ASK_ALLWAYS)) {
+			externalButton.setSelection(false);
+			externalFastButton.setSelection(false);
+			s60Button.setSelection(false);
+			askButton.setSelection(true);
+			setFileModeEnabled(false);
+		} else if( mode.equals(Constants.LOGGING_EXT_FAST)) {
+			externalButton.setSelection(false);
+			externalFastButton.setSelection(true);
+			s60Button.setSelection(false);
+			askButton.setSelection(false);
+			setFileModeEnabled(false);
+		} else {
+			externalButton.setSelection(true);
+			externalFastButton.setSelection(false);
+			s60Button.setSelection(false);
+			askButton.setSelection(false);
+			setFileModeEnabled(false);
+		}
+	}
+
+	/**
+	 * Update atool.exe version number.
+	 *
+	 * @param path
+	 *            Atool.exe location
+	 */
+	private void updateAtoolVersion(final String path) {
+		atoolVerLabel.setText(Util.getAtoolVersionNumber(path));
+		atoolVerLabel.update();
+		updateCSGroup(path);
+	}
+
+	/**
+	 * Checks what version of command line is used, if the version is 1.7.4 or
+	 * higher enables callstack size selection otherwise disables callstack size
+	 * selection.
+	 *
+	 * @param path
+	 *            Command line engine path
+	 */
+	private void updateCSGroup(final String path) {
+		int compared = Constants.VERSION_NUMBERS_INVALID;
+
+		// compare version numbers
+		compared = Util.compareVersionNumber(Constants.CS_SUPPORT_MIN_VERSION,
+				Util.getAtoolVersionNumber(path));
+
+		// if used command line version is 1.7.4 or higher enable callstack size
+		// selection
+		if (compared == Constants.VERSION_NUMBERS_SECOND
+				|| compared == Constants.VERSION_NUMBERS_EQUALS) {
+			zeroButton.setEnabled(true);
+			fortyButton.setEnabled(true);
+			hundredButton.setEnabled(true);
+			customButton.setEnabled(true);
+			spinner.setEnabled(true);
+			csSizeGroup.setToolTipText("");
+			externalFastButton.setEnabled(true);
+			externalFastButton.setToolTipText("");
+		} else {
+			zeroButton.setEnabled(false);
+			fortyButton.setEnabled(false);
+			hundredButton.setEnabled(false);
+			customButton.setEnabled(false);
+			spinner.setEnabled(false);
+			csSizeGroup
+					.setToolTipText(Constants.PREFS_CS_SIZE_DISABLED_TOOLTIP);
+
+			if( externalFastButton.getSelection() ) {
+				externalButton.setSelection(true);
+			}
+			externalFastButton.setSelection(false);
+			externalFastButton.setEnabled(false);
+			externalFastButton.setToolTipText(Constants.PREFS_CS_SIZE_DISABLED_TOOLTIP);
+
+
+		}
+
+	}
+}
\ No newline at end of file