| /******************************************************************************* |
| * Copyright (c) 2003, 2006 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 |
| *******************************************************************************/ |
| /* |
| * Created on Mar 17, 2004 |
| * |
| * To change the template for this generated file go to |
| * Window>Preferences>Java>Code Generation>Code and Comments |
| */ |
| package org.eclipse.jst.j2ee.internal.project; |
| |
| import java.io.ByteArrayInputStream; |
| import java.io.ByteArrayOutputStream; |
| import java.io.File; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.lang.reflect.Method; |
| import java.net.MalformedURLException; |
| import java.net.URL; |
| import java.net.URLClassLoader; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.StringTokenizer; |
| |
| import org.eclipse.core.resources.IContainer; |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.resources.IFolder; |
| import org.eclipse.core.resources.IMarker; |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.resources.IProjectDescription; |
| import org.eclipse.core.resources.IResource; |
| import org.eclipse.core.resources.IWorkspace; |
| import org.eclipse.core.resources.IncrementalProjectBuilder; |
| import org.eclipse.core.resources.ProjectScope; |
| import org.eclipse.core.resources.ResourcesPlugin; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.FileLocator; |
| import org.eclipse.core.runtime.IPath; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.NullProgressMonitor; |
| import org.eclipse.core.runtime.Path; |
| import org.eclipse.core.runtime.Platform; |
| import org.eclipse.core.runtime.SubProgressMonitor; |
| import org.eclipse.core.runtime.preferences.IEclipsePreferences; |
| import org.eclipse.core.runtime.preferences.IScopeContext; |
| import org.eclipse.emf.codegen.CodeGenPlugin; |
| import org.eclipse.emf.codegen.jet.JETCompiler; |
| import org.eclipse.emf.codegen.jet.JETEmitter; |
| import org.eclipse.emf.codegen.jet.JETException; |
| import org.eclipse.jdt.core.IClasspathAttribute; |
| import org.eclipse.jdt.core.IClasspathEntry; |
| import org.eclipse.jdt.core.IJavaModel; |
| import org.eclipse.jdt.core.IJavaProject; |
| import org.eclipse.jdt.core.IPackageFragmentRoot; |
| import org.eclipse.jdt.core.JavaCore; |
| import org.eclipse.jdt.core.JavaModelException; |
| import org.eclipse.jdt.launching.JavaRuntime; |
| import org.eclipse.jst.j2ee.internal.plugin.IJ2EEModuleConstants; |
| import org.eclipse.jst.j2ee.internal.plugin.J2EEPlugin; |
| import org.eclipse.jst.j2ee.internal.plugin.J2EEPluginResourceHandler; |
| import org.eclipse.osgi.util.ManifestElement; |
| import org.osgi.framework.Bundle; |
| import org.osgi.framework.Constants; |
| import org.osgi.service.prefs.BackingStoreException; |
| |
| /** |
| * @author schacher, mdelder |
| * |
| * To change the template for this generated type comment go to |
| * Window>Preferences>Java>Code Generation>Code and Comments |
| */ |
| public class WTPJETEmitter extends JETEmitter { |
| |
| public static final String PROJECT_NAME = ".JETEmitters"; //$NON-NLS-1$ |
| private Map variables; |
| |
| private boolean intelligentLinkingEnabled = false; |
| |
| private JETCompiler jetCompiler; |
| |
| /** |
| * @param templateURI |
| */ |
| public WTPJETEmitter(String templateURI) { |
| super(templateURI); |
| } |
| |
| /** |
| * @param templateURIPath |
| * @param relativeTemplateURI |
| */ |
| public WTPJETEmitter(String[] templateURIPath, String relativeTemplateURI) { |
| super(templateURIPath, relativeTemplateURI); |
| } |
| |
| /** |
| * @param templateURI |
| * @param classLoader |
| */ |
| public WTPJETEmitter(String templateURI, ClassLoader classLoader) { |
| super(templateURI, classLoader); |
| try { |
| initialize(new NullProgressMonitor()); |
| } catch (JETException e) { |
| J2EEPlugin.logError(e); |
| } |
| } |
| |
| /** |
| * @param templateURIPath |
| * @param relativeTemplateURI |
| * @param classLoader |
| */ |
| public WTPJETEmitter(String[] templateURIPath, String relativeTemplateURI, ClassLoader classLoader) { |
| super(templateURIPath, relativeTemplateURI, classLoader); |
| } |
| |
| /** |
| * @param templateURIPath |
| * @param relativeTemplateURI |
| * @param classLoader |
| * @param encoding |
| */ |
| public WTPJETEmitter(String[] templateURIPath, String relativeTemplateURI, ClassLoader classLoader, String encoding) { |
| super(templateURIPath, relativeTemplateURI, classLoader, encoding); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.emf.codegen.jet.JETEmitter#initialize(org.eclipse.core.runtime.IProgressMonitor) |
| */ |
| @Override |
| public void initialize(IProgressMonitor progressMonitor) throws JETException { |
| |
| progressMonitor.beginTask("", 10); //$NON-NLS-1$ |
| progressMonitor.subTask(CodeGenPlugin.getPlugin().getString("_UI_GeneratingJETEmitterFor_message", new Object[]{templateURI})); //$NON-NLS-1$ |
| |
| try { |
| // This ensures that the JRE variables are initialized. |
| try { |
| JavaRuntime.getDefaultVMInstall(); |
| } catch (Throwable throwable) { |
| // This is kind of nasty to come here. |
| URL jreURL = Platform.find(Platform.getBundle("org.eclipse.emf.codegen"),new Path("plugin.xml")); //$NON-NLS-1$ //$NON-NLS-2$ |
| IPath jrePath = new Path(Platform.asLocalURL(jreURL).getFile()); |
| jrePath = jrePath.removeLastSegments(1).append(new Path("../../jre/lib/rt.jar")); //$NON-NLS-1$ |
| if (!jrePath.equals(JavaCore.getClasspathVariable(JavaRuntime.JRELIB_VARIABLE))) { |
| JavaCore.setClasspathVariable(JavaRuntime.JRELIB_VARIABLE, jrePath, null); |
| } |
| } |
| |
| /* |
| * final JETCompiler jetCompiler = templateURIPath == null ? new |
| * MyJETCompiler(templateURI, encoding) : |
| */ |
| |
| getJetCompiler(); |
| |
| progressMonitor.subTask(CodeGenPlugin.getPlugin().getString("_UI_JETParsing_message", new Object[]{jetCompiler.getResolvedTemplateURI()})); //$NON-NLS-1$ |
| jetCompiler.parse(); |
| progressMonitor.worked(1); |
| |
| ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); |
| jetCompiler.generate(outputStream); |
| final InputStream contents = new ByteArrayInputStream(outputStream.toByteArray()); |
| |
| final IWorkspace workspace = ResourcesPlugin.getWorkspace(); |
| IJavaModel javaModel = JavaCore.create(ResourcesPlugin.getWorkspace().getRoot()); |
| if (!javaModel.isOpen()) { |
| javaModel.open(new SubProgressMonitor(progressMonitor, 1)); |
| } else { |
| progressMonitor.worked(1); |
| } |
| |
| final IProject project = workspace.getRoot().getProject(getProjectName()); |
| progressMonitor.subTask(CodeGenPlugin.getPlugin().getString("_UI_JETPreparingProject_message", new Object[]{project.getName()})); //$NON-NLS-1$ |
| |
| IJavaProject javaProject; |
| if (!project.exists()) { |
| javaProject = createJavaProject(progressMonitor, workspace, project); |
| |
| initializeJavaProject(progressMonitor, project, javaProject); |
| |
| javaProject.close(); |
| } else { |
| project.open(new SubProgressMonitor(progressMonitor, 5)); |
| javaProject = JavaCore.create(project); |
| List rawClassPath = Arrays.asList(javaProject.getRawClasspath()); |
| for (int i=0; i<rawClassPath.size(); i++) { |
| IClasspathEntry entry = (IClasspathEntry) rawClassPath.get(i); |
| if (entry.getEntryKind()==IClasspathEntry.CPE_LIBRARY) |
| classpathEntries.add(entry); |
| } |
| } |
| |
| IPackageFragmentRoot sourcePackageFragmentRoot = openJavaProjectIfNecessary(progressMonitor, project, javaProject); |
| |
| String packageName = jetCompiler.getSkeleton().getPackageName(); |
| StringTokenizer stringTokenizer = new StringTokenizer(packageName, "."); //$NON-NLS-1$ |
| IProgressMonitor subProgressMonitor = new SubProgressMonitor(progressMonitor, 1); |
| subProgressMonitor.beginTask("", stringTokenizer.countTokens() + 4); //$NON-NLS-1$ |
| subProgressMonitor.subTask(CodeGenPlugin.getPlugin().getString("_UI_CreateTargetFile_message")); //$NON-NLS-1$ |
| IContainer sourceContainer = (IContainer) sourcePackageFragmentRoot.getCorrespondingResource(); |
| while (stringTokenizer.hasMoreElements()) { |
| String folderName = stringTokenizer.nextToken(); |
| sourceContainer = sourceContainer.getFolder(new Path(folderName)); |
| if (!sourceContainer.exists()) { |
| ((IFolder) sourceContainer).create(false, true, new SubProgressMonitor(subProgressMonitor, 1)); |
| } |
| } |
| IFile targetFile = sourceContainer.getFile(new Path(jetCompiler.getSkeleton().getClassName() + ".java")); //$NON-NLS-1$ |
| if (!targetFile.exists()) { |
| subProgressMonitor.subTask(CodeGenPlugin.getPlugin().getString("_UI_JETCreating_message", new Object[]{targetFile.getFullPath()})); //$NON-NLS-1$ |
| targetFile.create(contents, true, new SubProgressMonitor(subProgressMonitor, 1)); |
| } else { |
| subProgressMonitor.subTask(CodeGenPlugin.getPlugin().getString("_UI_JETUpdating_message", new Object[]{targetFile.getFullPath()})); //$NON-NLS-1$ |
| targetFile.setContents(contents, true, true, new SubProgressMonitor(subProgressMonitor, 1)); |
| } |
| |
| boolean errors = performBuild(project, subProgressMonitor, targetFile); |
| |
| if (!errors) { |
| loadClass(workspace, project, javaProject, packageName, subProgressMonitor); |
| } |
| |
| subProgressMonitor.done(); |
| } catch (CoreException exception) { |
| throw new JETException(exception); |
| } catch (Exception exception) { |
| throw new JETException(exception); |
| } finally { |
| progressMonitor.done(); |
| } |
| |
| } |
| |
| /** |
| * @param progressMonitor |
| * @param project |
| * @param javaProject |
| * @return |
| * @throws JavaModelException |
| */ |
| protected IPackageFragmentRoot openJavaProjectIfNecessary(IProgressMonitor progressMonitor, final IProject project, IJavaProject javaProject) throws JavaModelException { |
| progressMonitor.subTask(CodeGenPlugin.getPlugin().getString("_UI_JETOpeningJavaProject_message", new Object[]{project.getName()})); //$NON-NLS-1$ |
| javaProject.open(new SubProgressMonitor(progressMonitor, 1)); |
| |
| IPackageFragmentRoot[] packageFragmentRoots = javaProject.getPackageFragmentRoots(); |
| IPackageFragmentRoot sourcePackageFragmentRoot = null; |
| for (int j = 0; j < packageFragmentRoots.length; ++j) { |
| IPackageFragmentRoot packageFragmentRoot = packageFragmentRoots[j]; |
| if (packageFragmentRoot.getKind() == IPackageFragmentRoot.K_SOURCE) { |
| sourcePackageFragmentRoot = packageFragmentRoot; |
| break; |
| } |
| } |
| return sourcePackageFragmentRoot; |
| } |
| |
| /** |
| * @param progressMonitor |
| * @param project |
| * @param javaProject |
| * @throws CoreException |
| * @throws JavaModelException |
| * @throws BackingStoreException |
| */ |
| protected void initializeJavaProject(IProgressMonitor progressMonitor, final IProject project, IJavaProject javaProject) throws CoreException, JavaModelException, BackingStoreException { |
| progressMonitor.subTask(CodeGenPlugin.getPlugin().getString("_UI_JETInitializingProject_message", new Object[]{project.getName()})); //$NON-NLS-1$ |
| IClasspathEntry classpathEntry = JavaCore.newSourceEntry(new Path("/" + project.getName() + "/src")); //$NON-NLS-1$ //$NON-NLS-2$ |
| |
| //IClasspathEntry jreClasspathEntry = JavaCore.newVariableEntry(new Path(JavaRuntime.JRELIB_VARIABLE), new Path(JavaRuntime.JRESRC_VARIABLE), new Path(JavaRuntime.JRESRCROOT_VARIABLE)); |
| IClasspathEntry jreClasspathEntry = JavaRuntime.getDefaultJREContainerEntry(); |
| |
| List classpath = new ArrayList(); |
| classpath.add(classpathEntry); |
| classpath.add(jreClasspathEntry); |
| classpath.addAll(classpathEntries); |
| |
| IFolder sourceFolder = project.getFolder(new Path("src")); //$NON-NLS-1$ |
| if (!sourceFolder.exists()) { |
| sourceFolder.create(false, true, new SubProgressMonitor(progressMonitor, 1)); |
| } |
| IFolder runtimeFolder = project.getFolder(new Path("runtime")); //$NON-NLS-1$ |
| if (!runtimeFolder.exists()) { |
| runtimeFolder.create(false, true, new SubProgressMonitor(progressMonitor, 1)); |
| } |
| |
| IClasspathEntry[] classpathEntryArray = (IClasspathEntry[]) classpath.toArray(new IClasspathEntry[classpath.size()]); |
| |
| javaProject.setRawClasspath(classpathEntryArray, new SubProgressMonitor(progressMonitor, 1)); |
| |
| javaProject.setOutputLocation(new Path("/" + project.getName() + "/runtime"), new SubProgressMonitor(progressMonitor, 1)); //$NON-NLS-1$ //$NON-NLS-2$ |
| |
| // appended from previous implementation |
| createClasspathEntries(project); |
| |
| IScopeContext context = new ProjectScope( project ); |
| IEclipsePreferences prefs = context.getNode( JavaCore.PLUGIN_ID ); |
| prefs.put( JavaCore.COMPILER_PB_RAW_TYPE_REFERENCE, JavaCore.IGNORE ); |
| prefs.put( JavaCore.COMPILER_PB_UNCHECKED_TYPE_OPERATION, JavaCore.IGNORE ); |
| |
| // set Java compiler compliance level to 1.5 |
| prefs.put( JavaCore.COMPILER_COMPLIANCE, JavaCore.VERSION_1_5 ); |
| prefs.put( JavaCore.COMPILER_CODEGEN_TARGET_PLATFORM, JavaCore.VERSION_1_5 ); |
| prefs.put( JavaCore.COMPILER_SOURCE, JavaCore.VERSION_1_5 ); |
| prefs.put( JavaCore.COMPILER_PB_ASSERT_IDENTIFIER, JavaCore.ERROR ); |
| prefs.put( JavaCore.COMPILER_PB_ENUM_IDENTIFIER, JavaCore.ERROR ); |
| |
| // set Javadoc validation to the default ignore level |
| prefs.put( JavaCore.COMPILER_PB_INVALID_JAVADOC, JavaCore.IGNORE ); |
| prefs.put( JavaCore.COMPILER_PB_INVALID_JAVADOC_TAGS, JavaCore.DISABLED ); |
| prefs.put( JavaCore.COMPILER_PB_INVALID_JAVADOC_TAGS__DEPRECATED_REF, JavaCore.DISABLED ); |
| prefs.put( JavaCore.COMPILER_PB_INVALID_JAVADOC_TAGS__NOT_VISIBLE_REF, JavaCore.DISABLED ); |
| prefs.put( JavaCore.COMPILER_PB_INVALID_JAVADOC_TAGS_VISIBILITY, JavaCore.PUBLIC ); |
| prefs.put( JavaCore.COMPILER_PB_MISSING_JAVADOC_TAG_DESCRIPTION, JavaCore.COMPILER_PB_MISSING_JAVADOC_TAG_DESCRIPTION_RETURN_TAG ); |
| prefs.put( JavaCore.COMPILER_PB_MISSING_JAVADOC_TAGS, JavaCore.IGNORE ); |
| prefs.put( JavaCore.COMPILER_PB_MISSING_JAVADOC_TAGS_VISIBILITY, JavaCore.PUBLIC ); |
| prefs.put( JavaCore.COMPILER_PB_MISSING_JAVADOC_TAGS_OVERRIDING, JavaCore.DISABLED ); |
| prefs.put( JavaCore.COMPILER_PB_MISSING_JAVADOC_COMMENTS, JavaCore.IGNORE ); |
| prefs.put( JavaCore.COMPILER_PB_MISSING_JAVADOC_COMMENTS_VISIBILITY, JavaCore.PUBLIC ); |
| prefs.put( JavaCore.COMPILER_PB_MISSING_JAVADOC_COMMENTS_OVERRIDING, JavaCore.DISABLED ); |
| |
| // store changed properties permanently |
| prefs.flush(); |
| } |
| |
| /** |
| * @param progressMonitor |
| * @param workspace |
| * @param project |
| * @return |
| * @throws CoreException |
| */ |
| private IJavaProject createJavaProject(IProgressMonitor progressMonitor, final IWorkspace workspace, final IProject project) throws CoreException { |
| IJavaProject javaProject; |
| progressMonitor.subTask("JET creating project " + project.getName()); //$NON-NLS-1$ |
| project.create(new SubProgressMonitor(progressMonitor, 1)); |
| progressMonitor.subTask(CodeGenPlugin.getPlugin().getString("_UI_JETCreatingProject_message", new Object[]{project.getName()})); //$NON-NLS-1$ |
| IProjectDescription description = workspace.newProjectDescription(project.getName()); |
| description.setNatureIds(new String[]{JavaCore.NATURE_ID}); |
| description.setLocation(null); |
| project.open(new SubProgressMonitor(progressMonitor, 1)); |
| project.setDescription(description, new SubProgressMonitor(progressMonitor, 1)); |
| |
| javaProject = JavaCore.create(project); |
| return javaProject; |
| } |
| |
| /** |
| * @param workspace |
| * @param project |
| * @param javaProject |
| * @param packageName |
| * @param subProgressMonitor |
| * @throws JavaModelException |
| * @throws MalformedURLException |
| * @throws ClassNotFoundException |
| * @throws SecurityException |
| */ |
| protected void loadClass(final IWorkspace workspace, final IProject project, IJavaProject javaProject, String packageName, IProgressMonitor subProgressMonitor) throws JavaModelException, MalformedURLException, ClassNotFoundException, SecurityException { |
| //IContainer targetContainer = |
| // workspace.getRoot().getFolder(javaProject.getOutputLocation()); |
| |
| subProgressMonitor.subTask(CodeGenPlugin.getPlugin().getString("_UI_JETLoadingClass_message", new Object[]{jetCompiler.getSkeleton().getClassName() + ".class"})); //$NON-NLS-1$ //$NON-NLS-2$ |
| |
| // Construct a proper URL for relative lookup. |
| // |
| URL url = new File(project.getLocation() + "/" + javaProject.getOutputLocation().removeFirstSegments(1) + "/").toURL(); //$NON-NLS-1$ //$NON-NLS-2$ |
| URLClassLoader theClassLoader = new URLClassLoader(new URL[]{url}, classLoader); |
| Class theClass = theClassLoader.loadClass((packageName.length() == 0 ? "" : packageName + ".") + jetCompiler.getSkeleton().getClassName()); //$NON-NLS-1$ //$NON-NLS-2$ |
| String methodName = jetCompiler.getSkeleton().getMethodName(); |
| Method[] methods = theClass.getDeclaredMethods(); |
| for (int i = 0; i < methods.length; ++i) { |
| if (methods[i].getName().equals(methodName)) { |
| setMethod(methods[i]); |
| break; |
| } |
| } |
| } |
| |
| /** |
| * @param project |
| * @param subProgressMonitor |
| * @param targetFile |
| * @return |
| * @throws CoreException |
| */ |
| protected boolean performBuild(final IProject project, IProgressMonitor subProgressMonitor, IFile targetFile) throws CoreException { |
| subProgressMonitor.subTask(CodeGenPlugin.getPlugin().getString("_UI_JETBuilding_message", new Object[]{project.getName()})); //$NON-NLS-1$ |
| project.build(IncrementalProjectBuilder.INCREMENTAL_BUILD, new SubProgressMonitor(subProgressMonitor, 1)); |
| |
| IMarker[] markers = targetFile.findMarkers(IMarker.PROBLEM, true, IResource.DEPTH_INFINITE); |
| boolean errors = false; |
| for (int i = 0; i < markers.length; ++i) { |
| IMarker marker = markers[i]; |
| if (marker.getAttribute(IMarker.SEVERITY, IMarker.SEVERITY_INFO) == IMarker.SEVERITY_ERROR) { |
| errors = true; |
| subProgressMonitor.subTask(marker.getAttribute(IMarker.MESSAGE) + " : " + (CodeGenPlugin.getPlugin().getString("jet.mark.file.line", new Object[]{targetFile.getLocation(), marker.getAttribute(IMarker.LINE_NUMBER)}))); //$NON-NLS-1$ //$NON-NLS-2$ |
| } |
| } |
| return errors; |
| } |
| |
| /** |
| * Create the correct classpath entries for the given project |
| * |
| * @param project |
| */ |
| protected void createClasspathEntries(IProject project) { |
| Assert.isNotNull(project, "A valid project is required in order to append to a classpath"); //$NON-NLS-1$ |
| String variableName = null; |
| String pluginId = null; |
| for (Iterator variablesKeyIterator = getVariables().keySet().iterator(); variablesKeyIterator.hasNext();) { |
| variableName = (String) variablesKeyIterator.next(); |
| pluginId = (String) getVariables().get(variableName); |
| if (hasOutputDirectory(pluginId)) |
| addLinkedFolderAsLibrary(project, variableName, pluginId); |
| else |
| addRuntimeJarsAsLibrary(project, pluginId); |
| } |
| } |
| |
| /** |
| * @param pluginId |
| * @return |
| */ |
| protected boolean hasOutputDirectory(String pluginId) { |
| Bundle bundle = Platform.getBundle(pluginId); |
| URL outputDirectory = Platform.find(bundle,new Path("bin")); //$NON-NLS-1$ |
| if (outputDirectory == null) |
| return false; |
| URL installLocation = null; |
| try { |
| installLocation = Platform.asLocalURL(outputDirectory); |
| File outputDirectoryFile = new File(installLocation.getPath());// new File(location); |
| return outputDirectoryFile.canRead() && outputDirectoryFile.isDirectory() && outputDirectoryFile.listFiles().length > 0; |
| } catch (IOException e) { |
| J2EEPlugin.logWarning(J2EEPluginResourceHandler.getString("Install_Location_Error_", new Object[]{installLocation}) + e); //$NON-NLS-1$ |
| } |
| return false; |
| |
| } |
| |
| /** |
| * @param project |
| * @param variableName |
| * @param pluginId |
| */ |
| protected void addRuntimeJarsAsLibrary(IProject project, String pluginId) { |
| ManifestElement[] elements = null; |
| Bundle bundle = Platform.getBundle(pluginId); |
| try { |
| String requires = bundle.getHeaders().get(Constants.BUNDLE_CLASSPATH); |
| elements = ManifestElement.parseHeader(Constants.BUNDLE_CLASSPATH, requires); |
| } catch (Exception e) { |
| J2EEPlugin.logError(e); |
| elements = new ManifestElement[0]; |
| } |
| IPath runtimeLibFullPath = null; |
| URL fullurl = null; |
| if (elements == null) { |
| if (bundle.getLocation().endsWith(IJ2EEModuleConstants.JAR_EXT)) |
| try { |
| runtimeLibFullPath = getJarredPluginPath(bundle); |
| } catch (IOException e) { |
| J2EEPlugin.logError(e); |
| } |
| appendToClassPath(runtimeLibFullPath,project); |
| return; |
| } |
| for (int i = 0; i < elements.length; i++) { |
| String value = elements[i].getValue(); |
| if (".".equals(value)) //$NON-NLS-1$ |
| value = "/"; //$NON-NLS-1$ |
| fullurl = Platform.getBundle(pluginId).getEntry(value); |
| // fix the problem with leading slash that caused dup classpath entries |
| if (fullurl==null) continue; |
| try { |
| runtimeLibFullPath = new Path(Platform.asLocalURL(fullurl).getPath()); |
| } catch (Exception e) { |
| J2EEPlugin.logError(e); |
| } |
| //TODO handle jar'ed plugins, this is a hack for now, need to find proper bundle API |
| if (bundle.getLocation().endsWith(IJ2EEModuleConstants.JAR_EXT)) |
| try { |
| runtimeLibFullPath = getJarredPluginPath(bundle); |
| } catch (IOException e) { |
| J2EEPlugin.logError(e); |
| } |
| |
| if (runtimeLibFullPath != null && !"jar".equals(runtimeLibFullPath.getFileExtension()) && !"zip".equals(runtimeLibFullPath.getFileExtension())) //$NON-NLS-1$ //$NON-NLS-2$ |
| continue; |
| appendToClassPath(runtimeLibFullPath,project); |
| } |
| } |
| |
| private void appendToClassPath(IPath runtimeLibFullPath, IProject project) { |
| IClasspathEntry entry = null; |
| entry = JavaCore.newLibraryEntry(runtimeLibFullPath, null,null,null,new IClasspathAttribute[]{},false); |
| try { |
| if (!classpathEntries.contains(entry)) |
| classpathEntries.add(entry); |
| //J2EEProjectUtilities.appendJavaClassPath(project, entry); |
| } catch (Exception e) { |
| J2EEPlugin.logError("Problem appending \"" + entry.getPath() + "\" to classpath of Project \"" + project.getName() + "\"."); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ |
| J2EEPlugin.logError(e); |
| } |
| } |
| |
| private IPath getJarredPluginPath(Bundle bundle) throws IOException { |
| Path runtimeLibFullPath = null; |
| String jarPluginLocation = FileLocator.getBundleFile(bundle).getPath(); |
| Path jarPluginPath = new Path(jarPluginLocation); |
| // handle case where jars are installed outside of eclipse installation |
| if (jarPluginPath.isAbsolute()) |
| runtimeLibFullPath = jarPluginPath; |
| // handle normal case where all plugins under eclipse install |
| else { |
| String installPath = Platform.getInstallLocation().getURL().getPath(); |
| runtimeLibFullPath = new Path(installPath+"/"+jarPluginLocation); //$NON-NLS-1$ |
| } |
| return runtimeLibFullPath; |
| } |
| |
| /** |
| * @param progressMonitor |
| */ |
| protected void updateProgress(IProgressMonitor progressMonitor, String key) { |
| progressMonitor.subTask(getMessage(key)); |
| } |
| |
| /** |
| * @param progressMonitor |
| */ |
| protected void updateProgress(IProgressMonitor progressMonitor, String key, Object[] args) { |
| progressMonitor.subTask(getMessage(key, args)); |
| } |
| |
| protected String getMessage(String key) { |
| return CodeGenPlugin.getPlugin().getString(key); |
| } |
| |
| protected String getMessage(String key, Object[] args) { |
| return CodeGenPlugin.getPlugin().getString(key, args); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.emf.codegen.jet.JETEmitter#addVariable(java.lang.String, java.lang.String) |
| */ |
| @Override |
| public void addVariable(String variableName, String pluginID) throws JETException { |
| if (!isIntelligentLinkingEnabled()) |
| super.addVariable(variableName, pluginID); |
| else { |
| getVariables().put(variableName, pluginID); |
| IWorkspace workspace = ResourcesPlugin.getWorkspace(); |
| IProject project = workspace.getRoot().getProject(getProjectName()); |
| if (project != null && project.exists()) |
| createClasspathEntries(project); |
| } |
| |
| } |
| |
| /** |
| * @return |
| */ |
| private boolean isIntelligentLinkingEnabled() { |
| return intelligentLinkingEnabled; |
| } |
| |
| /** |
| * @return |
| */ |
| private Map getVariables() { |
| if (variables == null) |
| variables = new HashMap(); |
| return variables; |
| } |
| |
| protected void addLinkedFolderAsLibrary(IProject project, String variableName, String pluginID) { |
| try { |
| URL outputDirectory = Platform.find(Platform.getBundle(pluginID),new Path("bin")); //$NON-NLS-1$ |
| // IPluginDescriptor pluginDescriptor = Platform.getPlugin(pluginID).getDescriptor(); |
| // URL outputDirectory = pluginDescriptor.find(new Path("bin")); //$NON-NLS-1$ |
| String pathString = Platform.asLocalURL(outputDirectory).getPath(); |
| if (pathString.endsWith("/")) //$NON-NLS-1$ |
| pathString = pathString.substring(0, pathString.length() - 1); |
| if (pathString.startsWith("/")) //$NON-NLS-1$ |
| pathString = pathString.substring(1, pathString.length()); |
| IPath path = new Path(pathString).makeAbsolute(); |
| |
| String binDirectoryVariable = variableName + "_BIN"; //$NON-NLS-1$ |
| IFolder linkedDirectory = project.getFolder(binDirectoryVariable); |
| if (!linkedDirectory.exists()) { |
| linkedDirectory.createLink(path, IResource.ALLOW_MISSING_LOCAL, null); |
| linkedDirectory.setDerived(true); |
| project.refreshLocal(IResource.DEPTH_INFINITE, null); |
| } |
| IClasspathEntry entry = JavaCore.newLibraryEntry(linkedDirectory.getFullPath(), null,null,null,new IClasspathAttribute[]{},false); |
| |
| if (!classpathEntries.contains(entry)) |
| classpathEntries.add(entry); |
| //J2EEProjectUtilities.appendJavaClassPath(project, entry); |
| |
| } catch (Exception e) { |
| J2EEPlugin.logError(e); |
| } |
| } |
| |
| /** |
| * @param intelligentLinkingEnabled |
| * The intelligentLinkingEnabled to set. |
| */ |
| public void setIntelligentLinkingEnabled(boolean intelligentLinkingEnabled) { |
| this.intelligentLinkingEnabled = intelligentLinkingEnabled; |
| } |
| |
| protected JETCompiler getJetCompiler() { |
| try { |
| if (jetCompiler == null) { |
| jetCompiler = templateURIPath == null ? new MyJETCompiler(templateURI, encoding) : new MyJETCompiler(templateURIPath, templateURI, encoding); |
| } |
| } catch (JETException e) { |
| J2EEPlugin.logError(e); |
| } |
| return jetCompiler; |
| } |
| } |
