org.eclipse.ui.dialogs.WizardNewFolderMainPage Maven / Gradle / Ivy
/*******************************************************************************
* Copyright (c) 2000, 2019 IBM Corporation and others.
*
* This program and the accompanying materials
* are made available under the terms of the Eclipse Public License 2.0
* which accompanies this distribution, and is available at
* https://www.eclipse.org/legal/epl-2.0/
*
* SPDX-License-Identifier: EPL-2.0
*
* Contributors:
* IBM Corporation - initial API and implementation
* Leon J. Breedt - Added multiple folder creation support (in WizardNewFolderMainPage)
* Lars Vogel - Bug 430694, 472784
* Patrik Suzzi - Bug 371776
* Alexander Fedorov - Bug 548799
*******************************************************************************/
package org.eclipse.ui.dialogs;
import java.lang.reflect.InvocationTargetException;
import java.net.URI;
import java.util.Iterator;
import java.util.Optional;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.commands.operations.AbstractOperation;
import org.eclipse.core.filesystem.EFS;
import org.eclipse.core.filesystem.IFileStore;
import org.eclipse.core.filesystem.URIUtil;
import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IResourceStatus;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.Adapters;
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.NullProgressMonitor;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.core.runtime.Preferences;
import org.eclipse.core.runtime.SubMonitor;
import org.eclipse.jface.dialogs.ErrorDialog;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.dialogs.IMessageProvider;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.resource.CompositeImageDescriptor;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.resource.ResourceLocator;
import org.eclipse.jface.viewers.DecorationOverlayIcon;
import org.eclipse.jface.viewers.IDecoration;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.window.Window;
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.Image;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Resource;
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.swt.widgets.Widget;
import org.eclipse.ui.ISharedImages;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.ide.dialogs.UIResourceFilterDescription;
import org.eclipse.ui.ide.undo.CreateFolderOperation;
import org.eclipse.ui.ide.undo.WorkspaceUndoUtil;
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.dialogs.ResourceFilterEditDialog;
import org.eclipse.ui.internal.ide.misc.ResourceAndContainerGroup;
/**
* Standard main page for a wizard that creates a folder resource.
*
* This page may be used by clients as-is; it may be also be subclassed to suit.
*
*
* Subclasses may extend
*
*
* handleEvent
*/
public class WizardNewFolderMainPage extends WizardPage implements Listener {
private static final int SIZING_CONTAINER_GROUP_HEIGHT = 250;
private IStructuredSelection currentSelection;
private IFolder newFolder;
// link target location
private URI linkTargetPath;
// widgets
private ResourceAndContainerGroup resourceGroup;
private Button advancedButton;
private Button useDefaultLocation;
private Button useVirtualFolder;
private Button useLinkedResource;
private Button filterButton;
private CreateLinkedResourceGroup linkedResourceGroup;
private Composite advancedComposite;
private Composite linkedResourceComposite;
private Composite linkedGroupComposite;
private UIResourceFilterDescription[] filterList = null;
/**
* 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 folder 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 WizardNewFolderMainPage(String pageName, IStructuredSelection selection) {
super("newFolderPage1");//$NON-NLS-1$
setTitle(pageName);
setDescription(IDEWorkbenchMessages.WizardNewFolderMainPage_description);
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)) {
advancedComposite = new Composite(parent, SWT.NONE);
advancedComposite.setFont(parent.getFont());
advancedComposite.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
GridLayout layout = new GridLayout();
layout.marginHeight = 0;
layout.marginWidth = 0;
advancedComposite.setLayout(layout);
advancedButton = new Button(advancedComposite, SWT.PUSH);
advancedButton.setFont(advancedComposite.getFont());
advancedButton.setText(IDEWorkbenchMessages.showAdvanced);
GridData data = setButtonLayoutData(advancedButton);
data.horizontalAlignment = GridData.BEGINNING;
advancedButton.setLayoutData(data);
advancedButton.addSelectionListener(new SelectionAdapter() {
@Override
public void widgetSelected(SelectionEvent e) {
handleAdvancedButtonSelect();
}
});
}
linkedResourceGroup = new CreateLinkedResourceGroup(IResource.FOLDER, e -> {
setPageComplete(validatePage());
firstLinkCheck = false;
}, new CreateLinkedResourceGroup.IStringValue() {
@Override
public String getValue() {
return resourceGroup.getResource();
}
@Override
public void setValue(String string) {
resourceGroup.setResource(string);
}
@Override
public IResource getResource() {
IPath path = resourceGroup.getContainerFullPath();
if (path != null) {
IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
IResource resource = root.findMember(path);
if (resource != null && resource instanceof IContainer) {
String resourceName = resourceGroup.getResource();
if (resourceName.length() > 0) {
try {
return ((IContainer) resource).getFolder(IPath.fromOSString(resourceName));
} catch (IllegalArgumentException e) {
// continue below.
}
}
return resource;
}
return resource;
}
return null;
}
});
}
boolean setupLinkedResourceTargetRecursiveFlag = false;
private Image virtualFolderImage;
private Image linkedFolderImage;
private Image folderImage;
private void setupLinkedResourceTarget() {
if (!setupLinkedResourceTargetRecursiveFlag) {
setupLinkedResourceTargetRecursiveFlag = true;
try {
if (isFilteredByParent()) {
URI existingLink = linkedResourceGroup.getLinkTargetURI();
boolean setDefaultLinkValue = false;
if (existingLink == null)
setDefaultLinkValue = true;
else {
IPath path = URIUtil.toPath(existingLink);
if (path != null)
setDefaultLinkValue = path.toPortableString().length() > 0;
}
if (setDefaultLinkValue) {
IPath containerPath = resourceGroup.getContainerFullPath();
IPath newFilePath = containerPath.append(resourceGroup.getResource());
IFolder newFolderHandle = createFolderHandle(newFilePath);
try {
URI uri = newFolderHandle.getPathVariableManager()
.convertToRelative(newFolderHandle.getLocationURI(), false, null);
linkedResourceGroup.setLinkTarget(URIUtil.toPath(uri).toPortableString());
} catch (CoreException e) {
// nothing
}
}
}
} finally {
setupLinkedResourceTargetRecursiveFlag = false;
}
}
}
@Override
public void createControl(Composite parent) {
initializeDialogUnits(parent);
// top level group
Composite composite = new Composite(parent, SWT.NONE);
composite.setFont(parent.getFont());
composite.setLayout(new GridLayout());
composite.setLayoutData(new GridData(GridData.VERTICAL_ALIGN_FILL | GridData.HORIZONTAL_ALIGN_FILL));
PlatformUI.getWorkbench().getHelpSystem().setHelp(composite, IIDEHelpContextIds.NEW_FOLDER_WIZARD_PAGE);
resourceGroup = new ResourceAndContainerGroup(composite, this,
IDEWorkbenchMessages.WizardNewFolderMainPage_folderName,
IDEWorkbenchMessages.WizardNewFolderMainPage_folderLabel, false, SIZING_CONTAINER_GROUP_HEIGHT);
resourceGroup.setAllowExistingResources(false);
createAdvancedControls(composite);
initializePage();
validatePage();
// Show description on opening
setErrorMessage(null);
setMessage(null);
setControl(composite);
}
/**
* Creates a folder resource given the folder handle.
*
* @param folderHandle the folder handle to create a folder resource for
* @param monitor the progress monitor to show visual progress with
* @exception CoreException if the operation fails
* @exception OperationCanceledException if the operation is canceled
*
* @deprecated As of 3.3, use {@link #createNewFolder()} which uses the undoable
* operation support.
*/
@Deprecated
protected void createFolder(IFolder folderHandle, IProgressMonitor monitor) throws CoreException {
SubMonitor subMonitor = SubMonitor.convert(monitor, 100);
try {
// Create the folder resource in the workspace
// Update: Recursive to create any folders which do not exist
// already
if (!folderHandle.exists()) {
if (linkTargetPath != null) {
folderHandle.createLink(linkTargetPath, IResource.ALLOW_MISSING_LOCAL, subMonitor.split(100));
} else {
IPath path = folderHandle.getFullPath();
IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
int numSegments = path.segmentCount();
if (numSegments > 2 && !root.getFolder(path.removeLastSegments(1)).exists()) {
SubMonitor loopProgress = subMonitor.split(90).setWorkRemaining(numSegments - 3);
// 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, loopProgress.split(1));
}
}
}
subMonitor.setWorkRemaining(10);
folderHandle.create(false, true, subMonitor.split(10));
}
}
} catch (CoreException e) {
// If the folder already existed locally, just refresh to get
// contents
if (e.getStatus().getCode() == IResourceStatus.PATH_OCCUPIED) {
folderHandle.refreshLocal(IResource.DEPTH_INFINITE, subMonitor.setWorkRemaining(1).split(1));
} else {
throw e;
}
}
}
/**
* Creates a folder resource handle for the folder with the given workspace
* path. This method does not create the folder resource; this is the
* responsibility of createFolder.
*
* @param folderPath the path of the folder resource to create a handle for
* @return the new folder resource handle
* @see #createFolder
*/
protected IFolder createFolderHandle(IPath folderPath) {
return IDEWorkbenchPlugin.getPluginWorkspace().getRoot().getFolder(folderPath);
}
/**
* Creates a container resource handle for the container with the given
* workspace path. This method does not create the resource.
*
* @param containerPath the path of the container resource to create a handle
* for
* @return the new container resource handle
* @see #createFolder
* @since 3.6
*/
protected IContainer createContainerHandle(IPath containerPath) {
if (containerPath.segmentCount() == 1)
return IDEWorkbenchPlugin.getPluginWorkspace().getRoot().getProject(containerPath.segment(0));
return IDEWorkbenchPlugin.getPluginWorkspace().getRoot().getFolder(containerPath);
}
/**
* Creates the link target path if a link target has been specified.
*/
protected void createLinkTarget() {
linkTargetPath = linkedResourceGroup.getLinkTargetURI();
}
/**
* Creates a new folder 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.
*
* 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
* this page currently contain valid values.
*
*
* Note that this page caches the new folder once it has been successfully
* created; subsequent invocations of this method will answer the same folder
* resource without attempting to create it again.
*
*
* This method should be called within a workspace modify operation since it
* creates resources.
*
*
* @return the created folder resource, or null if the folder was
* not created
*/
public IFolder createNewFolder() {
if (newFolder != null) {
return newFolder;
}
// create the new folder and cache it if successful
final IPath containerPath = resourceGroup.getContainerFullPath();
IPath newFolderPath = containerPath.append(resourceGroup.getResource());
final IFolder newFolderHandle = createFolderHandle(newFolderPath);
final boolean createVirtualFolder = useVirtualFolder != null && useVirtualFolder.getSelection();
createLinkTarget();
if (linkTargetPath != null) {
URI resolvedPath = newFolderHandle.getPathVariableManager().resolveURI(linkTargetPath);
try {
IFileStore store = EFS.getStore(resolvedPath);
if (!store.fetchInfo().exists()) {
MessageDialog dlg = new MessageDialog(getContainer().getShell(),
IDEWorkbenchMessages.WizardNewFolderCreationPage_createLinkLocationTitle, null,
NLS.bind(IDEWorkbenchMessages.WizardNewFolderCreationPage_createLinkLocationQuestion,
linkTargetPath),
MessageDialog.QUESTION_WITH_CANCEL, 0, IDialogConstants.YES_LABEL,
IDialogConstants.NO_LABEL, IDialogConstants.CANCEL_LABEL);
int result = dlg.open();
if (result == Window.OK) {
store.mkdir(0, new NullProgressMonitor());
}
if (result == 2)
return null;
}
} catch (CoreException e) {
MessageDialog.open(MessageDialog.ERROR, getContainer().getShell(),
IDEWorkbenchMessages.WizardNewFileCreationPage_internalErrorTitle,
NLS.bind(IDEWorkbenchMessages.WizardNewFileCreationPage_internalErrorMessage, e.getMessage()),
SWT.SHEET);
return null;
}
}
IRunnableWithProgress op = monitor -> {
AbstractOperation op1;
op1 = new CreateFolderOperation(newFolderHandle, linkTargetPath, createVirtualFolder, filterList,
IDEWorkbenchMessages.WizardNewFolderCreationPage_title);
try {
// see bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=219901
// directly execute the operation so that the undo state is
// not preserved. Making this undoable can result in accidental
// folder (and file) deletions.
op1.execute(monitor, WorkspaceUndoUtil.getUIInfoAdapter(getShell()));
} catch (final ExecutionException e) {
getContainer().getShell().getDisplay().syncExec(() -> {
if (e.getCause() instanceof CoreException) {
ErrorDialog.openError(getContainer().getShell(), // Was Utilities.getFocusShell()
IDEWorkbenchMessages.WizardNewFolderCreationPage_errorTitle, null, // no special message
((CoreException) e.getCause()).getStatus());
} else {
IDEWorkbenchPlugin.log(getClass(), "createNewFolder()", e.getCause()); //$NON-NLS-1$
MessageDialog.openError(getContainer().getShell(),
IDEWorkbenchMessages.WizardNewFolderCreationPage_internalErrorTitle, NLS.bind(
IDEWorkbenchMessages.WizardNewFolder_internalError, e.getCause().getMessage()));
}
});
}
};
try {
getContainer().run(true, true, op);
} catch (InterruptedException e) {
return null;
} catch (InvocationTargetException e) {
// ExecutionExceptions are handled above, but unexpected runtime
// exceptions and errors may still occur.
IDEWorkbenchPlugin.log(getClass(), "createNewFolder()", e.getTargetException()); //$NON-NLS-1$
MessageDialog.open(MessageDialog.ERROR, getContainer().getShell(),
IDEWorkbenchMessages.WizardNewFolderCreationPage_internalErrorTitle,
NLS.bind(IDEWorkbenchMessages.WizardNewFolder_internalError, e.getTargetException().getMessage()),
SWT.SHEET);
return null;
}
newFolder = newFolderHandle;
return newFolder;
}
/**
* Shows/hides the advanced option widgets.
*/
protected void handleAdvancedButtonSelect() {
Shell shell = getShell();
Point shellSize = shell.getSize();
Composite composite = (Composite) getControl();
if (linkedResourceComposite != null) {
disposeAdvancedControls();
composite.layout();
shell.setSize(shellSize.x, shellSize.y - linkedResourceGroupHeight);
advancedButton.setText(IDEWorkbenchMessages.showAdvanced);
} else {
Point oldCompositeSize = advancedComposite.computeSize(SWT.DEFAULT, SWT.DEFAULT);
ImageDescriptor folderDescriptor = PlatformUI.getWorkbench().getSharedImages()
.getImageDescriptor(ISharedImages.IMG_OBJ_FOLDER);
Optional linkOverlay = ResourceLocator
.imageDescriptorFromBundle(WizardNewFolderMainPage.class, "$nl$/icons/full/ovr16/link_ovr.png"); //$NON-NLS-1$
CompositeImageDescriptor linkedFolderDescriptor = new DecorationOverlayIcon(folderDescriptor,
linkOverlay.orElse(null), IDecoration.BOTTOM_RIGHT);
Optional virtualOverlay = ResourceLocator
.imageDescriptorFromBundle(WizardNewFolderMainPage.class, "$nl$/icons/full/ovr16/virt_ovr.png"); //$NON-NLS-1$
CompositeImageDescriptor virtualFolderDescriptor = new DecorationOverlayIcon(folderDescriptor,
virtualOverlay.orElse(null), IDecoration.BOTTOM_RIGHT);
folderImage = folderDescriptor.createImage();
useDefaultLocation = new Button(advancedComposite, SWT.RADIO);
int indent = useDefaultLocation.computeSize(SWT.DEFAULT, SWT.DEFAULT).x;
useDefaultLocation.setFont(advancedComposite.getFont());
useDefaultLocation.setText(IDEWorkbenchMessages.useDefaultLocation);
useDefaultLocation.setImage(folderImage);
GridData data = setButtonLayoutData(useDefaultLocation);
data.horizontalAlignment = GridData.BEGINNING;
data.horizontalIndent = indent;
useDefaultLocation.setLayoutData(data);
virtualFolderImage = virtualFolderDescriptor.createImage();
useVirtualFolder = new Button(advancedComposite, SWT.RADIO);
useVirtualFolder.setFont(advancedComposite.getFont());
useVirtualFolder.setImage(virtualFolderImage);
useVirtualFolder.setText(IDEWorkbenchMessages.createVirtualFolder);
data = setButtonLayoutData(useVirtualFolder);
data.horizontalAlignment = GridData.BEGINNING;
data.horizontalIndent = indent;
useVirtualFolder.setLayoutData(data);
linkedFolderImage = linkedFolderDescriptor.createImage();
useLinkedResource = new Button(advancedComposite, SWT.RADIO);
useLinkedResource.setFont(advancedComposite.getFont());
useLinkedResource.setText(IDEWorkbenchMessages.createLinkedFolder);
useLinkedResource.setImage(linkedFolderImage);
data = setButtonLayoutData(useLinkedResource);
data.horizontalAlignment = GridData.BEGINNING;
data.horizontalIndent = indent;
useLinkedResource.setLayoutData(data);
SelectionAdapter radioListener = new SelectionAdapter() {
@Override
public void widgetSelected(SelectionEvent e) {
handleRadioSelect();
}
};
useLinkedResource.addSelectionListener(radioListener);
useVirtualFolder.addSelectionListener(radioListener);
useDefaultLocation.addSelectionListener(radioListener);
useDefaultLocation.setSelection(true);
linkedGroupComposite = new Composite(advancedComposite, 0);
data = new GridData(SWT.FILL, SWT.BEGINNING, true, false);
data.horizontalIndent = indent;
linkedGroupComposite.setFont(advancedComposite.getFont());
linkedGroupComposite.setLayoutData(data);
GridLayout layout = new GridLayout();
layout.marginHeight = 0;
layout.marginWidth = 0;
linkedGroupComposite.setLayout(layout);
linkedResourceComposite = linkedResourceGroup.createTextOnlyContents(linkedGroupComposite);
if (linkedResourceGroupHeight == -1) {
Point groupSize = linkedResourceComposite.computeSize(SWT.DEFAULT, SWT.DEFAULT, true);
linkedResourceGroupHeight = groupSize.y;
}
linkedResourceGroup.setEnabled(false);
filterButton = new Button(advancedComposite, SWT.PUSH);
filterButton.setFont(advancedComposite.getFont());
filterButton.setText(IDEWorkbenchMessages.editfilters);
data = setButtonLayoutData(filterButton);
data.horizontalAlignment = GridData.BEGINNING;
data.horizontalIndent = indent;
filterButton.setLayoutData(data);
filterButton.addSelectionListener(new SelectionAdapter() {
@Override
public void widgetSelected(SelectionEvent e) {
handleEditFilterSelect();
}
});
setupLinkedResourceTarget();
advancedButton.setText(IDEWorkbenchMessages.hideAdvanced);
Point newCompositeSize = advancedComposite.computeSize(SWT.DEFAULT, SWT.DEFAULT);
linkedResourceGroupHeight = newCompositeSize.y - oldCompositeSize.y;
getShell().setSize(shellSize.x, shellSize.y + linkedResourceGroupHeight);
composite.layout(true);
}
}
@Override
public void dispose() {
disposeAdvancedControls();
super.dispose();
}
private void disposeAdvancedControls() {
dispose(linkedResourceComposite);
dispose(filterButton);
dispose(useDefaultLocation);
dispose(useVirtualFolder);
dispose(useLinkedResource);
dispose(linkedGroupComposite);
dispose(folderImage);
dispose(virtualFolderImage);
dispose(linkedFolderImage);
linkedResourceComposite = null;
filterButton = null;
useDefaultLocation = null;
useVirtualFolder = null;
useLinkedResource = null;
linkedGroupComposite = null;
}
private void dispose(Resource resource) {
if (resource != null) {
resource.dispose();
}
}
private void dispose(Widget widget) {
if (widget != null) {
widget.dispose();
}
}
private void handleRadioSelect() {
linkedResourceGroup.setEnabled(useLinkedResource.getSelection());
}
/**
* Show the Resource Filter dialog.
*/
private void handleEditFilterSelect() {
ResourceFilterEditDialog dialog = new ResourceFilterEditDialog(getShell());
dialog.setFilters(filterList);
if (dialog.open() == Window.OK)
filterList = dialog.getFilters();
}
/**
* The WizardNewFolderCreationPage implementation of this
* Listener method handles all events and enablements for controls
* on this page. Subclasses may extend.
*/
@Override
public void handleEvent(Event ev) {
setPageComplete(validatePage());
}
/**
* Initializes this page's controls.
*/
protected void initializePage() {
Iterator it = currentSelection.iterator();
if (it.hasNext()) {
Object next = it.next();
IResource selectedResource = Adapters.adapt(next, IResource.class);
if (selectedResource != null) {
if (selectedResource.getType() == IResource.FILE) {
selectedResource = selectedResource.getParent();
}
if (selectedResource.isAccessible()) {
resourceGroup.setContainerFullPath(selectedResource.getFullPath());
}
}
}
setPageComplete(false);
}
/*
* @see DialogPage.setVisible(boolean)
*/
@Override
public void setVisible(boolean visible) {
super.setVisible(visible);
if (visible) {
resourceGroup.setFocus();
}
}
/**
* 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 newFolderPath = containerPath.append(resourceGroup.getResource());
IFolder newFolderHandle = createFolderHandle(newFolderPath);
IStatus status = linkedResourceGroup.validateLinkLocation(newFolderHandle);
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 true if all controls are valid, and false
* if at least one is invalid
*/
protected boolean validatePage() {
boolean valid = true;
if (!resourceGroup.areAllValuesValid()) {
setErrorMessage(resourceGroup.getProblemMessage());
valid = false;
}
if (valid && (useDefaultLocation == null || useDefaultLocation.getSelection())) {
IPath containerPath = resourceGroup.getContainerFullPath();
if (containerPath != null && createContainerHandle(containerPath).isVirtual()) {
valid = false;
setErrorMessage(IDEWorkbenchMessages.CreateLinkedResourceGroup_linkRequiredUnderAGroup);
}
}
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);
}
if (isFilteredByParent()) {
setMessage(IDEWorkbenchMessages.WizardNewFolderCreationPage_resourceWillBeFilteredWarning,
IMessageProvider.ERROR);
setupLinkedResourceTarget();
valid = false;
}
return valid;
}
private boolean isFilteredByParent() {
boolean createVirtualFolder = useVirtualFolder != null && useVirtualFolder.getSelection();
if (createVirtualFolder)
return false;
if ((linkedResourceGroup == null) || linkedResourceGroup.isEnabled())
return false;
IPath containerPath = resourceGroup.getContainerFullPath();
if (containerPath == null)
return false;
String resourceName = resourceGroup.getResource();
if (resourceName == null)
return false;
if (resourceName.length() > 0) {
IPath newFolderPath = containerPath.append(resourceName);
if (newFolderPath.segmentCount() < 2)
return false;
IFolder newFolderHandle = createFolderHandle(newFolderPath);
IWorkspace workspace = newFolderHandle.getWorkspace();
return !workspace.validateFiltered(newFolderHandle).isOK();
}
return false;
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy