Attachment #79147 for bug #83258

Lines 24-29 Link Here

(-)META-INF/MANIFEST.MF (+1 lines)
24	org.eclipse.jdt.ui.tests.core;x-internal:=true,	24	org.eclipse.jdt.ui.tests.core;x-internal:=true,
25	org.eclipse.jdt.ui.tests.core.source;x-internal:=true,	25	org.eclipse.jdt.ui.tests.core.source;x-internal:=true,
26	org.eclipse.jdt.ui.tests.dialogs;x-internal:=true,	26	org.eclipse.jdt.ui.tests.dialogs;x-internal:=true,
		27	org.eclipse.jdt.ui.tests.jarexport,
27	org.eclipse.jdt.ui.tests.leaks;x-internal:=true,	28	org.eclipse.jdt.ui.tests.leaks;x-internal:=true,
28	org.eclipse.jdt.ui.tests.model;x-internal:=true,	29	org.eclipse.jdt.ui.tests.model;x-internal:=true,
29	org.eclipse.jdt.ui.tests.packageview;x-internal:=true,	30	org.eclipse.jdt.ui.tests.packageview;x-internal:=true,




/*******************************************************************************
 * Copyright (c) 2007 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
 *******************************************************************************/
package org.eclipse.jdt.ui.tests.jarexport;

import junit.framework.Test;
import junit.framework.TestSuite;

public class JarExportTests {

	public static Test suite() {
		TestSuite suite= new TestSuite("Test for org.eclipse.jdt.ui.tests.jarexport");
		//$JUnit-BEGIN$
		suite.addTest(FatJarExportTests.allTests());
		//$JUnit-END$
		return suite;
	}
}




/*******************************************************************************
 * Copyright (c) 2007 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
 *******************************************************************************/
package org.eclipse.jdt.ui.tests.jarexport;

import java.io.File;
import java.util.zip.ZipFile;

import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Path;

import org.eclipse.core.resources.IMarker;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IncrementalProjectBuilder;
import org.eclipse.core.resources.ResourcesPlugin;

import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PlatformUI;

import org.eclipse.debug.core.ILaunchConfiguration;

import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IPackageFragment;
import org.eclipse.jdt.core.IPackageFragmentRoot;
import org.eclipse.jdt.core.JavaCore;

import org.eclipse.jdt.ui.jarpackager.IJarExportRunnable;
import org.eclipse.jdt.ui.jarpackager.JarPackageData;

import org.eclipse.jdt.internal.ui.jarpackager.JarPackagerUtil;
import org.eclipse.jdt.internal.ui.jarpackagerfat.FatJarBuilder;
import org.eclipse.jdt.internal.ui.jarpackagerfat.FatJarPackageWizardPage;
import org.eclipse.jdt.internal.ui.util.BusyIndicatorRunnableContext;

import org.eclipse.jdt.testplugin.JavaProjectHelper;
import org.eclipse.jdt.testplugin.JavaTestPlugin;

import org.eclipse.jdt.ui.tests.core.ProjectTestSetup;

public class FatJarExportTests extends TestCase {

	private static final Class THIS= FatJarExportTests.class;
	
	public static Test suite() {
		return allTests();
	}

	public static Test allTests() {
		return new ProjectTestSetup(new TestSuite(THIS));
	}

	private IJavaProject fProject;
	private IPackageFragmentRoot fMainRoot;

	/**
	 * {@inheritDoc}
	 */
	protected void setUp() throws Exception {
		fProject= ProjectTestSetup.getProject();
		
		fMainRoot= JavaProjectHelper.addSourceContainer(fProject, "src");
		IPackageFragment fragment= fMainRoot.createPackageFragment("org.eclipse.jdt.ui.test", true, null);
		StringBuffer buf= new StringBuffer();
		buf.append("package org.eclipse.jdt.ui.test;\n");
		buf.append("import mylib.Foo;\n");
		buf.append("public class Main {\n");
		buf.append("    public static void main(String[] args) {\n");
		buf.append("        new Foo();\n");
		buf.append("        new Foo.FooInner();\n");
		buf.append("        new Foo.FooInner.FooInnerInner();\n");
		buf.append("    }\n");
		buf.append("}\n");
		fragment.createCompilationUnit("Main.java", buf.toString(), true, null);
	}
	
	/**
	 * {@inheritDoc}
	 */
	protected void tearDown() throws Exception {
		JavaProjectHelper.clear(fProject, ProjectTestSetup.getDefaultClasspath());
	}
	
	private static String getFooContent() {
		StringBuffer buf= new StringBuffer();
		buf.append("package mylib;\n");
		buf.append("public class Foo {\n");
		buf.append("    public static class FooInner {\n");
		buf.append("        public static class FooInnerInner {\n");
		buf.append("        }\n");
		buf.append("    }\n");
		buf.append("}\n");
		return buf.toString();
	}
	
	private static void assertFatJarExport(IJavaProject project, String archiveName) throws Exception {
		//create class files
		ResourcesPlugin.getWorkspace().build(IncrementalProjectBuilder.FULL_BUILD, null);
	
		IMarker[] markers= ResourcesPlugin.getWorkspace().getRoot().findMarkers(null, true, IResource.DEPTH_INFINITE);
		for (int i= 0; i < markers.length; i++) {
			IMarker marker= markers[i];
			if (marker.getAttribute(IMarker.SEVERITY, IMarker.SEVERITY_INFO) == IMarker.SEVERITY_ERROR) {
				assertTrue((String) marker.getAttribute(IMarker.MESSAGE), false);
			}
		}
		
		//create data
		JarPackageData data= createJarPackageData(project, archiveName);
		
		//create archive
		ZipFile generatedArchive= createArchive(data);
	
		//assert archive content as expected
		assertNotNull(generatedArchive);
		assertNotNull(generatedArchive.getEntry("org/eclipse/jdt/ui/test/Main.class"));
		assertNotNull(generatedArchive.getEntry("mylib/Foo.class"));
		assertNotNull(generatedArchive.getEntry("mylib/Foo$FooInner.class"));
		assertNotNull(generatedArchive.getEntry("mylib/Foo$FooInner$FooInnerInner.class"));
	}

	private static JarPackageData createJarPackageData(IJavaProject project, String archiveName) throws CoreException {
		JarPackageData data= new JarPackageData();
		data.setJarBuilder(new FatJarBuilder());
		
		IPath destination= ResourcesPlugin.getWorkspace().getRoot().getLocation().append(archiveName);
		data.setJarLocation(destination);
		
		ILaunchConfiguration launchConfig= FatJarPackageWizardPage.createTempLaunchConfig(project);
		Object[] children= FatJarPackageWizardPage.getSelectedElementsWithoutContainedChildren(launchConfig, data, new BusyIndicatorRunnableContext());
		data.setElements(children);
		return data;
	}
	
	private static ZipFile createArchive(JarPackageData data) throws Exception, CoreException {
		IWorkbenchWindow window= PlatformUI.getWorkbench().getActiveWorkbenchWindow();
		
		IJarExportRunnable op= data.createJarExportRunnable(window.getShell());
		window.run(false, false, op);
		
		IStatus status= op.getStatus();
		if (status.getSeverity() == IStatus.ERROR)
			throw new CoreException(status);
		
		return JarPackagerUtil.getArchiveFile(data.getJarLocation());
	}
	
	public void testExportSameSrcRoot() throws Exception {
		IPackageFragment pack= fMainRoot.createPackageFragment("mylib", true, null);
		try {
			pack.createCompilationUnit("Foo.java", getFooContent(), true, null);
			
			assertFatJarExport(fProject, getName() + ".jar");
		} finally {
			pack.delete(true, null);
		}
	}
	
	public void testExportOtherSrcRoot() throws Exception {
		IPackageFragmentRoot root= JavaProjectHelper.addSourceContainer(fProject, "other");
		try {
			IPackageFragment pack= root.createPackageFragment("mylib", true, null);
			pack.createCompilationUnit("Foo.java", getFooContent(), true, null);
			
			assertFatJarExport(fProject, getName() + ".jar");
		} finally {
			JavaProjectHelper.removeSourceContainer(fProject, root.getElementName());
		}
	}
	
	public void testExportOtherProject() throws Exception {
		IJavaProject otherProject= JavaProjectHelper.createJavaProject("OtherProject", "bin");
		try {
			otherProject.setRawClasspath(ProjectTestSetup.getDefaultClasspath(), null);

			IPackageFragmentRoot root= JavaProjectHelper.addSourceContainer(otherProject, "other");
			IPackageFragment pack= root.createPackageFragment("mylib", true, null);
			pack.createCompilationUnit("Foo.java", getFooContent(), true, null);
			
			JavaProjectHelper.addRequiredProject(fProject, otherProject);
			
			assertFatJarExport(fProject, getName() + ".jar");
		} finally {
			JavaProjectHelper.removeFromClasspath(fProject, otherProject.getProject().getFullPath());
			JavaProjectHelper.delete(otherProject);
		}
	}
	
	public void testExportInternalLib() throws Exception {
		File lib= JavaTestPlugin.getDefault().getFileInPlugin(JavaProjectHelper.MYLIB);
		IPackageFragmentRoot root= JavaProjectHelper.addLibraryWithImport(fProject, Path.fromOSString(lib.getPath()), null, null); 

		try {
			assertFatJarExport(fProject, getName() + ".jar");
		} finally {
			JavaProjectHelper.removeFromClasspath(fProject, root.getPath());
		}
	}
	
	public void testExportExternalLib() throws Exception {
		File lib= JavaTestPlugin.getDefault().getFileInPlugin(JavaProjectHelper.MYLIB);
		IPackageFragmentRoot root= JavaProjectHelper.addLibrary(fProject, Path.fromOSString(lib.getPath())); 

		try {
			assertFatJarExport(fProject, getName() + ".jar");
		} finally {
			JavaProjectHelper.removeFromClasspath(fProject, root.getPath());
		}
	}
	
	public void testClassFolder() throws Exception {
		File lib= JavaTestPlugin.getDefault().getFileInPlugin(JavaProjectHelper.MYLIB);
		
		IPackageFragmentRoot root= JavaProjectHelper.addClassFolderWithImport(fProject, "cf", null, null, lib);
		try {
			assertFatJarExport(fProject, getName() + ".jar");
		} finally {
			JavaProjectHelper.removeFromClasspath(fProject, root.getPath());
		}
	}
	
	public void testVariable() throws Exception {
		File lib= JavaTestPlugin.getDefault().getFileInPlugin(JavaProjectHelper.MYLIB);
		JavaCore.setClasspathVariable("MYLIB", Path.fromOSString(lib.getPath()), null);
		
		JavaProjectHelper.addVariableEntry(fProject, new Path("MYLIB"), null, null);
		try {
			assertFatJarExport(fProject, getName() + ".jar");
		} finally {
			JavaProjectHelper.removeFromClasspath(fProject, new Path("MYLIB"));
		}
	}	
}

Lines 189-194 Link Here

(-)plugin.properties (+2 lines)
189	jarExportWizard.label=JAR file	189	jarExportWizard.label=JAR file
190	jarExportWizard.description=Export resources into a JAR file on the local file system.	190	jarExportWizard.description=Export resources into a JAR file on the local file system.
191		191
		192	fatJarExportWizard.label=Runnable JAR file
		193	fatJarExportWizard.description=Export all resources required to run an application into a JAR file on the local file system.
192		194
193	createJarAction.label=Create &JAR	195	createJarAction.label=Create &JAR
194	createJarAction.tooltip=Creates the JAR Based on the Selected JAR Description File	196	createJarAction.tooltip=Creates the JAR Based on the Selected JAR Description File




               class="org.eclipse.core.resources.IResource">
         </selection>
      </wizard>
      <wizard
            name="%fatJarExportWizard.label"
            icon="$nl$/icons/full/etool16/exportfatjar_wiz.gif"
            class="org.eclipse.jdt.internal.ui.jarpackagerfat.FatJarPackageWizard"
            category="org.eclipse.jdt.ui.Java"
            id="org.eclipse.jdt.internal.ui.fatjarpackager.JarPackageWizard">
         <description>
            %fatJarExportWizard.description
         </description>
         <selection
               class="org.eclipse.core.resources.IResource">
         </selection>
      </wizard>
   </extension>
   <extension
         point="org.eclipse.ui.popupMenus">




 *******************************************************************************/
package org.eclipse.jdt.internal.ui.jarpackager;

import java.io.File;
import java.lang.reflect.InvocationTargetException;
import java.util.HashSet;
import java.util.Iterator;

import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Path;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;

import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Combo;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.FileDialog;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Link;
import org.eclipse.swt.widgets.TreeItem;

import org.eclipse.jface.wizard.IWizardPage;

import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.dialogs.WizardExportResourcesPage;

import org.eclipse.ltk.core.refactoring.RefactoringCore;
import org.eclipse.ltk.core.refactoring.history.IRefactoringHistoryService;

import org.eclipse.jdt.internal.ui.IJavaHelpContextIds;
import org.eclipse.jdt.internal.ui.filters.EmptyInnerPackageFilter;
import org.eclipse.jdt.internal.ui.util.ExceptionHandler;
import org.eclipse.jdt.internal.ui.util.SWTUtil;
import org.eclipse.jdt.internal.ui.viewsupport.LibraryFilter;

/**
 *	Page 1 of the JAR Package wizard
 */
class JarPackageWizardPage extends AbstractJarDestinationWizardPage {

	private JarPackageData fJarPackage;
	private IStructuredSelection fInitialSelection;

	private Button	fExportRefactoringsCheckbox;
	private Link fRefactoringLink;
	
	private Combo	fDestinationNamesCombo;
	private Button	fDestinationBrowseButton;
	
	private Button		fCompressCheckbox;
	private Button		fOverwriteCheckbox;
	private Button		fIncludeDirectoryEntriesCheckbox;

	private static final String STORE_EXPORT_OUTPUT_FOLDERS= PAGE_NAME + ".EXPORT_OUTPUT_FOLDER"; //$NON-NLS-1$
	private static final String STORE_EXPORT_JAVA_FILES= PAGE_NAME + ".EXPORT_JAVA_FILES"; //$NON-NLS-1$
	
	private static final String STORE_DESTINATION_NAMES= PAGE_NAME + ".DESTINATION_NAMES_ID"; //$NON-NLS-1$
	
	private static final String STORE_REFACTORINGS= PAGE_NAME + ".REFACTORINGS"; //$NON-NLS-1$
	private static final String STORE_COMPRESS= PAGE_NAME + ".COMPRESS"; //$NON-NLS-1$
	private final static String STORE_OVERWRITE= PAGE_NAME + ".OVERWRITE"; //$NON-NLS-1$

	
	/**
	 *	Create an instance of this class
	 *
	 * @param jarPackage an object containing all required information to make an export
	 * @param selection the initial selection
	 */
	public JarPackageWizardPage(JarPackageData jarPackage, IStructuredSelection selection) {
		super(PAGE_NAME, selection, jarPackage);
		setTitle(JarPackagerMessages.JarPackageWizardPage_title); 
		setDescription(JarPackagerMessages.JarPackageWizardPage_description); 
		fJarPackage= jarPackage;

	}

	/**
	 * Answer the contents of the destination specification widget. If this
	 * value does not have the required suffix then add it first.
	 * 
	 * @return java.lang.String
	 */
	protected String getDestinationValue() {
		String destinationText= fDestinationNamesCombo.getText().trim();
		if (destinationText.indexOf('.') < 0)
			destinationText += getOutputSuffix();
		return destinationText;
	}

	/**
	 *	Answer the string to display in self as the destination type
	 *
	 *	@return java.lang.String
	 */
	protected String getDestinationLabel() {
		return JarPackagerMessages.JarPackageWizardPage_destination_label; 
	}

	/**
	 *	Answer the suffix that files exported from this wizard must have.
	 *	If this suffix is a file extension (which is typically the case)
	 *	then it must include the leading period character.
	 *
	 *	@return java.lang.String
	 */
	protected String getOutputSuffix() {
		return "." + JarPackagerUtil.JAR_EXTENSION; //$NON-NLS-1$
	}

