| package org.eclipse.ui.wizards.datatransfer; |
| |
| /* |
| * (c) Copyright IBM Corp. 2000, 2001. |
| * All Rights Reserved. |
| */ |
| import java.io.File; |
| import java.io.IOException; |
| import java.util.List; |
| import java.util.zip.ZipException; |
| import java.util.zip.ZipFile; |
| |
| import org.eclipse.jface.dialogs.IDialogSettings; |
| import org.eclipse.jface.viewers.ISelectionChangedListener; |
| import org.eclipse.jface.viewers.IStructuredSelection; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.layout.GridData; |
| import org.eclipse.swt.layout.GridLayout; |
| import org.eclipse.swt.widgets.*; |
| import org.eclipse.ui.IWorkbench; |
| import org.eclipse.ui.dialogs.FileSystemElement; |
| |
| /** |
| * Page 1 of the base resource import-from-zip Wizard. |
| * |
| * Note that importing from .jar is identical to importing from .zip, so |
| * all references to .zip in this class are equally applicable to .jar |
| * references. |
| * @deprecated use WizardZipFileResourceImportPage1 |
| */ |
| /*package*/ class WizardZipFileImportPage1 extends WizardFileSystemImportPage1 implements ISelectionChangedListener, Listener { |
| private ZipFileStructureProvider providerCache; |
| |
| // constants |
| private static final int COMBO_HISTORY_LENGTH = 5; |
| private static final String FILE_IMPORT_MASK = "*.jar;*.zip";//$NON-NLS-1$ |
| |
| // dialog store id constants |
| private final static String STORE_SOURCE_NAMES_ID = "WizardZipFileImportPage1.STORE_SOURCE_NAMES_ID";//$NON-NLS-1$ |
| private final static String STORE_IMPORT_ALL_RESOURCES_ID = "WizardZipFileImportPage1.STORE_IMPORT_ALL_ENTRIES_ID";//$NON-NLS-1$ |
| private final static String STORE_OVERWRITE_EXISTING_RESOURCES_ID = "WizardZipFileImportPage1.STORE_OVERWRITE_EXISTING_RESOURCES_ID";//$NON-NLS-1$ |
| private final static String STORE_SELECTED_TYPES_ID = "WizardZipFileImportPage1.STORE_SELECTED_TYPES_ID";//$NON-NLS-1$ |
| /** |
| * Creates an instance of this class |
| */ |
| public WizardZipFileImportPage1(IWorkbench aWorkbench, IStructuredSelection selection) { |
| super("zipFileImportPage1", aWorkbench, selection);//$NON-NLS-1$ |
| setTitle(DataTransferMessages.getString("ZipExport.exportTitle")); //$NON-NLS-1$ |
| setDescription(DataTransferMessages.getString("ZipImport.description")); //$NON-NLS-1$ |
| } |
| /** |
| * Called when the user presses the Cancel button. Return a boolean |
| * indicating permission to close the wizard. |
| */ |
| public boolean cancel() { |
| clearProviderCache(); |
| return true; |
| } |
| /** |
| * Clears the cached structure provider after first finalizing |
| * it properly. |
| */ |
| protected void clearProviderCache() { |
| if (providerCache != null) { |
| closeZipFile(providerCache.getZipFile()); |
| providerCache = null; |
| } |
| } |
| /** |
| * Attempts to close the passed zip file, and answers a boolean indicating success. |
| */ |
| protected boolean closeZipFile(ZipFile file) { |
| try { |
| file.close(); |
| } catch (IOException e) { |
| displayErrorDialog(DataTransferMessages.format("ZipImport.couldNotClose", new Object [] {file.getName()})); //$NON-NLS-1$ |
| return false; |
| } |
| |
| return true; |
| } |
| /** |
| * Create the import options specification widgets. |
| */ |
| protected void createOptionsGroup(Composite parent) { |
| // options group |
| Composite optionsGroup = new Composite(parent, SWT.NONE); |
| GridLayout layout = new GridLayout(); |
| layout.marginHeight = 0; |
| optionsGroup.setLayout(layout); |
| optionsGroup.setLayoutData(new GridData(GridData.HORIZONTAL_ALIGN_FILL | GridData.GRAB_HORIZONTAL)); |
| |
| // overwrite... checkbox |
| overwriteExistingResourcesCheckbox = new Button(optionsGroup,SWT.CHECK); |
| overwriteExistingResourcesCheckbox.setText(DataTransferMessages.getString("FileImport.overwriteExisting")); //$NON-NLS-1$ |
| } |
| /** |
| * Display the appropriate string representing a selection of the |
| * passed size. |
| */ |
| protected void displaySelectedCount(int selectedEntryCount) { |
| if (selectedEntryCount == 1) |
| detailsDescriptionLabel.setText(DataTransferMessages.getString("ImportPage.oneSelected")); //$NON-NLS-1$ |
| else |
| detailsDescriptionLabel.setText(DataTransferMessages.format("ZipImport.entriesSelected",new Object[] {String.valueOf(selectedEntryCount)})); //$NON-NLS-1$ |
| } |
| /** |
| * Answer a boolean indicating whether the specified source currently exists |
| * and is valid (ie.- proper format) |
| */ |
| protected boolean ensureSourceIsValid() { |
| ZipFile specifiedFile = getSpecifiedSourceFile(); |
| |
| if (specifiedFile == null) |
| return false; |
| |
| return closeZipFile(specifiedFile); |
| } |
| /** |
| * The Finish button was pressed. Try to do the required work now and answer |
| * a boolean indicating success. If <code>false</code> is returned then the |
| * wizard will not close. |
| */ |
| public boolean finish() { |
| if (!super.finish()) |
| return false; |
| |
| clearProviderCache(); |
| return true; |
| } |
| /** |
| * Answer the root FileSystemElement that represents the contents of the |
| * currently-specified .zip file. If this FileSystemElement is not |
| * currently defined then create and return it. |
| */ |
| protected FileSystemElement getFileSystemTree() { |
| if (getRoot() != null) |
| return getRoot(); |
| |
| ZipFile sourceFile = getSpecifiedSourceFile(); |
| if (sourceFile == null) |
| return null; |
| |
| ZipFileStructureProvider provider = getStructureProvider(sourceFile); |
| return selectFiles(provider.getRoot(),provider); |
| } |
| /** |
| * Answer the string to display as the label for the source specification field |
| */ |
| protected String getSourceLabel() { |
| return DataTransferMessages.getString("ZipExport.destinationLabel"); //$NON-NLS-1$ |
| } |
| /** |
| * Answer a handle to the zip file currently specified as being the source. |
| * Return null if this file does not exist or is not of valid format. |
| */ |
| protected ZipFile getSpecifiedSourceFile() { |
| try { |
| return new ZipFile(sourceNameField.getText()); |
| } catch (ZipException e) { |
| displayErrorDialog(DataTransferMessages.getString("ZipImport.badFormat")); //$NON-NLS-1$ |
| } catch (IOException e) { |
| displayErrorDialog(DataTransferMessages.getString("ZipImport.couldNotRead")); //$NON-NLS-1$ |
| } |
| |
| sourceNameField.setFocus(); |
| return null; |
| } |
| /** |
| * Returns a structure provider for the specified zip file. |
| */ |
| protected ZipFileStructureProvider getStructureProvider(ZipFile targetZip) { |
| if (providerCache == null) |
| providerCache = new ZipFileStructureProvider(targetZip); |
| else if (!providerCache.getZipFile().getName().equals(targetZip.getName())) { |
| clearProviderCache(); // ie.- new value, so finalize&remove old value |
| providerCache = new ZipFileStructureProvider(targetZip); |
| } else if (!providerCache.getZipFile().equals(targetZip)) |
| closeZipFile(targetZip); // ie.- duplicate handle to same .zip |
| |
| return providerCache; |
| } |
| /** |
| * Open a FileDialog so that the user can specify the source |
| * file to import from |
| */ |
| protected void handleSourceBrowseButtonPressed() { |
| String selectedFile = queryZipFileToImport(); |
| |
| if (selectedFile != null) { |
| if (!selectedFile.equals(sourceNameField.getText())) { |
| resetSelection(); |
| sourceNameField.setText(selectedFile); |
| } |
| } |
| } |
| /** |
| * Recursively import all resources starting at the user-specified source location. |
| * Answer a boolean indicating success. |
| */ |
| protected boolean importAllResources() { |
| ZipFileStructureProvider structureProvider = getStructureProvider(getSpecifiedSourceFile()); |
| |
| return executeImportOperation( |
| new ImportOperation( |
| getContainerFullPath(), |
| structureProvider.getRoot(), |
| structureProvider, |
| this)); |
| } |
| /** |
| * Import the resources with extensions as specified by the user |
| */ |
| protected boolean importResources(List fileSystemObjects) { |
| ZipFileStructureProvider structureProvider = getStructureProvider(getSpecifiedSourceFile()); |
| |
| return executeImportOperation( |
| new ImportOperation( |
| getContainerFullPath(), |
| structureProvider.getRoot(), |
| structureProvider, |
| this, |
| fileSystemObjects)); |
| } |
| /** |
| * Initializes the specified operation appropriately. |
| */ |
| protected void initializeOperation(ImportOperation op) { |
| op.setOverwriteResources(overwriteExistingResourcesCheckbox.getSelection()); |
| } |
| /** |
| * Opens a file selection dialog and returns a string representing the |
| * selected file, or <code>null</code> if the dialog was canceled. |
| */ |
| protected String queryZipFileToImport() { |
| FileDialog dialog = new FileDialog(sourceNameField.getShell(),SWT.OPEN); |
| dialog.setFilterExtensions(new String[] {FILE_IMPORT_MASK}); |
| |
| String currentSourceString = sourceNameField.getText(); |
| int lastSeparatorIndex = currentSourceString.lastIndexOf(File.separator); |
| if (lastSeparatorIndex != -1) |
| dialog.setFilterPath(currentSourceString.substring(0,lastSeparatorIndex)); |
| |
| return dialog.open(); |
| } |
| /** |
| * Use the dialog store to restore widget values to the values that they held |
| * last time this wizard was used to completion |
| */ |
| protected void restoreWidgetValues() { |
| IDialogSettings settings = getDialogSettings(); |
| if(settings != null) { |
| String[] sourceNames = settings.getArray(STORE_SOURCE_NAMES_ID); |
| if (sourceNames == null) |
| return; // ie.- no settings stored |
| |
| // set all/specific types radios and related enablements |
| if (settings.getBoolean(STORE_IMPORT_ALL_RESOURCES_ID)) { |
| importAllResourcesRadio.setSelection(true); |
| importTypedResourcesRadio.setSelection(false); |
| } else { |
| importTypedResourcesRadio.setSelection(true); |
| importAllResourcesRadio.setSelection(false); |
| } |
| |
| // set filenames history |
| sourceNameField.setText(sourceNames[0]); |
| for (int i = 0; i < sourceNames.length; i++) |
| sourceNameField.add(sourceNames[i]); |
| |
| // set selected types |
| String[] selectedTypes = settings.getArray(STORE_SELECTED_TYPES_ID); |
| if (selectedTypes.length > 0) |
| typesToImportField.setText((String)selectedTypes[0]); |
| for (int i = 0; i < selectedTypes.length; i++) |
| typesToImportField.add((String)selectedTypes[i]); |
| |
| // radio buttons and checkboxes |
| overwriteExistingResourcesCheckbox.setSelection( |
| settings.getBoolean(STORE_OVERWRITE_EXISTING_RESOURCES_ID)); |
| } |
| } |
| /** |
| * Since Finish was pressed, write widget values to the dialog store so that they |
| * will persist into the next invocation of this wizard page. |
| * |
| * Note that this method is identical to the one that appears in the superclass. |
| * This is necessary because proper overriding of instance variables is not occurring. |
| */ |
| protected void saveWidgetValues() { |
| IDialogSettings settings = getDialogSettings(); |
| if(settings != null) { |
| // update source names history |
| String[] sourceNames = settings.getArray(STORE_SOURCE_NAMES_ID); |
| if (sourceNames == null) |
| sourceNames = new String[0]; |
| |
| sourceNames = addToHistory(sourceNames,sourceNameField.getText()); |
| settings.put( |
| STORE_SOURCE_NAMES_ID, |
| sourceNames); |
| |
| // update specific types to import history |
| String[] selectedTypesNames = settings.getArray(STORE_SELECTED_TYPES_ID); |
| if (selectedTypesNames == null) |
| selectedTypesNames = new String[0]; |
| |
| if (importTypedResourcesRadio.getSelection()) |
| selectedTypesNames = addToHistory(selectedTypesNames,typesToImportField.getText()); |
| settings.put( |
| STORE_SELECTED_TYPES_ID, |
| selectedTypesNames); |
| |
| // radio buttons and checkboxes |
| settings.put( |
| STORE_IMPORT_ALL_RESOURCES_ID, |
| importAllResourcesRadio.getSelection()); |
| |
| settings.put( |
| STORE_OVERWRITE_EXISTING_RESOURCES_ID, |
| overwriteExistingResourcesCheckbox.getSelection()); |
| } |
| } |
| } |