@Override
public String[] getFrameworkVMArguments() {
IPath installPath = getServer().getRuntime().getLocation();
// If installPath is relative, convert to canonical path and hope for
// the best
if (!installPath.isAbsolute()) {
try {
String installLoc = (new File(installPath.toOSString())).getCanonicalPath();
installPath = new Path(installLoc);
} catch (IOException e) {
// Ignore if there is a problem
}
}
IPath deployPath = getBaseDirectory();
// If deployPath is relative, convert to canonical path and hope for the
// best
if (!deployPath.isAbsolute()) {
try {
String deployLoc = (new File(deployPath.toOSString())).getCanonicalPath();
deployPath = new Path(deployLoc);
} catch (IOException e) {
// Ignore if there is a problem
}
}
return getJonasVersionHandler().getFrameworkVMArguments(installPath, null, deployPath, false);
}
/**
* Set the boolean symbol on and off image path. If the path is relative, then build absolute
* path.
*
* <p><b>Rules:</b> <br>
* If the image selected is on, then search off image. <br>
* If the image selected is off, then search on image. <br>
* If one or both is not found, the image path selected is the same for both.
*
* @param model
* @param imagePath The path to the selected image (on or off or other)
*/
public synchronized void setSymbolImagePath(ControlBoolSymbolModel model, IPath imagePath) {
if (imagePath == null || imagePath.isEmpty()) {
return;
}
if (!imagePath.isAbsolute()) {
imagePath = org.csstudio.opibuilder.util.ResourceUtil.buildAbsolutePath(model, imagePath);
}
// Default
this.onImagePath = imagePath;
this.offImagePath = imagePath;
// Search on or off equivalent
if (ImageUtils.isOnImage(imagePath)) {
IPath offImagePath = ImageUtils.searchOffImage(imagePath);
if (offImagePath != null) {
this.offImagePath = offImagePath;
}
} else if (ImageUtils.isOffImage(imagePath)) {
IPath onImagePath = ImageUtils.searchOnImage(imagePath);
if (onImagePath != null) {
this.onImagePath = onImagePath;
}
}
if (imagePath.getFileExtension() != null
&& "svg".compareToIgnoreCase(imagePath.getFileExtension()) == 0) {
workingWithSVG = true;
} else {
workingWithSVG = false;
}
loadOffImage();
loadOnImage();
}
protected IFile findFileInWorkspace(IPath path) {
IFile file = null;
if (path.isAbsolute()) {
IWorkspaceRoot root = getProject().getWorkspace().getRoot();
// construct a URI, based on the project's locationURI, that points
// to the given path
URI projectURI = project.getLocationURI();
URI newURI =
EFSExtensionManager.getDefault().createNewURIFromPath(projectURI, path.toString());
IFile[] files = root.findFilesForLocationURI(newURI);
for (int i = 0; i < files.length; i++) {
if (files[i].getProject().equals(getProject())) {
file = files[i];
break;
}
}
} else {
file = getProject().getFile(path);
}
return file;
}
/**
* @param filePath
* @return
*/
protected IFile findFilePath(String filePath) {
IPath path = null;
IPath fp = new Path(filePath);
if (fp.isAbsolute()) {
if (getBaseDirectory().isPrefixOf(fp)) {
int segments = getBaseDirectory().matchingFirstSegments(fp);
path = fp.removeFirstSegments(segments);
} else {
path = fp;
}
} else {
path = getWorkingDirectory().append(filePath);
}
IFile file = null;
// The workspace may throw an IllegalArgumentException
// Catch it and the parser should fallback to scan the entire project.
try {
file = findFileInWorkspace(path);
} catch (Exception e) {
}
// We have to do another try, on Windows for cases like "TEST.C" vs "test.c"
// We use the java.io.File canonical path.
if (file == null || !file.exists()) {
File f = path.toFile();
try {
String canon = f.getCanonicalPath();
path = new Path(canon);
file = findFileInWorkspace(path);
} catch (IOException e1) {
}
}
return (file != null && file.exists()) ? file : null;
}
/**
* @param filePath : String
* @return filePath : IPath - not <code>null</code>
*/
public IPath getAbsolutePath(String filePath) {
IPath pFilePath;
if (filePath.startsWith("/")) { // $NON-NLS-1$
return convertCygpath(new Path(filePath));
} else if (filePath.startsWith("\\")
|| //$NON-NLS-1$
(!filePath.startsWith(".")
&& //$NON-NLS-1$
filePath.length() > 2
&& filePath.charAt(1) == ':'
&& (filePath.charAt(2) == '\\' || filePath.charAt(2) == '/'))) {
// absolute path
pFilePath = new Path(filePath);
} else {
// relative path
IPath cwd = getWorkingDirectory();
if (!cwd.isAbsolute()) {
cwd = getBaseDirectory().append(cwd);
}
if (filePath.startsWith("`pwd`")) { // $NON-NLS-1$
if (filePath.length() > 5 && (filePath.charAt(5) == '/' || filePath.charAt(5) == '\\')) {
filePath = filePath.substring(6);
} else {
filePath = filePath.substring(5);
}
}
pFilePath = cwd.append(filePath);
}
return pFilePath;
}
private File[] parseEndorsedDirs(IProject project, String endorsedDirs) {
if (endorsedDirs == null) {
return null;
}
// Remove quotes, use system separators
endorsedDirs = endorsedDirs.replaceAll("\"", "");
// Quote from http://docs.oracle.com/javase/6/docs/technotes/guides/standards/
// "If more than one directory path is specified by java.endorsed.dirs,
// they must be separated by File.pathSeparatorChar."
String[] paths = endorsedDirs.split("" + File.pathSeparatorChar);
// Convert dir paths to Files
List<File> dirs = new ArrayList<File>(paths.length);
for (String path : paths) {
IPath p = new Path(useSystemSeparator(path));
if (!p.isAbsolute()) {
p = project.getLocation().append(p);
}
File lib = new File(p.toOSString());
dirs.add(lib);
}
return dirs.toArray(new File[0]);
}
/**
* Return true if the IFile with the given name exists in this project.
*
* @param aFileName filename can be relative to one of the input file paths for the
* WorkbenchURIConverter.
* @return <code>true</code> if filename exists in this project
* @since 1.0.0
*/
public boolean fileExists(String aFileName) {
if (aFileName == null) return false;
IPath path = new Path(aFileName);
if (path.isAbsolute()) return ResourcesPlugin.getWorkspace().getRoot().getFile(path).exists();
else return getWorkbenchURIConverter().canGetUnderlyingResource(aFileName);
}
public Collection<IPath> getIncludeDirs(
final IProject project, final Collection<IPath> includeDirs) {
final IErlProject erlProject = ErlModelManager.getErlangModel().getErlangProject(project);
if (erlProject == null) {
return includeDirs;
}
final Collection<IPath> projectIncludeDirs = erlProject.getIncludeDirs();
final IPathVariableManager pvm = ResourcesPlugin.getWorkspace().getPathVariableManager();
for (IPath inc : projectIncludeDirs) {
inc = PluginUtils.resolvePVMPath(pvm, inc);
if (inc.isAbsolute()) {
includeDirs.add(inc);
} else {
final IFolder folder = project.getFolder(inc);
if (folder != null) {
final IPath location = folder.getLocation();
if (location != null) {
includeDirs.add(location);
} else {
ErlLogger.warn("No location for %s", folder);
}
}
}
}
return includeDirs;
}
/**
* Respects images residing in any plug-in. If path is relative, then this bundle is looked up for
* the image, otherwise, for absolute path, first segment is taken as id of plug-in with image
*
* @generated
* @param path the path to image, either absolute (with plug-in id as first segment), or relative
* for bundled images
* @return the image descriptor
*/
public static ImageDescriptor findImageDescriptor(String path) {
final IPath p = new Path(path);
if (p.isAbsolute() && p.segmentCount() > 1) {
return AbstractUIPlugin.imageDescriptorFromPlugin(
p.segment(0), p.removeFirstSegments(1).makeAbsolute().toString());
} else {
return getBundledImageDescriptor(p.makeAbsolute().toString());
}
}
/**
* @deprecated
* @param folder
* @param runtime
* @param ignoreError
* @return
*/
public static String getFolder(String folder, IRuntime runtime, boolean ignoreError) {
String tmp =
new ConfigNameResolver()
.performSubstitutions(folder, runtime == null ? null : runtime.getName(), ignoreError);
IPath p = new Path(tmp);
if (!p.isAbsolute() && runtime != null) {
p = runtime.getLocation().append(p);
}
return p.toString();
}
public static IIncludePathEntry newSourceEntry(IPath path, IResource resource) {
if (path == null) {
throw new IllegalArgumentException("Source path cannot be null"); // $NON-NLS-1$
}
if (!path.isAbsolute()) {
throw new IllegalArgumentException(
"Path for IIncludePathEntry must be absolute"); //$NON-NLS-1$
}
return new IncludePathEntry(K_SOURCE, IIncludePathEntry.IPE_SOURCE, path, resource, false);
}
public static IIncludePathEntry newProjectEntry(
IPath path, IResource resource, boolean isExported) {
if (path == null || resource == null) {
throw new IllegalArgumentException("Null arguments are not allowed"); // $NON-NLS-1$
}
if (!path.isAbsolute()) {
throw new IllegalArgumentException(
"Path for IIncludePathEntry must be absolute"); //$NON-NLS-1$
}
return new IncludePathEntry(
K_SOURCE, IIncludePathEntry.IPE_PROJECT, path, resource, isExported);
}
/**
* Get list of clones for the given workspace or path. When <code>path</code> is not <code>null
* </code> the result is narrowed to clones under the <code>path</code>.
*
* @param workspaceId the workspace ID. Must be null if path is provided.
* @param path path under the workspace starting with project ID. Must be null if workspaceId is
* provided.
* @return the request
*/
private WebRequest listGitClonesRequest(String workspaceId, IPath path) {
assertTrue(workspaceId == null && path != null || workspaceId != null && path == null);
String requestURI = SERVER_LOCATION + GIT_SERVLET_LOCATION + Clone.RESOURCE + '/';
if (workspaceId != null) {
requestURI += "workspace/" + workspaceId;
} else {
requestURI += "path" + (path.isAbsolute() ? path : path.makeAbsolute());
}
WebRequest request = new GetMethodWebRequest(requestURI);
request.setHeaderField(ProtocolConstants.HEADER_ORION_VERSION, "1");
setAuthentication(request);
return request;
}
private static void buildPaths(
final IWorkspaceRoot root, final IProject project, final Collection<IPath> list)
throws CoreException {
final IPath projectPath = project.getFullPath();
for (final IPath pp : list) {
// only create in-project paths
if (!pp.isAbsolute() && !pp.toString().equals(".") && !pp.isEmpty()) {
final IPath path = projectPath.append(pp);
final IFolder folder = root.getFolder(path);
createFolderHelper(folder);
}
}
}
/** @return the folder */
public String getFolder() {
String result = new ExpressionResolver(resolver).resolve(folder);
// This resolved variable still might be relative, so we must
// resolve it further if possible, by prepending the server home
IPath p = new Path(result);
if (!p.isAbsolute()) {
String s2 =
ConfigNameResolver.getVariablePattern(ConfigNameResolver.JBOSS_SERVER_HOME)
+ IPath.SEPARATOR
+ result;
result = new ExpressionResolver(resolver).resolve(s2);
}
return result;
}
private String getBopOpenFileText() {
// from project relative path to absolute path
String fileName = bopOpenFileText.getText().trim();
if (fileName.length() > 0) {
IPath filePath = new Path(fileName);
if (!filePath.isAbsolute()) {
if (getContainer().getProject() != null) {
IPath projectPath = getContainer().getProject().getLocation();
filePath = projectPath.append(filePath);
fileName = filePath.toString();
}
}
}
return fileName;
}
@SuppressWarnings("rawtypes")
public List getFrameworkClasspath(IPath configPath) {
IPath installPath = getRuntime().getLocation();
// If installPath is relative, convert to canonical path and hope for
// the best
if (!installPath.isAbsolute()) {
try {
String installLoc = (new File(installPath.toOSString())).getCanonicalPath();
installPath = new Path(installLoc);
} catch (IOException e) {
// Ignore if there is a problem
}
}
return getVersionHandler().getFrameworkClasspath(installPath, configPath);
}
private void setBopOpenFileText(String fileName) {
// from absolute path to project relative path
if (fileName.length() > 0) {
IPath filePath = new Path(fileName);
if (filePath.isAbsolute()) {
if (getContainer().getProject() != null) {
IPath projectPath = getContainer().getProject().getLocation();
if (projectPath.isPrefixOf(filePath)) {
filePath = filePath.removeFirstSegments(projectPath.segmentCount());
filePath = filePath.setDevice(null);
fileName = filePath.toString();
}
}
}
}
bopOpenFileText.setText(fileName);
}
/**
* Removes path information from the given string containing one or more comma separated osgi
* bundles. Replaces escaped '\:' with ':'. Removes, reference, platform and file prefixes.
* Removes any other path information converting the location or the last segment to a bundle id.
*
* @param osgiBundles list of bundles to strip path information from (commma separated)
* @return list of bundles with path information stripped
*/
public static String stripPathInformation(String osgiBundles) {
StringBuffer result = new StringBuffer();
StringTokenizer tokenizer = new StringTokenizer(osgiBundles, ","); // $NON-NLS-1$
while (tokenizer.hasMoreElements()) {
String token = tokenizer.nextToken();
token = token.replaceAll("\\\\:|/:", ":"); // $NON-NLS-1$ //$NON-NLS-2$
// read up until the first @, if there
int atIndex = token.indexOf('@');
String bundle = atIndex > 0 ? token.substring(0, atIndex) : token;
bundle = bundle.trim();
// strip [reference:][platform:][file:] prefixes if any
if (bundle.startsWith(REFERENCE_PREFIX) && bundle.length() > REFERENCE_PREFIX.length())
bundle = bundle.substring(REFERENCE_PREFIX.length());
if (bundle.startsWith(PLATFORM_PREFIX) && bundle.length() > PLATFORM_PREFIX.length())
bundle = bundle.substring(PLATFORM_PREFIX.length());
if (bundle.startsWith(FILE_URL_PREFIX) && bundle.length() > FILE_URL_PREFIX.length())
bundle = bundle.substring(FILE_URL_PREFIX.length());
// if the path is relative, the last segment is the bundle symbolic name
// Otherwise, we need to retrieve the bundle symbolic name ourselves
IPath path = new Path(bundle);
String id = null;
if (path.isAbsolute()) {
id = getSymbolicName(bundle);
}
if (id == null) {
id = path.lastSegment();
}
if (id != null) {
int underscoreIndex = id.indexOf('_');
if (underscoreIndex >= 0) {
id = id.substring(0, underscoreIndex);
}
if (id.endsWith(JAR_EXTENSION)) {
id = id.substring(0, id.length() - 4);
}
}
if (result.length() > 0) result.append(","); // $NON-NLS-1$
result.append(id != null ? id : bundle);
if (atIndex > -1) result.append(token.substring(atIndex).trim());
}
return result.toString();
}
public IEditorInput getEditorInput(IPath p, IProject project) {
IFile f = getFileForPath(p, project);
if (f != null && f.exists()) {
return new FileEditorInput(f);
}
if (p.isAbsolute()) {
File file = p.toFile();
if (file.exists()) {
try {
IFileStore ifs = EFS.getStore(file.toURI());
return new FileStoreEditorInput(ifs);
} catch (CoreException _) {
Activator.getDefault().getLog().log(_.getStatus());
}
}
}
return findFileInCommonSourceLookup(p);
}
/**
* If the file designated by filename exists, return the IPath representation of the filename If
* it does not exist, try cygpath translation
*
* @param filename - file name
* @return location (outside of the workspace).
*/
protected IPath getLocation(String filename) {
IPath path = new Path(filename);
File file = path.toFile();
if (!file.exists() && isCygwin && path.isAbsolute()) {
try {
String cygfilename = Cygwin.cygwinToWindowsPath(filename);
IPath convertedPath = new Path(cygfilename);
file = convertedPath.toFile();
if (file.exists()) {
path = convertedPath;
}
} catch (UnsupportedOperationException e) {
isCygwin = false;
} catch (IOException e) {
}
}
return path;
}
private IFile getFileForPathImpl(IPath path, IProject project) {
IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
if (path.isAbsolute()) {
IFile c = root.getFileForLocation(path);
return c;
}
if (project != null && project.exists()) {
ICProject cproject = CoreModel.getDefault().create(project);
if (cproject != null) {
try {
ISourceRoot[] roots = cproject.getAllSourceRoots();
for (ISourceRoot sourceRoot : roots) {
IResource r = sourceRoot.getResource();
if (r instanceof IContainer) {
IContainer parent = (IContainer) r;
IResource res = parent.findMember(path);
if (res != null && res.exists() && res instanceof IFile) {
IFile file = (IFile) res;
return file;
}
}
}
IOutputEntry entries[] = cproject.getOutputEntries();
for (IOutputEntry pathEntry : entries) {
IPath p = pathEntry.getPath();
IResource r = root.findMember(p);
if (r instanceof IContainer) {
IContainer parent = (IContainer) r;
IResource res = parent.findMember(path);
if (res != null && res.exists() && res instanceof IFile) {
IFile file = (IFile) res;
return file;
}
}
}
} catch (CModelException _) {
Activator.getDefault().getLog().log(_.getStatus());
}
}
}
return null;
}
/**
* Helper method - returns the targeted item (IResource if internal or java.io.File if external),
* or null if unbound Internal items must be referred to using container relative paths.
*/
public static Object getTarget(IContainer container, IPath path, boolean checkResourceExistence) {
if (path == null) return null;
// lookup - inside the container
if (path.getDevice() == null) { // container relative paths should not contain a device
// (see http://dev.eclipse.org/bugs/show_bug.cgi?id=18684)
// (case of a workspace rooted at d:\ )
IResource resource = container.findMember(path);
if (resource != null) {
if (!checkResourceExistence || resource.exists()) return resource;
return null;
}
}
// if path is relative, it cannot be an external path
// (see http://dev.eclipse.org/bugs/show_bug.cgi?id=22517)
if (!path.isAbsolute()) return null;
// lookup - outside the container
File externalFile = new File(path.toOSString());
if (!checkResourceExistence) {
return externalFile;
} else if (existingExternalFiles.contains(externalFile)) {
return externalFile;
} else {
if (ModelWorkspaceManager.ZIP_ACCESS_VERBOSE) {
System.out.println(
"("
+ Thread.currentThread()
+ ") [ModelWorkspaceImpl.getTarget(...)] Checking existence of "
+ path.toString()); // $NON-NLS-1$ //$NON-NLS-2$
}
if (externalFile.exists()) {
// cache external file
existingExternalFiles.add(externalFile);
return externalFile;
}
}
return null;
}
protected void checkIfPatternValid() {
String pattern = fExclusionPatternDialog.getText().trim();
if (pattern.length() == 0) {
fExclusionPatternStatus.setError(NewWizardMessages.ExclusionInclusionEntryDialog_error_empty);
return;
}
IPath path = new Path(pattern);
if (path.isAbsolute() || path.getDevice() != null) {
fExclusionPatternStatus.setError(
NewWizardMessages.ExclusionInclusionEntryDialog_error_notrelative);
return;
}
if (fExistingPatterns.contains(pattern)) {
fExclusionPatternStatus.setError(
NewWizardMessages.ExclusionInclusionEntryDialog_error_exists);
return;
}
fExclusionPattern = pattern;
fExclusionPatternStatus.setOK();
}
/**
* Verify that program name of the configuration can be found as a file.
*
* @return Absolute path of the program location
*/
public static IPath verifyProgramPath(ILaunchConfiguration configuration, ICProject cproject)
throws CoreException {
String programName =
configuration.getAttribute(
ICDTLaunchConfigurationConstants.ATTR_PROGRAM_NAME, (String) null);
if (programName == null) {
abort(
LaunchMessages.getString("AbstractCLaunchDelegate.Program_file_not_specified"),
null, //$NON-NLS-1$
ICDTLaunchConfigurationConstants.ERR_NOT_A_C_PROJECT);
}
IPath programPath = new Path(programName);
if (programPath.isEmpty()) {
abort(
LaunchMessages.getString("AbstractCLaunchDelegate.Program_file_does_not_exist"),
null, //$NON-NLS-1$
ICDTLaunchConfigurationConstants.ERR_NOT_A_C_PROJECT);
}
if (!programPath.isAbsolute() && cproject != null) {
// Find the specified program within the specified project
IFile wsProgramPath = cproject.getProject().getFile(programPath);
programPath = wsProgramPath.getLocation();
}
if (!programPath.toFile().exists()) {
abort(
LaunchMessages.getString(
"AbstractCLaunchDelegate.Program_file_does_not_exist"), //$NON-NLS-1$
new FileNotFoundException(
LaunchMessages.getFormattedString(
"AbstractCLaunchDelegate.PROGRAM_PATH_not_found", //$NON-NLS-1$
programPath.toOSString())),
ICDTLaunchConfigurationConstants.ERR_PROGRAM_NOT_EXIST);
}
return programPath;
}
private void addBaseString(IPath endPath, CPElement cpentry, StringBuffer str) {
IPath baseRef = (IPath) cpentry.getAttribute(CPElement.BASE_REF);
if (!baseRef.isEmpty()) {
if (baseRef.isAbsolute()) {
// str.append("From project ");
IPath path = baseRef;
if (endPath != null) {
path = path.append(endPath);
}
str.append(path.makeRelative().toPortableString());
} else {
// str.append("From contribution ");
IPathEntryContainer container;
if (endPath != null) {
str.append(endPath.toPortableString());
}
str.append(" - ("); // $NON-NLS-1$
try {
container = CoreModel.getPathEntryContainer(baseRef, cpentry.getCProject());
if (container != null) {
str.append(container.getDescription());
}
} catch (CModelException e1) {
}
str.append(')');
}
} else {
IPath path = (IPath) cpentry.getAttribute(CPElement.BASE);
if (!path.isEmpty()) {
if (endPath != null) {
path = path.append(endPath);
}
str.insert(0, path.toPortableString());
} else if (endPath != null) {
str.insert(0, endPath.toPortableString());
}
}
}
/**
* @param checked pass true to get the checked elements, false to get the selected elements
* @return map between project and repository root directory (converted to an absolute path) for
* all projects selected by user
*/
public Map<IProject, File> getProjects(boolean checked) {
final Object[] elements;
if (!internalMode)
if (checked) elements = projectMoveViewer.getCheckedElements();
else {
ISelection selection = viewer.getSelection();
elements = ((IStructuredSelection) selection).toArray();
}
else if (checked) elements = viewer.getCheckedElements();
else {
ISelection selection = viewer.getSelection();
if (selection instanceof IStructuredSelection)
elements = ((IStructuredSelection) selection).toArray();
else elements = new Object[0];
}
Map<IProject, File> ret = new HashMap<IProject, File>(elements.length);
for (Object ti : elements) {
if (!internalMode) {
File workdir = selectedRepository.getWorkTree();
IProject project = (IProject) ti;
IPath targetLocation = new Path(relPath.getText()).append(project.getName());
File targetFile = new File(workdir, targetLocation.toOSString());
ret.put(project, targetFile);
} else {
final IProject project = ((ProjectAndRepo) ti).getProject();
String path = ((ProjectAndRepo) ti).getRepo();
final IPath selectedRepo = Path.fromOSString(path);
IPath localPathToRepo = selectedRepo;
if (!selectedRepo.isAbsolute()) {
localPathToRepo = project.getLocation().append(selectedRepo);
}
ret.put(project, localPathToRepo.toFile());
}
}
return ret;
}
@Override
public void importRuntimeConfiguration(IRuntime runtime, IProgressMonitor monitor)
throws CoreException {
super.importRuntimeConfiguration(runtime, monitor);
OSGIFrameworkInstanceBehaviorDelegate fsb =
(OSGIFrameworkInstanceBehaviorDelegate)
getServer().loadAdapter(EquinoxFrameworkInstanceBehavior.class, null);
if (fsb != null) {
IPath tempDir = fsb.getTempDirectory();
if (!tempDir.isAbsolute()) {
IPath rootPath = ResourcesPlugin.getWorkspace().getRoot().getLocation();
tempDir = rootPath.append(tempDir);
}
setInstanceDirectory(tempDir.toPortableString());
}
try {
getEquinoxConfiguration();
} catch (CoreException e) {
Trace.trace(Trace.SEVERE, "Can't setup for Equinox configuration.", e);
}
}
/** Save attributes to an XML file. */
static void saveAttributes(IPath filenameHint, AttributeValueSets attributes) {
final IPath pathHint =
filenameHint.isAbsolute()
? filenameHint
: FileDialogs.recallPath(REMEMBER_DIRECTORY).append(filenameHint);
final Path saveLocation = FileDialogs.openSaveXML(pathHint);
if (saveLocation != null) {
try {
final Persister persister = new Persister(new Format(2));
persister.write(attributes, saveLocation.toFile());
} catch (Exception e) {
Utils.showError(
new Status(
IStatus.ERROR,
WorkbenchCorePlugin.PLUGIN_ID,
"An error occurred while saving attributes.",
e));
}
FileDialogs.rememberDirectory(REMEMBER_DIRECTORY, saveLocation);
}
}
/* (non-Javadoc)
* @see org.eclipse.jface.viewers.ILabelProvider#getText(java.lang.Object)
*/
public String getText(Object element) {
IRuntimeClasspathEntry entry = (IRuntimeClasspathEntry) element;
switch (entry.getType()) {
case IRuntimeClasspathEntry.PROJECT:
IResource res = entry.getResource();
IJavaElement proj = JavaCore.create(res);
if (proj == null) {
return entry.getPath().lastSegment();
} else {
return lp.getText(proj);
}
case IRuntimeClasspathEntry.ARCHIVE:
IPath path = entry.getPath();
if (path == null) {
return MessageFormat.format("Invalid path: {0}", new Object[] {"null"}); // $NON-NLS-1$
}
if (!path.isAbsolute() || !path.isValidPath(path.toString())) {
return MessageFormat.format("Invalid path: {0}", new Object[] {path.toOSString()});
}
String[] segments = path.segments();
StringBuffer displayPath = new StringBuffer();
if (segments.length > 0) {
String device = path.getDevice();
if (device != null) {
displayPath.append(device);
displayPath.append(File.separator);
}
for (int i = 0; i < segments.length - 1; i++) {
displayPath.append(segments[i]).append(File.separator);
}
displayPath.append(segments[segments.length - 1]);
// getDevice means that's a absolute path.
if (path.getDevice() != null && !path.toFile().exists()) {
displayPath.append(" (missing) ");
}
} else {
displayPath.append(path.toOSString());
}
return displayPath.toString();
case IRuntimeClasspathEntry.VARIABLE:
path = entry.getPath();
IPath srcPath = entry.getSourceAttachmentPath();
StringBuffer buf = new StringBuffer(path.toString());
if (srcPath != null) {
buf.append(" ["); // $NON-NLS-1$
buf.append(srcPath.toString());
IPath rootPath = entry.getSourceAttachmentRootPath();
if (rootPath != null) {
buf.append(IPath.SEPARATOR);
buf.append(rootPath.toString());
}
buf.append(']');
}
// append JRE name if we can compute it
if (path.equals(new Path(JavaRuntime.JRELIB_VARIABLE)) && fLaunchConfiguration != null) {
try {
IVMInstall vm = JavaRuntime.computeVMInstall(fLaunchConfiguration);
buf.append(" - "); // $NON-NLS-1$
buf.append(vm.getName());
} catch (CoreException e) {
}
}
return buf.toString();
case IRuntimeClasspathEntry.CONTAINER:
path = entry.getPath();
if (fLaunchConfiguration != null) {
try {
IJavaProject project = null;
try {
project = JavaRuntime.getJavaProject(fLaunchConfiguration);
} catch (CoreException e) {
}
if (project == null) {
} else {
IClasspathContainer container =
JavaCore.getClasspathContainer(entry.getPath(), project);
if (container != null) {
if (container.getDescription().startsWith("Persisted container")) {
return container.getPath().toString();
} else {
return container.getDescription();
}
}
}
} catch (CoreException e) {
}
}
return entry.getPath().toString();
case IRuntimeClasspathEntry.OTHER:
IRuntimeClasspathEntry delegate = entry;
if (entry instanceof ClasspathEntry) {
delegate = ((ClasspathEntry) entry).getDelegate();
}
String name = lp.getText(delegate);
if (name == null || name.length() == 0) {
return ((IRuntimeClasspathEntry2) delegate).getName();
}
return name;
}
return ""; //$NON-NLS-1$
}