	/**
	 * Returns an iterator over this page's collection of currently-specified 
	 * elements to be exported. This is the primary element selection facility
	 * accessor for subclasses.

	 * <code>internalSaveWidgetValues</code>.
	 */
	public final void saveWidgetValues() {
		super.saveWidgetValues();
		// update directory names history
		IDialogSettings settings= getDialogSettings();
		if (settings != null) {
			String[] directoryNames= settings.getArray(STORE_DESTINATION_NAMES);
			if (directoryNames == null)
				directoryNames= new String[0];
			directoryNames= addToHistory(directoryNames, getDestinationValue());
			settings.put(STORE_DESTINATION_NAMES, directoryNames);

			settings.put(STORE_EXPORT_CLASS_FILES, fJarPackage.areClassFilesExported());
			settings.put(STORE_EXPORT_OUTPUT_FOLDERS, fJarPackage.areOutputFoldersExported());
			settings.put(STORE_EXPORT_JAVA_FILES, fJarPackage.areJavaFilesExported());

		fExportOutputFoldersCheckbox.setSelection(fJarPackage.areOutputFoldersExported());
		fExportJavaFilesCheckbox.setSelection(fJarPackage.areJavaFilesExported());

		super.restoreWidgetValues();
		if (fJarPackage.getJarLocation().isEmpty())
			fDestinationNamesCombo.setText(""); //$NON-NLS-1$
		else
			fDestinationNamesCombo.setText(fJarPackage.getJarLocation().toOSString());
		IDialogSettings settings= getDialogSettings();
		if (settings != null) {
			String[] directoryNames= settings.getArray(STORE_DESTINATION_NAMES);
			if (directoryNames == null)
				return; // ie.- no settings stored
			if (! fDestinationNamesCombo.getText().equals(directoryNames[0]))
				fDestinationNamesCombo.add(fDestinationNamesCombo.getText());
			for (int i= 0; i < directoryNames.length; i++)
				fDestinationNamesCombo.add(directoryNames[i]);
		}
		
		// options
		if (fExportRefactoringsCheckbox != null)

	 *	Initializes the JAR package from last used wizard page values.
	 */
	protected void initializeJarPackage() {
		super.initializeJarPackage();
		
		IDialogSettings settings= getDialogSettings();
		if (settings != null) {
			// source

			fJarPackage.setCompress(settings.getBoolean(STORE_COMPRESS));
			fJarPackage.setIncludeDirectoryEntries(settings.getBoolean(STORE_INCLUDE_DIRECTORY_ENTRIES));
			fJarPackage.setOverwrite(settings.getBoolean(STORE_OVERWRITE));
						
			// destination
			String[] directoryNames= settings.getArray(STORE_DESTINATION_NAMES);
			if (directoryNames == null)
				return; // ie.- no settings stored
			fJarPackage.setJarLocation(Path.fromOSString(directoryNames[0]));
		}
	}


		fJarPackage.setExportJavaFiles(fExportJavaFilesCheckbox.getSelection());
		fJarPackage.setElements(getSelectedElements());

		super.updateModel();
		String comboText= fDestinationNamesCombo.getText();
		IPath path= Path.fromOSString(comboText);

		if (path.segmentCount() > 0 && ensureTargetFileIsValid(path.toFile()) && path.getFileExtension() == null) 
			// append .jar
			path= path.addFileExtension(JarPackagerUtil.JAR_EXTENSION);

		fJarPackage.setJarLocation(path);

		// options
		if (fExportRefactoringsCheckbox != null)
			fJarPackage.setRefactoringAware(fExportRefactoringsCheckbox.getSelection());

	}

	/**
	 * Returns a boolean indicating whether the passed File handle is
	 * is valid and available for use.
	 *
	 * @return boolean
	 */
	protected boolean ensureTargetFileIsValid(File targetFile) {
		if (targetFile.exists() && targetFile.isDirectory() && fDestinationNamesCombo.getText().length() > 0) {
			setErrorMessage(JarPackagerMessages.JarPackageWizardPage_error_exportDestinationMustNotBeDirectory); 
			fDestinationNamesCombo.setFocus();
			return false;
		}
		if (targetFile.exists()) {
			if (!targetFile.canWrite()) {
				setErrorMessage(JarPackagerMessages.JarPackageWizardPage_error_jarFileExistsAndNotWritable); 
				fDestinationNamesCombo.setFocus();
				return false;
			}
		}
		return true;
	}

	/*
	 * Overrides method from WizardExportPage
	 */
	protected void createDestinationGroup(Composite parent) {
		
		initializeDialogUnits(parent);
		
		// destination specification group
		Composite destinationSelectionGroup= new Composite(parent, SWT.NONE);
		GridLayout layout= new GridLayout();
		layout.numColumns= 3;
		destinationSelectionGroup.setLayout(layout);
		destinationSelectionGroup.setLayoutData(new GridData(GridData.HORIZONTAL_ALIGN_FILL | GridData.VERTICAL_ALIGN_FILL));

		new Label(destinationSelectionGroup, SWT.NONE).setText(getDestinationLabel());

		// destination name entry field
		fDestinationNamesCombo= new Combo(destinationSelectionGroup, SWT.SINGLE | SWT.BORDER);
		fDestinationNamesCombo.addListener(SWT.Modify, this);
		fDestinationNamesCombo.addListener(SWT.Selection, this);
		GridData data= new GridData(GridData.HORIZONTAL_ALIGN_FILL | GridData.GRAB_HORIZONTAL);
		data.widthHint= SIZING_TEXT_FIELD_WIDTH;
		fDestinationNamesCombo.setLayoutData(data);

		// destination browse button
		fDestinationBrowseButton= new Button(destinationSelectionGroup, SWT.PUSH);
		fDestinationBrowseButton.setText(JarPackagerMessages.JarPackageWizardPage_browseButton_text); 
		fDestinationBrowseButton.setLayoutData(new GridData(GridData.HORIZONTAL_ALIGN_FILL));
		SWTUtil.setButtonDimensionHint(fDestinationBrowseButton);
		fDestinationBrowseButton.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {
				handleDestinationBrowseButtonPressed();
			}
		});
	}

	/**
	 *	Open an appropriate destination browser so that the user can specify a source
	 *	to import from
	 */
	protected void handleDestinationBrowseButtonPressed() {
		FileDialog dialog= new FileDialog(getContainer().getShell(), SWT.SAVE);
		dialog.setFilterExtensions(new String[] {"*.jar", "*.zip"}); //$NON-NLS-1$ //$NON-NLS-2$

		String currentSourceString= getDestinationValue();
		int lastSeparatorIndex= currentSourceString.lastIndexOf(File.separator);
		if (lastSeparatorIndex != -1) {
			dialog.setFilterPath(currentSourceString.substring(0, lastSeparatorIndex));
			dialog.setFileName(currentSourceString.substring(lastSeparatorIndex + 1, currentSourceString.length()));
		}
		else
			dialog.setFileName(currentSourceString);
		String selectedFileName= dialog.open();
		if (selectedFileName != null)
			fDestinationNamesCombo.setText(selectedFileName);
	}

	/**
	 * Returns the resource for the specified path.
	 *
	 * @param path	the path for which the resource should be returned

			setErrorMessage(null);
		return complete;
	}

	/*
	 * Implements method from Listener
	 */	
	public void handleEvent(Event e) {
		if (getControl() == null)
			return;
		update();
	}
	
	protected void update() {
		updateModel();
		updateWidgetEnablements();
		updatePageCompletion();
	}
	
	protected void updatePageCompletion() {
		boolean pageComplete= isPageComplete();

	/*
	 * Overrides method from WizardDataTransferPage
	 */
	protected boolean validateDestinationGroup() {
		if (fDestinationNamesCombo.getText().length() == 0) {
			// Clear error 
			if (getErrorMessage() != null)
				setErrorMessage(null);
			if (getMessage() != null)
				setMessage(null);
			return false;
		}
		if (fJarPackage.getAbsoluteJarLocation().toString().endsWith("/")) { //$NON-NLS-1$
			setErrorMessage(JarPackagerMessages.JarPackageWizardPage_error_exportDestinationMustNotBeDirectory); 
			fDestinationNamesCombo.setFocus();
			return false;
		}
		// Check if the Jar is put into the workspace and conflicts with the containers
		// exported. If the workspace isn't on the local files system we are fine since
		// the Jar is always created in the local file system
		IPath workspaceLocation= ResourcesPlugin.getWorkspace().getRoot().getLocation();
		if (workspaceLocation != null && workspaceLocation.isPrefixOf(fJarPackage.getAbsoluteJarLocation())) {
			int segments= workspaceLocation.matchingFirstSegments(fJarPackage.getAbsoluteJarLocation());
			IPath path= fJarPackage.getAbsoluteJarLocation().removeFirstSegments(segments);
			IResource resource= ResourcesPlugin.getWorkspace().getRoot().findMember(path);
			if (resource != null && resource.getType() == IResource.FILE) {
				// test if included
				if (JarPackagerUtil.contains(JarPackagerUtil.asResources(fJarPackage.getElements()), (IFile)resource)) {
					setErrorMessage(JarPackagerMessages.JarPackageWizardPage_error_cantExportJARIntoItself); 
					return false;
				}
			}
		}
		// Inform user about relative directory
		String currentMessage= getMessage();
		if (!(new File(fDestinationNamesCombo.getText()).isAbsolute())) {
			if (currentMessage == null)
				setMessage(JarPackagerMessages.JarPackageWizardPage_info_relativeExportDestination, IMessageProvider.INFORMATION); 
		} else {
			if (currentMessage != null)
				setMessage(null);
		}
		return ensureTargetFileIsValid(fJarPackage.getAbsoluteJarLocation().toFile());
	}

	/*
	 * Overrides method from WizardDataTransferPage
	 */
	protected boolean validateOptionsGroup() {
		return true;
	}

			return null;
	}

	/**
	 * Set the current input focus to self's destination entry field
 	 */
	protected void giveFocusToDestination() {
		fDestinationNamesCombo.setFocus();
	}

	/* 
	 * Overrides method from WizardExportResourcePage
	 */

	}

	/* 
	 * Implements method from IJarPackageWizardPage.
	 */
	public void finish() {
		saveWidgetValues();
	}

	/* 
	 * Method declared on IWizardPage.
	 */
	public void setPreviousPage(IWizardPage page) {




/*******************************************************************************
 * Copyright (c) 2000, 2007 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

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.net.URI;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.jar.JarEntry;
import java.util.zip.CRC32;
import java.util.zip.ZipException;
import java.util.zip.ZipFile;

import org.eclipse.core.filesystem.EFS;
import org.eclipse.core.filesystem.IFileStore;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;

import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.ResourcesPlugin;

import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;

	 * Computes and returns the elements as resources.
	 * The underlying resource is used for Java elements.
	 * 
	 * @param elements elements for which to retrieve the resources from
	 * @return a List with the selected resources
	 */
	public static List asResources(Object[] elements) {
		if (elements == null)
			return null;
		List selectedResources= new ArrayList(elements.length);
		for (int i= 0; i < elements.length; i++) {
			Object element= elements[i];
			if (element instanceof IJavaElement) {
				selectedResources.add(((IJavaElement)element).getResource());
			}

	/**
	 * Gets the name of the manifest's main class
	 * 
	 * @param jarPackage 
	 * @return a string with the name
	 */
	static String getMainClassName(JarPackageData jarPackage) {

	}

	/**
	 * Tells whether the specified manifest main class is valid.\
	 * 
	 * @param data 
	 * @param context 
	 * @return <code>true</code> if a main class is specified and valid
	 */
	public static boolean isMainClassValid(JarPackageData data, IRunnableContext context) {

		entry.setSize(size);
		entry.setCrc(crc.getValue());
	}
	
	/**
	 * The archive file at the given location
	 * 
	 * @param location
	 *        the location of the archive file
	 * @return the archive or null if it could not be retrieved
	 * @throws CoreException
	 *         if the archive could not be read
	 * 
	 * @since 3.4
	 */
	public static ZipFile getArchiveFile(IPath location) throws CoreException {
		File localFile= null;

		IResource file= ResourcesPlugin.getWorkspace().getRoot().findMember(location);
		if (file != null) {
			// internal resource
			URI fileLocation= file.getLocationURI();

			IFileStore fileStore= EFS.getStore(fileLocation);
			localFile= fileStore.toLocalFile(EFS.NONE, null);
			if (localFile == null)
				// non local file system
				localFile= fileStore.toLocalFile(EFS.CACHE, null);
		} else {
			// external resource -> it is ok to use toFile()
			localFile= location.toFile();
		}

		if (localFile == null)
			return null;

		try {
			return new ZipFile(localFile);
		} catch (ZipException e) {
			throw new CoreException(new Status(IStatus.ERROR, JavaUI.ID_PLUGIN, e.getLocalizedMessage(), e));
		} catch (IOException e) {
			throw new CoreException(new Status(IStatus.ERROR, JavaUI.ID_PLUGIN, e.getLocalizedMessage(), e));
		}
	}
}

Lines 248-253 Link Here

(-)ui/org/eclipse/jdt/internal/ui/jarpackager/JarPackagerMessages.java (+2 lines)
248		248
249	public static String JarPackageReader_error_tagPathNotFound;	249	public static String JarPackageReader_error_tagPathNotFound;
250		250
		251	public static String JarPackageReader_error_unknownJarBuilder;
		252
251	public static String JarPackageReader_jarPackageReaderWarnings;	253	public static String JarPackageReader_jarPackageReaderWarnings;
252		254
253	public static String JarPackageReader_warning_javaElementDoesNotExist;	255	public static String JarPackageReader_warning_javaElementDoesNotExist;




import java.util.Set;
import java.util.jar.Manifest;
import java.util.zip.ZipException;
import java.util.zip.ZipFile;

import org.eclipse.core.filesystem.EFS;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.jdt.ui.jarpackager.IJarDescriptionWriter;
import org.eclipse.jdt.ui.jarpackager.IJarExportRunnable;
import org.eclipse.jdt.ui.jarpackager.JarPackageData;
import org.eclipse.jdt.ui.jarpackager.JarWriter3;

import org.eclipse.jdt.internal.ui.IJavaStatusConstants;
import org.eclipse.jdt.internal.ui.JavaPlugin;

		}
	}

	private JarBuilder fJarBuilder;
	private JarPackageData fJarPackage;
	private JarPackageData[] fJarPackages;
	private Shell fParentShell;

					continue;
				}
				
				if (resource == null) {
					if (element instanceof IPackageFragmentRoot) {
						IPackageFragmentRoot root= (IPackageFragmentRoot) element;
						if (root.isArchive()) {
							try {
								ZipFile file= JarPackagerUtil.getArchiveFile(root.getPath());
								if (file != null)
									count+= file.size();
							} catch (CoreException e) {
								JavaPlugin.log(e);
							}
						}
					}
					continue;
				}
			}
			else
				resource= (IResource)element;

	}

	private void exportJavaElement(IProgressMonitor progressMonitor, IJavaElement je) throws InterruptedException {
		if (je.getElementType() == IJavaElement.PACKAGE_FRAGMENT_ROOT && ((IPackageFragmentRoot)je).isArchive()) {
			fJarBuilder.addJar((IPackageFragmentRoot) je, progressMonitor);
			return;
		}

		Object[] children= fJavaElementContentProvider.getChildren(je);
		for (int i= 0; i < children.length; i++)

			try {
				IPath destinationPath= resource.getFullPath().removeFirstSegments(leadingSegmentsToRemove);
				progressMonitor.subTask(Messages.format(JarPackagerMessages.JarFileExportOperation_exporting, destinationPath.toString())); 
				fJarBuilder.addFile((IFile)resource, destinationPath);
			} catch (CoreException ex) {
				Throwable realEx= ex.getStatus().getException();
				if (realEx instanceof ZipException && realEx.getMessage() != null && realEx.getMessage().startsWith("duplicate entry:")) //$NON-NLS-1$

			|| (fJarPackage.areJavaFilesExported() && (isNonJavaResource || (pkgRoot != null && !isClassFile(resource)) || (isInClassFolder && isClassFile(resource) && !fJarPackage.areClassFilesExported())))) {
			try {
				progressMonitor.subTask(Messages.format(JarPackagerMessages.JarFileExportOperation_exporting, destinationPath.toString())); 
				fJarBuilder.addFile((IFile)resource, destinationPath);
			} catch (CoreException ex) {
				Throwable realEx= ex.getStatus().getException();
				if (realEx instanceof ZipException && realEx.getMessage() != null && realEx.getMessage().startsWith("duplicate entry:")) //$NON-NLS-1$

					IFile file= (IFile)iter.next();
					IPath classFilePath= baseDestinationPath.append(file.getName());
					progressMonitor.subTask(Messages.format(JarPackagerMessages.JarFileExportOperation_exporting, classFilePath.toString())); 
					fJarBuilder.addFile(file, classFilePath);
				}
			} catch (CoreException ex) {
				addToStatus(ex);

				buildProjects(subProgressMonitor);
			} else
				progressMonitor.beginTask("", totalWork); //$NON-NLS-1$
			
			fJarBuilder = fJarPackage.getJarBuilder();
			fJarPackage.setManifestProvider(fJarBuilder.getManifestProvider());
			fJarBuilder.open(fJarPackage, fParentShell, fStatus);
			
			exportSelectedElements(progressMonitor);
			if (getStatus().getSeverity() != IStatus.ERROR) {
				progressMonitor.subTask(JarPackagerMessages.JarFileExportOperation_savingFiles); 

			addToStatus(ex);
		} finally {
			try {
				if (fJarBuilder != null)
					fJarBuilder.close();
			} catch (CoreException ex) {
				addToStatus(ex);
			}

Lines 118-123 Link Here

(-)ui/org/eclipse/jdt/internal/ui/jarpackager/JarPackagerMessages.properties (+1 lines)
118	JarPackageReader_error_illegalValueForBooleanAttribute= Invalid format. The value for a boolean attribute is invalid.	118	JarPackageReader_error_illegalValueForBooleanAttribute= Invalid format. The value for a boolean attribute is invalid.
119	JarPackageReader_error_tagNameNotFound= Invalid format. The tag 'name' cannot be found.	119	JarPackageReader_error_tagNameNotFound= Invalid format. The tag 'name' cannot be found.
120	JarPackageReader_error_tagPathNotFound= Invalid format. The tag 'path' cannot be found.	120	JarPackageReader_error_tagPathNotFound= Invalid format. The tag 'path' cannot be found.
		121	JarPackageReader_error_unknownJarBuilder=Jar builder ''{0}'' is unkown
121	JarPackageReader_error_tagHandleIdentifierNotFoundOrEmpty= Invalid format: The tag 'handleIdentifier' cannot be found or is empty.	122	JarPackageReader_error_tagHandleIdentifierNotFoundOrEmpty= Invalid format: The tag 'handleIdentifier' cannot be found or is empty.
122	JarPackageReader_warning_javaElementDoesNotExist= Warning: Java element does not exist in workspace	123	JarPackageReader_warning_javaElementDoesNotExist= Warning: Java element does not exist in workspace
123	JarPackageReader_error_duplicateTag= Invalid format. {0} is a duplicate tag.	124	JarPackageReader_error_duplicateTag= Invalid format. {0} is a duplicate tag.

Lines 1-5 Link Here

(-)ui/org/eclipse/jdt/internal/ui/jarpackager/JarPackageReader.java (-13 / +32 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2006 IBM Corporation and others.	2	* Copyright (c) 2000, 2007 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 23-33 Link Here
23	import javax.xml.parsers.DocumentBuilderFactory;	23	import javax.xml.parsers.DocumentBuilderFactory;
24	import javax.xml.parsers.ParserConfigurationException;	24	import javax.xml.parsers.ParserConfigurationException;
25		25
26	import org.eclipse.core.resources.IFile;
27	import org.eclipse.core.resources.IFolder;
28	import org.eclipse.core.resources.IProject;
29	import org.eclipse.core.resources.ResourcesPlugin;
30
31	import org.eclipse.core.runtime.Assert;	26	import org.eclipse.core.runtime.Assert;
32	import org.eclipse.core.runtime.CoreException;	27	import org.eclipse.core.runtime.CoreException;
33	import org.eclipse.core.runtime.IPath;	28	import org.eclipse.core.runtime.IPath;
Lines 36-41 Link Here
36	import org.eclipse.core.runtime.Path;	31	import org.eclipse.core.runtime.Path;
37	import org.eclipse.core.runtime.Status;	32	import org.eclipse.core.runtime.Status;
38		33
		34	import org.eclipse.core.resources.IFile;
		35	import org.eclipse.core.resources.IFolder;
		36	import org.eclipse.core.resources.IProject;
		37	import org.eclipse.core.resources.ResourcesPlugin;
39		38
40	import org.eclipse.ltk.core.refactoring.RefactoringCore;	39	import org.eclipse.ltk.core.refactoring.RefactoringCore;
41	import org.eclipse.ltk.core.refactoring.RefactoringDescriptor;	40	import org.eclipse.ltk.core.refactoring.RefactoringDescriptor;
Lines 43-54 Link Here
43	import org.eclipse.ltk.core.refactoring.history.IRefactoringHistoryService;	42	import org.eclipse.ltk.core.refactoring.history.IRefactoringHistoryService;
44	import org.eclipse.ltk.core.refactoring.history.RefactoringHistory;	43	import org.eclipse.ltk.core.refactoring.history.RefactoringHistory;
45		44
46	import org.w3c.dom.Element;
47	import org.w3c.dom.Node;
48	import org.w3c.dom.NodeList;
49	import org.xml.sax.InputSource;
50	import org.xml.sax.SAXException;
51
52	import org.eclipse.jdt.core.IJavaElement;	45	import org.eclipse.jdt.core.IJavaElement;
53	import org.eclipse.jdt.core.IPackageFragment;	46	import org.eclipse.jdt.core.IPackageFragment;
54	import org.eclipse.jdt.core.IType;	47	import org.eclipse.jdt.core.IType;
Lines 59-66 Link Here
59	import org.eclipse.jdt.ui.jarpackager.IJarDescriptionReader;	52	import org.eclipse.jdt.ui.jarpackager.IJarDescriptionReader;
60	import org.eclipse.jdt.ui.jarpackager.JarPackageData;	53	import org.eclipse.jdt.ui.jarpackager.JarPackageData;
61		54
62	import org.eclipse.jdt.internal.ui.JavaPlugin;
63	import org.eclipse.jdt.internal.ui.IJavaStatusConstants;	55	import org.eclipse.jdt.internal.ui.IJavaStatusConstants;
		56	import org.eclipse.jdt.internal.ui.JavaPlugin;
		57	import org.eclipse.jdt.internal.ui.jarpackagerfat.FatJarBuilder;
		58
		59	import org.w3c.dom.Element;
		60	import org.w3c.dom.Node;
		61	import org.w3c.dom.NodeList;
		62	import org.xml.sax.InputSource;
		63	import org.xml.sax.SAXException;
64		64
65	/**	65	/**
66	* Reads data from an InputStream and returns a JarPackage	66	* Reads data from an InputStream and returns a JarPackage
Lines 74-79 Link Here
74	/**	74	/**
75	* Reads a Jar Package from the underlying stream.	75	* Reads a Jar Package from the underlying stream.
76	* It is the client's responsibility to close the stream.	76	* It is the client's responsibility to close the stream.
		77	* @param inputStream
77	*/	78	*/
78	public JarPackageReader(InputStream inputStream) {	79	public JarPackageReader(InputStream inputStream) {
79	Assert.isNotNull(inputStream);	80	Assert.isNotNull(inputStream);
Lines 139-144 Link Here
139	if (jarPackage.areGeneratedFilesExported())	140	if (jarPackage.areGeneratedFilesExported())
140	xmlReadManifest(jarPackage, element);	141	xmlReadManifest(jarPackage, element);
141	xmlReadSelectedElements(jarPackage, element);	142	xmlReadSelectedElements(jarPackage, element);
		143
		144	// fatjar read builder props
		145	xmlReadFatjar(jarPackage, element);
142	}	146	}
143	return jarPackage;	147	return jarPackage;
144	}	148	}
Lines 403-406 Link Here
403	protected void addWarning(String message, Throwable error) {	407	protected void addWarning(String message, Throwable error) {
404	fWarnings.add(new Status(IStatus.WARNING, JavaPlugin.getPluginId(), 0, message, error));	408	fWarnings.add(new Status(IStatus.WARNING, JavaPlugin.getPluginId(), 0, message, error));
405	}	409	}
		410
		411	private void xmlReadFatjar(JarPackageData jarPackage, Element element) throws java.io.IOException {
		412	if (element.getNodeName().equals("fatjar")) { //$NON-NLS-1$
		413	String id = element.getAttribute("builder"); //$NON-NLS-1$
		414	if (FatJarBuilder.BUILDER_ID.equals(id)) {
		415	jarPackage.setJarBuilder(new FatJarBuilder());
		416	} else if (PlainJarBuilder.BUILDER_ID.equals(id)) {
		417	//the default anyway
		418	} else {
		419	throw new IOException(Messages.format(JarPackagerMessages.JarPackageReader_error_unknownJarBuilder, id));
		420	}
		421	jarPackage.setLaunchConfigurationName(element.getAttribute("launchConfig")); //$NON-NLS-1$
		422	}
		423	}
		424
406	}	425	}

Lines 1-5 Link Here

(-)ui/org/eclipse/jdt/internal/ui/jarpackager/JarPackageWriter.java (-2 / +14 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2006 IBM Corporation and others.	2	* Copyright (c) 2000, 2007 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 34-40 Link Here
34	import org.eclipse.core.resources.IProject;	34	import org.eclipse.core.resources.IProject;
35	import org.eclipse.core.resources.IResource;	35	import org.eclipse.core.resources.IResource;
36		36
37
38	import org.eclipse.ltk.core.refactoring.RefactoringCore;	37	import org.eclipse.ltk.core.refactoring.RefactoringCore;
39	import org.eclipse.ltk.core.refactoring.RefactoringDescriptor;	38	import org.eclipse.ltk.core.refactoring.RefactoringDescriptor;
40	import org.eclipse.ltk.core.refactoring.RefactoringDescriptorProxy;	39	import org.eclipse.ltk.core.refactoring.RefactoringDescriptorProxy;
Lines 64-69 Link Here
64	/**	63	/**
65	* Create a JarPackageWriter on the given output stream.	64	* Create a JarPackageWriter on the given output stream.
66	* It is the clients responsibility to close the output stream.	65	* It is the clients responsibility to close the output stream.
		66	*
		67	* @param outputStream
		68	* @param encoding
67	*/	69	*/
68	public JarPackageWriter(OutputStream outputStream, String encoding) {	70	public JarPackageWriter(OutputStream outputStream, String encoding) {
69	Assert.isNotNull(outputStream);	71	Assert.isNotNull(outputStream);
Lines 84-89 Link Here
84	* Writes a XML representation of the JAR specification	86	* Writes a XML representation of the JAR specification
85	* to to the underlying stream.	87	* to to the underlying stream.
86	*	88	*
		89	* @param jarPackage
87	* @exception IOException if writing to the underlying stream fails	90	* @exception IOException if writing to the underlying stream fails
88	*/	91	*/
89	public void writeXML(JarPackageData jarPackage) throws IOException {	92	public void writeXML(JarPackageData jarPackage) throws IOException {
Lines 109-114 Link Here
109	xmlWriteManifest(jarPackage, document, xmlJarDesc);	112	xmlWriteManifest(jarPackage, document, xmlJarDesc);
110	xmlWriteSelectedElements(jarPackage, document, xmlJarDesc);	113	xmlWriteSelectedElements(jarPackage, document, xmlJarDesc);
111		114
		115	xmlWriteFatjar(jarPackage, document, xmlJarDesc);
		116
112	try {	117	try {
113	// Write the document to the stream	118	// Write the document to the stream
114	Transformer transformer=TransformerFactory.newInstance().newTransformer();	119	Transformer transformer=TransformerFactory.newInstance().newTransformer();
Lines 285-288 Link Here
285	public IStatus getStatus() {	290	public IStatus getStatus() {
286	return new Status(IStatus.OK, JavaPlugin.getPluginId(), 0, "", null); //$NON-NLS-1$	291	return new Status(IStatus.OK, JavaPlugin.getPluginId(), 0, "", null); //$NON-NLS-1$
287	}	292	}
		293
		294	private void xmlWriteFatjar(JarPackageData jarPackage, Document document, Element xmlJarDesc) throws DOMException {
		295	Element fatjar= document.createElement("fatjar"); //$NON-NLS-1$
		296	xmlJarDesc.appendChild(fatjar);
		297	fatjar.setAttribute("builder", jarPackage.getJarBuilder().getId()); //$NON-NLS-1$
		298	fatjar.setAttribute("launchConfig", jarPackage.getLaunchConfigurationName()); //$NON-NLS-1$
		299	}
288	}	300	}

Lines 394-399 Link Here

(-)ui/org/eclipse/jdt/internal/ui/JavaPluginImages.java (+1 lines)
394	public static final ImageDescriptor DESC_WIZBAN_REFACTOR_PULL_UP= createUnManaged(T_WIZBAN, "pullup_wiz.png"); //$NON-NLS-1$	394	public static final ImageDescriptor DESC_WIZBAN_REFACTOR_PULL_UP= createUnManaged(T_WIZBAN, "pullup_wiz.png"); //$NON-NLS-1$
395	public static final ImageDescriptor DESC_WIZBAN_REFACTOR_FIX_DEPRECATION= createUnManaged(T_WIZBAN, "fixdepr_wiz.png"); //$NON-NLS-1$	395	public static final ImageDescriptor DESC_WIZBAN_REFACTOR_FIX_DEPRECATION= createUnManaged(T_WIZBAN, "fixdepr_wiz.png"); //$NON-NLS-1$
396	public static final ImageDescriptor DESC_WIZBAN_JAR_PACKAGER= createUnManaged(T_WIZBAN, "jar_pack_wiz.png"); //$NON-NLS-1$	396	public static final ImageDescriptor DESC_WIZBAN_JAR_PACKAGER= createUnManaged(T_WIZBAN, "jar_pack_wiz.png"); //$NON-NLS-1$
		397	public static final ImageDescriptor DESC_WIZBAN_FAT_JAR_PACKAGER= createUnManaged(T_WIZBAN, "fatjar_pack_wiz.png"); //$NON-NLS-1$
397	public static final ImageDescriptor DESC_WIZBAN_REFACTOR_EXTRACT_SUPERTYPE= createUnManaged(T_WIZBAN, "extractsupertype_wiz.png"); //$NON-NLS-1$	398	public static final ImageDescriptor DESC_WIZBAN_REFACTOR_EXTRACT_SUPERTYPE= createUnManaged(T_WIZBAN, "extractsupertype_wiz.png"); //$NON-NLS-1$
398	public static final ImageDescriptor DESC_WIZBAN_REPLACE_JAR= createUnManaged(T_WIZBAN, "replacejar_wiz.png"); //$NON-NLS-1$	399	public static final ImageDescriptor DESC_WIZBAN_REPLACE_JAR= createUnManaged(T_WIZBAN, "replacejar_wiz.png"); //$NON-NLS-1$
399	public static final ImageDescriptor DESC_WIZBAN_JAVA_WORKINGSET= createUnManaged(T_WIZBAN, "java_workingset_wiz.png");//$NON-NLS-1$	400	public static final ImageDescriptor DESC_WIZBAN_JAVA_WORKINGSET= createUnManaged(T_WIZBAN, "java_workingset_wiz.png");//$NON-NLS-1$





import org.eclipse.swt.widgets.Shell;


import org.eclipse.ltk.core.refactoring.RefactoringCore;
import org.eclipse.ltk.core.refactoring.RefactoringDescriptor;
import org.eclipse.ltk.core.refactoring.RefactoringDescriptorProxy;

	 * 
	 * @throws IOException
	 *             if an I/O error has occurred
	 * @throws CoreException 
	 */
	protected void addDirectories(IResource resource, IPath destinationPath) throws IOException, CoreException {
		IContainer parent= null;

			// fJarOutputStream.closeEntry();
		}
	}
	
	/**
	 * Creates a new JarEntry with the passed path and contents, and writes it
	 * to the current archive.
	 *
	 * @param	contentStream		the content to write
	 * @param	path				the path inside the archive
	 * 
     * @throws	IOException			if an I/O error has occurred
	 * @throws	CoreException 		if the resource can-t be accessed
	 * 
	 * @since 3.4
	 */
	public void addStream(InputStream contentStream, String path) throws IOException, CoreException {
		JarEntry newEntry= new JarEntry(path.replace(File.separatorChar, '/'));
		byte[] readBuffer= new byte[4096];             
		
		if (fJarPackage.isCompressed())
			newEntry.setMethod(ZipEntry.DEFLATED);
			// Entry is filled automatically.
		else {
			newEntry.setMethod(ZipEntry.STORED);
			// JarPackagerUtil.calculateCrcAndSize(newEntry, resource.getContents(false), readBuffer);
		}
		
		long lastModified= System.currentTimeMillis();
		
		// Set modification time
		newEntry.setTime(lastModified);
		
		try {		
			fJarOutputStream.putNextEntry(newEntry);
			int count;
			while ((count= contentStream.read(readBuffer, 0, readBuffer.length)) != -1)
				fJarOutputStream.write(readBuffer, 0, count);
		} finally  {
			/*
			 * Commented out because some JREs throw an NPE if a stream
			 * is closed twice. This works because
			 * a) putNextEntry closes the previous entry
			 * b) closing the stream closes the last entry
			 */
			// fJarOutputStream.closeEntry();
		}
	}

	/**
	 * Creates a new JAR file entry containing the refactoring history.

	 *             if the meta file could not be found
	 * @throws IOException
	 *             if an input/output error occurs
	 * @throws CoreException 
	 */
	private void writeMetaData(final JarPackageData data, final File file, final IPath path) throws FileNotFoundException, IOException, CoreException {
		Assert.isNotNull(data);




/*******************************************************************************
 * Copyright (c) 2000, 2007 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

import java.io.InputStream;
import java.io.OutputStream;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.ResourcesPlugin;

import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.ResourcesPlugin;

import org.eclipse.swt.widgets.Shell;

import org.eclipse.jface.operation.IRunnableContext;

import org.eclipse.jdt.core.IPackageFragment;
import org.eclipse.jdt.core.IType;


import org.eclipse.jdt.internal.ui.JavaPlugin;
import org.eclipse.jdt.internal.ui.jarpackager.JarBuilder;
import org.eclipse.jdt.internal.ui.jarpackager.JarFileExportOperation;
import org.eclipse.jdt.internal.ui.jarpackager.JarPackageReader;
import org.eclipse.jdt.internal.ui.jarpackager.JarPackageWriter;
import org.eclipse.jdt.internal.ui.jarpackager.JarPackagerUtil;
import org.eclipse.jdt.internal.ui.jarpackager.ManifestProvider;
import org.eclipse.jdt.internal.ui.jarpackager.PlainJarBuilder;
import org.eclipse.jdt.internal.ui.util.BusyIndicatorRunnableContext;

/**

	// The refactoring descriptors to export
	private RefactoringDescriptorProxy[] fRefactoringDescriptors= {};

	// Builder used by the JarFileExportOperation to build the jar file
	private JarBuilder fJarBuilder;
	
	// The launch configuration used by the fat jar builder to determine dependencies
 	private String  fLaunchConfigurationName;

	/**
	 * Creates a new Jar Package Data structure
	 */
	public JarPackageData() {
		setJarBuilder(new PlainJarBuilder());
		setExportClassFiles(true);
		setExportOutputFolders(false);
		setUseSourceFolderHierarchy(false);

	public void setExportStructuralOnly(boolean structural) {
		fRefactoringStructural= structural;
	}
	
	/**
	 * Returns the jar builder to use to build the jar described by this package data.
	 * 
	 * @return the builder to use
	 * @since 3.4
	 */
	public JarBuilder getJarBuilder() {
		return fJarBuilder;
	}

	/**
	 * Set the jar builder to use to build the jar.
	 * 
	 * @param jarBuilder
	 *        the builder to use
	 * @since 3.4
	 */
	public void setJarBuilder(JarBuilder jarBuilder) {
		fJarBuilder= jarBuilder;
	}

	/**
	 * Get the name of the launch configuration from which to create an executable jar.
	 * 
	 * @return the name of the launch configuration
	 * @since 3.4
	 */
	public String getLaunchConfigurationName() {
		return fLaunchConfigurationName;
	}

	/**
	 * Set the name of the launch configuration form which to create an executable jar.
	 * 
	 * @param name
	 *        name of the launch configuration
	 * @since 3.4
	 */
	public void setLaunchConfigurationName(String name) {
		fLaunchConfigurationName= name;
	}

}




 org.eclipse.jdt.internal.corext.refactoring.util;x-internal:=true,
 org.eclipse.jdt.internal.corext.template.java;x-internal:=true,
 org.eclipse.jdt.internal.corext.util;x-friends:="org.eclipse.jdt.junit",
 org.eclipse.jdt.internal.ui;x-friends:="org.eclipse.jdt.junit,org.eclipse.jdt.apt.ui",
 org.eclipse.jdt.internal.ui.actions;x-friends:="org.eclipse.jdt.junit",
 org.eclipse.jdt.internal.ui.browsing;x-internal:=true,
 org.eclipse.jdt.internal.ui.callhierarchy;x-internal:=true,

 org.eclipse.jdt.internal.ui.infoviews;x-internal:=true,
 org.eclipse.jdt.internal.ui.jarimport;x-internal:=true,
 org.eclipse.jdt.internal.ui.jarpackager;x-internal:=true,
 org.eclipse.jdt.internal.ui.jarpackagerfat;x-internal:=true,
 org.eclipse.jdt.internal.ui.javadocexport;x-internal:=true,
 org.eclipse.jdt.internal.ui.javaeditor;x-friends:="org.eclipse.jdt.junit",
 org.eclipse.jdt.internal.ui.javaeditor.saveparticipant;x-internal:=true,

 org.eclipse.jdt.internal.ui.text.template.contentassist;x-internal:=true,
 org.eclipse.jdt.internal.ui.text.template.preferences;x-internal:=true,
 org.eclipse.jdt.internal.ui.typehierarchy;x-internal:=true,
 org.eclipse.jdt.internal.ui.util;x-friends:="org.eclipse.jdt.junit,org.eclipse.jdt.apt.ui",
 org.eclipse.jdt.internal.ui.viewsupport;x-friends:="org.eclipse.jdt.junit",
 org.eclipse.jdt.internal.ui.wizards;x-friends:="org.eclipse.jdt.junit,org.eclipse.jdt.apt.ui",
 org.eclipse.jdt.internal.ui.wizards.buildpaths;x-internal:=true,
 org.eclipse.jdt.internal.ui.wizards.buildpaths.newsourcepage;x-internal:=true,
 org.eclipse.jdt.internal.ui.wizards.dialogfields;x-friends:="org.eclipse.jdt.apt.ui",




/*******************************************************************************
 * Copyright (c) 2007 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
 *******************************************************************************/
package org.eclipse.jdt.internal.ui.jarpackagerfat;

import java.io.IOException;
import java.io.StringReader;
import java.io.StringWriter;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;

/**
 * TODO: Remove, not used?
 * @since 3.4
 */
public class JarBuilderProperties {

	private JarBuilderProperty[] fProperties;

	public JarBuilderProperties(JarBuilderProperty[] properties) {
		fProperties= properties;
	}

	public JarBuilderProperty[] getProperties() {
		return fProperties;
	}

	public String xmlExport() throws IOException {

		String result;
		DocumentBuilder docBuilder= null;
		DocumentBuilderFactory factory= DocumentBuilderFactory.newInstance();
		factory.setValidating(false);
		try {
			docBuilder= factory.newDocumentBuilder();
		} catch (ParserConfigurationException ex) {
			throw new IOException(FatJarPackagerMessages.JarWriter_error_couldNotGetXmlBuilder);
		}
		Document document= docBuilder.newDocument();

		xmlExport(document, null);

		try {
			// Write the document to the stream
			Transformer transformer= TransformerFactory.newInstance().newTransformer();
			transformer.setOutputProperty(OutputKeys.METHOD, "xml"); //$NON-NLS-1$
			transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8"); //$NON-NLS-1$
			transformer.setOutputProperty(OutputKeys.INDENT, "yes"); //$NON-NLS-1$
			transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "yes"); //$NON-NLS-1$
			transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "4"); //$NON-NLS-1$ //$NON-NLS-2$
			DOMSource source= new DOMSource(document);
			StringWriter writer= new StringWriter();
			StreamResult strResult= new StreamResult(writer);
			transformer.transform(source, strResult);
			result= writer.toString();
		} catch (TransformerException e) {
			throw new IOException(FatJarPackagerMessages.JarWriter_error_couldNotTransformToXML);
		}

		return result.trim();
	}

	public void xmlExport(Document document, Element parent) {
		// Create the document
		Element xmlProps= document.createElement("props"); //$NON-NLS-1$
		if (parent == null) {
			document.appendChild(xmlProps);
		} else {
			parent.appendChild(xmlProps);
		}

		for (int i= 0; i < fProperties.length; i++) {
			JarBuilderProperty property= fProperties[i];
			xmlProps.setAttribute(property.getName(), property.getValue());
		}

	}

	public void xmlImport(String propertiesImportData) throws IOException {

		DocumentBuilderFactory factory= DocumentBuilderFactory.newInstance();
		factory.setValidating(false);
		DocumentBuilder parser= null;
		Element xmlProps= null;
		try {
			parser= factory.newDocumentBuilder();
			StringReader reader= new StringReader(propertiesImportData);
			xmlProps= parser.parse(new InputSource(reader)).getDocumentElement();
		} catch (ParserConfigurationException ex) {
			throw new IOException(ex.getLocalizedMessage());
		} catch (SAXException ex) {
			throw new IOException(ex.getLocalizedMessage());
		} finally {
		}
		xmlImport(xmlProps);
	}

	public void xmlImport(Element xmlProps) throws IOException {

		if (!xmlProps.getNodeName().equals("props")) { //$NON-NLS-1$
			throw new IOException("invalid XML format <props>"); //$NON-NLS-1$
		}
		NamedNodeMap map= xmlProps.getAttributes();
		for (int j= 0; j < map.getLength(); j++) {
			Node item= map.item(j);
			String name= item.getNodeName();
			String value= item.getNodeValue();
			setProperty(name, value);
		}
	}


	private boolean setProperty(String name, String value) {
		boolean result= false;
		for (int i= 0; i < fProperties.length; i++) {
			JarBuilderProperty property= fProperties[i];
			if (name.equals(property.getName())) {
				property.setValue(value);
				result= true;
				break;
			}
		}
		return result;
	}

	public String toString() {
		String result;
		try {
			result= xmlExport();
		} catch (IOException e) {
			result= "<error>" + e.getLocalizedMessage() + "</error>"; //$NON-NLS-1$ //$NON-NLS-2$
		}
		return result;
	}

	public JarBuilderProperty getProperty(String propertyName) {
		JarBuilderProperty result= null;
		JarBuilderProperty[] props= getProperties();
		for (int i= 0; i < props.length; i++) {
			if (propertyName.equals(props[i].getName())) {
				result= props[i];
				break;
			}
		}
		return result;
	}

}




/*******************************************************************************
 * Copyright (c) 2007 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
 *******************************************************************************/
package org.eclipse.jdt.internal.ui.jarpackagerfat;

import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Status;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.ResourcesPlugin;

import org.eclipse.swt.SWT;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Combo;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Listener;

import org.eclipse.jface.dialogs.Dialog;
import org.eclipse.jface.dialogs.IDialogSettings;
import org.eclipse.jface.operation.IRunnableContext;
import org.eclipse.jface.viewers.StructuredSelection;

import org.eclipse.debug.core.DebugPlugin;
import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.debug.core.ILaunchConfigurationType;
import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
import org.eclipse.debug.core.ILaunchManager;

import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IPackageFragmentRoot;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.search.IJavaSearchScope;

import org.eclipse.jdt.internal.corext.util.Messages;

import org.eclipse.jdt.launching.IJavaLaunchConfigurationConstants;
import org.eclipse.jdt.launching.IRuntimeClasspathEntry;
import org.eclipse.jdt.launching.JavaRuntime;

import org.eclipse.jdt.ui.JavaUI;
import org.eclipse.jdt.ui.jarpackager.JarPackageData;

import org.eclipse.jdt.internal.ui.JavaPlugin;
import org.eclipse.jdt.internal.ui.jarpackager.AbstractJarDestinationWizardPage;
import org.eclipse.jdt.internal.ui.jarpackager.JarPackagerUtil;
import org.eclipse.jdt.internal.ui.search.JavaSearchScopeFactory;
import org.eclipse.jdt.internal.ui.util.MainMethodSearchEngine;

/**
 * First page for the runnable jar export wizard
 * @since 3.4
 */
public class FatJarPackageWizardPage extends AbstractJarDestinationWizardPage implements Listener {

	private abstract static class LaunchConfigurationElement {

		public abstract ILaunchConfiguration getLaunchConfiguration();

		public abstract String getLaunchConfigurationName();

		public void dispose() {
			//do nothing
		}
	}

	private static class ExistingLaunchConfigurationElement extends LaunchConfigurationElement {

		private ILaunchConfiguration fLaunchConfiguration;
		private final String fProjectName;

		public ExistingLaunchConfigurationElement(ILaunchConfiguration launchConfiguration, String projectName) {
			fLaunchConfiguration= launchConfiguration;
			fProjectName= projectName;
		}

		/**
		 * {@inheritDoc}
		 */
		public ILaunchConfiguration getLaunchConfiguration() {
			return fLaunchConfiguration;
		}

		/**
		 * {@inheritDoc}
		 */
		public String getLaunchConfigurationName() {
			return fProjectName + " : " + fLaunchConfiguration.getName(); //$NON-NLS-1$
		}

	}

	private static class DefaultLaunchConfigurationElement extends LaunchConfigurationElement {
		
		private IJavaProject fJavaProject;
		private ILaunchConfiguration fLaunchConfiguration;

		public DefaultLaunchConfigurationElement(IJavaProject javaProject) {
			fJavaProject= javaProject;
		}

		/**
		 * {@inheritDoc}
		 */
		public ILaunchConfiguration getLaunchConfiguration() {
			if (fLaunchConfiguration == null)
				fLaunchConfiguration= createTempLaunchConfig(fJavaProject);

			return fLaunchConfiguration;
		}

		/**
		 * {@inheritDoc}
		 */
		public String getLaunchConfigurationName() {
			return Messages.format(FatJarPackagerMessages.FatJarPackageWizardPage_defaultLaunchConfigName, fJavaProject.getElementName());
		}

		/**
		 * {@inheritDoc}
		 */
		public void dispose() {
			if (fLaunchConfiguration != null) {
				try {
					fLaunchConfiguration.delete();
					fLaunchConfiguration= null;
				} catch (CoreException e) {
					JavaPlugin.log(e);
				}
			}
		}
	}

	private static final String PAGE_NAME= "FatJarPackageWizardPage"; //$NON-NLS-1$
	private static final String STORE_LAUNCH_CONFIGURATION_SELECTION_NAME= PAGE_NAME + ".LAUNCH_CONFIGURATION_SELECTION_NAME"; //$NON-NLS-1$
	private static final String STORE_DESTINATION_ELEMENT= PAGE_NAME + ".DESTINATION_PATH_SELECTION"; //$NON-NLS-1$

	private final JarPackageData fJarPackage;
	/**
	 * Model for the launch combo box. Element: {@link LaunchConfigurationElement}
	 */
	private final ArrayList fLauchConfigurationModel;
	
	private Combo fLaunchConfigurationCombo;

	public FatJarPackageWizardPage(JarPackageData jarPackage) {
		super(PAGE_NAME, StructuredSelection.EMPTY, jarPackage);
		setTitle(FatJarPackagerMessages.JarPackageWizardPage_title);
		setDescription(FatJarPackagerMessages.FatJarPackageWizardPage_description);
		fJarPackage= jarPackage;
		fLauchConfigurationModel= new ArrayList();
	}

	/**
	 * {@inheritDoc}
	 */
	public void createControl(Composite parent) {
		Composite composite= new Composite(parent, SWT.NONE);
		composite.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
		composite.setLayout(new GridLayout(1, false));
		
		Label description= new Label(composite, SWT.NONE);
		GridData gridData= new GridData(SWT.BEGINNING, SWT.CENTER, false, false);
		description.setLayoutData(gridData);
		description.setText(FatJarPackagerMessages.FatJarPackageWizardPage_launchConfigGroupTitle);
		
		createLaunchConfigSelectionGroup(composite);
		
		Label label= new Label(composite, SWT.NONE);
		label.setLayoutData(new GridData(SWT.BEGINNING, SWT.CENTER, false, false));
		label.setText(FatJarPackagerMessages.FatJarPackageWizardPage_destinationGroupTitle);
		
		createDestinationGroup(composite);
	
		restoreWidgetValues();
		
		update();

		Dialog.applyDialogFont(composite);
		setControl(composite);
	}

	protected String getDestinationLabel() {
		return null;
	}
	
	private void createLaunchConfigSelectionGroup(Composite parent) {
		Composite composite= new Composite(parent, SWT.NONE);
		composite.setLayoutData(new GridData(SWT.FILL, SWT.TOP, true, false));
		composite.setLayout(new GridLayout(1, false));

		fLaunchConfigurationCombo= new Combo(composite, SWT.DROP_DOWN | SWT.READ_ONLY);
		fLaunchConfigurationCombo.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false));

		fLauchConfigurationModel.addAll(Arrays.asList(getLaunchConfigurations()));
		String[] names= new String[fLauchConfigurationModel.size()];
		for (int i= 0, size= fLauchConfigurationModel.size(); i < size; i++) {
			LaunchConfigurationElement element= (LaunchConfigurationElement) fLauchConfigurationModel.get(i);
			names[i]= element.getLaunchConfigurationName();
		}
		fLaunchConfigurationCombo.setItems(names);

		fLaunchConfigurationCombo.addListener(SWT.Selection, this);
		fLaunchConfigurationCombo.addListener(SWT.Modify, this);
	}

	protected void updateWidgetEnablements() {
	}

	public boolean isPageComplete() {
		boolean complete= validateDestinationGroup();
		complete= validateLaunchConfigurationGroup() && complete;
		if (complete)
			setErrorMessage(null);
		return complete;
	}

	private boolean validateLaunchConfigurationGroup() {
		return fLaunchConfigurationCombo.getSelectionIndex() != -1;
	}

	private LaunchConfigurationElement[] getLaunchConfigurations() {
		ArrayList result= new ArrayList();

		HashSet projectNamesWithLaunchConfig= new HashSet();
		try {
			ILaunchConfiguration[] launchconfigs= DebugPlugin.getDefault().getLaunchManager().getLaunchConfigurations();

			for (int i= 0; i < launchconfigs.length; i++) {
				ILaunchConfiguration launchconfig= launchconfigs[i];

				String projectName= launchconfig.getAttribute(IJavaLaunchConfigurationConstants.ATTR_PROJECT_NAME, ""); //$NON-NLS-1$
				result.add(new ExistingLaunchConfigurationElement(launchconfig, projectName));
				projectNamesWithLaunchConfig.add(projectName);
			}
		} catch (CoreException e) {
			JavaPlugin.log(e);
		}

		IJavaProject[] javaProjects= getJavaProjects();
		for (int i= 0; i < javaProjects.length; i++) {
			if (!projectNamesWithLaunchConfig.contains(javaProjects[i].getElementName())) {
				result.add(new DefaultLaunchConfigurationElement(javaProjects[i]));
			}
		}

		return (LaunchConfigurationElement[]) result.toArray(new LaunchConfigurationElement[result.size()]);
	}

	private IJavaProject[] getJavaProjects() {
		ArrayList result= new ArrayList();

		IProject[] projects= ResourcesPlugin.getWorkspace().getRoot().getProjects();
		for (int i= 0; i < projects.length; i++) {
			IJavaProject javaProject= JavaCore.create(projects[i]);
			if (javaProject != null && javaProject.exists()) {
				result.add(javaProject);
			}
		}

		return (IJavaProject[]) result.toArray(new IJavaProject[result.size()]);
	}

	public Object[] getSelectedElementsWithoutContainedChildren() {
		try {
			LaunchConfigurationElement element= (LaunchConfigurationElement) fLauchConfigurationModel.get(fLaunchConfigurationCombo.getSelectionIndex());
			ILaunchConfiguration launchconfig= element.getLaunchConfiguration();
			fJarPackage.setLaunchConfigurationName(element.getLaunchConfigurationName());

			return getSelectedElementsWithoutContainedChildren(launchconfig, fJarPackage, getContainer());
		} catch (CoreException e) {
			JavaPlugin.log(e);
		}

		return null;
	}

	private static String[] getProjectSearchOrder(String projectName) {

		ArrayList result= new ArrayList();
		result.add(projectName);

		int nextProject= 0;
		while (nextProject < result.size()) {
			String nextProjectName= (String) result.get(nextProject);
			IJavaProject jproject= getJavaProject(nextProjectName);

			if (jproject != null) {
				try {
					String[] childProjectNames= jproject.getRequiredProjectNames();
					for (int i= 0; i < childProjectNames.length; i++) {
						if (!result.contains(childProjectNames[i])) {
							result.add(childProjectNames[i]);
						}
					}
				} catch (JavaModelException e) {
					JavaPlugin.log(e);
				}
			}
			nextProject+= 1;
		}

		return (String[]) result.toArray(new String[result.size()]);
	}

	private static IJavaProject getJavaProject(String projectName) {
		IJavaProject result= JavaCore.create(ResourcesPlugin.getWorkspace().getRoot().getProject(projectName));
		if (result == null)
			return null;

		if (!result.exists())
			return null;

		return result;
	}

	private static String[] getClasspath(ILaunchConfiguration configuration) throws CoreException {
		IRuntimeClasspathEntry[] entries= JavaRuntime.computeUnresolvedRuntimeClasspath(configuration);
		entries= JavaRuntime.resolveRuntimeClasspath(entries, configuration);
		List userEntries= new ArrayList(entries.length);
		for (int i= 0; i < entries.length; i++) {
			if (entries[i].getClasspathProperty() == IRuntimeClasspathEntry.USER_CLASSES) {
				String location= entries[i].getLocation();
				if (location != null) {
					userEntries.add(location);
				}
			}
		}
		return (String[]) userEntries.toArray(new String[userEntries.size()]);
	}

	private static String getMainClass(ILaunchConfiguration launchConfig) {
		String result= null;
		if (launchConfig != null) {
			try {
				result= launchConfig.getAttribute(IJavaLaunchConfigurationConstants.ATTR_MAIN_TYPE_NAME, (String) null);
			} catch (CoreException ignore) {
			}
		}
		if (result == null) {
			result= ""; //$NON-NLS-1$
		}
		return result;
	}

	private static IPackageFragmentRoot[] getRequiredPackageFragmentRoots(final String[] classpathEntries, final String[] projectNames) {
		ArrayList result= new ArrayList();

		for (int i= 0; i < classpathEntries.length; i++) {
			String path= classpathEntries[i];
			IPackageFragmentRoot[] elements= findRootsForClasspath(path, projectNames);
			if (elements.length == 0) {
				JavaPlugin.log(new Status(IStatus.WARNING, JavaUI.ID_PLUGIN, Messages.format(FatJarPackagerMessages.FatJarPackageWizardPage_error_missingClassFile, path)));
			}
			
			for (int j= 0; j < elements.length; j++) {
				result.add(elements[j]);
			}
		}
		
		return (IPackageFragmentRoot[]) result.toArray(new IPackageFragmentRoot[result.size()]);
	}

	private static IPackageFragmentRoot[] findRootsForClasspath(String path, String[] projectNames) {

		path= path.replace('\\', '/');
		for (int i= 0; i < projectNames.length; i++) {
			IJavaProject javaProject= getJavaProject(projectNames[i]);
			if (javaProject != null) {
				IPackageFragmentRoot[] elements= findRootsInProject(path, javaProject);
				if (elements.length > 0) {
					return elements;
				}
			}
		}
		return new IPackageFragmentRoot[0];
	}

	private static IPackageFragmentRoot[] findRootsInProject(String path, IJavaProject project) {
		ArrayList result= new ArrayList();

		try {
			IPackageFragmentRoot[] roots= project.getPackageFragmentRoots();
			for (int i= 0; i < roots.length; i++) {
				IPackageFragmentRoot packageFragmentRoot= roots[i];
				if (isRootAt(packageFragmentRoot, path))
					result.add(packageFragmentRoot);
			}
		} catch (Exception e) {
			JavaPlugin.log(e);
		}

		return (IPackageFragmentRoot[]) result.toArray(new IPackageFragmentRoot[result.size()]);
	}

	private static boolean isRootAt(IPackageFragmentRoot pfr, String path) {
		try {
			IClasspathEntry cpe= pfr.getRawClasspathEntry();
			if (cpe.getEntryKind() == IClasspathEntry.CPE_SOURCE) {
				IPath relIPath= pfr.getJavaProject().getOutputLocation();
				IPath iPath= pfr.getJavaModel().getWorkspace().getRoot().findMember(relIPath, true).getLocation();
				if (iPath != null) {
					String strPath= iPath.toString();
					if (path.equals(strPath)) {
						return true;
					}
				}
			}
		} catch (JavaModelException e) {
			JavaPlugin.log(e);
		}

		IResource res= pfr.getResource();
		if (res != null) {
			IPath iPath= res.getLocation();
			if (iPath != null) {
				String strPath= iPath.toString();
				if (path.equals(strPath)) {
					return true;
				}
			}
		}

		IPath iPath= pfr.getPath();
		if (iPath != null) {
			String strPath= iPath.toString();
			if (path.equals(strPath)) {
				return true;
			}
		}

		return false;
	}

	private static IType findMainMethodByName(String name, IPackageFragmentRoot[] classpathResources, IRunnableContext context) throws CoreException {
		
		List resources= JarPackagerUtil.asResources(classpathResources);
		if (resources == null)
			throw new CoreException(new Status(IStatus.ERROR, JavaUI.ID_PLUGIN, FatJarPackagerMessages.FatJarPackageWizardPage_error_noMainMethod));

		for (Iterator iterator= resources.iterator(); iterator.hasNext();) {
			IResource element= (IResource) iterator.next();
			if (element == null)
				iterator.remove();
		}
		
		IJavaSearchScope searchScope= JavaSearchScopeFactory.getInstance().createJavaSearchScope((IResource[]) resources.toArray(new IResource[resources.size()]), true);
		MainMethodSearchEngine engine= new MainMethodSearchEngine();
		try {
			IType[] mainTypes= engine.searchMainMethods(context, searchScope, 0);
			for (int i= 0; i < mainTypes.length; i++) {
				if (mainTypes[i].getFullyQualifiedName().equals(name))
					return mainTypes[i];
			}
		} catch (InvocationTargetException ex) {
			JavaPlugin.log(ex);
		} catch (InterruptedException e) {
			// null
		}
		
		return null;
	}
	
	public void dispose() {
		super.dispose();
		if (fLauchConfigurationModel != null) {
			for (int i= 0, size= fLauchConfigurationModel.size(); i < size; i++) {
				LaunchConfigurationElement element= (LaunchConfigurationElement) fLauchConfigurationModel.get(i);
				element.dispose();
			}
		}
	}
	
	protected void restoreWidgetValues() {
		
		IDialogSettings settings= getDialogSettings();
		if (settings != null) {
			String name= settings.get(STORE_LAUNCH_CONFIGURATION_SELECTION_NAME);
			if (name != null) {
				String[] items= fLaunchConfigurationCombo.getItems();
				for (int i= 0; i < items.length; i++) {
					if (name.equals(items[i])) {
						fLaunchConfigurationCombo.select(i);
					}
				}
			}
			
			String destinationPath= settings.get(STORE_DESTINATION_ELEMENT);
			if (destinationPath != null && destinationPath.length() > 0) {
				fJarPackage.setJarLocation(Path.fromOSString(destinationPath));
			}
		}
		
		super.restoreWidgetValues();
	}
	
	/**
	 * {@inheritDoc}
	 */
	protected void saveWidgetValues() {
		super.saveWidgetValues();
		
		IDialogSettings settings= getDialogSettings();
		if (settings != null) {
			int index= fLaunchConfigurationCombo.getSelectionIndex();
			if (index == -1) {
				settings.put(STORE_LAUNCH_CONFIGURATION_SELECTION_NAME, ""); //$NON-NLS-1$
			} else {
				String selectedItem= fLaunchConfigurationCombo.getItem(index);
				settings.put(STORE_LAUNCH_CONFIGURATION_SELECTION_NAME, selectedItem);
			}
			
			IPath location= fJarPackage.getJarLocation();
			if (location == null) {
				settings.put(STORE_DESTINATION_ELEMENT, ""); //$NON-NLS-1$
			} else {
				settings.put(STORE_DESTINATION_ELEMENT, location.toOSString());
			}
		}
	}
	
	/*
	 * For internal use only (testing), clients must not call.
	 */
	public static Object[] getSelectedElementsWithoutContainedChildren(ILaunchConfiguration launchconfig, JarPackageData data, IRunnableContext context)  throws CoreException {
		if (launchconfig == null)
			return new Object[0];

		String projectName= launchconfig.getAttribute(IJavaLaunchConfigurationConstants.ATTR_PROJECT_NAME, ""); //$NON-NLS-1$

		String[] searchOrder= getProjectSearchOrder(projectName);
		String[] classpath= getClasspath(launchconfig);
		IPackageFragmentRoot[] classpathResources= getRequiredPackageFragmentRoots(classpath, searchOrder);

		String mainClass= getMainClass(launchconfig);
		data.setManifestMainClass(findMainMethodByName(mainClass, classpathResources, context));

		return classpathResources;
	}
	
	/*
	 *  From org.eclipse.jdt.internal.debug.ui.launcher.JavaApplicationLaunchShortcut
	 *  
	 *  For internal use only (testing), clients must not call.
	 */
	public static ILaunchConfiguration createTempLaunchConfig(IJavaProject project) {
		String projectName= project.getElementName();

		String configname= "fatjar_cfg_eraseme_" + projectName; //$NON-NLS-1$
		ILaunchConfiguration config= null;
		ILaunchConfigurationWorkingCopy wc= null;
		try {
			ILaunchManager launchManager= DebugPlugin.getDefault().getLaunchManager();
			ILaunchConfigurationType configType= launchManager.getLaunchConfigurationType(IJavaLaunchConfigurationConstants.ID_JAVA_APPLICATION);
			wc= configType.newInstance(null, launchManager.generateUniqueLaunchConfigurationNameFrom(configname));
		} catch (CoreException e) {
			JavaPlugin.log(e);
			return null;
		}
		 
		//TODO
//		IType[] mainTypes= findMainTypes(project);
//		if (mainTypes.length == 1)
//			wc.setAttribute(IJavaLaunchConfigurationConstants.ATTR_MAIN_TYPE_NAME, mainTypes[0].getElementName());
		
		wc.setAttribute(IJavaLaunchConfigurationConstants.ATTR_PROJECT_NAME, projectName);
		try {
			config= wc.doSave();
		} catch (CoreException e) {
			JavaPlugin.log(e);
		}
		
		return config;
	}

}




/*******************************************************************************
 * Copyright (c) 2007 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
 *******************************************************************************/
package org.eclipse.jdt.internal.ui.jarpackager;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.MultiStatus;
import org.eclipse.core.runtime.Status;

import org.eclipse.core.resources.IFile;

import org.eclipse.swt.widgets.Shell;

import org.eclipse.jdt.core.IPackageFragmentRoot;

import org.eclipse.jdt.ui.jarpackager.IManifestProvider;
import org.eclipse.jdt.ui.jarpackager.JarPackageData;

import org.eclipse.jdt.internal.ui.IJavaStatusConstants;
import org.eclipse.jdt.internal.ui.JavaPlugin;

/**
 * Base class for all jar builders. A jar builder is used by
 * the {@link JarFileExportOperation} to build a jar file.
 *
 * @since 3.4
 */
public abstract class JarBuilder {

	private MultiStatus fStatus;

	/**
	 * @return the unique id of this builder
	 */
	public abstract String getId();

	/**
	 * @return the manifest provider to build the manifest
	 */
	public abstract IManifestProvider getManifestProvider();

	/**
	 * Called when building of the jar starts
	 * 
	 * @param jarPackage
	 *        the package to build
	 * @param shell
	 *        shell to show dialogs in, <b>null</b> if no dialog must be shown
	 * @param status
	 *        a status to use to report status to the user
	 * @throws CoreException
	 */
	public void open(JarPackageData jarPackage, Shell shell, MultiStatus status) throws CoreException {
		fStatus= status;
	}

	/**
	 * Add the given resource to the archive at the given path
	 * 
	 * @param resource
	 *        the file to be written
	 * @param destinationPath
	 *        the path for the file inside the archive
	 * @throws CoreException 
	 */
	public abstract void addFile(IFile resource, IPath destinationPath) throws CoreException;

	/**
	 * Add the given package fragment root to the archive. The root is an archive.
	 * 
	 * @param root
	 *        the package fragment root to add
	 * @param monitor
	 *        a monitor to report progress to
	 */
	public abstract void addJar(IPackageFragmentRoot root, IProgressMonitor monitor);

	/**
	 * Called when building of the jar finished.
	 * 
	 * @throws CoreException
	 */
	public abstract void close() throws CoreException;

	//some methods for convenience
	protected final void addInfo(String message, Throwable error) {
		fStatus.add(new Status(IStatus.INFO, JavaPlugin.getPluginId(), IJavaStatusConstants.INTERNAL_ERROR, message, error));
	}

	protected final void addWarning(String message, Throwable error) {
		fStatus.add(new Status(IStatus.WARNING, JavaPlugin.getPluginId(), IJavaStatusConstants.INTERNAL_ERROR, message, error));
	}

	protected final void addError(String message, Throwable error) {
		fStatus.add(new Status(IStatus.ERROR, JavaPlugin.getPluginId(), IJavaStatusConstants.INTERNAL_ERROR, message, error));
	}

	protected final void addToStatus(CoreException ex) {
		IStatus status= ex.getStatus();
		String message= ex.getLocalizedMessage();
		if (message == null || message.length() < 1) {
			message= JarPackagerMessages.JarFileExportOperation_coreErrorDuringExport;
			status= new Status(status.getSeverity(), status.getPlugin(), status.getCode(), message, ex);
		}
		fStatus.add(status);
	}
}




###############################################################################
# Copyright (c) 2007 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
###############################################################################

JarPackageWizard_windowTitle= Runnable JAR Export
JarPackageWizard_jarExport_title= Runnable JAR Export
FatJarBuilder_error_exportingStream=Exporting stream to {0} failed.
FatJarBuilder_error_readingArchiveFile=Could not read jar file ''{0}''. Reason: {1}
FatJarPackageWizardPage_defaultLaunchConfigName={0} : <default>
FatJarPackageWizardPage_description=Select a launch configuration to use to create a runnable JAR.
FatJarPackageWizardPage_destinationGroupTitle=Select the export destination:
FatJarPackageWizardPage_error_missingClassFile=Fat Jar Export: Could not find classpath entry for '{0}'
FatJarPackageWizardPage_error_noMainMethod=Could not find main method from given launch configuration.
FatJarPackageWizardPage_launchConfigGroupTitle=Select the launch configuration:
JarPackageWizard_jarExportError_title= Runnable JAR Export Error
JarPackageWizard_jarExportError_message= Creation of runnable JAR failed

JarPackageWizardPage_title= Runnable JAR File Specification

JarWriter_error_couldNotGetXmlBuilder = Could not get XML builder
JarWriter_error_couldNotTransformToXML= Could not transform to XML




/*******************************************************************************
 * Copyright (c) 2007 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
 *******************************************************************************/
package org.eclipse.jdt.internal.ui.jarpackager;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.MultiStatus;

import org.eclipse.core.resources.IFile;

import org.eclipse.swt.widgets.Shell;

import org.eclipse.jdt.core.IPackageFragmentRoot;

import org.eclipse.jdt.ui.jarpackager.IManifestProvider;
import org.eclipse.jdt.ui.jarpackager.JarPackageData;
import org.eclipse.jdt.ui.jarpackager.JarWriter3;

/**
 * Jar builder for the plain jar exported. Does not export required archives.
 * 
 * @since 3.4
 */
public class PlainJarBuilder extends JarBuilder {
	
	public static final String BUILDER_ID= "org.eclipse.jdt.ui.plain_jar_builder"; //$NON-NLS-1$
	
	private JarPackageData fJarPackage;
	private JarWriter3 fJarWriter;
	
	/**
	 * {@inheritDoc}
	 */
	public String getId() {
		return BUILDER_ID;
	}
	
	/**
	 * {@inheritDoc}
	 */
	public IManifestProvider getManifestProvider() {
		return new ManifestProvider();
	}

	/**
	 * {@inheritDoc}
	 */
	public void open(JarPackageData jarPackage, Shell displayShell, MultiStatus statusMsg) throws CoreException {
		super.open(jarPackage, displayShell, statusMsg);
		fJarPackage = jarPackage;
		fJarWriter = new JarWriter3(fJarPackage, displayShell);
	}

	/**
	 * {@inheritDoc}
	 */
	public void addFile(IFile resource, IPath destinationPath) throws CoreException {
		fJarWriter.write(resource, destinationPath);
	}

	/**
	 * {@inheritDoc}
	 */
	public void addJar(IPackageFragmentRoot archiveRoot, IProgressMonitor progressMonitor) {
		//do nothing, plain jar builder can not handle archives, use fat jar builder
	}
	
	/**
	 * {@inheritDoc}
	 */
	public void close() throws CoreException {
		fJarWriter.close();
	}

}




/*******************************************************************************
 * Copyright (c) 2007 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
 *******************************************************************************/
package org.eclipse.jdt.internal.ui.jarpackagerfat;

import org.eclipse.osgi.util.NLS;

public final class FatJarPackagerMessages extends NLS {

	private static final String BUNDLE_NAME= "org.eclipse.jdt.internal.ui.jarpackagerfat.FatJarPackagerMessages";//$NON-NLS-1$

	public static String JarPackageWizard_jarExport_title;
	public static String JarPackageWizard_jarExportError_message;
	public static String FatJarBuilder_error_exportingStream;

	public static String FatJarBuilder_error_readingArchiveFile;

	public static String FatJarPackageWizardPage_defaultLaunchConfigName;

	public static String FatJarPackageWizardPage_destinationGroupTitle;

	public static String FatJarPackageWizardPage_error_missingClassFile;

	public static String FatJarPackageWizardPage_error_noMainMethod;

	public static String FatJarPackageWizardPage_launchConfigGroupTitle;

	public static String FatJarPackageWizardPage_description;

	public static String JarPackageWizard_jarExportError_title;
	public static String JarPackageWizard_windowTitle;

	public static String JarPackageWizardPage_title;

	public static String JarWriter_error_couldNotGetXmlBuilder;
	public static String JarWriter_error_couldNotTransformToXML;

	static {
		NLS.initializeMessages(BUNDLE_NAME, FatJarPackagerMessages.class);
	}

	private FatJarPackagerMessages() {
		// Do not instantiate
	}
}




/*******************************************************************************
 * Copyright (c) 2007 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
 *******************************************************************************/
package org.eclipse.jdt.internal.ui.jarpackagerfat;

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.jar.Attributes;
import java.util.jar.Manifest;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.jdt.core.IPackageFragment;
import org.eclipse.jdt.core.IPackageFragmentRoot;

import org.eclipse.jdt.ui.jarpackager.IManifestProvider;
import org.eclipse.jdt.ui.jarpackager.JarPackageData;

import org.eclipse.jdt.internal.ui.JavaPlugin;
import org.eclipse.jdt.internal.ui.jarpackager.JarPackagerUtil;

/**
 * A manifest provider creates manifest files for a fat jar.
 * 
 * @since 3.4
 */
public class FatJarManifestProvider implements IManifestProvider {

	private static final String SEALED_VALUE= "true"; //$NON-NLS-1$
	private static final String UNSEALED_VALUE= "false"; //$NON-NLS-1$
	
	private FatJarBuilder fBuilder;
	
	public FatJarManifestProvider(FatJarBuilder builder) {
		fBuilder = builder;
	}

	/**
	 * {@inheritDoc}
	 */
	public Manifest create(JarPackageData jarPackage) throws CoreException {
		Manifest result;
		Manifest ownManifest = createOwn(jarPackage);
		setManifestClasspath(ownManifest, fBuilder.getManifestClasspath());
		if (fBuilder.isMergeManifests()) {
			List otherManifests = new ArrayList(); 
			Object[] elements = jarPackage.getElements();
			for (int i = 0; i < elements.length; i++) {
				Object element = elements[i];
				if (element instanceof IPackageFragmentRoot && ((IPackageFragmentRoot)element).isArchive()) {
					ZipFile zip = JarPackagerUtil.getArchiveFile(((IPackageFragmentRoot) element).getPath());
					Enumeration entries = zip.entries();
					while (entries.hasMoreElements()) {
						ZipEntry entry = (ZipEntry)entries.nextElement();
						if (entry.getName().equalsIgnoreCase("META-INF/MANIFEST.MF")) { //$NON-NLS-1$
							try {
								Manifest otherManifest = new Manifest(zip.getInputStream(entry));
								otherManifests.add(otherManifest);
							} catch (IOException e) {
								JavaPlugin.log(e);
							}
						}
					}
				}
			}
			result = merge(ownManifest, otherManifests);
		}
		else {
			result = ownManifest;
		}
		return result;
	}

	private void setManifestClasspath(Manifest ownManifest, String manifestClasspath) {
		if ((manifestClasspath != null) && !manifestClasspath.trim().equals("")) { //$NON-NLS-1$
			Attributes mainAttr = ownManifest.getMainAttributes();
			mainAttr.putValue("Class-Path", manifestClasspath); //$NON-NLS-1$
		}
	}

	private Manifest merge(Manifest ownManifest, List otherManifests) {
		Manifest mergedManifest = new Manifest(ownManifest);
		Map mergedEntries = mergedManifest.getEntries();
		for (Iterator iter = otherManifests.iterator(); iter.hasNext();) {
			Manifest otherManifest = (Manifest)iter.next();
			Map otherEntries = otherManifest.getEntries();
			for (Iterator iterator = otherEntries.keySet().iterator(); iterator.hasNext();) {
				String attributeName = (String)iterator.next();
				if (mergedEntries.containsKey(attributeName)) {
					// TODO: WARNING
				}
				else {
					mergedEntries.put(attributeName, otherEntries.get(attributeName));
				}
			}
		}
		return mergedManifest;
	}

	private Manifest createOwn(JarPackageData jarPackage) throws CoreException {
		if (jarPackage.isManifestGenerated())
			return createGeneratedManifest(jarPackage);

		try {
			return createSuppliedManifest(jarPackage);
		} catch (IOException ex) {
			throw JarPackagerUtil.createCoreException(ex.getLocalizedMessage(), ex);
		}
	}	
	
	/**
	 * {@inheritDoc}
	 */
	public Manifest createDefault(String manifestVersion) {
		Manifest manifest= new Manifest();
		manifest.getMainAttributes().put(Attributes.Name.MANIFEST_VERSION, manifestVersion);
		return manifest;
	}

	/**
	 * Hook for subclasses to add additional manifest entries.
	 * 
	 * @param	manifest	the manifest to which the entries should be added
	 * @param	jarPackage	the JAR package specification
	 */
	protected void putAdditionalEntries(Manifest manifest, JarPackageData jarPackage) {
	}

	private Manifest createGeneratedManifest(JarPackageData jarPackage) {
		Manifest manifest= new Manifest();
		putVersion(manifest, jarPackage);
		putSealing(manifest, jarPackage);
		putMainClass(manifest, jarPackage);
		putAdditionalEntries(manifest, jarPackage);
		return manifest;
	}

	private void putVersion(Manifest manifest, JarPackageData jarPackage) {
		manifest.getMainAttributes().put(Attributes.Name.MANIFEST_VERSION, jarPackage.getManifestVersion());
	}
		
	private void putSealing(Manifest manifest, JarPackageData jarPackage) {
		if (jarPackage.isJarSealed()) {
			manifest.getMainAttributes().put(Attributes.Name.SEALED, SEALED_VALUE);
			IPackageFragment[] packages= jarPackage.getPackagesToUnseal();
			if (packages != null) {
				for (int i= 0; i < packages.length; i++) {
					Attributes attributes= new Attributes();
					attributes.put(Attributes.Name.SEALED, UNSEALED_VALUE);
					manifest.getEntries().put(getInManifestFormat(packages[i]), attributes);
				}
			}
		}
		else {
			IPackageFragment[] packages= jarPackage.getPackagesToSeal();
			if (packages != null)
				for (int i= 0; i < packages.length; i++) {
					Attributes attributes= new Attributes();
					attributes.put(Attributes.Name.SEALED, SEALED_VALUE);
					manifest.getEntries().put(getInManifestFormat(packages[i]), attributes);
				}
		}
	}
	
	private void putMainClass(Manifest manifest, JarPackageData jarPackage) {
		if (jarPackage.getManifestMainClass() != null && jarPackage.getManifestMainClass().getFullyQualifiedName().length() > 0)
			manifest.getMainAttributes().put(Attributes.Name.MAIN_CLASS, jarPackage.getManifestMainClass().getFullyQualifiedName());
	}
	
	private String getInManifestFormat(IPackageFragment packageFragment) {
		String name= packageFragment.getElementName();
		return name.replace('.', '/') + '/';
	}

	private Manifest createSuppliedManifest(JarPackageData jarPackage) throws CoreException, IOException {
		Manifest manifest;
		// No need to use buffer here because Manifest(...) does
		InputStream stream= jarPackage.getManifestFile().getContents(false);
		try {
			manifest= new Manifest(stream);
		} finally {
			if (stream != null)
				stream.close();
		}
		return manifest;
	}

}




/*******************************************************************************
 * Copyright (c) 2007 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
 *******************************************************************************/
package org.eclipse.jdt.internal.ui.jarpackager;

import java.io.File;

import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.ResourcesPlugin;

import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Combo;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.FileDialog;
import org.eclipse.swt.widgets.Label;

import org.eclipse.jface.dialogs.IDialogSettings;
import org.eclipse.jface.dialogs.IMessageProvider;
import org.eclipse.jface.viewers.IStructuredSelection;

import org.eclipse.ui.dialogs.WizardExportResourcesPage;

import org.eclipse.jdt.ui.jarpackager.JarPackageData;

import org.eclipse.jdt.internal.ui.util.SWTUtil;

/**
 * A wizard page containing a destination block for a jar file. Including
 * all required validation code. Clients should overwrite <code>createControl</code>.
 * 
 * @since 3.4
 */
public abstract class AbstractJarDestinationWizardPage extends WizardExportResourcesPage implements IJarPackageWizardPage {
	
	private final String fStoreDestinationNamesId;
	
	private Combo	fDestinationNamesCombo;
	private Button	fDestinationBrowseButton;
	private final JarPackageData fJarPackage;

	public AbstractJarDestinationWizardPage(String pageName, IStructuredSelection selection, JarPackageData jarPackage) {
		super(pageName, selection);
		fStoreDestinationNamesId= pageName + ".DESTINATION_NAMES_ID"; //$NON-NLS-1$
		fJarPackage= jarPackage;
	}
	
	/*
	 * Overrides method from WizardExportPage
	 */
	protected void createDestinationGroup(Composite parent) {
		
		initializeDialogUnits(parent);
		
		// destination specification group
		Composite destinationSelectionGroup= new Composite(parent, SWT.NONE);
		GridLayout layout= new GridLayout();
		layout.numColumns= 3;
		destinationSelectionGroup.setLayout(layout);
		destinationSelectionGroup.setLayoutData(new GridData(GridData.HORIZONTAL_ALIGN_FILL | GridData.VERTICAL_ALIGN_FILL));

		String label= getDestinationLabel();
		if (label != null) {
			new Label(destinationSelectionGroup, SWT.NONE).setText(label);
		}

		// destination name entry field
		fDestinationNamesCombo= new Combo(destinationSelectionGroup, SWT.SINGLE | SWT.BORDER);
		fDestinationNamesCombo.addListener(SWT.Modify, this);
		fDestinationNamesCombo.addListener(SWT.Selection, this);
		GridData data= new GridData(GridData.HORIZONTAL_ALIGN_FILL | GridData.GRAB_HORIZONTAL);
		data.widthHint= SIZING_TEXT_FIELD_WIDTH;
		data.horizontalSpan= label == null ? 2 : 1;
		fDestinationNamesCombo.setLayoutData(data);

		// destination browse button
		fDestinationBrowseButton= new Button(destinationSelectionGroup, SWT.PUSH);
		fDestinationBrowseButton.setText(JarPackagerMessages.JarPackageWizardPage_browseButton_text); 
		fDestinationBrowseButton.setLayoutData(new GridData(GridData.HORIZONTAL_ALIGN_FILL));
		SWTUtil.setButtonDimensionHint(fDestinationBrowseButton);
		fDestinationBrowseButton.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {
				handleDestinationBrowseButtonPressed();
			}
		});
	}
	
	/**
	 *	Open an appropriate destination browser so that the user can specify a source
	 *	to import from
	 */
	protected void handleDestinationBrowseButtonPressed() {
		FileDialog dialog= new FileDialog(getContainer().getShell(), SWT.SAVE);
		dialog.setFilterExtensions(new String[] {"*.jar", "*.zip"}); //$NON-NLS-1$ //$NON-NLS-2$

		String currentSourceString= getDestinationValue();
		int lastSeparatorIndex= currentSourceString.lastIndexOf(File.separator);
		if (lastSeparatorIndex != -1) {
			dialog.setFilterPath(currentSourceString.substring(0, lastSeparatorIndex));
			dialog.setFileName(currentSourceString.substring(lastSeparatorIndex + 1, currentSourceString.length()));
		}
		else
			dialog.setFileName(currentSourceString);
		String selectedFileName= dialog.open();
		if (selectedFileName != null)
			fDestinationNamesCombo.setText(selectedFileName);
	}
	

	/**
	 * Answer the contents of the destination specification widget. If this
	 * value does not have the required suffix then add it first.
	 * 
	 * @return java.lang.String
	 */
	protected String getDestinationValue() {
		String destinationText= fDestinationNamesCombo.getText().trim();
		if (destinationText.indexOf('.') < 0)
			destinationText += getOutputSuffix();
		return destinationText;
	}

	/**
	 *	Answer the string to display in self as the destination type
	 *
	 *	@return java.lang.String
	 */
	protected String getDestinationLabel() {
		return JarPackagerMessages.JarPackageWizardPage_destination_label; 
	}

	/**
	 *	Answer the suffix that files exported from this wizard must have.
	 *	If this suffix is a file extension (which is typically the case)
	 *	then it must include the leading period character.
	 *
	 *	@return java.lang.String
	 */
	protected String getOutputSuffix() {
		return "." + JarPackagerUtil.JAR_EXTENSION; //$NON-NLS-1$
	}
	
	protected void restoreWidgetValues() {
		// destination
		if (fJarPackage.getJarLocation().isEmpty())
			fDestinationNamesCombo.setText(""); //$NON-NLS-1$
		else
			fDestinationNamesCombo.setText(fJarPackage.getJarLocation().toOSString());
		IDialogSettings settings= getDialogSettings();
		if (settings != null) {
			String[] directoryNames= settings.getArray(fStoreDestinationNamesId);
			if (directoryNames == null)
				return; // ie.- no settings stored
			if (! fDestinationNamesCombo.getText().equals(directoryNames[0]))
				fDestinationNamesCombo.add(fDestinationNamesCombo.getText());
			for (int i= 0; i < directoryNames.length; i++)
				fDestinationNamesCombo.add(directoryNames[i]);
		}
	}

	protected void updateModel() {
		// destination
		String comboText= fDestinationNamesCombo.getText();
		IPath path= Path.fromOSString(comboText);

		if (path.segmentCount() > 0 && ensureTargetFileIsValid(path.toFile()) && path.getFileExtension() == null) 
			// append .jar
			path= path.addFileExtension(JarPackagerUtil.JAR_EXTENSION);

		fJarPackage.setJarLocation(path);
	}
	
	/**
	 * Returns a boolean indicating whether the passed File handle is
	 * is valid and available for use.
	 *
	 * @param targetFile the target
	 * @return boolean
	 */
	protected boolean ensureTargetFileIsValid(File targetFile) {
		if (targetFile.exists() && targetFile.isDirectory() && fDestinationNamesCombo.getText().length() > 0) {
			setErrorMessage(JarPackagerMessages.JarPackageWizardPage_error_exportDestinationMustNotBeDirectory); 
			fDestinationNamesCombo.setFocus();
			return false;
		}
		if (targetFile.exists()) {
			if (!targetFile.canWrite()) {
				setErrorMessage(JarPackagerMessages.JarPackageWizardPage_error_jarFileExistsAndNotWritable); 
				fDestinationNamesCombo.setFocus();
				return false;
			}
		}
		return true;
	}
	
	/*
	 * Overrides method from WizardDataTransferPage
	 */
	protected boolean validateDestinationGroup() {
		if (fDestinationNamesCombo.getText().length() == 0) {
			// Clear error 
			if (getErrorMessage() != null)
				setErrorMessage(null);
			if (getMessage() != null)
				setMessage(null);
			return false;
		}
		if (fJarPackage.getAbsoluteJarLocation().toString().endsWith("/")) { //$NON-NLS-1$
			setErrorMessage(JarPackagerMessages.JarPackageWizardPage_error_exportDestinationMustNotBeDirectory); 
			fDestinationNamesCombo.setFocus();
			return false;
		}
		// Check if the Jar is put into the workspace and conflicts with the containers
		// exported. If the workspace isn't on the local files system we are fine since
		// the Jar is always created in the local file system
		IPath workspaceLocation= ResourcesPlugin.getWorkspace().getRoot().getLocation();
		if (workspaceLocation != null && workspaceLocation.isPrefixOf(fJarPackage.getAbsoluteJarLocation())) {
			int segments= workspaceLocation.matchingFirstSegments(fJarPackage.getAbsoluteJarLocation());
			IPath path= fJarPackage.getAbsoluteJarLocation().removeFirstSegments(segments);
			IResource resource= ResourcesPlugin.getWorkspace().getRoot().findMember(path);
			if (resource != null && resource.getType() == IResource.FILE) {
				// test if included
				if (JarPackagerUtil.contains(JarPackagerUtil.asResources(fJarPackage.getElements()), (IFile)resource)) {
					setErrorMessage(JarPackagerMessages.JarPackageWizardPage_error_cantExportJARIntoItself); 
					return false;
				}
			}
		}
		// Inform user about relative directory
		String currentMessage= getMessage();
		if (!(new File(fDestinationNamesCombo.getText()).isAbsolute())) {
			if (currentMessage == null)
				setMessage(JarPackagerMessages.JarPackageWizardPage_info_relativeExportDestination, IMessageProvider.INFORMATION); 
		} else {
			if (currentMessage != null)
				setMessage(null);
		}
		return ensureTargetFileIsValid(fJarPackage.getAbsoluteJarLocation().toFile());
	}
	
	/**
	 * Set the current input focus to self's destination entry field
 	 */
	protected void giveFocusToDestination() {
		fDestinationNamesCombo.setFocus();
	}
	
	/**
	 * {@inheritDoc}
	 */
	protected void saveWidgetValues() {
		IDialogSettings settings= getDialogSettings();
		if (settings != null) {
			String[] directoryNames= settings.getArray(fStoreDestinationNamesId);
			if (directoryNames == null)
				directoryNames= new String[0];
			directoryNames= addToHistory(directoryNames, getDestinationValue());
			settings.put(fStoreDestinationNamesId, directoryNames);
		}
	}

	/**
	 *	Initializes the JAR package from last used wizard page values.
	 */
	protected void initializeJarPackage() {
		IDialogSettings settings= getDialogSettings();
		if (settings != null) {
			// destination
			String[] directoryNames= settings.getArray(fStoreDestinationNamesId);
			if (directoryNames == null)
				return; // ie.- no settings stored
			fJarPackage.setJarLocation(Path.fromOSString(directoryNames[0]));
		}
	}
	
	/* 
	 * Implements method from IJarPackageWizardPage.
	 */
	public void finish() {
		saveWidgetValues();
	}
	
	/*
	 * Implements method from Listener
	 */	
	public void handleEvent(Event e) {
		if (getControl() == null)
			return;
		update();
	}
	
	protected void update() {
		updateModel();
		updateWidgetEnablements();
		updatePageCompletion();
	}
	
	protected void updatePageCompletion() {
		boolean pageComplete= isPageComplete();
		setPageComplete(pageComplete);
		if (pageComplete)
			setErrorMessage(null);
	}
}




