| /******************************************************************************* |
| * Copyright (c) 2000, 2015 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 |
| * Anton Leherbauer (Wind River) - [296800] UI build actions should not lock the workspace |
| *******************************************************************************/ |
| package org.eclipse.ui.actions; |
| |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.resources.IncrementalProjectBuilder; |
| import org.eclipse.core.resources.ResourcesPlugin; |
| import org.eclipse.core.runtime.Assert; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.Status; |
| import org.eclipse.core.runtime.SubMonitor; |
| import org.eclipse.core.runtime.jobs.Job; |
| import org.eclipse.jface.action.Action; |
| import org.eclipse.jface.dialogs.ErrorDialog; |
| import org.eclipse.jface.dialogs.MessageDialog; |
| import org.eclipse.osgi.util.NLS; |
| import org.eclipse.swt.widgets.Shell; |
| import org.eclipse.ui.IWorkbench; |
| import org.eclipse.ui.IWorkbenchCommandConstants; |
| import org.eclipse.ui.IWorkbenchWindow; |
| import org.eclipse.ui.internal.ide.IDEInternalWorkbenchImages; |
| 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.actions.BuildUtilities; |
| import org.eclipse.ui.progress.IProgressConstants2; |
| import org.eclipse.ui.statushandlers.StatusManager; |
| |
| /** |
| * Standard action for full and incremental builds of all projects within the |
| * workspace. |
| * <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 GlobalBuildAction extends Action implements |
| ActionFactory.IWorkbenchAction { |
| /** |
| * The type of build performed by this action. Can be either |
| * <code>IncrementalProjectBuilder.INCREMENTAL_BUILD</code> or |
| * <code>IncrementalProjectBuilder.FULL_BUILD</code>. |
| */ |
| private int buildType; |
| |
| /** |
| * The workbench window; or <code>null</code> if this action has been |
| * <code>dispose</code>d. |
| */ |
| private IWorkbenchWindow workbenchWindow; |
| |
| /** |
| * Creates a new action of the appropriate type. The action id is |
| * <code>IWorkbenchActionConstants.BUILD</code> for incremental builds and |
| * <code>IWorkbenchActionConstants.REBUILD_ALL</code> for full builds. |
| * |
| * @param workbench |
| * the active workbench |
| * @param shell |
| * the shell for any dialogs |
| * @param type |
| * the type of build; one of |
| * <code>IncrementalProjectBuilder.INCREMENTAL_BUILD</code> or |
| * <code>IncrementalProjectBuilder.FULL_BUILD</code> |
| * |
| * @deprecated use GlobalBuildAction(IWorkbenchWindow, type) instead |
| */ |
| @Deprecated |
| public GlobalBuildAction(IWorkbench workbench, Shell shell, int type) { |
| // always use active window; ignore shell |
| this(workbench.getActiveWorkbenchWindow(), type); |
| Assert.isNotNull(shell); |
| } |
| |
| /** |
| * Creates a new action of the appropriate type. The action id is |
| * <code>IWorkbenchActionConstants.BUILD</code> for incremental builds and |
| * <code>IWorkbenchActionConstants.REBUILD_ALL</code> for full builds. |
| * |
| * @param window |
| * the window in which this action appears |
| * @param type |
| * the type of build; one of |
| * <code>IncrementalProjectBuilder.INCREMENTAL_BUILD</code> or |
| * <code>IncrementalProjectBuilder.FULL_BUILD</code> |
| */ |
| public GlobalBuildAction(IWorkbenchWindow window, int type) { |
| Assert.isNotNull(window); |
| this.workbenchWindow = window; |
| setBuildType(type); |
| } |
| |
| /** |
| * Sets the build type. |
| * |
| * @param type |
| * the type of build; one of |
| * <code>IncrementalProjectBuilder.INCREMENTAL_BUILD</code> or |
| * <code>IncrementalProjectBuilder.FULL_BUILD</code> |
| */ |
| private void setBuildType(int type) { |
| // allow AUTO_BUILD as well for backwards compatibility, but treat it |
| // the same as INCREMENTAL_BUILD |
| switch (type) { |
| case IncrementalProjectBuilder.INCREMENTAL_BUILD: |
| case IncrementalProjectBuilder.AUTO_BUILD: |
| setText(IDEWorkbenchMessages.GlobalBuildAction_text); |
| setToolTipText(IDEWorkbenchMessages.GlobalBuildAction_toolTip); |
| setId("build"); //$NON-NLS-1$ |
| workbenchWindow.getWorkbench().getHelpSystem().setHelp(this, |
| IIDEHelpContextIds.GLOBAL_INCREMENTAL_BUILD_ACTION); |
| setImageDescriptor(IDEInternalWorkbenchImages |
| .getImageDescriptor(IDEInternalWorkbenchImages.IMG_ETOOL_BUILD_EXEC)); |
| setDisabledImageDescriptor(IDEInternalWorkbenchImages |
| .getImageDescriptor(IDEInternalWorkbenchImages.IMG_ETOOL_BUILD_EXEC_DISABLED)); |
| setActionDefinitionId(IWorkbenchCommandConstants.PROJECT_BUILD_ALL); |
| break; |
| case IncrementalProjectBuilder.FULL_BUILD: |
| setText(IDEWorkbenchMessages.GlobalBuildAction_rebuildText); |
| setToolTipText(IDEWorkbenchMessages.GlobalBuildAction_rebuildToolTip); |
| setId("rebuildAll"); //$NON-NLS-1$ |
| workbenchWindow.getWorkbench().getHelpSystem().setHelp(this, |
| IIDEHelpContextIds.GLOBAL_FULL_BUILD_ACTION); |
| setActionDefinitionId("org.eclipse.ui.project.rebuildAll"); //$NON-NLS-1$ |
| break; |
| default: |
| throw new IllegalArgumentException("Invalid build type"); //$NON-NLS-1$ |
| } |
| this.buildType = type; |
| } |
| |
| /** |
| * Returns the shell to use. |
| */ |
| private Shell getShell() { |
| return workbenchWindow.getShell(); |
| } |
| |
| /** |
| * Returns the operation name to use |
| */ |
| private String getOperationMessage() { |
| if (buildType == IncrementalProjectBuilder.INCREMENTAL_BUILD) { |
| return IDEWorkbenchMessages.GlobalBuildAction_buildOperationTitle; |
| } |
| return IDEWorkbenchMessages.GlobalBuildAction_rebuildAllOperationTitle; |
| } |
| |
| /** |
| * Builds all projects within the workspace. Does not save any open editors. |
| */ |
| public void doBuild() { |
| doBuildOperation(); |
| } |
| |
| /** |
| * Invokes a build on all projects within the workspace. Reports any errors |
| * with the build to the user. |
| */ |
| /* package */void doBuildOperation() { |
| Job buildJob = new Job(IDEWorkbenchMessages.GlobalBuildAction_jobTitle) { |
| @Override |
| protected IStatus run(IProgressMonitor monitor) { |
| SubMonitor subMonitor = SubMonitor.convert(monitor, getOperationMessage(), 100); |
| try { |
| ResourcesPlugin.getWorkspace().build(buildType, subMonitor.split(100)); |
| } catch (CoreException e) { |
| return e.getStatus(); |
| } |
| return Status.OK_STATUS; |
| } |
| |
| @Override |
| public boolean belongsTo(Object family) { |
| return ResourcesPlugin.FAMILY_MANUAL_BUILD == family; |
| } |
| }; |
| buildJob.setUser(true); |
| buildJob.setProperty(IProgressConstants2.SHOW_IN_TASKBAR_ICON_PROPERTY, Boolean.TRUE); |
| buildJob.schedule(); |
| } |
| |
| /** |
| * Returns an array of all projects in the workspace |
| */ |
| /* package */IProject[] getWorkspaceProjects() { |
| return ResourcesPlugin.getWorkspace().getRoot().getProjects(); |
| } |
| |
| @Override |
| public void run() { |
| if (workbenchWindow == null) { |
| // action has been disposed |
| return; |
| } |
| // Do nothing if there are no projects... |
| IProject[] roots = getWorkspaceProjects(); |
| if (roots.length < 1) { |
| return; |
| } |
| // Verify that there are builders registered on at |
| // least one project |
| if (!verifyBuildersAvailable(roots)) { |
| return; |
| } |
| if (!verifyNoManualRunning()) { |
| return; |
| } |
| // Save all resources prior to doing build |
| BuildUtilities.saveEditors(null); |
| // Perform the build on all the projects |
| doBuildOperation(); |
| } |
| |
| /** |
| * Checks that there is at least one project with a builder registered on |
| * it. |
| */ |
| /* package */boolean verifyBuildersAvailable(IProject[] roots) { |
| try { |
| for (IProject root : roots) { |
| if (root.isAccessible()) { |
| if (root.getDescription().getBuildSpec().length > 0) { |
| return true; |
| } |
| } |
| } |
| } catch (CoreException e) { |
| StatusManager.getManager().handle(e, IDEWorkbenchPlugin.IDE_WORKBENCH); |
| ErrorDialog |
| .openError( |
| getShell(), |
| IDEWorkbenchMessages.GlobalBuildAction_buildProblems, |
| NLS.bind(IDEWorkbenchMessages.GlobalBuildAction_internalError, e.getMessage()), |
| e.getStatus()); |
| return false; |
| } |
| return false; |
| } |
| |
| @Override |
| public void dispose() { |
| if (workbenchWindow == null) { |
| // action has already been disposed |
| return; |
| } |
| workbenchWindow = null; |
| } |
| |
| /** |
| * Verify that no manual build is running. If it is then give the use the |
| * option to cancel. If they cancel, cancel the jobs and return true, |
| * otherwise return false. |
| * |
| * @return whether or not there is a manual build job running. |
| */ |
| private boolean verifyNoManualRunning() { |
| Job[] buildJobs = Job.getJobManager().find( |
| ResourcesPlugin.FAMILY_MANUAL_BUILD); |
| if (buildJobs.length == 0) { |
| return true; |
| } |
| boolean cancel = MessageDialog.openQuestion(getShell(), |
| IDEWorkbenchMessages.GlobalBuildAction_BuildRunningTitle, |
| IDEWorkbenchMessages.GlobalBuildAction_BuildRunningMessage); |
| if (cancel) { |
| for (Job job : buildJobs) { |
| job.cancel(); |
| } |
| } |
| //If they cancelled get them to do it again. |
| return false; |
| } |
| } |
