blob: bee9707031dd1b528268b37bfc7503bd05f4b728 [file] [log] [blame]
/*******************************************************************************
* Copyright (c) 2000, 2005 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.ui.dialogs;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.lang.reflect.InvocationTargetException;
import java.util.Iterator;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IResourceStatus;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
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.runtime.OperationCanceledException;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Preferences;
import org.eclipse.core.runtime.SubProgressMonitor;
import org.eclipse.core.runtime.jobs.ISchedulingRule;
import org.eclipse.jface.dialogs.ErrorDialog;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.wizard.WizardPage;
import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.graphics.Point;
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.Event;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.actions.WorkspaceModifyOperation;
import org.eclipse.ui.internal.ide.IDEWorkbenchMessages;
import org.eclipse.ui.internal.ide.IDEWorkbenchPlugin;
import org.eclipse.ui.internal.ide.IIDEHelpContextIds;
import org.eclipse.ui.internal.ide.dialogs.CreateLinkedResourceGroup;
import org.eclipse.ui.internal.ide.misc.ResourceAndContainerGroup;
/**
* Standard main page for a wizard that creates a file resource.
* <p>
* This page may be used by clients as-is; it may be also be subclassed to suit.
* </p>
* <p>
* Subclasses may override
* <ul>
* <li><code>getInitialContents</code></li>
* <li><code>getNewFileLabel</code></li>
* </ul>
* </p>
* <p>
* Subclasses may extend
* <ul>
* <li><code>handleEvent</code></li>
* </ul>
* </p>
*/
public class WizardNewFileCreationPage extends WizardPage implements Listener {
private static final int SIZING_CONTAINER_GROUP_HEIGHT = 250;
// the current resource selection
private IStructuredSelection currentSelection;
// cache of newly-created file
private IFile newFile;
private IPath linkTargetPath;
// widgets
private ResourceAndContainerGroup resourceGroup;
private Button advancedButton;
private CreateLinkedResourceGroup linkedResourceGroup;
private Composite linkedResourceParent;
private Composite linkedResourceComposite;
// initial value stores
private String initialFileName;
private IPath initialContainerFullPath;
/**
* Height of the "advanced" linked resource group. Set when the
* advanced group is first made visible.
*/
private int linkedResourceGroupHeight = -1;
/**
* First time the advanced group is validated.
*/
private boolean firstLinkCheck = true;
/**
* Creates a new file creation wizard page. If the initial resource selection
* contains exactly one container resource then it will be used as the default
* container resource.
*
* @param pageName the name of the page
* @param selection the current resource selection
*/
public WizardNewFileCreationPage(String pageName,
IStructuredSelection selection) {
super(pageName);
setPageComplete(false);
this.currentSelection = selection;
}
/**
* Creates the widget for advanced options.
*
* @param parent the parent composite
*/
protected void createAdvancedControls(Composite parent) {
Preferences preferences = ResourcesPlugin.getPlugin()
.getPluginPreferences();
if (preferences.getBoolean(ResourcesPlugin.PREF_DISABLE_LINKING) == false) {
linkedResourceParent = new Composite(parent, SWT.NONE);
linkedResourceParent.setFont(parent.getFont());
linkedResourceParent.setLayoutData(new GridData(
GridData.FILL_HORIZONTAL));
GridLayout layout = new GridLayout();
layout.marginHeight = 0;
layout.marginWidth = 0;
linkedResourceParent.setLayout(layout);
advancedButton = new Button(linkedResourceParent, SWT.PUSH);
advancedButton.setFont(linkedResourceParent.getFont());
advancedButton.setText(IDEWorkbenchMessages.showAdvanced);
GridData data = setButtonLayoutData(advancedButton);
data.horizontalAlignment = GridData.BEGINNING;
advancedButton.setLayoutData(data);
advancedButton.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(SelectionEvent e) {
handleAdvancedButtonSelect();
}
});
}
linkedResourceGroup = new CreateLinkedResourceGroup(IResource.FILE,
new Listener() {
public void handleEvent(Event e) {
setPageComplete(validatePage());
firstLinkCheck = false;
}
},
new CreateLinkedResourceGroup.IStringValue(){
public void setValue(String string) {
resourceGroup.setResource(string);
}
public String getValue() {
return resourceGroup.getResource();
}
});
}
/** (non-Javadoc)
* Method declared on IDialogPage.
*/
public void createControl(Composite parent) {
initializeDialogUnits(parent);
// top level group
Composite topLevel = new Composite(parent, SWT.NONE);
topLevel.setLayout(new GridLayout());
topLevel.setLayoutData(new GridData(GridData.VERTICAL_ALIGN_FILL
| GridData.HORIZONTAL_ALIGN_FILL));
topLevel.setFont(parent.getFont());
PlatformUI.getWorkbench().getHelpSystem().setHelp(topLevel,
IIDEHelpContextIds.NEW_FILE_WIZARD_PAGE);
// resource and container group
resourceGroup = new ResourceAndContainerGroup(
topLevel,
this,
getNewFileLabel(),
IDEWorkbenchMessages.WizardNewFileCreationPage_file, false, SIZING_CONTAINER_GROUP_HEIGHT);
resourceGroup.setAllowExistingResources(false);
initialPopulateContainerNameField();
createAdvancedControls(topLevel);
if (initialFileName != null)
resourceGroup.setResource(initialFileName);
validatePage();
// Show description on opening
setErrorMessage(null);
setMessage(null);
setControl(topLevel);
}
/**
* Creates a file resource given the file handle and contents.
*
* @param fileHandle the file handle to create a file resource with
* @param contents the initial contents of the new file resource, or
* <code>null</code> if none (equivalent to an empty stream)
* @param monitor the progress monitor to show visual progress with
* @exception CoreException if the operation fails
* @exception OperationCanceledException if the operation is canceled
*/
protected void createFile(IFile fileHandle, InputStream contents,
IProgressMonitor monitor) throws CoreException {
if (contents == null)
contents = new ByteArrayInputStream(new byte[0]);
try {
// Create a new file resource in the workspace
if (linkTargetPath != null)
fileHandle.createLink(linkTargetPath,
IResource.ALLOW_MISSING_LOCAL, monitor);
else {
IPath path = fileHandle.getFullPath();
IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
int numSegments= path.segmentCount();
if (numSegments > 2 && !root.getFolder(path.removeLastSegments(1)).exists()) {
// If the direct parent of the path doesn't exist, try to create the
// necessary directories.
for (int i= numSegments - 2; i > 0; i--) {
IFolder folder = root.getFolder(path.removeLastSegments(i));
if (!folder.exists()) {
folder.create(false, true, monitor);
}
}
}
fileHandle.create(contents, false, monitor);
}
} catch (CoreException e) {
// If the file already existed locally, just refresh to get contents
if (e.getStatus().getCode() == IResourceStatus.PATH_OCCUPIED)
fileHandle.refreshLocal(IResource.DEPTH_ZERO, null);
else
throw e;
}
if (monitor.isCanceled())
throw new OperationCanceledException();
}
/**
* 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
* @see #createFile
*/
protected IFile createFileHandle(IPath filePath) {
return IDEWorkbenchPlugin.getPluginWorkspace().getRoot().getFile(
filePath);
}
/**
* Creates the link target path if a link target has been specified.
*/
protected void createLinkTarget() {
String linkTarget = linkedResourceGroup.getLinkTarget();
if (linkTarget != null) {
linkTargetPath = new Path(linkTarget);
} else {
linkTargetPath = null;
}
}
/**
* Creates a new file resource in the selected container and with the selected
* name. Creates any missing resource containers along the path; does nothing if
* the container resources already exist.
* <p>
* In normal usage, this method is invoked after the user has pressed Finish on
* the wizard; the enablement of the Finish button implies that all controls on
* on this page currently contain valid values.
* </p>
* <p>
* Note that this page caches the new file once it has been successfully
* created; subsequent invocations of this method will answer the same
* file resource without attempting to create it again.
* </p>
* <p>
* This method should be called within a workspace modify operation since
* it creates resources.
* </p>
*
* @return the created file resource, or <code>null</code> if the file
* was not created
*/
public IFile createNewFile() {
if (newFile != null)
return newFile;
// create the new file and cache it if successful
final IPath containerPath = resourceGroup.getContainerFullPath();
IPath newFilePath = containerPath.append(resourceGroup.getResource());
final IFile newFileHandle = createFileHandle(newFilePath);
final InputStream initialContents = getInitialContents();
createLinkTarget();
WorkspaceModifyOperation op = new WorkspaceModifyOperation(createRule(newFileHandle)) {
protected void execute(IProgressMonitor monitor)
throws CoreException {
try {
monitor.beginTask(IDEWorkbenchMessages.WizardNewFileCreationPage_progress, 2000);
ContainerGenerator generator = new ContainerGenerator(
containerPath);
generator.generateContainer(new SubProgressMonitor(monitor,
1000));
createFile(newFileHandle, initialContents,
new SubProgressMonitor(monitor, 1000));
} finally {
monitor.done();
}
}
};
try {
getContainer().run(true, true, op);
} catch (InterruptedException e) {
return null;
} catch (InvocationTargetException e) {
if (e.getTargetException() instanceof CoreException) {
ErrorDialog
.openError(
getContainer().getShell(), // Was Utilities.getFocusShell()
IDEWorkbenchMessages.WizardNewFileCreationPage_errorTitle,
null, // no special message
((CoreException) e.getTargetException())
.getStatus());
} else {
// CoreExceptions are handled above, but unexpected runtime exceptions and errors may still occur.
IDEWorkbenchPlugin.log(getClass(),
"createNewFile()", e.getTargetException()); //$NON-NLS-1$
MessageDialog
.openError(
getContainer().getShell(),
IDEWorkbenchMessages.WizardNewFileCreationPage_internalErrorTitle, NLS.bind(IDEWorkbenchMessages.WizardNewFileCreationPage_internalErrorMessage, e.getTargetException().getMessage()));
}
return null;
}
newFile = newFileHandle;
return newFile;
}
/**
* Returns the scheduling rule to use when creating the resource at
* the given container path. The rule should be the creation rule for
* the top-most non-existing parent.
* @param resource The resource being created
* @return The scheduling rule for creating the given resource
* @since 3.1
*/
protected ISchedulingRule createRule(IResource resource) {
IResource parent = resource.getParent();
while (parent != null) {
if (parent.exists())
return resource.getWorkspace().getRuleFactory().createRule(resource);
resource = parent;
parent = parent.getParent();
}
return resource.getWorkspace().getRoot();
}
/**
* Returns the current full path of the containing resource as entered or
* selected by the user, or its anticipated initial value.
*
* @return the container's full path, anticipated initial value,
* or <code>null</code> if no path is known
*/
public IPath getContainerFullPath() {
return resourceGroup.getContainerFullPath();
}
/**
* Returns the current file name as entered by the user, or its anticipated
* initial value.
*
* @return the file name, its anticipated initial value, or <code>null</code>
* if no file name is known
*/
public String getFileName() {
if (resourceGroup == null)
return initialFileName;
return resourceGroup.getResource();
}
/**
* Returns a stream containing the initial contents to be given to new file resource
* instances. <b>Subclasses</b> may wish to override. This default implementation
* provides no initial contents.
*
* @return initial contents to be given to new file resource instances
*/
protected InputStream getInitialContents() {
return null;
}
/**
* Returns the label to display in the file name specification visual
* component group.
* <p>
* Subclasses may reimplement.
* </p>
*
* @return the label to display in the file name specification visual
* component group
*/
protected String getNewFileLabel() {
return IDEWorkbenchMessages.WizardNewFileCreationPage_fileLabel;
}
/**
* Shows/hides the advanced option widgets.
*/
protected void handleAdvancedButtonSelect() {
Shell shell = getShell();
Point shellSize = shell.getSize();
Composite composite = (Composite) getControl();
if (linkedResourceComposite != null) {
linkedResourceComposite.dispose();
linkedResourceComposite = null;
composite.layout();
shell.setSize(shellSize.x, shellSize.y - linkedResourceGroupHeight);
advancedButton.setText(IDEWorkbenchMessages.showAdvanced);
} else {
linkedResourceComposite = linkedResourceGroup
.createContents(linkedResourceParent);
if (linkedResourceGroupHeight == -1) {
Point groupSize = linkedResourceComposite.computeSize(
SWT.DEFAULT, SWT.DEFAULT, true);
linkedResourceGroupHeight = groupSize.y;
}
shell.setSize(shellSize.x, shellSize.y + linkedResourceGroupHeight);
composite.layout();
advancedButton.setText(IDEWorkbenchMessages.hideAdvanced);
}
}
/**
* The <code>WizardNewFileCreationPage</code> implementation of this
* <code>Listener</code> method handles all events and enablements for controls
* on this page. Subclasses may extend.
*/
public void handleEvent(Event event) {
setPageComplete(validatePage());
}
/**
* Sets the initial contents of the container name entry field, based upon
* either a previously-specified initial value or the ability to determine
* such a value.
*/
protected void initialPopulateContainerNameField() {
if (initialContainerFullPath != null)
resourceGroup.setContainerFullPath(initialContainerFullPath);
else {
Iterator it = currentSelection.iterator();
if (it.hasNext()) {
Object object = it.next();
IResource selectedResource = null;
if (object instanceof IResource) {
selectedResource = (IResource) object;
} else if (object instanceof IAdaptable) {
selectedResource = (IResource) ((IAdaptable) object)
.getAdapter(IResource.class);
}
if (selectedResource != null) {
if (selectedResource.getType() == IResource.FILE)
selectedResource = selectedResource.getParent();
if (selectedResource.isAccessible())
resourceGroup.setContainerFullPath(selectedResource
.getFullPath());
}
}
}
}
/**
* Sets the value of this page's container name field, or stores
* it for future use if this page's controls do not exist yet.
*
* @param path the full path to the container
*/
public void setContainerFullPath(IPath path) {
if (resourceGroup == null)
initialContainerFullPath = path;
else
resourceGroup.setContainerFullPath(path);
}
/**
* Sets the value of this page's file name field, or stores
* it for future use if this page's controls do not exist yet.
*
* @param value new file name
*/
public void setFileName(String value) {
if (resourceGroup == null)
initialFileName = value;
else
resourceGroup.setResource(value);
}
/**
* Checks whether the linked resource target is valid.
* Sets the error message accordingly and returns the status.
*
* @return IStatus validation result from the CreateLinkedResourceGroup
*/
protected IStatus validateLinkedResource() {
IPath containerPath = resourceGroup.getContainerFullPath();
IPath newFilePath = containerPath.append(resourceGroup.getResource());
IFile newFileHandle = createFileHandle(newFilePath);
IStatus status = linkedResourceGroup
.validateLinkLocation(newFileHandle);
if (status.getSeverity() == IStatus.ERROR) {
if (firstLinkCheck)
setMessage(status.getMessage());
else
setErrorMessage(status.getMessage());
} else if (status.getSeverity() == IStatus.WARNING) {
setMessage(status.getMessage(), WARNING);
setErrorMessage(null);
}
return status;
}
/**
* Returns whether this page's controls currently all contain valid
* values.
*
* @return <code>true</code> if all controls are valid, and
* <code>false</code> if at least one is invalid
*/
protected boolean validatePage() {
boolean valid = true;
if (!resourceGroup.areAllValuesValid()) {
// if blank name then fail silently
if (resourceGroup.getProblemType() == ResourceAndContainerGroup.PROBLEM_RESOURCE_EMPTY
|| resourceGroup.getProblemType() == ResourceAndContainerGroup.PROBLEM_CONTAINER_EMPTY) {
setMessage(resourceGroup.getProblemMessage());
setErrorMessage(null);
} else
setErrorMessage(resourceGroup.getProblemMessage());
valid = false;
}
IStatus linkedResourceStatus = null;
if (valid) {
linkedResourceStatus = validateLinkedResource();
if (linkedResourceStatus.getSeverity() == IStatus.ERROR)
valid = false;
}
// validateLinkedResource sets messages itself
if (valid
&& (linkedResourceStatus == null || linkedResourceStatus.isOK())) {
setMessage(null);
setErrorMessage(null);
}
return valid;
}
/*
* @see DialogPage.setVisible(boolean)
*/
public void setVisible(boolean visible) {
super.setVisible(visible);
if (visible)
resourceGroup.setFocus();
}
}