package org.eclipse.jdt.internal.ui.jarpackagerfat;

import java.io.IOException;
import java.io.InputStream;
import java.util.Enumeration;
import java.util.zip.ZipEntry;
import java.util.zip.ZipException;
import java.util.zip.ZipFile;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.MultiStatus;
import org.eclipse.core.runtime.OperationCanceledException;

import org.eclipse.core.resources.IFile;

import org.eclipse.swt.widgets.Shell;

import org.eclipse.jdt.core.IPackageFragmentRoot;

import org.eclipse.jdt.internal.corext.util.Messages;

import org.eclipse.jdt.ui.jarpackager.IManifestProvider;
import org.eclipse.jdt.ui.jarpackager.JarPackageData;
import org.eclipse.jdt.ui.jarpackager.JarWriter3;

import org.eclipse.jdt.internal.ui.jarpackager.JarBuilder;
import org.eclipse.jdt.internal.ui.jarpackager.JarPackagerUtil;

public class FatJarBuilder extends JarBuilder {

	public static final String BUILDER_ID= "org.eclipse.jdt.ui.fat_jar_builder"; //$NON-NLS-1$

//	private static final String PROPS_MERGEMANIFESTS= "mergemanifests"; //$NON-NLS-1$
//	private static final String PROPS_REMOVESIGNERS= "removesigners"; //$NON-NLS-1$
//	private static final String PROPS_MANIFESTCLASSPATH= "manifestclasspath"; //$NON-NLS-1$

