| /******************************************************************************* |
| * Copyright (c) 2006 Sybase, Inc. 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: |
| * Sybase, Inc. - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.jst.jsf.common.ui.internal.utils; |
| |
| import java.io.File; |
| import java.util.StringTokenizer; |
| |
| import org.eclipse.core.resources.IContainer; |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.resources.IResource; |
| import org.eclipse.core.resources.ResourcesPlugin; |
| import org.eclipse.core.runtime.IPath; |
| import org.eclipse.core.runtime.Path; |
| import org.eclipse.jdt.core.IClasspathEntry; |
| import org.eclipse.jdt.core.IJarEntryResource; |
| import org.eclipse.jdt.core.IJavaElement; |
| import org.eclipse.jdt.core.IJavaProject; |
| import org.eclipse.jst.jsf.common.ui.IFileFolderConstants; |
| import org.eclipse.ui.IFileEditorInput; |
| import org.eclipse.ui.IWorkbenchPage; |
| import org.eclipse.ui.IWorkbenchWindow; |
| import org.eclipse.ui.PlatformUI; |
| |
| /** |
| * Collection of helper methods to manage and convert links Originally part of |
| * the LinksManager (com.ibm.iwt.parser.util) |
| */ |
| public final class PathUtil { |
| private static final String FORWARD_SLASH = "/"; //$NON-NLS-1$ |
| |
| private static final String RELATIVE_PATH_SIGNAL = IFileFolderConstants.DOT |
| + IFileFolderConstants.DOT + IFileFolderConstants.PATH_SEPARATOR; |
| |
| /** |
| * adjust relative path isside the absolute path |
| * @param path |
| * @return the adjusted path |
| */ |
| public static String adjustPath(String path) { |
| int i = 0; |
| while ((i = path.indexOf(RELATIVE_PATH_SIGNAL)) > 0) { |
| // split the string into two |
| String part1 = path.substring(0, i - 1); |
| String part2 = path |
| .substring(i + RELATIVE_PATH_SIGNAL.length() - 1); |
| // strip one path seg from part1 |
| int j = part1.lastIndexOf(FORWARD_SLASH); |
| if (j == -1) { |
| return "";//$NON-NLS-1$ |
| } |
| part1 = part1.substring(0, j); |
| path = part1 + part2; |
| } |
| return path; |
| } |
| |
| /** |
| * Append trailing url slash if needed |
| * @param input |
| * @return the string |
| */ |
| public static String appendTrailingURLSlash(String input) { |
| // check to see already a slash |
| if (!input.endsWith(FORWARD_SLASH)) { |
| input += FORWARD_SLASH; |
| } |
| return input; |
| } |
| |
| /** |
| * Convert to relative url based on base |
| * @param input |
| * @param base |
| * @return the string |
| */ |
| public static String convertToRelativePath(String input, String base) { |
| // tokenize the strings |
| StringTokenizer inputTokenizer = new StringTokenizer(input, |
| FORWARD_SLASH); |
| StringTokenizer baseTokenizer = new StringTokenizer(base, FORWARD_SLASH); |
| String token1 = "", token2 = "";//$NON-NLS-2$//$NON-NLS-1$ |
| // |
| // Go through until equls |
| while (true) { |
| if (!inputTokenizer.hasMoreTokens() |
| || !baseTokenizer.hasMoreTokens()) { |
| break; |
| } |
| token1 = baseTokenizer.nextToken(); |
| token2 = inputTokenizer.nextToken(); |
| if (!token1.equals(token2)) { |
| break; |
| } |
| } |
| // now generate the backs |
| String output = "";//$NON-NLS-1$ |
| while (baseTokenizer.hasMoreTokens()) { |
| baseTokenizer.nextToken(); |
| output += RELATIVE_PATH_SIGNAL; |
| } |
| output += token2; |
| // generate the rest |
| while (inputTokenizer.hasMoreTokens()) { |
| output = output + FORWARD_SLASH + inputTokenizer.nextToken(); |
| } |
| return output; |
| } |
| |
| /** |
| * @param projectName |
| * @param path |
| * @return the path in the project converted to a path relative to the |
| * web folder |
| */ |
| public static String convertToWebPath(String projectName, String path) { |
| String name = ""; //$NON-NLS-1$ |
| IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject( |
| projectName); |
| String webrootName = WebrootUtil.getWebContentFolder(project).getName(); |
| |
| if (path.indexOf(webrootName) != -1) { |
| name = projectName + IFileFolderConstants.PATH_SEPARATOR |
| + webrootName; |
| } else { |
| name = projectName; |
| } |
| int index = path.indexOf(projectName); |
| |
| return path.substring(index + name.length()); |
| } |
| |
| /** |
| * convert path relative to current active file to absolute path in |
| * filesystem |
| * |
| * @param uri |
| * the relative path |
| * @param curFile |
| * @return absolute path in file system |
| */ |
| public static String convertToAbsolutePath(String uri, IFile curFile) { |
| if (uri == null || uri.trim().equals("")) { //$NON-NLS-1$ |
| return uri; |
| } |
| String webroot = ""; //$NON-NLS-1$ |
| IFile jsp = curFile; |
| try { |
| if (jsp == null) { |
| jsp = ((IFileEditorInput) getActivePage() |
| .getActiveEditor().getEditorInput()).getFile(); |
| } |
| if (jsp != null) { |
| String webrootName = WebrootUtil.getWebContentFolder( |
| jsp.getProject()).getName(); |
| webroot = jsp.getProject().getFolder(webrootName).getLocation() |
| .toString(); |
| } |
| } catch (NullPointerException e) { |
| return uri; |
| } |
| if (uri.startsWith(IFileFolderConstants.PATH_SEPARATOR)) |
| { |
| return webroot + uri; |
| } |
| if (jsp != null) { |
| IContainer con = jsp.getParent(); |
| if (con != null) { |
| IPath path = con.getLocation(); |
| if (path != null) { |
| String aPath = path.toString() + File.separator + uri; |
| aPath = aPath.replace('/', File.separatorChar); |
| aPath = aPath.replace('\\', File.separatorChar); |
| if (aPath.endsWith(File.separator)) { |
| aPath += IFileFolderConstants.PATH_SEPARATOR; |
| } |
| File file = new File(aPath); |
| if (file.exists() && file.isFile()) { |
| return file.getAbsolutePath(); |
| } |
| return uri; |
| } |
| } |
| } |
| return uri; |
| } |
| |
| /** |
| * Returns the active workbench window. |
| * |
| * @return the active workbench window. this can be null but I've never seen |
| * it. |
| */ |
| private static IWorkbenchWindow getActiveWorkbenchWindow() { |
| if (PlatformUI.getWorkbench() == null) { |
| return null; |
| } |
| return PlatformUI.getWorkbench().getActiveWorkbenchWindow(); |
| } |
| |
| /** |
| * Returns the active workbench page. Note that the active page may not be |
| * the one that the user perceives as active in some situations so this |
| * method of obtaining the activate page should only be used if no other |
| * method is available. |
| * |
| * @return the active workbench page |
| */ |
| private static IWorkbenchPage getActivePage() { |
| IWorkbenchWindow window = getActiveWorkbenchWindow(); |
| if (window == null) { |
| return null; |
| } |
| return window.getActivePage(); |
| } |
| /** |
| * @param javaProject |
| * @param parent |
| * @return the IPath for a a classpath object (?) |
| */ |
| public static IPath getPathOnClasspath(IJavaProject javaProject, |
| Object parent) { |
| IPath result = null; |
| if (javaProject == null || parent == null) { |
| return new Path(""); //$NON-NLS-1$ |
| } |
| IClasspathEntry[] entries = javaProject.readRawClasspath(); |
| IPath classPath = null; |
| if (parent instanceof IResource) { |
| if (((javaProject != null) && !javaProject |
| .isOnClasspath((IResource) parent))) { |
| return new Path(""); //$NON-NLS-1$ |
| } |
| if (parent instanceof IFile) { |
| IPath elementPath = ((IFile) parent).getFullPath(); |
| if (((IFile) parent).getFileExtension().equalsIgnoreCase( |
| IFileFolderConstants.EXT_PROPERTIES)) { |
| int machings = 0; |
| try { |
| for (int i = 0; i < entries.length; i++) { |
| // Determine whether on this classentry's path |
| int n = entries[i].getPath().matchingFirstSegments( |
| elementPath); |
| if (n > machings) { |
| // Get package name |
| machings = n; |
| classPath = elementPath.removeFirstSegments( |
| machings).removeLastSegments(1); |
| } |
| } |
| |
| // Not on the classpath? |
| if (classPath == null) { |
| return null; |
| } else if (classPath.segmentCount() > 0) { |
| IJavaElement element = javaProject |
| .findElement(classPath); |
| if (element != null) { |
| IPath path = element.getPath(); |
| if (path != null) { |
| IPath path1 = path |
| .removeFirstSegments(machings); |
| |
| String fileName = ((IFile) parent) |
| .getName(); |
| if (fileName != null) { |
| result = path1.append(fileName); |
| } |
| } |
| } |
| |
| } else { |
| result = ((IFile) parent).getFullPath() |
| .removeFirstSegments(machings); |
| } |
| } catch (Exception e) { |
| return null; |
| } |
| } |
| } |
| } else if (parent instanceof IJarEntryResource) { |
| IPath elementPath = ((IJarEntryResource) parent).getFullPath(); |
| if (elementPath.getFileExtension().equalsIgnoreCase( |
| IFileFolderConstants.EXT_PROPERTIES)) { |
| result = elementPath; |
| } |
| } |
| if (result != null) { |
| return result; |
| } |
| return new Path(""); //$NON-NLS-1$ |
| } |
| |
| private PathUtil() |
| { |
| // utility class, no instantiation |
| } |
| } |