Java tutorial
/******************************************************************************* * Copyright (c) 2000, 2010 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 * Mohamed Tarief , IBM - Bug 139211 *******************************************************************************/ package org.eclipse.ui.actions; import java.util.ArrayList; import java.util.Iterator; import java.util.List; import org.eclipse.core.resources.IProject; import org.eclipse.core.resources.IResource; import org.eclipse.core.resources.IResourceChangeEvent; import org.eclipse.core.resources.IResourceChangeListener; import org.eclipse.core.resources.IResourceDelta; import org.eclipse.core.resources.ResourcesPlugin; import org.eclipse.core.resources.WorkspaceJob; import org.eclipse.core.runtime.CoreException; import org.eclipse.core.runtime.IProgressMonitor; import org.eclipse.core.runtime.IStatus; import org.eclipse.core.runtime.OperationCanceledException; import org.eclipse.core.runtime.Status; import org.eclipse.core.runtime.SubProgressMonitor; import org.eclipse.core.runtime.jobs.Job; import org.eclipse.jface.dialogs.IDialogConstants; import org.eclipse.jface.dialogs.MessageDialogWithToggle; import org.eclipse.jface.preference.IPreferenceStore; import org.eclipse.jface.viewers.IStructuredSelection; import org.eclipse.jface.window.IShellProvider; import org.eclipse.jface.window.Window; import org.eclipse.swt.SWT; import org.eclipse.swt.widgets.Display; import org.eclipse.swt.widgets.Shell; import org.eclipse.ui.PlatformUI; import org.eclipse.ui.internal.ide.IDEInternalPreferences; import org.eclipse.ui.internal.ide.IDEWorkbenchMessages; import org.eclipse.ui.internal.ide.IDEWorkbenchPlugin; import org.eclipse.ui.internal.ide.IIDEHelpContextIds; /** * Standard action for opening the currently selected project(s). * <p> * Note that there is a different action for opening an editor on file * resources: <code>OpenFileAction</code>. * </p> * <p> * This class may be instantiated; it is not intended to be subclassed. * </p> * @noextend This class is not intended to be subclassed by clients. */ public class OpenResourceAction extends WorkspaceAction implements IResourceChangeListener { /** * The id of this action. */ public static final String ID = PlatformUI.PLUGIN_ID + ".OpenResourceAction"; //$NON-NLS-1$ /** * Creates a new action. * * @param shell * the shell for any dialogs * * @deprecated {@link #OpenResourceAction(IShellProvider)} */ public OpenResourceAction(Shell shell) { super(shell, IDEWorkbenchMessages.OpenResourceAction_text); initAction(); } /** * Creates a new action. * * @param provider * the shell for any dialogs * @since 3.4 */ public OpenResourceAction(IShellProvider provider) { super(provider, IDEWorkbenchMessages.OpenResourceAction_text); initAction(); } /** * Initializes the workbench */ private void initAction() { PlatformUI.getWorkbench().getHelpSystem().setHelp(this, IIDEHelpContextIds.OPEN_RESOURCE_ACTION); setToolTipText(IDEWorkbenchMessages.OpenResourceAction_toolTip); setId(ID); } /** * Returns the total number of closed projects in the workspace. */ private int countClosedProjects() { int count = 0; IProject[] projects = ResourcesPlugin.getWorkspace().getRoot().getProjects(); for (int i = 0; i < projects.length; i++) { if (!projects[i].isOpen()) { count++; } } return count; } /* * (non-Javadoc) Method declared on WorkspaceAction. */ protected String getOperationMessage() { return IDEWorkbenchMessages.OpenResourceAction_operationMessage; } /* * (non-Javadoc) Method declared on WorkspaceAction. */ protected String getProblemsMessage() { return IDEWorkbenchMessages.OpenResourceAction_problemMessage; } /* * (non-Javadoc) Method declared on WorkspaceAction. */ protected String getProblemsTitle() { return IDEWorkbenchMessages.OpenResourceAction_dialogTitle; } /** * Returns whether there are closed projects in the workspace that are * not part of the current selection. */ private boolean hasOtherClosedProjects() { //count the closed projects in the selection int closedInSelection = 0; Iterator resources = getSelectedResources().iterator(); while (resources.hasNext()) { IProject project = (IProject) resources.next(); if (!project.isOpen()) closedInSelection++; } //there are other closed projects if the selection does //not contain all closed projects in the workspace return closedInSelection < countClosedProjects(); } protected void invokeOperation(IResource resource, IProgressMonitor monitor) throws CoreException { ((IProject) resource).open(monitor); } /** * Returns the preference for whether to open required projects when opening * a project. Consults the preference and prompts the user if necessary. * * @return <code>true</code> if referenced projects should be opened, and * <code>false</code> otherwise. */ private boolean promptToOpenWithReferences() { IPreferenceStore store = IDEWorkbenchPlugin.getDefault().getPreferenceStore(); String key = IDEInternalPreferences.OPEN_REQUIRED_PROJECTS; String value = store.getString(key); if (MessageDialogWithToggle.ALWAYS.equals(value)) { return true; } if (MessageDialogWithToggle.NEVER.equals(value)) { return false; } String message = IDEWorkbenchMessages.OpenResourceAction_openRequiredProjects; MessageDialogWithToggle dialog = MessageDialogWithToggle.openYesNoQuestion(getShell(), IDEWorkbenchMessages.Question, message, null, false, store, key); int result = dialog.getReturnCode(); // the result is equal to SWT.DEFAULT if the user uses the 'esc' key to close the dialog if (result == Window.CANCEL || result == SWT.DEFAULT) { throw new OperationCanceledException(); } return dialog.getReturnCode() == IDialogConstants.YES_ID; } /** * Handles a resource changed event by updating the enablement if one of the * selected projects is opened or closed. */ public void resourceChanged(IResourceChangeEvent event) { // Warning: code duplicated in CloseResourceAction List sel = getSelectedResources(); // don't bother looking at delta if selection not applicable if (selectionIsOfType(IResource.PROJECT)) { IResourceDelta delta = event.getDelta(); if (delta != null) { IResourceDelta[] projDeltas = delta.getAffectedChildren(IResourceDelta.CHANGED); for (int i = 0; i < projDeltas.length; ++i) { IResourceDelta projDelta = projDeltas[i]; if ((projDelta.getFlags() & IResourceDelta.OPEN) != 0) { if (sel.contains(projDelta.getResource())) { selectionChanged(getStructuredSelection()); return; } } } } } } /* * (non-Javadoc) Method declared on IAction; overrides method on * WorkspaceAction. */ public void run() { try { runOpenWithReferences(); } catch (OperationCanceledException e) { //just return when canceled } } /** * Opens the selected projects, and all related projects, in the background. */ private void runOpenWithReferences() { final List resources = new ArrayList(getActionResources()); Job job = new WorkspaceJob(removeMnemonics(getText())) { private boolean openProjectReferences = true; private boolean hasPrompted = false; private boolean canceled = false; /** * Opens a project along with all projects it references */ private void doOpenWithReferences(IProject project, IProgressMonitor monitor) throws CoreException { if (!project.exists() || project.isOpen()) { return; } project.open(new SubProgressMonitor(monitor, 1000)); final IProject[] references = project.getReferencedProjects(); if (!hasPrompted) { openProjectReferences = false; for (int i = 0; i < references.length; i++) { if (references[i].exists() && !references[i].isOpen()) { openProjectReferences = true; break; } } if (openProjectReferences && hasOtherClosedProjects()) { Display.getDefault().syncExec(new Runnable() { public void run() { try { openProjectReferences = promptToOpenWithReferences(); } catch (OperationCanceledException e) { canceled = true; } //remember that we have prompted to avoid repeating the analysis hasPrompted = true; } }); if (canceled) throw new OperationCanceledException(); } } if (openProjectReferences) { for (int i = 0; i < references.length; i++) { doOpenWithReferences(references[i], monitor); } } } public IStatus runInWorkspace(IProgressMonitor monitor) throws CoreException { try { // at most we can only open all projects currently closed monitor.beginTask("", countClosedProjects() * 1000); //$NON-NLS-1$ monitor.setTaskName(getOperationMessage()); for (Iterator it = resources.iterator(); it.hasNext();) { doOpenWithReferences((IProject) it.next(), monitor); } } finally { monitor.done(); } return Status.OK_STATUS; } }; job.setRule(ResourcesPlugin.getWorkspace().getRoot()); job.setUser(true); job.schedule(); } /* * (non-Javadoc) Method declared on WorkspaceAction. */ protected boolean shouldPerformResourcePruning() { return false; } /** * The <code>OpenResourceAction</code> implementation of this * <code>SelectionListenerAction</code> method ensures that this action is * enabled only if one of the selections is a closed project. */ protected boolean updateSelection(IStructuredSelection s) { // don't call super since we want to enable if closed project is // selected. if (!selectionIsOfType(IResource.PROJECT)) { return false; } Iterator resources = getSelectedResources().iterator(); while (resources.hasNext()) { IProject currentResource = (IProject) resources.next(); if (!currentResource.isOpen()) { return true; } } return false; } }