	private boolean fMergeManifests;
	private boolean fRemoveSigners;
	private String fManifestClasspath;

	private JarPackageData fJarPackage;
	private JarWriter3 fJarWriter;
	
	/**
	 * {@inheritDoc}
	 */
	public String getId() {
		return BUILDER_ID;
	}
	
	/**
	 * {@inheritDoc}
	 */
	public IManifestProvider getManifestProvider() {
		return new FatJarManifestProvider(this);
	}
	
	public String getManifestClasspath() {
		return fManifestClasspath;
	}

	public boolean isMergeManifests() {
		return fMergeManifests;
	}

	public boolean isRemoveSigners() {
		return fRemoveSigners;
	}

	/**
	 * {@inheritDoc}
	 */
	public void open(JarPackageData jarPackage, Shell displayShell, MultiStatus status) throws CoreException {
		super.open(jarPackage, displayShell, status);
//		ExecutableJarBuilderProperty[] jarBuilderProperties= getExecutableJarBuilderProperties();

		fMergeManifests= true;//getBooleanValue(jarBuilderProperties, PROPS_MERGEMANIFESTS, true);
		fRemoveSigners= true;//getBooleanValue(jarBuilderProperties, PROPS_REMOVESIGNERS, true);
		fManifestClasspath= "";//getValue(jarBuilderProperties, PROPS_MANIFESTCLASSPATH, ""); //$NON-NLS-1$

		fJarPackage= jarPackage;
		fJarWriter= new JarWriter3(fJarPackage, displayShell);
	}
	
