/*******************************************************************************
* Copyright (c) 2000, 2011 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
* Ferenc Hechler, ferenc_hechler@users.sourceforge.net - 83258 [jar exporter] Deploy java application as executable jar
*******************************************************************************/
package org.eclipse.jdt.internal.ui.jarpackager;
import java.lang.reflect.InvocationTargetException;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.BusyIndicator;
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.Composite;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Link;
import org.eclipse.swt.widgets.TreeItem;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.jface.dialogs.Dialog;
import org.eclipse.jface.dialogs.IDialogSettings;
import org.eclipse.jface.dialogs.IMessageProvider;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.viewers.CheckStateChangedEvent;
import org.eclipse.jface.viewers.DecoratingLabelProvider;
import org.eclipse.jface.viewers.ICheckStateListener;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerFilter;
import org.eclipse.jface.wizard.IWizardPage;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ltk.core.refactoring.RefactoringCore;
import org.eclipse.ltk.core.refactoring.history.IRefactoringHistoryService;
import org.eclipse.ltk.core.refactoring.history.RefactoringHistory;
import org.eclipse.jdt.core.IClassFile;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaModel;
import org.eclipse.jdt.core.IPackageFragment;
import org.eclipse.jdt.core.IPackageFragmentRoot;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.refactoring.descriptors.JavaRefactoringDescriptor;
import org.eclipse.jdt.ui.JavaElementComparator;
import org.eclipse.jdt.ui.JavaElementLabelProvider;
import org.eclipse.jdt.ui.ProblemsLabelDecorator;
import org.eclipse.jdt.ui.StandardJavaElementContentProvider;
import org.eclipse.jdt.ui.jarpackager.JarPackageData;
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;
/**
* Page 1 of the JAR Package wizard
*/
class JarPackageWizardPage extends AbstractJarDestinationWizardPage {
private JarPackageData fJarPackage;
private IStructuredSelection fInitialSelection;
private CheckboxTreeAndListGroup fInputGroup;
// widgets
private Button fExportClassFilesCheckbox;
private Button fExportOutputFoldersCheckbox;
private Button fExportJavaFilesCheckbox;
private Button fExportRefactoringsCheckbox;
private Link fRefactoringLink;
private Button fCompressCheckbox;
private Button fOverwriteCheckbox;
private Button fIncludeDirectoryEntriesCheckbox;
private boolean fInitiallySelecting= true;
// dialog store id constants
private static final String PAGE_NAME= "JarPackageWizardPage"; //$NON-NLS-1$
private static final String STORE_EXPORT_CLASS_FILES= PAGE_NAME + ".EXPORT_CLASS_FILES"; //$NON-NLS-1$
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_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$
private final static String STORE_INCLUDE_DIRECTORY_ENTRIES= PAGE_NAME + ".INCLUDE_DIRECTORY_ENTRIES"; //$NON-NLS-1$
// other constants
private static final int SIZING_SELECTION_WIDGET_WIDTH= 480;
private static final int SIZING_SELECTION_WIDGET_HEIGHT= 150;
/**
* 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;
fInitialSelection= selection;
}
/*
* Method declared on IDialogPage.
*/
@Override
public void createControl(final Composite parent) {
initializeDialogUnits(parent);
Composite composite= new Composite(parent, SWT.NULL);
composite.setLayout(new GridLayout());
composite.setLayoutData(
new GridData(GridData.VERTICAL_ALIGN_FILL | GridData.HORIZONTAL_ALIGN_FILL));
createPlainLabel(composite, JarPackagerMessages.JarPackageWizardPage_whatToExport_label);
createInputGroup(composite);
createExportTypeGroup(composite);
new Label(composite, SWT.NONE); // vertical spacer
createPlainLabel(composite, JarPackagerMessages.JarPackageWizardPage_whereToExport_label);
createDestinationGroup(composite);
createPlainLabel(composite, JarPackagerMessages.JarPackageWizardPage_options_label);
createOptionsGroup(composite);
restoreResourceSpecificationWidgetValues(); // superclass API defines this hook
restoreWidgetValues();
if (fInitialSelection != null)
BusyIndicator.showWhile(parent.getDisplay(), new Runnable() {
public void run() {
setupBasedOnInitialSelections();
}
});
setControl(composite);
update();
fRefactoringLink.setEnabled(fExportRefactoringsCheckbox.getSelection());
giveFocusToDestination();
Dialog.applyDialogFont(composite);
PlatformUI.getWorkbench().getHelpSystem().setHelp(composite, IJavaHelpContextIds.JARPACKAGER_WIZARD_PAGE);
}
/**
* Create the export options specification widgets.
*
* @param parent org.eclipse.swt.widgets.Composite
*/
@Override
protected void createOptionsGroup(Composite parent) {
Composite optionsGroup= new Composite(parent, SWT.NONE);
GridLayout layout= new GridLayout();
layout.marginHeight= 0;
optionsGroup.setLayout(layout);
fCompressCheckbox= new Button(optionsGroup, SWT.CHECK | SWT.LEFT);
fCompressCheckbox.setText(JarPackagerMessages.JarPackageWizardPage_compress_text);
fCompressCheckbox.addListener(SWT.Selection, this);
fIncludeDirectoryEntriesCheckbox= new Button(optionsGroup, SWT.CHECK | SWT.LEFT);
fIncludeDirectoryEntriesCheckbox.setText(JarPackagerMessages.JarPackageWizardPage_includeDirectoryEntries_text);
fIncludeDirectoryEntriesCheckbox.addListener(SWT.Selection, this);
fOverwriteCheckbox= new Button(optionsGroup, SWT.CHECK | SWT.LEFT);
fOverwriteCheckbox.setText(JarPackagerMessages.JarPackageWizardPage_overwrite_text);
fOverwriteCheckbox.addListener(SWT.Selection, this);
}
/**
* 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.
*
* @return an iterator over the collection of elements currently selected for export
*/
@Override
protected Iterator<Object> getSelectedResourcesIterator() {
return fInputGroup.getAllCheckedListItems();
}
/**
* Persists resource specification control setting that are to be restored
* in the next instance of this page. Subclasses wishing to persist
* settings for their controls should extend the hook method
* <code>internalSaveWidgetValues</code>.
*/
@Override
public final void saveWidgetValues() {
super.saveWidgetValues();
// update directory names history
IDialogSettings settings= getDialogSettings();
if (settings != null) {
settings.put(STORE_EXPORT_CLASS_FILES, fJarPackage.areClassFilesExported());
settings.put(STORE_EXPORT_OUTPUT_FOLDERS, fJarPackage.areOutputFoldersExported());
settings.put(STORE_EXPORT_JAVA_FILES, fJarPackage.areJavaFilesExported());
// options
settings.put(STORE_REFACTORINGS, fJarPackage.isRefactoringAware());
settings.put(STORE_COMPRESS, fJarPackage.isCompressed());
settings.put(STORE_INCLUDE_DIRECTORY_ENTRIES, fJarPackage.areDirectoryEntriesIncluded());
settings.put(STORE_OVERWRITE, fJarPackage.allowOverwrite());
}
// Allow subclasses to save values
internalSaveWidgetValues();
}
/**
* Hook method for subclasses to persist their settings.
*/
@Override
protected void internalSaveWidgetValues() {
}
/**
* Hook method for restoring widget values to the values that they held
* last time this wizard was used to completion.
*/
@Override
protected void restoreWidgetValues() {
if (!((JarPackageWizard)getWizard()).isInitializingFromJarPackage())
initializeJarPackage();
fExportClassFilesCheckbox.setSelection(fJarPackage.areClassFilesExported());
fExportOutputFoldersCheckbox.setSelection(fJarPackage.areOutputFoldersExported());
fExportJavaFilesCheckbox.setSelection(fJarPackage.areJavaFilesExported());
super.restoreWidgetValues();
// options
if (fExportRefactoringsCheckbox != null)
fExportRefactoringsCheckbox.setSelection(fJarPackage.isRefactoringAware());
fCompressCheckbox.setSelection(fJarPackage.isCompressed());
fIncludeDirectoryEntriesCheckbox.setSelection(fJarPackage.areDirectoryEntriesIncluded());
fOverwriteCheckbox.setSelection(fJarPackage.allowOverwrite());
}
/**
* Initializes the JAR package from last used wizard page values.
*/
@Override
protected void initializeJarPackage() {
super.initializeJarPackage();
IDialogSettings settings= getDialogSettings();
if (settings != null) {
// source
fJarPackage.setElements(getSelectedElements());
fJarPackage.setExportClassFiles(settings.getBoolean(STORE_EXPORT_CLASS_FILES));
fJarPackage.setExportOutputFolders(settings.getBoolean(STORE_EXPORT_OUTPUT_FOLDERS));
fJarPackage.setExportJavaFiles(settings.getBoolean(STORE_EXPORT_JAVA_FILES));
// options
fJarPackage.setRefactoringAware(settings.getBoolean(STORE_REFACTORINGS));
fJarPackage.setCompress(settings.getBoolean(STORE_COMPRESS));
fJarPackage.setIncludeDirectoryEntries(settings.getBoolean(STORE_INCLUDE_DIRECTORY_ENTRIES));
fJarPackage.setOverwrite(settings.getBoolean(STORE_OVERWRITE));
}
}
/**
* Stores the widget values in the JAR package.
*/
@Override
protected void updateModel() {
if (getControl() == null)
return;
// source
if (fExportClassFilesCheckbox.getSelection() && !fJarPackage.areClassFilesExported())
fExportOutputFoldersCheckbox.setSelection(false);
if (fExportOutputFoldersCheckbox.getSelection() && !fJarPackage.areOutputFoldersExported())
fExportClassFilesCheckbox.setSelection(false);
fJarPackage.setExportClassFiles(fExportClassFilesCheckbox.getSelection());
fJarPackage.setExportOutputFolders(fExportOutputFoldersCheckbox.getSelection());
fJarPackage.setExportJavaFiles(fExportJavaFilesCheckbox.getSelection());
fJarPackage.setElements(getSelectedElements());
super.updateModel();
// options
if (fExportRefactoringsCheckbox != null)
fJarPackage.setRefactoringAware(fExportRefactoringsCheckbox.getSelection());
else
fJarPackage.setRefactoringAware(false);
fJarPackage.setCompress(fCompressCheckbox.getSelection());
fJarPackage.setIncludeDirectoryEntries(fIncludeDirectoryEntriesCheckbox.getSelection());
fJarPackage.setOverwrite(fOverwriteCheckbox.getSelection());
}
/**
* Returns the resource for the specified path.
*
* @param path the path for which the resource should be returned
* @return the resource specified by the path or <code>null</code>
*/
protected IResource findResource(IPath path) {
IWorkspace workspace= ResourcesPlugin.getWorkspace();
IStatus result= workspace.validatePath(
path.toString(),
IResource.ROOT | IResource.PROJECT | IResource.FOLDER | IResource.FILE);
if (result.isOK() && workspace.getRoot().exists(path))
return workspace.getRoot().findMember(path);
return null;
}
/**
* Creates the checkbox tree and list for selecting resources.
*
* @param parent the parent control
*/
protected void createInputGroup(Composite parent) {
int labelFlags= JavaElementLabelProvider.SHOW_BASICS
| JavaElementLabelProvider.SHOW_OVERLAY_ICONS
| JavaElementLabelProvider.SHOW_SMALL_ICONS;
ITreeContentProvider treeContentProvider=
new StandardJavaElementContentProvider() {
@Override
public boolean hasChildren(Object element) {
// prevent the + from being shown in front of packages
return !(element instanceof IPackageFragment) && super.hasChildren(element);
}
};
final DecoratingLabelProvider provider= new DecoratingLabelProvider(new JavaElementLabelProvider(labelFlags), new ProblemsLabelDecorator(null));
fInputGroup= new CheckboxTreeAndListGroup(
parent,
JavaCore.create(ResourcesPlugin.getWorkspace().getRoot()),
treeContentProvider,
provider,
new StandardJavaElementContentProvider(),
provider,
SWT.NONE,
SIZING_SELECTION_WIDGET_WIDTH,
SIZING_SELECTION_WIDGET_HEIGHT) {
@Override
protected void setTreeChecked(final Object element, final boolean state) {
if (fInitiallySelecting && element instanceof IResource) {
final IResource resource= (IResource) element;
if (resource.getName().charAt(0) == '.')
return;
}
super.setTreeChecked(element, state);
}
};
fInputGroup.addTreeFilter(new EmptyInnerPackageFilter());
fInputGroup.setTreeComparator(new JavaElementComparator());
fInputGroup.setListComparator(new JavaElementComparator());
fInputGroup.addTreeFilter(new ContainerFilter(ContainerFilter.FILTER_NON_CONTAINERS));
fInputGroup.addTreeFilter(new ViewerFilter() {
@Override
public boolean select(Viewer viewer, Object p, Object element) {
if (element instanceof IPackageFragmentRoot) {
IPackageFragmentRoot root= (IPackageFragmentRoot) element;
return !root.isArchive() && !root.isExternal();
}
return true;
}
});
fInputGroup.addListFilter(new ContainerFilter(ContainerFilter.FILTER_CONTAINERS));
fInputGroup.getTree().addListener(SWT.MouseUp, this);
fInputGroup.getTable().addListener(SWT.MouseUp, this);
SWTUtil.setAccessibilityText(fInputGroup.getTree(), JarPackagerMessages.JarPackageWizardPage_tree_accessibility_message);
SWTUtil.setAccessibilityText(fInputGroup.getTable(), JarPackagerMessages.JarPackageWizardPage_table_accessibility_message);
ICheckStateListener listener = new ICheckStateListener() {
public void checkStateChanged(CheckStateChangedEvent event) {
update();
}
};
fInputGroup.addCheckStateListener(listener);
}
/**
* Creates the export type controls.
*
* @param parent
* the parent control
*/
protected void createExportTypeGroup(Composite parent) {
Composite optionsGroup= new Composite(parent, SWT.NONE);
GridLayout layout= new GridLayout();
layout.marginHeight= 0;
optionsGroup.setLayout(layout);
fExportClassFilesCheckbox= new Button(optionsGroup, SWT.CHECK | SWT.LEFT);
fExportClassFilesCheckbox.setText(JarPackagerMessages.JarPackageWizardPage_exportClassFiles_text);
fExportClassFilesCheckbox.addListener(SWT.Selection, this);
fExportOutputFoldersCheckbox= new Button(optionsGroup, SWT.CHECK | SWT.LEFT);
fExportOutputFoldersCheckbox.setText(JarPackagerMessages.JarPackageWizardPage_exportOutputFolders_text);
fExportOutputFoldersCheckbox.addListener(SWT.Selection, this);
fExportJavaFilesCheckbox= new Button(optionsGroup, SWT.CHECK | SWT.LEFT);
fExportJavaFilesCheckbox.setText(JarPackagerMessages.JarPackageWizardPage_exportJavaFiles_text);
fExportJavaFilesCheckbox.addListener(SWT.Selection, this);
Composite refactoringsGroup= new Composite(optionsGroup, SWT.NONE);
layout= new GridLayout();
layout.horizontalSpacing= 0;
layout.marginWidth= 0;
layout.marginHeight= 0;
layout.numColumns= 2;
refactoringsGroup.setLayout(layout);
fExportRefactoringsCheckbox= new Button(refactoringsGroup, SWT.CHECK | SWT.LEFT);
fExportRefactoringsCheckbox.setText(JarPackagerMessages.JarPackageWizardPage_refactorings_text);
fExportRefactoringsCheckbox.addListener(SWT.Selection, this);
fRefactoringLink= new Link(refactoringsGroup, SWT.WRAP);
fRefactoringLink.setText(JarPackagerMessages.JarPackageWizardPage_configure_label);
fRefactoringLink.addSelectionListener(new SelectionAdapter() {
@Override
public void widgetSelected(SelectionEvent event) {
openRefactoringDialog();
}
});
fRefactoringLink.setToolTipText(JarPackagerMessages.JarPackageWizardPage_configure_tooltip);
GridData data= new GridData(GridData.BEGINNING | GridData.GRAB_HORIZONTAL);
fRefactoringLink.setLayoutData(data);
fExportRefactoringsCheckbox.addSelectionListener(new SelectionAdapter() {
@Override
public void widgetSelected(SelectionEvent event) {
fRefactoringLink.setEnabled(fExportRefactoringsCheckbox.getSelection());
}
});
}
/**
* Opens the dialog to configure refactorings.
*/
protected void openRefactoringDialog() {
final RefactoringHistory[] history= { null};
final IRefactoringHistoryService service= RefactoringCore.getHistoryService();
try {
service.connect();
final Set<IProject> set= new HashSet<IProject>();
final Object[] elements= fJarPackage.getElements();
for (int index= 0; index < elements.length; index++) {
if (elements[index] instanceof IAdaptable) {
final IAdaptable adaptable= (IAdaptable) elements[index];
final IResource resource= (IResource) adaptable.getAdapter(IResource.class);
if (resource != null)
set.add(resource.getProject());
}
}
try {
getContainer().run(false, true, new IRunnableWithProgress() {
public void run(final IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
history[0]= service.getRefactoringHistory(set.toArray(new IProject[set.size()]), 0, Long.MAX_VALUE, JavaRefactoringDescriptor.JAR_MIGRATION, monitor);
}
});
} catch (InvocationTargetException exception) {
ExceptionHandler.handle(exception, getShell(), JarPackagerMessages.JarPackageWizardPage_error_caption, JarPackagerMessages.JarPackageWizardPage_error_label);
return;
} catch (InterruptedException exception) {
return;
}
new JarRefactoringDialog(getShell(), getDialogSettings(), fJarPackage, history[0]).open();
updatePageCompletion();
} finally {
service.disconnect();
}
}
/**
* Updates the enablement of this page's controls. Subclasses may extend.
*/
@Override
protected void updateWidgetEnablements() {
if (fExportRefactoringsCheckbox != null) {
final boolean selection= fExportRefactoringsCheckbox.getSelection();
fIncludeDirectoryEntriesCheckbox.setEnabled(!selection);
if (selection) {
fIncludeDirectoryEntriesCheckbox.setSelection(true);
fJarPackage.setIncludeDirectoryEntries(true);
}
}
}
/*
* Overrides method from IJarPackageWizardPage
*/
@Override
public boolean isPageComplete() {
boolean complete= validateSourceGroup();
complete= validateDestinationGroup() && complete;
complete= validateOptionsGroup() && complete;
if (complete)
setErrorMessage(null);
return complete;
}
@Override
protected void updatePageCompletion() {
boolean pageComplete= isPageComplete();
setPageComplete(pageComplete);
if (pageComplete)
setErrorMessage(null);
updateRefactoringMessage();
}
protected void updateRefactoringMessage() {
String currentMessage= getMessage();
if (fJarPackage.isRefactoringAware() && fJarPackage.getRefactoringDescriptors().length == 0) {
if (currentMessage == null)
setMessage(JarPackagerMessages.JarPackageWizardPage_no_refactorings_selected, IMessageProvider.INFORMATION);
} else if (JarPackagerMessages.JarPackageWizardPage_no_refactorings_selected.equals(currentMessage))
setMessage(null);
}
/*
* Overrides method from WizardDataTransferPage
*/
@Override
protected boolean validateOptionsGroup() {
return true;
}
/*
* Overrides method from WizardDataTransferPage
*/
@Override
protected boolean validateSourceGroup() {
if (!(fExportClassFilesCheckbox.getSelection() || fExportOutputFoldersCheckbox.getSelection() || fExportJavaFilesCheckbox.getSelection())) {
setErrorMessage(JarPackagerMessages.JarPackageWizardPage_error_noExportTypeChecked);
return false;
}
if (getSelectedResources().size() == 0) {
if (getErrorMessage() != null)
setErrorMessage(null);
return false;
}
if (fExportClassFilesCheckbox.getSelection() || fExportOutputFoldersCheckbox.getSelection())
return true;
// Source file only export - check if there are source files
Iterator<Object> iter= getSelectedResourcesIterator();
while (iter.hasNext()) {
Object element= iter.next();
if (element instanceof IClassFile) {
IPackageFragmentRoot root= (IPackageFragmentRoot)((IClassFile)element).getAncestor(IJavaElement.PACKAGE_FRAGMENT_ROOT);
if (root == null)
continue;
IClasspathEntry cpEntry;
try {
cpEntry= root.getRawClasspathEntry();
} catch (JavaModelException e) {
continue;
}
if (cpEntry.getEntryKind() == IClasspathEntry.CPE_LIBRARY) {
return true;
}
} else {
return true;
}
}
if (getErrorMessage() != null)
setErrorMessage(null);
return false;
}
/**
* Creates a file resource handle for the file with the given workspace path.
* This method does not create the file resource; this is the responsibility
* of <code>createFile</code>.
*
* @param filePath the path of the file resource to create a handle for
* @return the new file resource handle
*/
protected IFile createFileHandle(IPath filePath) {
if (filePath.isValidPath(filePath.toString()) && filePath.segmentCount() >= 2)
return ResourcesPlugin.getWorkspace().getRoot().getFile(filePath);
else
return null;
}
/*
* Overrides method from WizardExportResourcePage
*/
@Override
protected void setupBasedOnInitialSelections() {
Iterator<?> iterator= fInitialSelection.iterator();
while (iterator.hasNext()) {
Object selectedElement= iterator.next();
if (selectedElement instanceof IResource && !((IResource)selectedElement).isAccessible())
continue;
if (selectedElement instanceof IJavaElement && !((IJavaElement)selectedElement).exists())
continue;
if (selectedElement instanceof ICompilationUnit || selectedElement instanceof IClassFile || selectedElement instanceof IFile)
fInputGroup.initialCheckListItem(selectedElement);
else {
if (selectedElement instanceof IFolder) {
// Convert resource to Java element if possible
IJavaElement je= JavaCore.create((IResource)selectedElement);
if (je != null && je.exists() && je.getJavaProject().isOnClasspath((IResource)selectedElement))
selectedElement= je;
}
try {
fInputGroup.initialCheckTreeItem(selectedElement);
} finally {
fInitiallySelecting= false;
}
}
}
TreeItem[] items= fInputGroup.getTree().getItems();
int i= 0;
while (i < items.length && !items[i].getChecked())
i++;
if (i < items.length) {
fInputGroup.getTree().setSelection(new TreeItem[] {items[i]});
fInputGroup.getTree().showSelection();
fInputGroup.populateListViewer(items[i].getData());
}
}
/*
* Method declared on IWizardPage.
*/
@Override
public void setPreviousPage(IWizardPage page) {
super.setPreviousPage(page);
if (getControl() != null)
updatePageCompletion();
}
Object[] getSelectedElementsWithoutContainedChildren() {
Set<Object> closure= removeContainedChildren(fInputGroup.getWhiteCheckedTreeItems());
closure.addAll(getExportedNonContainers());
return closure.toArray();
}
private Set<Object> removeContainedChildren(Set<Object> elements) {
Set<Object> newList= new HashSet<Object>(elements.size());
Set<Object> javaElementResources= getCorrespondingContainers(elements);
Iterator<Object> iter= elements.iterator();
boolean removedOne= false;
while (iter.hasNext()) {
Object element= iter.next();
Object parent;
if (element instanceof IResource)
parent= ((IResource)element).getParent();
else if (element instanceof IJavaElement) {
parent= ((IJavaElement)element).getParent();
if (parent instanceof IPackageFragmentRoot) {
IPackageFragmentRoot pkgRoot= (IPackageFragmentRoot)parent;
try {
if (pkgRoot.getCorrespondingResource() instanceof IProject)
parent= pkgRoot.getJavaProject();
} catch (JavaModelException ex) {
// leave parent as is
}
}
}
else {
// unknown type
newList.add(element);
continue;
}
if (element instanceof IJavaModel || ((!(parent instanceof IJavaModel)) && (elements.contains(parent) || javaElementResources.contains(parent))))
removedOne= true;
else
newList.add(element);
}
if (removedOne)
return removeContainedChildren(newList);
else
return newList;
}
private Set<Object> getExportedNonContainers() {
Set<Object> whiteCheckedTreeItems= fInputGroup.getWhiteCheckedTreeItems();
Set<Object> exportedNonContainers= new HashSet<Object>(whiteCheckedTreeItems.size());
Set<Object> javaElementResources= getCorrespondingContainers(whiteCheckedTreeItems);
Iterator<Object> iter= fInputGroup.getAllCheckedListItems();
while (iter.hasNext()) {
Object element= iter.next();
Object parent= null;
if (element instanceof IResource)
parent= ((IResource)element).getParent();
else if (element instanceof IJavaElement)
parent= ((IJavaElement)element).getParent();
if (!whiteCheckedTreeItems.contains(parent) && !javaElementResources.contains(parent))
exportedNonContainers.add(element);
}
return exportedNonContainers;
}
/*
* Create a list with the folders / projects that correspond
* to the Java elements (Java project, package, package root)
*/
private Set<Object> getCorrespondingContainers(Set<Object> elements) {
Set<Object> javaElementResources= new HashSet<Object>(elements.size());
Iterator<Object> iter= elements.iterator();
while (iter.hasNext()) {
Object element= iter.next();
if (element instanceof IJavaElement) {
IJavaElement je= (IJavaElement)element;
int type= je.getElementType();
if (type == IJavaElement.JAVA_PROJECT || type == IJavaElement.PACKAGE_FRAGMENT || type == IJavaElement.PACKAGE_FRAGMENT_ROOT) {
// exclude default package since it is covered by the root
if (!(type == IJavaElement.PACKAGE_FRAGMENT && ((IPackageFragment)element).isDefaultPackage())) {
Object resource;
try {
resource= je.getCorrespondingResource();
} catch (JavaModelException ex) {
resource= null;
}
if (resource != null)
javaElementResources.add(resource);
}
}
}
}
return javaElementResources;
}
private Object[] getSelectedElements() {
return getSelectedResources().toArray();
}
}