/*******************************************************************************
* Copyright (c) 2004, 2013 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
* Eric Rizzo - added API to set the list of recent workspaces.
*******************************************************************************/
package au.gov.ga.earthsci.eclipse.extras.ide;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
import java.net.URL;
import java.util.StringTokenizer;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.preferences.ConfigurationScope;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.osgi.service.datalocation.Location;
import org.eclipse.ui.IMemento;
import org.eclipse.ui.WorkbenchException;
import org.eclipse.ui.XMLMemento;
import org.eclipse.ui.preferences.ScopedPreferenceStore;
import org.osgi.service.prefs.BackingStoreException;
import org.osgi.service.prefs.Preferences;
import au.gov.ga.earthsci.eclipse.extras.Activator;
/**
* This class stores the information behind the "Launch Workspace" dialog. The
* class is able to read and write itself to a well known configuration file.
*/
public class ChooseWorkspaceData {
/**
* The default max length of the recent workspace mru list.
*/
private static final int RECENT_MAX_LENGTH = 5;
/**
* The directory within the config area that will be used for the
* receiver's persisted data.
*/
private static final String PERS_FOLDER = "org.eclipse.ui.ide"; //$NON-NLS-1$
/**
* The name of the file within the config area that will be used for
* the recever's persisted data.
* @see PERS_FOLDER
*/
private static final String PERS_FILENAME = "recentWorkspaces.xml"; //$NON-NLS-1$
/**
* In the past a file was used to store persist these values. This file was written
* with this value as its protocol identifier.
*/
private static final int PERS_ENCODING_VERSION = 1;
/**
* This is the first version of the encode/decode protocol that uses the config area
* preference store for persistence. The only encoding done is to convert the recent
* workspace list into a comma-separated list.
*/
private static final int PERS_ENCODING_VERSION_CONFIG_PREFS = 2;
/**
* This is the second version of the encode/decode protocol that uses the
* confi area preferences store for persistence. This version is the same as
* the previous version except it uses a \n character to seperate the path
* entries instead of commas. (see bug 98467)
*
* @since 3.3.1
*/
private static final int PERS_ENCODING_VERSION_CONFIG_PREFS_NO_COMMAS = 3;
private boolean showDialog = true;
private String initialDefault;
private String selection;
private String[] recentWorkspaces;
// xml tags
private static interface XML {
public static final String PROTOCOL = "protocol"; //$NON-NLS-1$
public static final String VERSION = "version"; //$NON-NLS-1$
public static final String ALWAYS_ASK = "alwaysAsk"; //$NON-NLS-1$
public static final String SHOW_DIALOG = "showDialog"; //$NON-NLS-1$
public static final String WORKSPACE = "workspace"; //$NON-NLS-1$
public static final String RECENT_WORKSPACES = "recentWorkspaces"; //$NON-NLS-1$
public static final String MAX_LENGTH = "maxLength"; //$NON-NLS-1$
public static final String PATH = "path"; //$NON-NLS-1$
}
/**
* Creates a new instance, loading persistent data if its found.
*/
public ChooseWorkspaceData(String initialDefault) {
readPersistedData();
setInitialDefault(initialDefault);
}
/**
* Creates a new instance, loading persistent data if its found.
*/
public ChooseWorkspaceData(URL instanceUrl) {
readPersistedData();
if (instanceUrl != null) {
setInitialDefault(new File(instanceUrl.getFile()).toString());
}
}
/**
* Return the folder to be used as a default if no other information
* exists. Does not return null.
*/
public String getInitialDefault() {
if (initialDefault == null) {
setInitialDefault(System.getProperty("user.dir") //$NON-NLS-1$
+ File.separator + "workspace"); //$NON-NLS-1$
}
return initialDefault;
}
/**
* Set this data's initialDefault parameter to a properly formatted version
* of the argument directory string. The proper format is to the platform
* appropriate separator character without meaningless leading or trailing
* separator characters.
*/
private void setInitialDefault(String dir) {
if (dir == null || dir.length() <= 0) {
initialDefault = null;
return;
}
dir = new Path(dir).toOSString();
while (dir.charAt(dir.length() - 1) == File.separatorChar) {
dir = dir.substring(0, dir.length() - 1);
}
initialDefault = dir;
}
/**
* Return the currently selected workspace or null if nothing is selected.
*/
public String getSelection() {
return selection;
}
/**
* Return the currently selected workspace or null if nothing is selected.
*/
public boolean getShowDialog() {
return showDialog;
}
/**
* Return an array of recent workspaces sorted with the most recently used at
* the start.
*/
public String[] getRecentWorkspaces() {
return recentWorkspaces;
}
/**
* The argument workspace has been selected, update the receiver. Does not
* persist the new values.
*/
public void workspaceSelected(String dir) {
// this just stores the selection, it is not inserted and persisted
// until the workspace is actually selected
selection = dir;
}
/**
* Toggle value of the showDialog persistent setting.
*/
public void toggleShowDialog() {
showDialog = !showDialog;
}
/**
* Sets the list of recent workspaces.
*/
public void setRecentWorkspaces(String[] workspaces) {
if (workspaces == null) {
recentWorkspaces = new String[0];
} else {
recentWorkspaces = workspaces;
}
}
/**
* Update the persistent store. Call this function after the currently
* selected value has been found to be ok.
*/
public void writePersistedData() {
// 1. get config pref node
Preferences node = ConfigurationScope.INSTANCE.getNode(Activator.PLUGIN_ID);
// 2. get value for showDialog
node.putBoolean(
IDE.Preferences.SHOW_WORKSPACE_SELECTION_DIALOG,
showDialog);
// 3. use value of numRecent to create proper length array
node.putInt(IDE.Preferences.MAX_RECENT_WORKSPACES,
recentWorkspaces.length);
// move the new selection to the front of the list
if (selection != null) {
File newFolder = new File(selection);
String oldEntry = recentWorkspaces[0];
recentWorkspaces[0] = selection;
for (int i = 1; i < recentWorkspaces.length && oldEntry != null; ++i) {
File oldFolder = new File (oldEntry);
// If selection represents a file location we already have, don't store it
if (newFolder.compareTo(oldFolder) == 0){
break;
}
String tmp = recentWorkspaces[i];
recentWorkspaces[i] = oldEntry;
oldEntry = tmp;
}
}
// 4. store values of recent workspaces into array
String encodedRecentWorkspaces = encodeStoredWorkspacePaths(recentWorkspaces);
node.put(IDE.Preferences.RECENT_WORKSPACES,
encodedRecentWorkspaces);
// 5. store the protocol version used to encode the list
node.putInt(IDE.Preferences.RECENT_WORKSPACES_PROTOCOL,
PERS_ENCODING_VERSION_CONFIG_PREFS_NO_COMMAS);
// 6. store the node
try {
node.flush();
} catch (BackingStoreException e) {
// do nothing
}
}
/**
* Look for and read data that might have been persisted from some previous
* run. Leave the receiver in a default state if no persistent data is
* found.
*
* @return true if a file was successfully read and false otherwise
*/
private boolean readPersistedData_file() {
URL persUrl = null;
Location configLoc = Platform.getConfigurationLocation();
if (configLoc != null) {
persUrl = getPersistenceUrl(configLoc.getURL(), false);
}
try {
// inside try to get the safe default creation in the finally
// clause
if (persUrl == null) {
return false;
}
// E.g.,
// <launchWorkspaceData>
// <protocol version="1"/>
// <alwaysAsk showDialog="1"/>
// <recentWorkspaces maxLength="5">
// <workspace path="C:\eclipse\workspace0"/>
// <workspace path="C:\eclipse\workspace1"/>
// </recentWorkspaces>
// </launchWorkspaceData>
Reader reader = new FileReader(persUrl.getFile());
XMLMemento memento = XMLMemento.createReadRoot(reader);
if (memento == null || !compatibleFileProtocol(memento)) {
return false;
}
IMemento alwaysAskTag = memento.getChild(XML.ALWAYS_ASK);
showDialog = alwaysAskTag == null ? true : alwaysAskTag.getInteger(
XML.SHOW_DIALOG).intValue() == 1;
IMemento recent = memento.getChild(XML.RECENT_WORKSPACES);
if (recent == null) {
return false;
}
Integer maxLength = recent.getInteger(XML.MAX_LENGTH);
int max = RECENT_MAX_LENGTH;
if (maxLength != null) {
max = maxLength.intValue();
}
IMemento indices[] = recent.getChildren(XML.WORKSPACE);
if (indices == null || indices.length <= 0) {
return false;
}
// if a user has edited maxLength to be shorter than the listed
// indices, accept the list (its tougher for them to retype a long
// list of paths than to update a max number)
max = Math.max(max, indices.length);
recentWorkspaces = new String[max];
for (int i = 0; i < indices.length; ++i) {
String path = indices[i].getString(XML.PATH);
if (path == null) {
break;
}
recentWorkspaces[i] = path;
}
} catch (IOException e) {
// cannot log because instance area has not been set
return false;
} catch (WorkbenchException e) {
// cannot log because instance area has not been set
return false;
} finally {
// create safe default if needed
if (recentWorkspaces == null) {
recentWorkspaces = new String[RECENT_MAX_LENGTH];
}
}
return true;
}
/**
* Return the current (persisted) value of the "showDialog on startup"
* preference. Return the global default if the file cannot be accessed.
*/
public static boolean getShowDialogValue() {
// TODO See the long comment in #readPersistedData -- when the
// transition time is over this method can be changed to
// read the preference directly.
ChooseWorkspaceData data = new ChooseWorkspaceData(""); //$NON-NLS-1$
// return either the value in the file or true, which is the global
// default
return data.readPersistedData() ? data.showDialog : true;
}
/**
* Return the current (persisted) value of the "showDialog on startup"
* preference. Return the global default if the file cannot be accessed.
*/
public static void setShowDialogValue(boolean showDialog) {
// TODO See the long comment in #readPersistedData -- when the
// transition time is over this method can be changed to
// read the preference directly.
ChooseWorkspaceData data = new ChooseWorkspaceData(""); //$NON-NLS-1$
// update the value and write the new settings
data.showDialog = showDialog;
data.writePersistedData();
}
/**
* Look in the config area preference store for the list of recently used
* workspaces.
*
* NOTE: During the transition phase the file will be checked if no config
* preferences are found.
*
* @return true if the values were successfully retrieved and false
* otherwise
*/
public boolean readPersistedData() {
IPreferenceStore store = new ScopedPreferenceStore(
ConfigurationScope.INSTANCE, Activator.PLUGIN_ID);
// The old way was to store this information in a file, the new is to
// use the configuration area preference store. To help users with the
// transition, this code always looks for values in the preference
// store; they are used if found. If there aren't any related
// preferences, then the file method is used instead. This class always
// writes to the preference store, so the fall-back should be needed no
// more than once per-user, per-configuration.
// This code always sets the value of the protocol to a non-zero value
// (currently at 2). If the value comes back as the default (0), then
// none of the preferences were set, revert to the file method.
int protocol = store
.getInt(IDE.Preferences.RECENT_WORKSPACES_PROTOCOL);
if (protocol == IPreferenceStore.INT_DEFAULT_DEFAULT
&& readPersistedData_file()) {
return true;
}
// 2. get value for showDialog
showDialog = store
.getBoolean(IDE.Preferences.SHOW_WORKSPACE_SELECTION_DIALOG);
// 3. use value of numRecent to create proper length array
int max = store
.getInt(IDE.Preferences.MAX_RECENT_WORKSPACES);
max = Math.max(max, RECENT_MAX_LENGTH);
// 4. load values of recent workspaces into array
String workspacePathPref = store
.getString(IDE.Preferences.RECENT_WORKSPACES);
recentWorkspaces = decodeStoredWorkspacePaths(protocol, max, workspacePathPref);
return true;
}
/**
* The the list of recent workspaces must be stored as a string in the preference node.
*/
private static String encodeStoredWorkspacePaths(String[] recent) {
StringBuffer buff = new StringBuffer();
String path = null;
for (int i = 0; i < recent.length; ++i) {
if (recent[i] == null) {
break;
}
// as of 3.3.1 pump this out using newlines instead of commas
if (path != null) {
buff.append("\n"); //$NON-NLS-1$
}
path = recent[i];
buff.append(path);
}
return buff.toString();
}
/**
* The the preference for recent workspaces must be converted from the
* storage string into an array.
*/
private static String[] decodeStoredWorkspacePaths(int protocol, int max,
String prefValue) {
String[] paths = new String[max];
if (prefValue == null || prefValue.length() <= 0) {
return paths;
}
// if we're using the latest version of the protocol use the newline as a
// token. Otherwise use the older comma.
String tokens = null;
switch (protocol) {
case PERS_ENCODING_VERSION_CONFIG_PREFS_NO_COMMAS :
tokens = "\n"; //$NON-NLS-1$
break;
case PERS_ENCODING_VERSION_CONFIG_PREFS :
tokens = ","; //$NON-NLS-1$
break;
}
if (tokens == null) // unknown version? corrupt file? we can't log it
// because we dont have a workspace yet...
return new String[0];
StringTokenizer tokenizer = new StringTokenizer(prefValue, tokens);
for (int i = 0; i < paths.length && tokenizer.hasMoreTokens(); ++i) {
paths[i] = tokenizer.nextToken();
}
return paths;
}
/**
* Return true if the protocol used to encode the argument memento is
* compatible with the receiver's implementation and false otherwise.
*/
private static boolean compatibleFileProtocol(IMemento memento) {
IMemento protocolMemento = memento.getChild(XML.PROTOCOL);
if (protocolMemento == null) {
return false;
}
Integer version = protocolMemento.getInteger(XML.VERSION);
return version != null && version.intValue() == PERS_ENCODING_VERSION;
}
/**
* The workspace data is stored in the well known file pointed to by the result
* of this method.
* @param create If the directory and file does not exist this parameter
* controls whether it will be created.
* @return An url to the file and null if it does not exist or could not
* be created.
*/
private static URL getPersistenceUrl(URL baseUrl, boolean create) {
if (baseUrl == null) {
return null;
}
try {
// make sure the directory exists
URL url = new URL(baseUrl, PERS_FOLDER);
File dir = new File(url.getFile());
if (!dir.exists() && (!create || !dir.mkdir())) {
return null;
}
// make sure the file exists
url = new URL(dir.toURI().toURL(), PERS_FILENAME);
File persFile = new File(url.getFile());
if (!persFile.exists() && (!create || !persFile.createNewFile())) {
return null;
}
return persFile.toURI().toURL();
} catch (IOException e) {
// cannot log because instance area has not been set
return null;
}
}
}