	/**
	 * {@inheritDoc}
	 */
	public void addFile(IFile resource, IPath destinationPath) throws CoreException {
		fJarWriter.write(resource, destinationPath);
	}

	/**
	 * {@inheritDoc}
	 */
	public void addJar(IPackageFragmentRoot archiveRoot, IProgressMonitor progressMonitor) {
		try {
			ZipFile jarFile= JarPackagerUtil.getArchiveFile(archiveRoot.getPath());
			String readableJarName= archiveRoot.getElementName();
			addJar(readableJarName, jarFile, progressMonitor);
			jarFile.close();
		} catch (IOException ex) {
			addJarWarning(archiveRoot.getElementName(), ex);
		} catch (CoreException ex) {
			addJarWarning(archiveRoot.getElementName(), ex);
		}
	}
	
	private void addJar(String readableJarName, ZipFile jarFile, IProgressMonitor progressMonitor) {
		Enumeration jarEntriesEnum= jarFile.entries();
		while (jarEntriesEnum.hasMoreElements()) {
			ZipEntry jarEntry= (ZipEntry) jarEntriesEnum.nextElement();
			if (!jarEntry.isDirectory()) {
				String entryName= jarEntry.getName();
				InputStream stream= null;
				try {
					stream= jarFile.getInputStream(jarEntry);
					addFile(entryName, stream);
					stream.close();
				} catch (IOException e) {
					addJarWarning(readableJarName, e);
				}
			}
			progressMonitor.worked(1);
			if (progressMonitor.isCanceled())
				throw new OperationCanceledException();
		}
	}

	private void addFile(String destinationPath, InputStream fileStream) {
		// Handle META-INF/MANIFEST.MF 
		if (destinationPath.equalsIgnoreCase("META-INF/MANIFEST.MF") //$NON-NLS-1$
				|| (isRemoveSigners() && destinationPath.startsWith("META-INF/") && destinationPath.endsWith(".SF"))) {  //$NON-NLS-1$//$NON-NLS-2$
			return;
		}
		try {
			fJarWriter.addStream(fileStream, destinationPath);
		} catch (CoreException ex) {
			Throwable realEx= ex.getStatus().getException();
			if (realEx instanceof ZipException && realEx.getMessage() != null && realEx.getMessage().startsWith("duplicate entry:")) //$NON-NLS-1$
				addWarning(ex.getMessage(), realEx);
			else
				addToStatus(ex);
		} catch (IOException ex) {
			if (ex instanceof ZipException && ex.getMessage() != null && ex.getMessage().startsWith("duplicate entry:")) {//$NON-NLS-1$
				// ignore duplicates in META-INF (*.SF, *.RSA)
				if (!destinationPath.startsWith("META-INF/")) { //$NON-NLS-1$
					addWarning(ex.getMessage(), ex);
				}
			} else
				addError(Messages.format(FatJarPackagerMessages.FatJarBuilder_error_exportingStream, destinationPath), ex);
		}
	}
	
	/**
	 * {@inheritDoc}
	 */
	public void close() throws CoreException {
		if (fJarWriter != null) {
			fJarWriter.close();
		}
	}
	
	private void addJarWarning(String archiveRootName, Throwable ex) {
		addWarning(Messages.format(FatJarPackagerMessages.FatJarBuilder_error_readingArchiveFile, new Object[] {archiveRootName, ex.getLocalizedMessage()}), ex);
	}

//	private static String getValue(ExecutableJarBuilderProperty[] jarBuilderProperties, String name, String defaultValue) {
//		String result= defaultValue;
//		if ((name != null) && (jarBuilderProperties != null)) {
//			for (int i= 0; i < jarBuilderProperties.length; i++) {
//				if (name.equals(jarBuilderProperties[i].getName())) {
//					result= jarBuilderProperties[i].getValue();
//					break;
//				}
//			}
//		}
//		return result;
//	}
//
//	private static boolean getBooleanValue(ExecutableJarBuilderProperty[] jarBuilderProperties, String name, boolean defaultValue) {
//		boolean result= defaultValue;
//		if (name != null) {
//			for (int i= 0; i < jarBuilderProperties.length; i++) {
//				if (name.equals(jarBuilderProperties[i].getName())) {
//					result= jarBuilderProperties[i].getBooleanValue();
//					break;
//				}
//			}
//		}
//		return result;
//	}
//
//	private static ExecutableJarBuilderProperty[] getExecutableJarBuilderProperties() {
//		ExecutableJarBuilderProperty[] jbProperties= {
//				new ExecutableJarBuilderProperty(ExecutableJarBuilderProperty.PROPERTYTYPE_BOOLEAN, "mergemanifests", "true", //$NON-NLS-2$
//						"Merge attributes from all included libs together. Use this if the output jar produces an 'SecurityException: no manifiest section for signature file entry ...'"),
//				new ExecutableJarBuilderProperty(ExecutableJarBuilderProperty.PROPERTYTYPE_BOOLEAN, "removesigners", "true", //$NON-NLS-2$
//						"Remove signer files (*.SF) in META-INF. Use this if the output jar produces an 'SecurityException: invalid SHA1 signature file digest for ...'"),
//				new ExecutableJarBuilderProperty(ExecutableJarBuilderProperty.PROPERTYTYPE_STRING, "manifestclasspath", "", //$NON-NLS-2$
//						"Define the Class-Path attribute separated by spaces. Folders must end with an '/'. Example: '. xclasses/ lib/test.jar'"), };
//		return jbProperties;
//	}

}




/*******************************************************************************
 * Copyright (c) 2007 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
 *******************************************************************************/
package org.eclipse.jdt.internal.ui.jarpackagerfat;

/**
 * TODO: Remove, not used?
 * @since 3.4
 */
public class JarBuilderProperty {

	public final static int PROPERTYTYPE_STRING= 1;
	public final static int PROPERTYTYPE_BOOLEAN= 2;

	private int propertyType;
	private String name;
	private String value;
	private String tip;

	public JarBuilderProperty(int propertyType, String name, String value, String tip) {
		this.propertyType= propertyType;
		this.name= name;
		this.value= value;
		this.tip= tip;
	}

	public int getType() {
		return propertyType;
	}

	public boolean isBooleanType() {
		return getType() == PROPERTYTYPE_BOOLEAN;
	}

	public boolean isStringType() {
		return getType() == PROPERTYTYPE_STRING;
	}

	public String getName() {
		return name;
	}

	public String getTip() {
		return tip;
	}

	public String getValue() {
		return value;
	}

	public void setValue(String value) {
		this.value= value;
	}

	public boolean getBooleanValue() {
		return (value != null) && Boolean.getBoolean(value);
	}

	public void setBooleanValue(boolean value) {
		this.value= Boolean.toString(value);
	}

	public void exportToString(StringBuffer out) {
		out.append("<prop name=\"").append(getName()).append("\" value=\"").append(getValue()).append("\" />"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
	}

	public String toString() {
		StringBuffer result= new StringBuffer();
		result.append("P[").append(Integer.toString(propertyType)).append("|").append(getName()).append("='").append(getValue()).append("']"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
		return result.toString();
	}
}




/*******************************************************************************
 * Copyright (c) 2007 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
 *******************************************************************************/
package org.eclipse.jdt.internal.ui.jarpackagerfat;

import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;

import org.eclipse.jface.dialogs.ErrorDialog;
import org.eclipse.jface.dialogs.IDialogSettings;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.wizard.IWizardPage;
import org.eclipse.jface.wizard.Wizard;

import org.eclipse.ui.IExportWizard;
import org.eclipse.ui.IWorkbench;

import org.eclipse.jdt.core.IClassFile;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IOpenable;
import org.eclipse.jdt.core.IPackageFragmentRoot;
import org.eclipse.jdt.core.JavaCore;

import org.eclipse.jdt.internal.corext.util.JavaModelUtil;

import org.eclipse.jdt.ui.jarpackager.IJarExportRunnable;
import org.eclipse.jdt.ui.jarpackager.JarPackageData;

import org.eclipse.jdt.internal.ui.JavaPlugin;
import org.eclipse.jdt.internal.ui.JavaPluginImages;
import org.eclipse.jdt.internal.ui.util.ExceptionHandler;

/**
 * Wizard for exporting resources from the workspace to a Fat Java Archive (JAR) file.
 * The exported jar will contain all required libraries.
 * 
 * @since 3.4
 */
public class FatJarPackageWizard extends Wizard implements IExportWizard {

	private static String DIALOG_SETTINGS_KEY= "JarPackageWizard"; //$NON-NLS-1$

	private boolean fHasNewDialogSettings;
	private boolean fInitializeFromJarPackage;
	private JarPackageData fJarPackage;
	private FatJarPackageWizardPage fJarPackageWizardPage;

	/**
	 * Creates a wizard for exporting workspace resources to a JAR file.
	 */
	public FatJarPackageWizard() {
		IDialogSettings workbenchSettings= JavaPlugin.getDefault().getDialogSettings();
		IDialogSettings section= workbenchSettings.getSection(DIALOG_SETTINGS_KEY);
		if (section == null)
			fHasNewDialogSettings= true;
		else {
			fHasNewDialogSettings= false;
			setDialogSettings(section);
		}
	}

	private void addJavaElement(List selectedElements, IJavaElement je) {
		if (je.getElementType() == IJavaElement.COMPILATION_UNIT)
			selectedElements.add(je);
		else if (je.getElementType() == IJavaElement.CLASS_FILE)
			selectedElements.add(je);
		else if (je.getElementType() == IJavaElement.JAVA_PROJECT)
			selectedElements.add(je);
		else if (je.getElementType() == IJavaElement.PACKAGE_FRAGMENT) {
			if (!JavaModelUtil.getPackageFragmentRoot(je).isArchive())
				selectedElements.add(je);
		} else if (je.getElementType() == IJavaElement.PACKAGE_FRAGMENT_ROOT) {
			if (!((IPackageFragmentRoot) je).isArchive())
				selectedElements.add(je);
		} else {
			IOpenable openable= je.getOpenable();
			if (openable instanceof ICompilationUnit)
				selectedElements.add(((ICompilationUnit) openable).getPrimary());
			else if (openable instanceof IClassFile && !JavaModelUtil.getPackageFragmentRoot(je).isArchive())
				selectedElements.add(openable);
		}
	}

	/**
	 * {@inheritDoc}
	 */
	public void addPages() {
		super.addPages();
		fJarPackageWizardPage= new FatJarPackageWizardPage(fJarPackage);
		addPage(fJarPackageWizardPage);
	}

	private void addProject(List selectedElements, IProject project) {
		try {
			if (project.hasNature(JavaCore.NATURE_ID))
				selectedElements.add(JavaCore.create(project));
		} catch (CoreException ex) {
			// ignore selected element
		}
	}

	private void addResource(List selectedElements, IResource resource) {
		IJavaElement je= JavaCore.create(resource);
		if (je != null && je.exists() && je.getElementType() == IJavaElement.COMPILATION_UNIT)
			selectedElements.add(je);
		else
			selectedElements.add(resource);
	}

	/**
	 * Exports the JAR package.
	 * 
	 * @param op the operation to run
	 * @return a boolean indicating success or failure
	 */
	protected boolean executeExportOperation(IJarExportRunnable op) {
		try {
			getContainer().run(true, true, op);
		} catch (InterruptedException e) {
			return false;
		} catch (InvocationTargetException ex) {
			if (ex.getTargetException() != null) {
				ExceptionHandler.handle(ex, getShell(), FatJarPackagerMessages.JarPackageWizard_jarExportError_title, FatJarPackagerMessages.JarPackageWizard_jarExportError_message);
				return false;
			}
		}
		IStatus status= op.getStatus();
		if (!status.isOK()) {
			ErrorDialog.openError(getShell(), FatJarPackagerMessages.JarPackageWizard_jarExport_title, null, status);
			return !(status.matches(IStatus.ERROR));
		}
		return true;
	}

	public IWizardPage getNextPage(IWizardPage page) {
		return super.getNextPage(page);
	}

	public IWizardPage getPreviousPage(IWizardPage page) {
		return super.getPreviousPage(page);
	}

	/**
	 * Gets the current workspace page selection and converts it to a valid
	 * selection for this wizard: - resources and projects are OK - CUs are OK -
	 * Java projects are OK - Source package fragments and source packages
	 * fragement roots are ok - Java elements below a CU are converted to their
	 * CU - all other input elements are ignored
	 * 
	 * @return a valid structured selection based on the current selection
	 */
	protected IStructuredSelection getValidSelection() {
		ISelection currentSelection= JavaPlugin.getActiveWorkbenchWindow().getSelectionService().getSelection();
		if (currentSelection instanceof IStructuredSelection) {
			IStructuredSelection structuredSelection= (IStructuredSelection) currentSelection;
			List selectedElements= new ArrayList(structuredSelection.size());
			Iterator iter= structuredSelection.iterator();
			while (iter.hasNext()) {
				Object selectedElement= iter.next();
				if (selectedElement instanceof IProject)
					addProject(selectedElements, (IProject) selectedElement);
				else if (selectedElement instanceof IResource)
					addResource(selectedElements, (IResource) selectedElement);
				else if (selectedElement instanceof IJavaElement)
					addJavaElement(selectedElements, (IJavaElement) selectedElement);
			}
			return new StructuredSelection(selectedElements);
		} else
			return StructuredSelection.EMPTY;
	}

	/**
	 * {@inheritDoc}
	 */
	public void init(IWorkbench workbench, IStructuredSelection selection) {
		fJarPackage= new JarPackageData();
		setInitializeFromJarPackage(false);
		setWindowTitle(FatJarPackagerMessages.JarPackageWizard_windowTitle);
		setDefaultPageImageDescriptor(JavaPluginImages.DESC_WIZBAN_FAT_JAR_PACKAGER);
		setNeedsProgressMonitor(true);
	}

	/**
	 * Initializes this wizard from the given JAR package description.
	 * 
	 * @param workbench
	 *            the workbench which launched this wizard
	 * @param jarPackage
	 *            the JAR package description used to initialize this wizard
	 */
	public void init(IWorkbench workbench, JarPackageData jarPackage) {
		Assert.isNotNull(workbench);
		Assert.isNotNull(jarPackage);
		fJarPackage= jarPackage;
		setInitializeFromJarPackage(true);
		setWindowTitle(FatJarPackagerMessages.JarPackageWizard_windowTitle);
		setDefaultPageImageDescriptor(JavaPluginImages.DESC_WIZBAN_FAT_JAR_PACKAGER);
		setNeedsProgressMonitor(true);
	}

	boolean isInitializingFromJarPackage() {
		return fInitializeFromJarPackage;
	}

	/**
	 * {@inheritDoc}
	 */
	public boolean performFinish() {
		fJarPackage.setJarBuilder(new FatJarBuilder());
		fJarPackage.setElements(fJarPackageWizardPage.getSelectedElementsWithoutContainedChildren());

		if (!executeExportOperation(fJarPackage.createJarExportRunnable(getShell())))
			return false;

		// Save the dialog settings
		if (fHasNewDialogSettings) {
			IDialogSettings workbenchSettings= JavaPlugin.getDefault().getDialogSettings();
			IDialogSettings section= workbenchSettings.getSection(DIALOG_SETTINGS_KEY);
			section= workbenchSettings.addNewSection(DIALOG_SETTINGS_KEY);
			setDialogSettings(section);
		}
		
		fJarPackageWizardPage.finish();
		return true;
	}

	void setInitializeFromJarPackage(boolean state) {
		fInitializeFromJarPackage= state;
	}
}

Return to bug 83258

Lines 1906-1911 Link Here

(-)plugin.xml (+13 lines)
1906	class="org.eclipse.core.resources.IResource">	1906	class="org.eclipse.core.resources.IResource">
1907	</selection>	1907	</selection>
1908	</wizard>	1908	</wizard>
		1909	<wizard
		1910	name="%fatJarExportWizard.label"
		1911	icon="$nl$/icons/full/etool16/exportfatjar_wiz.gif"
		1912	class="org.eclipse.jdt.internal.ui.jarpackagerfat.FatJarPackageWizard"
		1913	category="org.eclipse.jdt.ui.Java"
		1914	id="org.eclipse.jdt.internal.ui.fatjarpackager.JarPackageWizard">
		1915	<description>
		1916	%fatJarExportWizard.description
		1917	</description>
		1918	<selection
		1919	class="org.eclipse.core.resources.IResource">
		1920	</selection>
		1921	</wizard>
1909	</extension>	1922	</extension>
1910	<extension	1923	<extension
1911	point="org.eclipse.ui.popupMenus">	1924	point="org.eclipse.ui.popupMenus">

Lines 29-36 Link Here

(-)ui/org/eclipse/jdt/internal/ui/jarpackager/JarFileExportOperation.java (-12 / +30 lines)
29	import java.util.Set;	29	import java.util.Set;
30	import java.util.jar.Manifest;	30	import java.util.jar.Manifest;
31	import java.util.zip.ZipException;	31	import java.util.zip.ZipException;
		32	import java.util.zip.ZipFile;
32		33
33	import org.eclipse.core.filesystem.EFS;	34	import org.eclipse.core.filesystem.EFS;
		35
34	import org.eclipse.core.runtime.CoreException;	36	import org.eclipse.core.runtime.CoreException;
35	import org.eclipse.core.runtime.IPath;	37	import org.eclipse.core.runtime.IPath;
36	import org.eclipse.core.runtime.IProgressMonitor;	38	import org.eclipse.core.runtime.IProgressMonitor;
Lines 76-82 Link Here
76	import org.eclipse.jdt.ui.jarpackager.IJarDescriptionWriter;	78	import org.eclipse.jdt.ui.jarpackager.IJarDescriptionWriter;
77	import org.eclipse.jdt.ui.jarpackager.IJarExportRunnable;	79	import org.eclipse.jdt.ui.jarpackager.IJarExportRunnable;
78	import org.eclipse.jdt.ui.jarpackager.JarPackageData;	80	import org.eclipse.jdt.ui.jarpackager.JarPackageData;
79	import org.eclipse.jdt.ui.jarpackager.JarWriter3;
80		81
81	import org.eclipse.jdt.internal.ui.IJavaStatusConstants;	82	import org.eclipse.jdt.internal.ui.IJavaStatusConstants;
82	import org.eclipse.jdt.internal.ui.JavaPlugin;	83	import org.eclipse.jdt.internal.ui.JavaPlugin;
Lines 100-106 Link Here
100	}	101	}
101	}	102	}
102		103
103	private JarWriter3 fJarWriter;	104	private JarBuilder fJarBuilder;
104	private JarPackageData fJarPackage;	105	private JarPackageData fJarPackage;
105	private JarPackageData[] fJarPackages;	106	private JarPackageData[] fJarPackages;
106	private Shell fParentShell;	107	private Shell fParentShell;
Lines 206-214 Link Here
206	continue;	207	continue;
207	}	208	}
208		209
209	// Should not happen since we only export source files	210	if (resource == null) {
210	if (resource == null)	211	if (element instanceof IPackageFragmentRoot) {
		212	IPackageFragmentRoot root= (IPackageFragmentRoot) element;
		213	if (root.isArchive()) {
		214	try {
		215	ZipFile file= JarPackagerUtil.getArchiveFile(root.getPath());
		216	if (file != null)
		217	count+= file.size();
		218	} catch (CoreException e) {
		219	JavaPlugin.log(e);
		220	}
		221	}
		222	}
211	continue;	223	continue;
		224	}
212	}	225	}
213	else	226	else
214	resource= (IResource)element;	227	resource= (IResource)element;
Lines 340-347 Link Here
340	}	353	}
341		354
342	private void exportJavaElement(IProgressMonitor progressMonitor, IJavaElement je) throws InterruptedException {	355	private void exportJavaElement(IProgressMonitor progressMonitor, IJavaElement je) throws InterruptedException {
343	if (je.getElementType() == IJavaElement.PACKAGE_FRAGMENT_ROOT && ((IPackageFragmentRoot)je).isArchive())	356	if (je.getElementType() == IJavaElement.PACKAGE_FRAGMENT_ROOT && ((IPackageFragmentRoot)je).isArchive()) {
		357	fJarBuilder.addJar((IPackageFragmentRoot) je, progressMonitor);
344	return;	358	return;
		359	}
345		360
346	Object[] children= fJavaElementContentProvider.getChildren(je);	361	Object[] children= fJavaElementContentProvider.getChildren(je);
347	for (int i= 0; i < children.length; i++)	362	for (int i= 0; i < children.length; i++)
Lines 365-371 Link Here
365	try {	380	try {
366	IPath destinationPath= resource.getFullPath().removeFirstSegments(leadingSegmentsToRemove);	381	IPath destinationPath= resource.getFullPath().removeFirstSegments(leadingSegmentsToRemove);
367	progressMonitor.subTask(Messages.format(JarPackagerMessages.JarFileExportOperation_exporting, destinationPath.toString()));	382	progressMonitor.subTask(Messages.format(JarPackagerMessages.JarFileExportOperation_exporting, destinationPath.toString()));
368	fJarWriter.write((IFile)resource, destinationPath);	383	fJarBuilder.addFile((IFile)resource, destinationPath);
369	} catch (CoreException ex) {	384	} catch (CoreException ex) {
370	Throwable realEx= ex.getStatus().getException();	385	Throwable realEx= ex.getStatus().getException();
371	if (realEx instanceof ZipException && realEx.getMessage() != null && realEx.getMessage().startsWith("duplicate entry:")) //$NON-NLS-1$	386	if (realEx instanceof ZipException && realEx.getMessage() != null && realEx.getMessage().startsWith("duplicate entry:")) //$NON-NLS-1$
Lines 428-434 Link Here
428	\|\| (fJarPackage.areJavaFilesExported() && (isNonJavaResource \|\| (pkgRoot != null && !isClassFile(resource)) \|\| (isInClassFolder && isClassFile(resource) && !fJarPackage.areClassFilesExported())))) {	443	\|\| (fJarPackage.areJavaFilesExported() && (isNonJavaResource \|\| (pkgRoot != null && !isClassFile(resource)) \|\| (isInClassFolder && isClassFile(resource) && !fJarPackage.areClassFilesExported())))) {
429	try {	444	try {
430	progressMonitor.subTask(Messages.format(JarPackagerMessages.JarFileExportOperation_exporting, destinationPath.toString()));	445	progressMonitor.subTask(Messages.format(JarPackagerMessages.JarFileExportOperation_exporting, destinationPath.toString()));
431	fJarWriter.write((IFile) resource, destinationPath);	446	fJarBuilder.addFile((IFile)resource, destinationPath);
432	} catch (CoreException ex) {	447	} catch (CoreException ex) {
433	Throwable realEx= ex.getStatus().getException();	448	Throwable realEx= ex.getStatus().getException();
434	if (realEx instanceof ZipException && realEx.getMessage() != null && realEx.getMessage().startsWith("duplicate entry:")) //$NON-NLS-1$	449	if (realEx instanceof ZipException && realEx.getMessage() != null && realEx.getMessage().startsWith("duplicate entry:")) //$NON-NLS-1$
Lines 462-468 Link Here
462	IFile file= (IFile)iter.next();	477	IFile file= (IFile)iter.next();
463	IPath classFilePath= baseDestinationPath.append(file.getName());	478	IPath classFilePath= baseDestinationPath.append(file.getName());
464	progressMonitor.subTask(Messages.format(JarPackagerMessages.JarFileExportOperation_exporting, classFilePath.toString()));	479	progressMonitor.subTask(Messages.format(JarPackagerMessages.JarFileExportOperation_exporting, classFilePath.toString()));
465	fJarWriter.write(file, classFilePath);	480	fJarBuilder.addFile(file, classFilePath);
466	}	481	}
467	} catch (CoreException ex) {	482	} catch (CoreException ex) {
468	addToStatus(ex);	483	addToStatus(ex);
Lines 857-864 Link Here
857	buildProjects(subProgressMonitor);	872	buildProjects(subProgressMonitor);
858	} else	873	} else
859	progressMonitor.beginTask("", totalWork); //$NON-NLS-1$	874	progressMonitor.beginTask("", totalWork); //$NON-NLS-1$
860		875
861	fJarWriter= fJarPackage.createJarWriter3(fParentShell);	876	fJarBuilder = fJarPackage.getJarBuilder();
		877	fJarPackage.setManifestProvider(fJarBuilder.getManifestProvider());
		878	fJarBuilder.open(fJarPackage, fParentShell, fStatus);
		879
862	exportSelectedElements(progressMonitor);	880	exportSelectedElements(progressMonitor);
863	if (getStatus().getSeverity() != IStatus.ERROR) {	881	if (getStatus().getSeverity() != IStatus.ERROR) {
864	progressMonitor.subTask(JarPackagerMessages.JarFileExportOperation_savingFiles);	882	progressMonitor.subTask(JarPackagerMessages.JarFileExportOperation_savingFiles);
Lines 868-875 Link Here
868	addToStatus(ex);	886	addToStatus(ex);
869	} finally {	887	} finally {
870	try {	888	try {
871	if (fJarWriter != null)	889	if (fJarBuilder != null)
872	fJarWriter.close();	890	fJarBuilder.close();
873	} catch (CoreException ex) {	891	} catch (CoreException ex) {
874	addToStatus(ex);	892	addToStatus(ex);
875	}	893	}

Lines 1-5 Link Here

(-)ui/org/eclipse/jdt/ui/tests/AutomatedSuite.java (-1 / +4 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2006 IBM Corporation and others.	2	* Copyright (c) 2000, 2007 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 21-26 Link Here
21	import org.eclipse.jdt.ui.tests.buildpath.BuildpathModifierActionTest;	21	import org.eclipse.jdt.ui.tests.buildpath.BuildpathModifierActionTest;
22	import org.eclipse.jdt.ui.tests.callhierarchy.CallHierarchyContentProviderTest;	22	import org.eclipse.jdt.ui.tests.callhierarchy.CallHierarchyContentProviderTest;
23	import org.eclipse.jdt.ui.tests.core.CoreTests;	23	import org.eclipse.jdt.ui.tests.core.CoreTests;
		24	import org.eclipse.jdt.ui.tests.jarexport.JarExportTests;
24	import org.eclipse.jdt.ui.tests.packageview.PackageExplorerTests;	25	import org.eclipse.jdt.ui.tests.packageview.PackageExplorerTests;
25	import org.eclipse.jdt.ui.tests.quickfix.QuickFixTest;	26	import org.eclipse.jdt.ui.tests.quickfix.QuickFixTest;
26	import org.eclipse.jdt.ui.tests.search.SearchTest;	27	import org.eclipse.jdt.ui.tests.search.SearchTest;
Lines 67-72 Link Here
67	addTest(JUnitJUnitTests.suite());	68	addTest(JUnitJUnitTests.suite());
68		69
69	addTest(BuildpathModifierActionTest.suite());	70	addTest(BuildpathModifierActionTest.suite());
		71
		72	addTest(JarExportTests.suite());
70	}	73	}
71	}	74	}
72		75

Added Link Here

(-)ui/org/eclipse/jdt/ui/tests/jarexport/JarExportTests.java (+25 lines)
1	/*******************************************************************************
2	* Copyright (c) 2007 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.jdt.ui.tests.jarexport;
12
13	import junit.framework.Test;
14	import junit.framework.TestSuite;
15
16	public class JarExportTests {
17
18	public static Test suite() {
19	TestSuite suite= new TestSuite("Test for org.eclipse.jdt.ui.tests.jarexport");
20	//$JUnit-BEGIN$
21	suite.addTest(FatJarExportTests.allTests());
22	//$JUnit-END$
23	return suite;
24	}
25	}

Lines 50-56 Link Here

(-)ui/org/eclipse/jdt/ui/jarpackager/JarWriter3.java (-1 / +47 lines)
50		50
51	import org.eclipse.swt.widgets.Shell;	51	import org.eclipse.swt.widgets.Shell;
52		52
53
54	import org.eclipse.ltk.core.refactoring.RefactoringCore;	53	import org.eclipse.ltk.core.refactoring.RefactoringCore;
55	import org.eclipse.ltk.core.refactoring.RefactoringDescriptor;	54	import org.eclipse.ltk.core.refactoring.RefactoringDescriptor;
56	import org.eclipse.ltk.core.refactoring.RefactoringDescriptorProxy;	55	import org.eclipse.ltk.core.refactoring.RefactoringDescriptorProxy;
Lines 162-167 Link Here
162	*	161	*
163	* @throws IOException	162	* @throws IOException
164	* if an I/O error has occurred	163	* if an I/O error has occurred
		164	* @throws CoreException
165	*/	165	*/
166	protected void addDirectories(IResource resource, IPath destinationPath) throws IOException, CoreException {	166	protected void addDirectories(IResource resource, IPath destinationPath) throws IOException, CoreException {
167	IContainer parent= null;	167	IContainer parent= null;
Lines 250-255 Link Here
250	// fJarOutputStream.closeEntry();	250	// fJarOutputStream.closeEntry();
251	}	251	}
252	}	252	}
		253
		254	/**
		255	* Creates a new JarEntry with the passed path and contents, and writes it
		256	* to the current archive.
		257	*
		258	* @param contentStream the content to write
		259	* @param path the path inside the archive
		260	*
		261	* @throws IOException if an I/O error has occurred
		262	* @throws CoreException if the resource can-t be accessed
		263	*
		264	* @since 3.4
		265	*/
		266	public void addStream(InputStream contentStream, String path) throws IOException, CoreException {
		267	JarEntry newEntry= new JarEntry(path.replace(File.separatorChar, '/'));
		268	byte[] readBuffer= new byte[4096];
		269
		270	if (fJarPackage.isCompressed())
		271	newEntry.setMethod(ZipEntry.DEFLATED);
		272	// Entry is filled automatically.
		273	else {
		274	newEntry.setMethod(ZipEntry.STORED);
		275	// JarPackagerUtil.calculateCrcAndSize(newEntry, resource.getContents(false), readBuffer);
		276	}
		277
		278	long lastModified= System.currentTimeMillis();
		279
		280	// Set modification time
		281	newEntry.setTime(lastModified);
		282
		283	try {
		284	fJarOutputStream.putNextEntry(newEntry);
		285	int count;
		286	while ((count= contentStream.read(readBuffer, 0, readBuffer.length)) != -1)
		287	fJarOutputStream.write(readBuffer, 0, count);
		288	} finally {
		289	/*
		290	* Commented out because some JREs throw an NPE if a stream
		291	* is closed twice. This works because
		292	* a) putNextEntry closes the previous entry
		293	* b) closing the stream closes the last entry
		294	*/
		295	// fJarOutputStream.closeEntry();
		296	}
		297	}
253		298
254	/**	299	/**
255	* Creates a new JAR file entry containing the refactoring history.	300	* Creates a new JAR file entry containing the refactoring history.
Lines 427-432 Link Here
427	* if the meta file could not be found	472	* if the meta file could not be found
428	* @throws IOException	473	* @throws IOException
429	* if an input/output error occurs	474	* if an input/output error occurs
		475	* @throws CoreException
430	*/	476	*/
431	private void writeMetaData(final JarPackageData data, final File file, final IPath path) throws FileNotFoundException, IOException, CoreException {	477	private void writeMetaData(final JarPackageData data, final File file, final IPath path) throws FileNotFoundException, IOException, CoreException {
432	Assert.isNotNull(data);	478	Assert.isNotNull(data);

Lines 40-46 Link Here

(-)META-INF/MANIFEST.MF (-3 / +4 lines)
40	org.eclipse.jdt.internal.corext.refactoring.util;x-internal:=true,	40	org.eclipse.jdt.internal.corext.refactoring.util;x-internal:=true,
41	org.eclipse.jdt.internal.corext.template.java;x-internal:=true,	41	org.eclipse.jdt.internal.corext.template.java;x-internal:=true,
42	org.eclipse.jdt.internal.corext.util;x-friends:="org.eclipse.jdt.junit",	42	org.eclipse.jdt.internal.corext.util;x-friends:="org.eclipse.jdt.junit",
43	org.eclipse.jdt.internal.ui;x-friends:="org.eclipse.jdt.junit, org.eclipse.jdt.apt.ui",	43	org.eclipse.jdt.internal.ui;x-friends:="org.eclipse.jdt.junit,org.eclipse.jdt.apt.ui",
44	org.eclipse.jdt.internal.ui.actions;x-friends:="org.eclipse.jdt.junit",	44	org.eclipse.jdt.internal.ui.actions;x-friends:="org.eclipse.jdt.junit",
45	org.eclipse.jdt.internal.ui.browsing;x-internal:=true,	45	org.eclipse.jdt.internal.ui.browsing;x-internal:=true,
46	org.eclipse.jdt.internal.ui.callhierarchy;x-internal:=true,	46	org.eclipse.jdt.internal.ui.callhierarchy;x-internal:=true,
Lines 53-58 Link Here
53	org.eclipse.jdt.internal.ui.infoviews;x-internal:=true,	53	org.eclipse.jdt.internal.ui.infoviews;x-internal:=true,
54	org.eclipse.jdt.internal.ui.jarimport;x-internal:=true,	54	org.eclipse.jdt.internal.ui.jarimport;x-internal:=true,
55	org.eclipse.jdt.internal.ui.jarpackager;x-internal:=true,	55	org.eclipse.jdt.internal.ui.jarpackager;x-internal:=true,
		56	org.eclipse.jdt.internal.ui.jarpackagerfat;x-internal:=true,
56	org.eclipse.jdt.internal.ui.javadocexport;x-internal:=true,	57	org.eclipse.jdt.internal.ui.javadocexport;x-internal:=true,
57	org.eclipse.jdt.internal.ui.javaeditor;x-friends:="org.eclipse.jdt.junit",	58	org.eclipse.jdt.internal.ui.javaeditor;x-friends:="org.eclipse.jdt.junit",
58	org.eclipse.jdt.internal.ui.javaeditor.saveparticipant;x-internal:=true,	59	org.eclipse.jdt.internal.ui.javaeditor.saveparticipant;x-internal:=true,
Lines 87-95 Link Here
87	org.eclipse.jdt.internal.ui.text.template.contentassist;x-internal:=true,	88	org.eclipse.jdt.internal.ui.text.template.contentassist;x-internal:=true,
88	org.eclipse.jdt.internal.ui.text.template.preferences;x-internal:=true,	89	org.eclipse.jdt.internal.ui.text.template.preferences;x-internal:=true,
89	org.eclipse.jdt.internal.ui.typehierarchy;x-internal:=true,	90	org.eclipse.jdt.internal.ui.typehierarchy;x-internal:=true,
90	org.eclipse.jdt.internal.ui.util;x-friends:="org.eclipse.jdt.junit, org.eclipse.jdt.apt.ui",	91	org.eclipse.jdt.internal.ui.util;x-friends:="org.eclipse.jdt.junit,org.eclipse.jdt.apt.ui",
91	org.eclipse.jdt.internal.ui.viewsupport;x-friends:="org.eclipse.jdt.junit",	92	org.eclipse.jdt.internal.ui.viewsupport;x-friends:="org.eclipse.jdt.junit",
92	org.eclipse.jdt.internal.ui.wizards;x-friends:="org.eclipse.jdt.junit, org.eclipse.jdt.apt.ui",	93	org.eclipse.jdt.internal.ui.wizards;x-friends:="org.eclipse.jdt.junit,org.eclipse.jdt.apt.ui",
93	org.eclipse.jdt.internal.ui.wizards.buildpaths;x-internal:=true,	94	org.eclipse.jdt.internal.ui.wizards.buildpaths;x-internal:=true,
94	org.eclipse.jdt.internal.ui.wizards.buildpaths.newsourcepage;x-internal:=true,	95	org.eclipse.jdt.internal.ui.wizards.buildpaths.newsourcepage;x-internal:=true,
95	org.eclipse.jdt.internal.ui.wizards.dialogfields;x-friends:="org.eclipse.jdt.apt.ui",	96	org.eclipse.jdt.internal.ui.wizards.dialogfields;x-friends:="org.eclipse.jdt.apt.ui",

Added Link Here

(-)ui/org/eclipse/jdt/internal/ui/jarpackagerfat/FatJarPackagerMessages.properties (+28 lines)
1	###############################################################################
2	# Copyright (c) 2007 IBM Corporation and others.
3	# All rights reserved. This program and the accompanying materials
4	# are made available under the terms of the Eclipse Public License v1.0
5	# which accompanies this distribution, and is available at
6	# http://www.eclipse.org/legal/epl-v10.html
7	#
8	# Contributors:
9	# IBM Corporation - initial API and implementation
10	###############################################################################
11
12	JarPackageWizard_windowTitle= Runnable JAR Export
13	JarPackageWizard_jarExport_title= Runnable JAR Export
14	FatJarBuilder_error_exportingStream=Exporting stream to {0} failed.
15	FatJarBuilder_error_readingArchiveFile=Could not read jar file ''{0}''. Reason: {1}
16	FatJarPackageWizardPage_defaultLaunchConfigName={0} : <default>
17	FatJarPackageWizardPage_description=Select a launch configuration to use to create a runnable JAR.
18	FatJarPackageWizardPage_destinationGroupTitle=Select the export destination:
19	FatJarPackageWizardPage_error_missingClassFile=Fat Jar Export: Could not find classpath entry for '{0}'
20	FatJarPackageWizardPage_error_noMainMethod=Could not find main method from given launch configuration.
21	FatJarPackageWizardPage_launchConfigGroupTitle=Select the launch configuration:
22	JarPackageWizard_jarExportError_title= Runnable JAR Export Error
23	JarPackageWizard_jarExportError_message= Creation of runnable JAR failed
24
25	JarPackageWizardPage_title= Runnable JAR File Specification
26
27	JarWriter_error_couldNotGetXmlBuilder = Could not get XML builder
28	JarWriter_error_couldNotTransformToXML= Could not transform to XML

Added Link Here

(-)ui/org/eclipse/jdt/internal/ui/jarpackagerfat/FatJarBuilder.java (+206 lines)
1	package org.eclipse.jdt.internal.ui.jarpackagerfat;
2
3	import java.io.IOException;
4	import java.io.InputStream;
5	import java.util.Enumeration;
6	import java.util.zip.ZipEntry;
7	import java.util.zip.ZipException;
8	import java.util.zip.ZipFile;
9
10	import org.eclipse.core.runtime.CoreException;
11	import org.eclipse.core.runtime.IPath;
12	import org.eclipse.core.runtime.IProgressMonitor;
13	import org.eclipse.core.runtime.MultiStatus;
14	import org.eclipse.core.runtime.OperationCanceledException;
15
16	import org.eclipse.core.resources.IFile;
17
18	import org.eclipse.swt.widgets.Shell;
19
20	import org.eclipse.jdt.core.IPackageFragmentRoot;
21
22	import org.eclipse.jdt.internal.corext.util.Messages;
23
24	import org.eclipse.jdt.ui.jarpackager.IManifestProvider;
25	import org.eclipse.jdt.ui.jarpackager.JarPackageData;
26	import org.eclipse.jdt.ui.jarpackager.JarWriter3;
27
28	import org.eclipse.jdt.internal.ui.jarpackager.JarBuilder;
29	import org.eclipse.jdt.internal.ui.jarpackager.JarPackagerUtil;
30
31	public class FatJarBuilder extends JarBuilder {
32
33	public static final String BUILDER_ID= "org.eclipse.jdt.ui.fat_jar_builder"; //$NON-NLS-1$
34
35	// private static final String PROPS_MERGEMANIFESTS= "mergemanifests"; //$NON-NLS-1$
36	// private static final String PROPS_REMOVESIGNERS= "removesigners"; //$NON-NLS-1$
37	// private static final String PROPS_MANIFESTCLASSPATH= "manifestclasspath"; //$NON-NLS-1$
38
39	private boolean fMergeManifests;
40	private boolean fRemoveSigners;
41	private String fManifestClasspath;
42
43	private JarPackageData fJarPackage;
44	private JarWriter3 fJarWriter;
45
46	/**
47	* {@inheritDoc}
48	*/
49	public String getId() {
50	return BUILDER_ID;
51	}
52
53	/**
54	* {@inheritDoc}
55	*/
56	public IManifestProvider getManifestProvider() {
57	return new FatJarManifestProvider(this);
58	}
59
60	public String getManifestClasspath() {
61	return fManifestClasspath;
62	}
63
64	public boolean isMergeManifests() {
65	return fMergeManifests;
66	}
67
68	public boolean isRemoveSigners() {
69	return fRemoveSigners;
70	}
71
72	/**
73	* {@inheritDoc}
74	*/
75	public void open(JarPackageData jarPackage, Shell displayShell, MultiStatus status) throws CoreException {
76	super.open(jarPackage, displayShell, status);
77	// ExecutableJarBuilderProperty[] jarBuilderProperties= getExecutableJarBuilderProperties();
78
79	fMergeManifests= true;//getBooleanValue(jarBuilderProperties, PROPS_MERGEMANIFESTS, true);
80	fRemoveSigners= true;//getBooleanValue(jarBuilderProperties, PROPS_REMOVESIGNERS, true);
81	fManifestClasspath= "";//getValue(jarBuilderProperties, PROPS_MANIFESTCLASSPATH, ""); //$NON-NLS-1$
82
83	fJarPackage= jarPackage;
84	fJarWriter= new JarWriter3(fJarPackage, displayShell);
85	}
86
87	/**
88	* {@inheritDoc}
89	*/
90	public void addFile(IFile resource, IPath destinationPath) throws CoreException {
91	fJarWriter.write(resource, destinationPath);
92	}
93
94	/**
95	* {@inheritDoc}
96	*/
97	public void addJar(IPackageFragmentRoot archiveRoot, IProgressMonitor progressMonitor) {
98	try {
99	ZipFile jarFile= JarPackagerUtil.getArchiveFile(archiveRoot.getPath());
100	String readableJarName= archiveRoot.getElementName();
101	addJar(readableJarName, jarFile, progressMonitor);
102	jarFile.close();
103	} catch (IOException ex) {
104	addJarWarning(archiveRoot.getElementName(), ex);
105	} catch (CoreException ex) {
106	addJarWarning(archiveRoot.getElementName(), ex);
107	}
108	}
109
110	private void addJar(String readableJarName, ZipFile jarFile, IProgressMonitor progressMonitor) {
111	Enumeration jarEntriesEnum= jarFile.entries();
112	while (jarEntriesEnum.hasMoreElements()) {
113	ZipEntry jarEntry= (ZipEntry) jarEntriesEnum.nextElement();
114	if (!jarEntry.isDirectory()) {
115	String entryName= jarEntry.getName();
116	InputStream stream= null;
117	try {
118	stream= jarFile.getInputStream(jarEntry);
119	addFile(entryName, stream);
120	stream.close();
121	} catch (IOException e) {
122	addJarWarning(readableJarName, e);
123	}
124	}
125	progressMonitor.worked(1);
126	if (progressMonitor.isCanceled())
127	throw new OperationCanceledException();
128	}
129	}
130
131	private void addFile(String destinationPath, InputStream fileStream) {
132	// Handle META-INF/MANIFEST.MF
133	if (destinationPath.equalsIgnoreCase("META-INF/MANIFEST.MF") //$NON-NLS-1$
134	\|\| (isRemoveSigners() && destinationPath.startsWith("META-INF/") && destinationPath.endsWith(".SF"))) { //$NON-NLS-1$//$NON-NLS-2$
135	return;
136	}
137	try {
138	fJarWriter.addStream(fileStream, destinationPath);
139	} catch (CoreException ex) {
140	Throwable realEx= ex.getStatus().getException();
141	if (realEx instanceof ZipException && realEx.getMessage() != null && realEx.getMessage().startsWith("duplicate entry:")) //$NON-NLS-1$
142	addWarning(ex.getMessage(), realEx);
143	else
144	addToStatus(ex);
145	} catch (IOException ex) {
146	if (ex instanceof ZipException && ex.getMessage() != null && ex.getMessage().startsWith("duplicate entry:")) {//$NON-NLS-1$
147	// ignore duplicates in META-INF (.SF, .RSA)
148	if (!destinationPath.startsWith("META-INF/")) { //$NON-NLS-1$
149	addWarning(ex.getMessage(), ex);
150	}
151	} else
152	addError(Messages.format(FatJarPackagerMessages.FatJarBuilder_error_exportingStream, destinationPath), ex);
153	}
154	}
155
156	/**
157	* {@inheritDoc}
158	*/
159	public void close() throws CoreException {
160	if (fJarWriter != null) {
161	fJarWriter.close();
162	}
163	}
164
165	private void addJarWarning(String archiveRootName, Throwable ex) {
166	addWarning(Messages.format(FatJarPackagerMessages.FatJarBuilder_error_readingArchiveFile, new Object[] {archiveRootName, ex.getLocalizedMessage()}), ex);
167	}
168
169	// private static String getValue(ExecutableJarBuilderProperty[] jarBuilderProperties, String name, String defaultValue) {
170	// String result= defaultValue;
171	// if ((name != null) && (jarBuilderProperties != null)) {
172	// for (int i= 0; i < jarBuilderProperties.length; i++) {
173	// if (name.equals(jarBuilderProperties[i].getName())) {
174	// result= jarBuilderProperties[i].getValue();
175	// break;
176	// }
177	// }
178	// }
179	// return result;
180	// }
181	//
182	// private static boolean getBooleanValue(ExecutableJarBuilderProperty[] jarBuilderProperties, String name, boolean defaultValue) {
183	// boolean result= defaultValue;
184	// if (name != null) {
185	// for (int i= 0; i < jarBuilderProperties.length; i++) {
186	// if (name.equals(jarBuilderProperties[i].getName())) {
187	// result= jarBuilderProperties[i].getBooleanValue();
188	// break;
189	// }
190	// }
191	// }
192	// return result;
193	// }
194	//
195	// private static ExecutableJarBuilderProperty[] getExecutableJarBuilderProperties() {
196	// ExecutableJarBuilderProperty[] jbProperties= {
197	// new ExecutableJarBuilderProperty(ExecutableJarBuilderProperty.PROPERTYTYPE_BOOLEAN, "mergemanifests", "true", //$NON-NLS-2$
198	// "Merge attributes from all included libs together. Use this if the output jar produces an 'SecurityException: no manifiest section for signature file entry ...'"),
199	// new ExecutableJarBuilderProperty(ExecutableJarBuilderProperty.PROPERTYTYPE_BOOLEAN, "removesigners", "true", //$NON-NLS-2$
200	// "Remove signer files (*.SF) in META-INF. Use this if the output jar produces an 'SecurityException: invalid SHA1 signature file digest for ...'"),
201	// new ExecutableJarBuilderProperty(ExecutableJarBuilderProperty.PROPERTYTYPE_STRING, "manifestclasspath", "", //$NON-NLS-2$
202	// "Define the Class-Path attribute separated by spaces. Folders must end with an '/'. Example: '. xclasses/ lib/test.jar'"), };
203	// return jbProperties;
204	// }
205
206	}