Attachment #145200 for bug #284363

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.




/*******************************************************************************
 * Copyright (c) 2006, 2009 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.debug.internal.core.commands;

import java.util.LinkedHashSet;

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.jobs.IJobChangeEvent;
import org.eclipse.core.runtime.jobs.IJobChangeListener;
import org.eclipse.core.runtime.jobs.ISchedulingRule;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.debug.core.DebugPlugin;
import org.eclipse.debug.core.IRequest;
import org.eclipse.debug.core.commands.IDebugCommandHandler;
import org.eclipse.debug.core.commands.IDebugCommandRequest;
import org.eclipse.debug.core.commands.IEnabledStateRequest;
import org.eclipse.debug.internal.core.DebugOptions;

/**
 * Common function for standard debug commands.
 * 
 * @since 3.3
 *
 */
public abstract class DebugCommand implements IDebugCommandHandler {
	
	/**
	 * Job to update enabled state of action.
	 */
	class UpdateJob extends Job implements IJobChangeListener {
		
		/**
		 * The request to update
		 */
		private IEnabledStateRequest request;
		
		/**
		 * Whether this job has been run
		 */
		private boolean run = false;
		
		/**
		 * Creates a new job to update the specified request
		 * 
		 * @param stateRequest
		 */
		UpdateJob(IEnabledStateRequest stateRequest) {
			super(getEnablementTaskName());
			request = stateRequest;
			setSystem(true);
			setRule(createUpdateSchedulingRule(request));
			getJobManager().addJobChangeListener(this);
		}
		
		protected IStatus run(IProgressMonitor monitor) {
			run = true;
			if (DebugOptions.DEBUG_COMMANDS) {
				System.out.print("can execute command: " + DebugCommand.this); //$NON-NLS-1$
			}
			if (monitor.isCanceled()) {
				if (DebugOptions.DEBUG_COMMANDS) {
					System.out.println(" >> *CANCELED* <<"); //$NON-NLS-1$
				}
				request.cancel();
			}
			Object[] elements = request.getElements();
			Object[] targets = new Object[elements.length];
			if (!request.isCanceled()) {
				for (int i = 0; i < elements.length; i++) {
					targets[i] = getTarget(elements[i]);
					if (targets[i] == null) {
						request.setEnabled(false);
						request.cancel();
						if (DebugOptions.DEBUG_COMMANDS) {
							System.out.println(" >> false (no adapter)"); //$NON-NLS-1$
						}
					}
				}
				if (monitor.isCanceled()) {
					request.cancel();
				}
			}
			if (!request.isCanceled()) {
				targets = coalesce(targets);
				monitor.beginTask(getEnablementTaskName(), targets.length);
				try {
					boolean executable = isExecutable(targets, monitor, request);
					if (DebugOptions.DEBUG_COMMANDS) {
						System.out.println(" >> " + executable); //$NON-NLS-1$
					}
					request.setEnabled(executable);
				} catch (CoreException e) {
					request.setStatus(e.getStatus());
					request.setEnabled(false);
					if (DebugOptions.DEBUG_COMMANDS) {
						System.out.println(" >> ABORTED"); //$NON-NLS-1$
						System.out.println("\t" + e.getStatus().getMessage()); //$NON-NLS-1$
					}
				}
			}
			monitor.setCanceled(request.isCanceled());
			request.done();
			monitor.done();
			return Status.OK_STATUS;
		}
		
		/* (non-Javadoc)
		 * @see org.eclipse.core.runtime.jobs.Job#belongsTo(java.lang.Object)
		 */
		public boolean belongsTo(Object family) {
			return getUpdateJobFamily().equals(family);
		}

		public void aboutToRun(IJobChangeEvent event) {
		}

		public void awake(IJobChangeEvent event) {
		}

		public void done(IJobChangeEvent event) {
			if (event.getJob() == this) {
				if (!run) {
					request.cancel();
					request.done();
					if (DebugOptions.DEBUG_COMMANDS) {
						System.out.println(" >> *CANCELED* <<" + DebugCommand.this); //$NON-NLS-1$
					}
				}
				getJobManager().removeJobChangeListener(this);
			}
		}

		public void running(IJobChangeEvent event) {
		}

		public void scheduled(IJobChangeEvent event) {
		}

		public void sleeping(IJobChangeEvent event) {
		}
				
	}
	
	/**
	 * Scheduling rule to serialize commands on an object
	 */
   class SerialPerObjectRule implements ISchedulingRule {

		private Object fObject = null;

		public SerialPerObjectRule(Object lock) {
			fObject = lock;
		}

		/*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.core.runtime.jobs.ISchedulingRule#contains(org.eclipse.core.runtime.jobs.ISchedulingRule)
		 */
		public boolean contains(ISchedulingRule rule) {
			return rule == this;
		}

		/*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.core.runtime.jobs.ISchedulingRule#isConflicting(org.eclipse.core.runtime.jobs.ISchedulingRule)
		 */
		public boolean isConflicting(ISchedulingRule rule) {
			if (rule instanceof SerialPerObjectRule) {
				SerialPerObjectRule vup = (SerialPerObjectRule) rule;
				return fObject == vup.fObject;
			}
			return false;
		}

	}
   
	public boolean execute(final IDebugCommandRequest request) {
		Job job = new Job(getExecuteTaskName()) {
			protected IStatus run(IProgressMonitor monitor) {
				if (DebugOptions.DEBUG_COMMANDS) {
					System.out.println("execute: " + DebugCommand.this); //$NON-NLS-1$
				}
				Object[] elements = request.getElements();
				Object[] targets = new Object[elements.length];
				for (int i = 0; i < elements.length; i++) {
					targets[i]= getTarget(elements[i]);
				}
				targets = coalesce(targets);
				monitor.beginTask(getExecuteTaskName(), targets.length);
				try {
					doExecute(targets, monitor, request);
				} catch (CoreException e) {
					request.setStatus(e.getStatus());
					if (DebugOptions.DEBUG_COMMANDS) {
						System.out.println("\t" + e.getStatus().getMessage()); //$NON-NLS-1$
					}
				}
				request.done();
				monitor.setCanceled(request.isCanceled());
				monitor.done();
				return Status.OK_STATUS;
			}
		};
		job.setSystem(true);
		job.schedule();
		return isRemainEnabled();
	}	
	
	/**
	 * Returns whether this command should remain enabled after execution is invoked.
	 * 
	 * @return whether to remain enabled
	 */
	protected boolean isRemainEnabled() {
		return false;
	}
	
	public void canExecute(final IEnabledStateRequest request) {
		Job job = new UpdateJob(request);
		job.schedule();
	}
	
	/**
	 * Returns the name to use for jobs and progress monitor task names when checking
	 * enabled state.
	 * 
	 * @return task name
	 */
	protected String getEnablementTaskName() {
		// this is a system job name and does not need to be NLS'd
		return "Check Debug Command"; //$NON-NLS-1$
	}
	
	/**
	 * Returns the name to use for jobs and progress monitor task names when executing
	 * a debug command
	 * 
	 * @return task name
	 */
	protected String getExecuteTaskName() {
		// this is a system job name and does not need to be NLS'd
		return "Execute Debug Command"; //$NON-NLS-1$
	}	

	/**
	 * Executes the actual operation.
	 * 
	 * @param targets objects to perform on
	 * @param request request
	 */
	protected abstract void doExecute(Object[] targets, IProgressMonitor monitor, IRequest request) throws CoreException;

	/**
	 * Returns whether this command is executable.
	 * 
	 * @param targets objects to check command for
	 * @param monitor progress monitor
	 * @param request request
	 * @return whether this command can be executed
	 */
	protected abstract boolean isExecutable(Object[] targets, IProgressMonitor monitor, IEnabledStateRequest request) throws CoreException;
	
	/**
	 * Returns the appropriate command adapter from the given object.
	 * 
	 * @param element object to obtain adapter from
	 * @return adapter
	 */
	protected abstract Object getTarget(Object element); 
	
	/**
	 * Returns an adapter of the specified type for the given object or <code>null</code>
	 * if none. The object itself is returned if it is an instance of the specified type.
	 * 
	 * @param element element to retrieve adapter for
	 * @param type adapter type
	 * @return adapter or <code>null</code>
	 */
	protected Object getAdapter(Object element, Class type) {
    	return DebugPlugin.getAdapter(element, type);	
	}	
	
	/**
	 * Scheduling rule for updating command enabled state.
	 * 
	 * @return scheduling rule or <code>null</code>
	 */
	protected ISchedulingRule createUpdateSchedulingRule(IDebugCommandRequest request) {
		return new SerialPerObjectRule(request.getElements()[0]);
	}
	
	private Object[] coalesce(Object[] objects) {
		if (objects.length == 1) {
			return objects;
		} else {
			LinkedHashSet set = new LinkedHashSet(objects.length);
			for (int i = 0; i < objects.length; i++) {
				set.add(objects[i]);
			}
			return set.toArray();
		}
	}
	
	/**
	 * Returns the job family for this command's "can execute" job.
	 * 
	 * @return the job family for this command's "can execute" job
	 */
	protected abstract Object getUpdateJobFamily();
	
}

Lines 13-18 Link Here

(-)core/org/eclipse/debug/internal/core/commands/ForEachCommand.java (-1 / +2 lines)
13	import org.eclipse.core.runtime.CoreException;	13	import org.eclipse.core.runtime.CoreException;
14	import org.eclipse.core.runtime.IProgressMonitor;	14	import org.eclipse.core.runtime.IProgressMonitor;
15	import org.eclipse.debug.core.IRequest;	15	import org.eclipse.debug.core.IRequest;
		16	import org.eclipse.debug.core.commands.AbstractDebugCommand;
16	import org.eclipse.debug.core.commands.IEnabledStateRequest;	17	import org.eclipse.debug.core.commands.IEnabledStateRequest;
17		18
18	/**	19	/**
Lines 20-26 Link Here
20	*	21	*
21	* @since 3.3	22	* @since 3.3
22	*/	23	*/
23	public abstract class ForEachCommand extends DebugCommand {	24	public abstract class ForEachCommand extends AbstractDebugCommand {
24		25
25	/* (non-Javadoc)	26	/* (non-Javadoc)
26	* @see org.eclipse.debug.internal.core.commands.DebugCommand#doExecute(java.lang.Object[], org.eclipse.core.runtime.IProgressMonitor, org.eclipse.debug.core.IRequest)	27	* @see org.eclipse.debug.internal.core.commands.DebugCommand#doExecute(java.lang.Object[], org.eclipse.core.runtime.IProgressMonitor, org.eclipse.debug.core.IRequest)

Lines 17-22 Link Here

(-)core/org/eclipse/debug/internal/core/commands/StepCommand.java (-1 / +2 lines)
17	import org.eclipse.core.runtime.IAdaptable;	17	import org.eclipse.core.runtime.IAdaptable;
18	import org.eclipse.core.runtime.IProgressMonitor;	18	import org.eclipse.core.runtime.IProgressMonitor;
19	import org.eclipse.debug.core.IRequest;	19	import org.eclipse.debug.core.IRequest;
		20	import org.eclipse.debug.core.commands.AbstractDebugCommand;
20	import org.eclipse.debug.core.commands.IEnabledStateRequest;	21	import org.eclipse.debug.core.commands.IEnabledStateRequest;
21	import org.eclipse.debug.core.model.IStackFrame;	22	import org.eclipse.debug.core.model.IStackFrame;
22	import org.eclipse.debug.core.model.IStep;	23	import org.eclipse.debug.core.model.IStep;
Lines 26-32 Link Here
26	*	27	*
27	* @since 3.3	28	* @since 3.3
28	*/	29	*/
29	public abstract class StepCommand extends DebugCommand {	30	public abstract class StepCommand extends AbstractDebugCommand {
30		31
31	protected void doExecute(Object[] targets, IProgressMonitor monitor, IRequest request) throws CoreException {	32	protected void doExecute(Object[] targets, IProgressMonitor monitor, IRequest request) throws CoreException {
32	for (int i = 0; i < targets.length; i++) {	33	for (int i = 0; i < targets.length; i++) {




/*******************************************************************************
 * Copyright (c) 2006, 2009 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.debug.core.commands;

import java.util.LinkedHashSet;

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.jobs.IJobChangeEvent;
import org.eclipse.core.runtime.jobs.IJobChangeListener;
import org.eclipse.core.runtime.jobs.ISchedulingRule;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.debug.core.DebugPlugin;
import org.eclipse.debug.core.IRequest;
import org.eclipse.debug.internal.core.DebugOptions;

/**
 * Common function for standard debug commands.
 * 
 * @since 3.6 This class was in the internal package 
 * <code>org.eclipse.debug.internal.core.commands</code> since 3.3.
 *
 */
public abstract class AbstractDebugCommand implements IDebugCommandHandler {
	
	/**
	 * Job to update enabled state of action.
	 */
	private class UpdateJob extends Job implements IJobChangeListener {
		
		/**
		 * The request to update
		 */
		private IEnabledStateRequest request;
		
		/**
		 * Whether this job has been run
		 */
		private boolean run = false;
		
		/**
		 * Creates a new job to update the specified request
		 * 
		 * @param stateRequest
		 */
		UpdateJob(IEnabledStateRequest stateRequest) {
			super(getEnablementTaskName());
			request = stateRequest;
			setSystem(true);
			setRule(createUpdateSchedulingRule(request));
			getJobManager().addJobChangeListener(this);
		}
		
		protected IStatus run(IProgressMonitor monitor) {
			run = true;
			if (DebugOptions.DEBUG_COMMANDS) {
				System.out.print("can execute command: " + AbstractDebugCommand.this); //$NON-NLS-1$
			}
			if (monitor.isCanceled()) {
				if (DebugOptions.DEBUG_COMMANDS) {
					System.out.println(" >> *CANCELED* <<"); //$NON-NLS-1$
				}
				request.cancel();
			}
			Object[] elements = request.getElements();
			Object[] targets = new Object[elements.length];
			if (!request.isCanceled()) {
				for (int i = 0; i < elements.length; i++) {
					targets[i] = getTarget(elements[i]);
					if (targets[i] == null) {
						request.setEnabled(false);
						request.cancel();
						if (DebugOptions.DEBUG_COMMANDS) {
							System.out.println(" >> false (no adapter)"); //$NON-NLS-1$
						}
					}
				}
				if (monitor.isCanceled()) {
					request.cancel();
				}
			}
			if (!request.isCanceled()) {
				targets = coalesce(targets);
				monitor.beginTask(getEnablementTaskName(), targets.length);
				try {
					boolean executable = isExecutable(targets, monitor, request);
					if (DebugOptions.DEBUG_COMMANDS) {
						System.out.println(" >> " + executable); //$NON-NLS-1$
					}
					request.setEnabled(executable);
				} catch (CoreException e) {
					request.setStatus(e.getStatus());
					request.setEnabled(false);
					if (DebugOptions.DEBUG_COMMANDS) {
						System.out.println(" >> ABORTED"); //$NON-NLS-1$
						System.out.println("\t" + e.getStatus().getMessage()); //$NON-NLS-1$
					}
				}
			}
			monitor.setCanceled(request.isCanceled());
			request.done();
			monitor.done();
			return Status.OK_STATUS;
		}
		
		/* (non-Javadoc)
		 * @see org.eclipse.core.runtime.jobs.Job#belongsTo(java.lang.Object)
		 */
		public boolean belongsTo(Object family) {
			return getUpdateJobFamily().equals(family);
		}

		public void aboutToRun(IJobChangeEvent event) {
		}

		public void awake(IJobChangeEvent event) {
		}

		public void done(IJobChangeEvent event) {
			if (event.getJob() == this) {
				if (!run) {
					request.cancel();
					request.done();
					if (DebugOptions.DEBUG_COMMANDS) {
						System.out.println(" >> *CANCELED* <<" + AbstractDebugCommand.this); //$NON-NLS-1$
					}
				}
				getJobManager().removeJobChangeListener(this);
			}
		}

		public void running(IJobChangeEvent event) {
		}

		public void scheduled(IJobChangeEvent event) {
		}

		public void sleeping(IJobChangeEvent event) {
		}
				
	}
	
	/**
	 * Scheduling rule to serialize commands on an object
	 */
   private class SerialPerObjectRule implements ISchedulingRule {

		private Object fObject = null;

		public SerialPerObjectRule(Object lock) {
			fObject = lock;
		}

		/*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.core.runtime.jobs.ISchedulingRule#contains(org.eclipse.core.runtime.jobs.ISchedulingRule)
		 */
		public boolean contains(ISchedulingRule rule) {
			return rule == this;
		}

		/*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.core.runtime.jobs.ISchedulingRule#isConflicting(org.eclipse.core.runtime.jobs.ISchedulingRule)
		 */
		public boolean isConflicting(ISchedulingRule rule) {
			if (rule instanceof SerialPerObjectRule) {
				SerialPerObjectRule vup = (SerialPerObjectRule) rule;
				return fObject == vup.fObject;
			}
			return false;
		}

	}
   
	public boolean execute(final IDebugCommandRequest request) {
		Job job = new Job(getExecuteTaskName()) {
			protected IStatus run(IProgressMonitor monitor) {
				if (DebugOptions.DEBUG_COMMANDS) {
					System.out.println("execute: " + AbstractDebugCommand.this); //$NON-NLS-1$
				}
				Object[] elements = request.getElements();
				Object[] targets = new Object[elements.length];
				for (int i = 0; i < elements.length; i++) {
					targets[i]= getTarget(elements[i]);
				}
				targets = coalesce(targets);
				monitor.beginTask(getExecuteTaskName(), targets.length);
				try {
					doExecute(targets, monitor, request);
				} catch (CoreException e) {
					request.setStatus(e.getStatus());
					if (DebugOptions.DEBUG_COMMANDS) {
						System.out.println("\t" + e.getStatus().getMessage()); //$NON-NLS-1$
					}
				}
				request.done();
				monitor.setCanceled(request.isCanceled());
				monitor.done();
				return Status.OK_STATUS;
			}
		};
		job.setSystem(true);
		job.schedule();
		return isRemainEnabled();
	}	
	
	/**
	 * Returns whether this command should remain enabled after execution is invoked.
	 * 
	 * @return whether to remain enabled
	 */
	protected boolean isRemainEnabled() {
		return false;
	}
	
	public void canExecute(final IEnabledStateRequest request) {
		Job job = new UpdateJob(request);
		job.schedule();
	}
	
	/**
	 * Returns the name to use for jobs and progress monitor task names when checking
	 * enabled state.
	 * 
	 * @return task name
	 */
	protected String getEnablementTaskName() {
		// this is a system job name and does not need to be NLS'd
		return "Check Debug Command"; //$NON-NLS-1$
	}
	
	/**
	 * Returns the name to use for jobs and progress monitor task names when executing
	 * a debug command
	 * 
	 * @return task name
	 */
	protected String getExecuteTaskName() {
		// this is a system job name and does not need to be NLS'd
		return "Execute Debug Command"; //$NON-NLS-1$
	}	

	/**
	 * Executes the actual operation.
	 * 
	 * @param targets objects to perform on
	 * @param request request
	 */
	protected abstract void doExecute(Object[] targets, IProgressMonitor monitor, IRequest request) throws CoreException;

	/**
	 * Returns whether this command is executable.
	 * 
	 * @param targets objects to check command for
	 * @param monitor progress monitor
	 * @param request request
	 * @return whether this command can be executed
	 */
	protected abstract boolean isExecutable(Object[] targets, IProgressMonitor monitor, IEnabledStateRequest request) throws CoreException;
	
	/**
	 * Returns the appropriate command adapter from the given object.
	 * 
	 * @param element object to obtain adapter from
	 * @return adapter
	 */
	protected abstract Object getTarget(Object element); 
	
	/**
	 * Returns an adapter of the specified type for the given object or <code>null</code>
	 * if none. The object itself is returned if it is an instance of the specified type.
	 * 
	 * @param element element to retrieve adapter for
	 * @param type adapter type
	 * @return adapter or <code>null</code>
	 */
	protected Object getAdapter(Object element, Class type) {
    	return DebugPlugin.getAdapter(element, type);	
	}	
	
	/**
	 * Scheduling rule for updating command enabled state.
	 * 
	 * @return scheduling rule or <code>null</code>
	 */
	protected ISchedulingRule createUpdateSchedulingRule(IDebugCommandRequest request) {
		return new SerialPerObjectRule(request.getElements()[0]);
	}
	
	private Object[] coalesce(Object[] objects) {
		if (objects.length == 1) {
			return objects;
		} else {
			LinkedHashSet set = new LinkedHashSet(objects.length);
			for (int i = 0; i < objects.length; i++) {
				set.add(objects[i]);
			}
			return set.toArray();
		}
	}
	
	/**
	 * Returns the job family for this command's "can execute" job.
	 * 
	 * @return the job family for this command's "can execute" job
	 */
	protected abstract Object getUpdateJobFamily();
	
}

Lines 11-16 Link Here

(-)ui/org/eclipse/debug/internal/ui/commands/actions/StepReturnCommandActionDelegate.java (+1 lines)
11		11
12	package org.eclipse.debug.internal.ui.commands.actions;	12	package org.eclipse.debug.internal.ui.commands.actions;
13		13
		14
14	/**	15	/**
15	* Step return action delegate.	16	* Step return action delegate.
16	*	17	*

Lines 14-19 Link Here

(-)ui/org/eclipse/debug/internal/ui/commands/actions/DropToFrameCommandAction.java (+1 lines)
14	import org.eclipse.debug.internal.ui.DebugPluginImages;	14	import org.eclipse.debug.internal.ui.DebugPluginImages;
15	import org.eclipse.debug.internal.ui.IInternalDebugUIConstants;	15	import org.eclipse.debug.internal.ui.IInternalDebugUIConstants;
16	import org.eclipse.debug.internal.ui.actions.ActionMessages;	16	import org.eclipse.debug.internal.ui.actions.ActionMessages;
		17	import org.eclipse.debug.ui.actions.DebugCommandAction;
17	import org.eclipse.jface.resource.ImageDescriptor;	18	import org.eclipse.jface.resource.ImageDescriptor;
18		19
19	/**	20	/**

Lines 14-19 Link Here

(-)ui/org/eclipse/debug/internal/ui/commands/actions/StepReturnCommandAction.java (+1 lines)
14	import org.eclipse.debug.internal.ui.DebugPluginImages;	14	import org.eclipse.debug.internal.ui.DebugPluginImages;
15	import org.eclipse.debug.internal.ui.IInternalDebugUIConstants;	15	import org.eclipse.debug.internal.ui.IInternalDebugUIConstants;
16	import org.eclipse.debug.internal.ui.actions.ActionMessages;	16	import org.eclipse.debug.internal.ui.actions.ActionMessages;
		17	import org.eclipse.debug.ui.actions.DebugCommandAction;
17	import org.eclipse.jface.resource.ImageDescriptor;	18	import org.eclipse.jface.resource.ImageDescriptor;
18		19
19	/**	20	/**





import org.eclipse.debug.core.commands.IEnabledStateRequest;
import org.eclipse.debug.internal.core.commands.DebugCommandRequest;
import org.eclipse.jface.action.IAction;

/**
 * Boolean collector that collects boolean results from a number of voters.

 */
public class UpdateActionsRequest extends DebugCommandRequest implements IEnabledStateRequest {
	
	private IEnabledTarget[] fActions;
	private boolean fEnabled = false;
	
	public UpdateActionsRequest(Object[] elements, IEnabledTarget[] actions) {
		super(elements);
		fActions = actions;
	}

Lines 15-21 Link Here

(-)ui/org/eclipse/debug/internal/ui/commands/actions/ICommandParticipant.java (-1 / +1 lines)
15	/**	15	/**
16	* Adds function to a command on completion.	16	* Adds function to a command on completion.
17	*	17	*
18	* @since 3.3	18	* @since 3.3.
19	*/	19	*/
20	public interface ICommandParticipant {	20	public interface ICommandParticipant {
21		21





package org.eclipse.debug.internal.ui.commands.actions;

import org.eclipse.debug.ui.actions.DebugCommandAction;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.swt.widgets.Event;

/**
 * Abstract base class for debug action delegates performing debug commands.
 * 
 * @since 3.3.
 */
public abstract class DebugCommandActionDelegate implements IWorkbenchWindowActionDelegate, IActionDelegate2 {


	 */
	private DebugCommandAction fDebugAction;
    
	protected void setAction(DebugCommandAction action) {
	    fDebugAction = action;
     */
    private IAction fWindowAction;
    
    /**
     * Whether this action has been initialized before it has been run
     * (ensures enablement state is up to date when lazily instantiated)
     */
    private boolean fInitialized = false;

	public DebugCommandActionDelegate() {
	}
	
	/*
     * (non-Javadoc)
     * @see org.eclipse.ui.IWorkbenchWindowActionDelegate#dispose()
	 */
	public void dispose() {
        fDebugAction.dispose();

	}

    /*

     * @see org.eclipse.ui.IActionDelegate2#init(org.eclipse.jface.action.IAction)
     */
    public void init(IAction action) {
        fDebugAction.setAction(action);
    }
    
    /*

     * @see org.eclipse.ui.IActionDelegate#run(org.eclipse.jface.action.IAction)
     */
	public void run(IAction action) {
		synchronized (this) {
			if (!fInitialized) {
				try {
					wait();
				} catch (InterruptedException e) {
				}
			}			
		}
        fDebugAction.run();
	}


	protected DebugCommandAction getAction() {
		return fDebugAction;
	}
    
    protected void setAction(DebugCommandAction action) {
        fDebugAction = action;
        action.setDelegate(this);
    }

    public void setEnabled(boolean enabled) {
    	synchronized (this) {
	    	if (!fInitialized) {
	    		fInitialized = true;
	    		notifyAll();
	    	}
    	}
        fWindowAction.setEnabled(enabled);
    }
    
    public void setChecked(boolean checked) {
    	fWindowAction.setChecked(checked);
    }
    
    protected IAction getWindowAction()
    {
    	return fWindowAction;
    }
    
    
}




/*******************************************************************************
 * Copyright (c) 2006, 2007 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.debug.internal.ui.commands.actions;

import org.eclipse.debug.ui.DebugUITools;
import org.eclipse.debug.ui.contexts.DebugContextEvent;
import org.eclipse.debug.ui.contexts.IDebugContextListener;
import org.eclipse.debug.ui.contexts.IDebugContextService;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.swt.widgets.Event;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PlatformUI;

/**
 * Abstract base class for actions performing debug commands
 *
 * @since 3.3
 */
public abstract class DebugCommandAction extends Action implements IDebugContextListener {

	/**
	 * The window this action is working for.
	 */
    private IWorkbenchWindow fWindow;
    
    /**
     * The part this action is working for, or <code>null</code> if global to
     * a window.
     */
    private IWorkbenchPart fPart;
    
    /**
     * Command service.
     */
    private DebugCommandService fUpdateService;
    
    /**
     * Delegate this action is working for or <code>null</code> if none.
     */
    private DebugCommandActionDelegate fDelegate;

    /**
     * Constructor
     */
    public DebugCommandAction() {
        super();
        String helpContextId = getHelpContextId();
        if (helpContextId != null)
            PlatformUI.getWorkbench().getHelpSystem().setHelp(this, helpContextId);
        setEnabled(false);
    }

	/**
     * Set the current delegate
     * @param delegate
     */
    public void setDelegate(DebugCommandActionDelegate delegate) {
        fDelegate = delegate;
    }

    /**
     * Executes this action on the given target object
     * 
     * @param target the target to perform the action on
     */
    protected boolean execute(Object[] targets) {
    	return fUpdateService.executeCommand(getCommandType(), targets, getCommandParticipant(targets));
    }
    
    /**
     * Creates and returns the command participant or <code>null</code>.
     * 
     * @return command participant to use on command completion
     */
    protected ICommandParticipant getCommandParticipant(Object[] targets) {
    	return null;
    }
    
    /**
     * Returns the command type this action executes.
     * 
     * @return command class.
     */
    abstract protected Class getCommandType();  

    /**
     * @see org.eclipse.debug.ui.contexts.IDebugContextListener#debugContextChanged(org.eclipse.debug.ui.contexts.DebugContextEvent)
     */
    public void debugContextChanged(DebugContextEvent event) {
    	fUpdateService.postUpdateCommand(getCommandType(), this);
	}

    /**
     * @see org.eclipse.jface.action.Action#setEnabled(boolean)
     */
    public void setEnabled(boolean enabled) {
        super.setEnabled(enabled);
        if (fDelegate != null) {
            fDelegate.setEnabled(enabled);
        }
    }

    /**
     * Initializes this action for a specific part.
     * 
     * @param part workbench part
     */
    public void init(IWorkbenchPart part) {
        fPart = part;
        fWindow = part.getSite().getWorkbenchWindow();
        fUpdateService = DebugCommandService.getService(fWindow);
        IDebugContextService service = getDebugContextService();
		String partId = part.getSite().getId();
		service.addDebugContextListener(this, partId);
        ISelection activeContext = service.getActiveContext(partId);
        if (activeContext != null) {
        	fUpdateService.updateCommand(getCommandType(), this);
        } else {
        	setEnabled(getInitialEnablement());
        }
    }
    
    /**
     * Initializes the context action
     * @param window the window
     */
    public void init(IWorkbenchWindow window) {
        fWindow = window;
        fUpdateService = DebugCommandService.getService(fWindow);
        IDebugContextService contextService = getDebugContextService();
		contextService.addDebugContextListener(this);
        ISelection activeContext = contextService.getActiveContext();
        if (activeContext != null) {
        	fUpdateService.updateCommand(getCommandType(), this);
        } else {
        	setEnabled(getInitialEnablement());
        }
    }
    
    /**
     * Returns whether this action should be enabled when initialized
     * and there is no active debug context.
     * 
     * @return false, by default
     */
    protected boolean getInitialEnablement() {
    	return false;
    }

    /**
     * Returns the most recent selection
     * 
     * @return structured selection
     */
    protected ISelection getContext() {
		if (fPart != null) {
			getDebugContextService().getActiveContext(fPart.getSite().getId());
    	}
        return getDebugContextService().getActiveContext();
    }

    /*
     * (non-Javadoc)
     * @see org.eclipse.jface.action.Action#run()
     */
    public void run() {
        ISelection selection = getContext();
        if (selection instanceof IStructuredSelection && isEnabled()) {
            IStructuredSelection ss = (IStructuredSelection) selection;
            boolean enabled = execute(ss.toArray());
            // disable the action according to the command
            setEnabled(enabled);
        }
    }

    /*
     * (non-Javadoc)
     * @see org.eclipse.jface.action.Action#runWithEvent(org.eclipse.swt.widgets.Event)
     */
    public void runWithEvent(Event event) {
        run();
    }

    /**
     * Clean up when removing
     */
    public void dispose() {
        IDebugContextService service = getDebugContextService();
        if (fPart != null) {
        	service.removeDebugContextListener(this, fPart.getSite().getId());
        } else {
            service.removeDebugContextListener(this);
        }
        fWindow = null;
        fPart = null;
    }
    
    /**
     * Returns the context service this action linked to.
     * @return
     */
    protected IDebugContextService getDebugContextService() {
    	return DebugUITools.getDebugContextManager().getContextService(fWindow);
    }

    /**
     * @return The help context id for this action
     */ 
    public abstract String getHelpContextId();

    /*
     * (non-Javadoc)
     * @see org.eclipse.jface.action.Action#getId()
     */
    public abstract String getId();

    /*
     * (non-Javadoc)
     * @see org.eclipse.jface.action.Action#getText()
     */
    public abstract String getText();

    /*
     * (non-Javadoc)
     * @see org.eclipse.jface.action.Action#getToolTipText()
     */
    public abstract String getToolTipText();

    /*
     * (non-Javadoc)
     * @see org.eclipse.jface.action.Action#getDisabledImageDescriptor()
     */
    public abstract ImageDescriptor getDisabledImageDescriptor();

    /*
     * (non-Javadoc)
     * @see org.eclipse.jface.action.Action#getHoverImageDescriptor()
     */
    public abstract ImageDescriptor getHoverImageDescriptor();

    /*
     * (non-Javadoc)
     * @see org.eclipse.jface.action.Action#getImageDescriptor()
     */
    public abstract ImageDescriptor getImageDescriptor();
    
    /**
     * Returns the delegate associated with this action or <code>null</code>
     * if none.
     * 
     * @return delegate or <code>null</code>
     */
    protected DebugCommandActionDelegate getDelegate() {
    	return fDelegate;
    }
}

Lines 11-16 Link Here

(-)ui/org/eclipse/debug/internal/ui/commands/actions/SuspendCommandActionDelegate.java (+1 lines)
11		11
12	package org.eclipse.debug.internal.ui.commands.actions;	12	package org.eclipse.debug.internal.ui.commands.actions;
13		13
		14
14	/**	15	/**
15	* Suspend action delegate.	16	* Suspend action delegate.
16	*	17	*




 *******************************************************************************/
package org.eclipse.debug.internal.ui.commands.actions;

import org.eclipse.jface.action.IAction;

/**
 * Collects votes from handler update requests.

 */
public class ActionsUpdater {
	
	private IEnabledTarget[] fActions;
	private int fNumVoters;
	private int fNumOfVotes = 0;
	private boolean fDone = false;
	private boolean fEnabled = true;
	
	public ActionsUpdater(IEnabledTarget[] actions, int numVoters) {
		fActions = actions;
		fNumVoters = numVoters;
	}

Lines 11-16 Link Here

(-)ui/org/eclipse/debug/internal/ui/commands/actions/StepOverCommandActionDelegate.java (+1 lines)
11		11
12	package org.eclipse.debug.internal.ui.commands.actions;	12	package org.eclipse.debug.internal.ui.commands.actions;
13		13
		14
14	/**	15	/**
15	* Step over action delegate.	16	* Step over action delegate.
16	*	17	*





package org.eclipse.debug.internal.ui.commands.actions;

import org.eclipse.debug.ui.actions.DebugCommandAction;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.swt.widgets.Event;
import org.eclipse.ui.IActionDelegate2;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.IWorkbenchWindowActionDelegate;

/**
 * Resume action delegate.
 * 
 * @since 3.3
 */
public class ResumeCommandActionDelegate implements IWorkbenchWindowActionDelegate, IActionDelegate2 {

    private DebugCommandAction fDebugAction = new ResumeCommandAction();
    
    public void dispose() {
        fDebugAction.dispose();
    }

    public void init(IWorkbenchWindow window) {
        fDebugAction.init(window);
    }

    public void run(IAction action) {
        fDebugAction.run();
    }

    public void selectionChanged(IAction action, ISelection selection) {
        // do nothing
    }

    public void init(IAction action) {
        fDebugAction.setAction(action);
        
    }

    public void runWithEvent(IAction action, Event event) {
        run(action);
    }
}

Lines 20-25 Link Here

(-)ui/org/eclipse/debug/internal/ui/commands/actions/TerminateAndRelaunchAction.java (+1 lines)
20	import org.eclipse.debug.internal.ui.actions.ActionMessages;	20	import org.eclipse.debug.internal.ui.actions.ActionMessages;
21	import org.eclipse.debug.internal.ui.actions.RelaunchActionDelegate;	21	import org.eclipse.debug.internal.ui.actions.RelaunchActionDelegate;
22	import org.eclipse.debug.internal.ui.launchConfigurations.LaunchConfigurationManager;	22	import org.eclipse.debug.internal.ui.launchConfigurations.LaunchConfigurationManager;
		23	import org.eclipse.debug.ui.actions.DebugCommandAction;
23	import org.eclipse.debug.ui.contexts.DebugContextEvent;	24	import org.eclipse.debug.ui.contexts.DebugContextEvent;
24	import org.eclipse.jface.resource.ImageDescriptor;	25	import org.eclipse.jface.resource.ImageDescriptor;
25	import org.eclipse.jface.viewers.ISelection;	26	import org.eclipse.jface.viewers.ISelection;




import org.eclipse.debug.internal.ui.IInternalDebugUIConstants;
import org.eclipse.debug.internal.ui.actions.ActionMessages;
import org.eclipse.debug.ui.DebugUITools;
import org.eclipse.debug.ui.actions.DebugCommandAction;
import org.eclipse.debug.ui.contexts.DebugContextEvent;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.ui.IWorkbenchPart;

		if (event.getProperty().equals(StepFilterManager.PREF_USE_STEP_FILTERS)) {
			boolean checked = DebugUITools.isUseStepFilters();
			setChecked(checked);
			IAction action = getAction();
			if (action != null) {
				action.setChecked(checked);
			}
		}		
	}




import org.eclipse.debug.internal.ui.DebugPluginImages;
import org.eclipse.debug.internal.ui.IInternalDebugUIConstants;
import org.eclipse.debug.internal.ui.actions.ActionMessages;
import org.eclipse.debug.ui.actions.DebugCommandAction;
import org.eclipse.jface.resource.ImageDescriptor;

/**

 */
public class TerminateAndRemoveAction extends DebugCommandAction {

    
    class TerminateAndRemoveParticipant implements ICommandParticipant {
        private Object[] fElements;
        
        TerminateAndRemoveParticipant(Object[] elements) {
            fElements = elements;
        }
        
		/* (non-Javadoc)
		 * @see org.eclipse.debug.internal.ui.commands.actions.ICommandParticipant#requestDone(org.eclipse.debug.core.commands.IRequest)
		 */
		public void requestDone(IRequest request) {
			IStatus status = request.getStatus();
			if(status == null || status.isOK()) {
				for (int i = 0; i < fElements.length; i++) {
					Object element = fElements[i];
	                ILaunch launch= null;
	                if (element instanceof ILaunch) {
	                    launch= (ILaunch) element;
	                } else if (element instanceof IDebugElement) {
	                    launch= ((IDebugElement) element).getLaunch();
	                } else if (element instanceof IProcess) {
	                    launch= ((IProcess) element).getLaunch();
	                }   
	                if (launch != null)
	                    DebugPlugin.getDefault().getLaunchManager().removeLaunch(launch);					
				}
            }
		}
        
    }

    public String getText() {
        return ActionMessages.TerminateAndRemoveAction_0;
    }

		return ITerminateHandler.class;
	}

    protected void requestDone(Object[] elements, IRequest request) {
        IStatus status = request.getStatus();
        if(status == null || status.isOK()) {
            for (int i = 0; i < elements.length; i++) {
                Object element = elements[i];
                ILaunch launch= null;
                if (element instanceof ILaunch) {
                    launch= (ILaunch) element;
                } else if (element instanceof IDebugElement) {
                    launch= ((IDebugElement) element).getLaunch();
                } else if (element instanceof IProcess) {
                    launch= ((IProcess) element).getLaunch();
                }   
                if (launch != null)
                    DebugPlugin.getDefault().getLaunchManager().removeLaunch(launch);                   
            }
        }
    }

    
}

Lines 14-19 Link Here

(-)ui/org/eclipse/debug/internal/ui/commands/actions/StepIntoCommandAction.java (+1 lines)
14	import org.eclipse.debug.internal.ui.DebugPluginImages;	14	import org.eclipse.debug.internal.ui.DebugPluginImages;
15	import org.eclipse.debug.internal.ui.IInternalDebugUIConstants;	15	import org.eclipse.debug.internal.ui.IInternalDebugUIConstants;
16	import org.eclipse.debug.internal.ui.actions.ActionMessages;	16	import org.eclipse.debug.internal.ui.actions.ActionMessages;
		17	import org.eclipse.debug.ui.actions.DebugCommandAction;
17	import org.eclipse.jface.resource.ImageDescriptor;	18	import org.eclipse.jface.resource.ImageDescriptor;
18		19
19	/**	20	/**

Lines 18-23 Link Here

(-)ui/org/eclipse/debug/internal/ui/commands/actions/TerminateAllAction.java (+1 lines)
18	import org.eclipse.debug.internal.ui.DebugPluginImages;	18	import org.eclipse.debug.internal.ui.DebugPluginImages;
19	import org.eclipse.debug.internal.ui.IInternalDebugUIConstants;	19	import org.eclipse.debug.internal.ui.IInternalDebugUIConstants;
20	import org.eclipse.debug.internal.ui.actions.ActionMessages;	20	import org.eclipse.debug.internal.ui.actions.ActionMessages;
		21	import org.eclipse.debug.ui.actions.DebugCommandAction;
21	import org.eclipse.jface.resource.ImageDescriptor;	22	import org.eclipse.jface.resource.ImageDescriptor;
22	import org.eclipse.jface.viewers.ISelection;	23	import org.eclipse.jface.viewers.ISelection;
23	import org.eclipse.jface.viewers.StructuredSelection;	24	import org.eclipse.jface.viewers.StructuredSelection;

Lines 15-20 Link Here

(-)ui/org/eclipse/debug/internal/ui/commands/actions/DisconnectCommandAction.java (+1 lines)
15	import org.eclipse.debug.internal.ui.IInternalDebugUIConstants;	15	import org.eclipse.debug.internal.ui.IInternalDebugUIConstants;
16	import org.eclipse.debug.internal.ui.actions.ActionMessages;	16	import org.eclipse.debug.internal.ui.actions.ActionMessages;
17	import org.eclipse.debug.ui.IDebugUIConstants;	17	import org.eclipse.debug.ui.IDebugUIConstants;
		18	import org.eclipse.debug.ui.actions.DebugCommandAction;
18	import org.eclipse.jface.resource.ImageDescriptor;	19	import org.eclipse.jface.resource.ImageDescriptor;
19	/**	20	/**
20	* Disconnect action.	21	* Disconnect action.

Lines 14-19 Link Here

(-)ui/org/eclipse/debug/internal/ui/commands/actions/SuspendCommandAction.java (+1 lines)
14	import org.eclipse.debug.internal.ui.DebugPluginImages;	14	import org.eclipse.debug.internal.ui.DebugPluginImages;
15	import org.eclipse.debug.internal.ui.IInternalDebugUIConstants;	15	import org.eclipse.debug.internal.ui.IInternalDebugUIConstants;
16	import org.eclipse.debug.internal.ui.actions.ActionMessages;	16	import org.eclipse.debug.internal.ui.actions.ActionMessages;
		17	import org.eclipse.debug.ui.actions.DebugCommandAction;
17	import org.eclipse.jface.resource.ImageDescriptor;	18	import org.eclipse.jface.resource.ImageDescriptor;
18		19
19	/**	20	/**

Lines 11-16 Link Here

(-)ui/org/eclipse/debug/internal/ui/commands/actions/StepIntoCommandActionDelegate.java (+1 lines)
11		11
12	package org.eclipse.debug.internal.ui.commands.actions;	12	package org.eclipse.debug.internal.ui.commands.actions;
13		13
		14
14	/**	15	/**
15	* Step into action delegate.	16	* Step into action delegate.
16	*	17	*




import org.eclipse.debug.ui.contexts.DebugContextEvent;
import org.eclipse.debug.ui.contexts.IDebugContextListener;
import org.eclipse.debug.ui.contexts.IDebugContextService;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;

	 * @param commandType
	 * @param monitor
	 */
	public void postUpdateCommand(Class commandType, IEnabledTarget action) {
		synchronized (fCommandUpdates) {
			Job.getJobManager().cancel(commandType);
			List actions = (List) fCommandUpdates.get(commandType);

	 * @param commandType
	 * @param requestMonitor
	 */
	public void updateCommand(Class commandType, IEnabledTarget action) {
		ISelection context = fContextService.getActiveContext();
		if (context instanceof IStructuredSelection && !context.isEmpty()) {
			Object[] elements = ((IStructuredSelection)context).toArray();
			updateCommand(commandType, elements, new IEnabledTarget[]{action});
		} else {
			action.setEnabled(false);
		}

				Entry entry = (Entry) iterator.next();
				Class commandType = (Class)entry.getKey();
				List actions = (List) entry.getValue();
				updateCommand(commandType, elements, (IEnabledTarget[]) actions.toArray(new IEnabledTarget[actions.size()]));
			}
		} else {
			Iterator iterator = commands.values().iterator();

	 * @param elements elements to update for
	 * @param monitor status monitor
	 */
	private void updateCommand(Class handlerType, Object[] elements, IEnabledTarget[] actions) {
		if (elements.length == 1) {
			// usual case - one element
			Object element = elements[0];

Lines 14-19 Link Here

(-)ui/org/eclipse/debug/internal/ui/commands/actions/ResumeCommandAction.java (+1 lines)
14	import org.eclipse.debug.internal.ui.DebugPluginImages;	14	import org.eclipse.debug.internal.ui.DebugPluginImages;
15	import org.eclipse.debug.internal.ui.IInternalDebugUIConstants;	15	import org.eclipse.debug.internal.ui.IInternalDebugUIConstants;
16	import org.eclipse.debug.internal.ui.actions.ActionMessages;	16	import org.eclipse.debug.internal.ui.actions.ActionMessages;
		17	import org.eclipse.debug.ui.actions.DebugCommandAction;
17	import org.eclipse.jface.resource.ImageDescriptor;	18	import org.eclipse.jface.resource.ImageDescriptor;
18		19
19	/**	20	/**

Lines 15-20 Link Here

(-)ui/org/eclipse/debug/internal/ui/commands/actions/StepOverCommandAction.java (+1 lines)
15	import org.eclipse.debug.internal.ui.DebugPluginImages;	15	import org.eclipse.debug.internal.ui.DebugPluginImages;
16	import org.eclipse.debug.internal.ui.IInternalDebugUIConstants;	16	import org.eclipse.debug.internal.ui.IInternalDebugUIConstants;
17	import org.eclipse.debug.internal.ui.actions.ActionMessages;	17	import org.eclipse.debug.internal.ui.actions.ActionMessages;
		18	import org.eclipse.debug.ui.actions.DebugCommandAction;
18	import org.eclipse.jface.resource.ImageDescriptor;	19	import org.eclipse.jface.resource.ImageDescriptor;
19		20
20	/**	21	/**




package org.eclipse.debug.internal.ui.commands.actions;

import org.eclipse.debug.ui.DebugUITools;
import org.eclipse.jface.action.IAction;

/**
 * Toggle step filters action delegate.

        setAction(new ToggleStepFiltersAction());
    }

    public void init(IAction action) {
        super.init(action);
        action.setChecked(DebugUITools.isUseStepFilters());
    }
		super.init(window);
		setChecked(DebugUITools.isUseStepFilters());
	}
}

Lines 14-19 Link Here

(-)ui/org/eclipse/debug/internal/ui/commands/actions/TerminateCommandAction.java (+1 lines)
14	import org.eclipse.debug.internal.ui.DebugPluginImages;	14	import org.eclipse.debug.internal.ui.DebugPluginImages;
15	import org.eclipse.debug.internal.ui.IInternalDebugUIConstants;	15	import org.eclipse.debug.internal.ui.IInternalDebugUIConstants;
16	import org.eclipse.debug.internal.ui.actions.ActionMessages;	16	import org.eclipse.debug.internal.ui.actions.ActionMessages;
		17	import org.eclipse.debug.ui.actions.DebugCommandAction;
17	import org.eclipse.jface.resource.ImageDescriptor;	18	import org.eclipse.jface.resource.ImageDescriptor;
18		19
19	/**	20	/**

Lines 11-16 Link Here

(-)ui/org/eclipse/debug/internal/ui/commands/actions/TerminateCommandActionDelegate.java (+1 lines)
11		11
12	package org.eclipse.debug.internal.ui.commands.actions;	12	package org.eclipse.debug.internal.ui.commands.actions;
13		13
		14
14	/**	15	/**
15	* Terminate action delegate.	16	* Terminate action delegate.
16	*	17	*




/*******************************************************************************
 * Copyright (c) 2006, 2007 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:
 *     Wind River Systems - initial API and implementation
 *******************************************************************************/

package org.eclipse.debug.ui.actions;

import java.util.Iterator;
import java.util.Map;
import java.util.WeakHashMap;

import org.eclipse.core.commands.AbstractHandler;
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.commands.HandlerEvent;
import org.eclipse.core.expressions.IEvaluationContext;
import org.eclipse.debug.internal.ui.commands.actions.DebugCommandService;
import org.eclipse.debug.internal.ui.commands.actions.ICommandParticipant;
import org.eclipse.debug.internal.ui.commands.actions.IEnabledTarget;
import org.eclipse.debug.ui.DebugUITools;
import org.eclipse.debug.ui.contexts.DebugContextEvent;
import org.eclipse.debug.ui.contexts.IDebugContextListener;
import org.eclipse.debug.ui.contexts.IDebugContextService;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.ui.ISources;
import org.eclipse.ui.IWindowListener;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.handlers.HandlerUtil;

/**
 * Abstract base class for re-targeting command framework handlers, which 
 * delegate execution to {@link org.eclipse.debug.core.commands.IDebugCommandHandler} 
 * handlers. The specific type of <code>IDebugCommandHandler</code> is 
 * determined by the abstract {@link #getCommandType()} method.    
 * 
 * <p> Note: This class is not an implementation of the <code>IDebugCommandHandler</code>
 * interface, which was somewhat unfortunately named.  <code>IDebugCommandHandler</code> 
 * is an interface that is internal to the debugger plugins.  This class implements 
 * {@link org.eclipse.core.commands.IHandler} interface and is to be used with the 
 * platform commands framework. </p>
 * 
 * @see org.eclipse.debug.core.commands.IDebugCommandHandler
 * @see org.eclipse.core.commands.IHandler
 *
 * @since 3.6
 */
public abstract class DebugCommandHandler extends AbstractHandler {

    private class EnabledTarget implements IEnabledTarget, IDebugContextListener, IWindowListener {
        boolean fEnabled = getInitialEnablement();
        IWorkbenchWindow fWindow;
        
        EnabledTarget(IWorkbenchWindow window) {
            fWindow = window;
            DebugCommandService.getService(fWindow).updateCommand(getCommandType(), this);
            getContextService(fWindow).addDebugContextListener(this);
            PlatformUI.getWorkbench().addWindowListener(this);
        }
        
        public void setEnabled(boolean enabled) {
            boolean oldEnabled = fEnabled;
            fEnabled = enabled;
            if (fEnabled != oldEnabled) {
                fireHandlerChanged(new HandlerEvent(DebugCommandHandler.this, true, false));
            }
        }
        
        public void debugContextChanged(DebugContextEvent event) {
            DebugCommandService.getService(fWindow).postUpdateCommand(getCommandType(), this);
        }
        
        public void windowOpened(IWorkbenchWindow w) {
        }
    
        public void windowDeactivated(IWorkbenchWindow w) {
        }
    
        public void windowClosed(IWorkbenchWindow w) {
            if (w.equals(fWindow)) {
                dispose();
            }
        }
    
        public void windowActivated(IWorkbenchWindow w) {
        }
        
        void dispose() {
            if (isDisposed()) {
                return;
            }
            PlatformUI.getWorkbench().removeWindowListener(this);
            getContextService(fWindow).removeDebugContextListener(this);
            fWindow = null;
        }
        
        boolean isDisposed() {
            return fWindow == null;
        }
    }

    private Map fEnabledTargetsMap = new WeakHashMap();

    private EnabledTarget fCurrentEnabledTarget = null;
    
    /**
     * Constructor
     */
    public DebugCommandHandler() {
        super();
        PlatformUI.getWorkbench().addWindowListener(new IWindowListener() {
            
            public void windowOpened(IWorkbenchWindow w) {
            }
        
            public void windowDeactivated(IWorkbenchWindow w) {
            }
        
            public void windowClosed(IWorkbenchWindow w) {
                EnabledTarget enabledTarget = (EnabledTarget)fEnabledTargetsMap.get(w);
                if (enabledTarget != null) {
                    enabledTarget.dispose();
                }
            }
        
            public void windowActivated(IWorkbenchWindow w) {
            }
        });
    }
    
    public void setEnabled(Object evaluationContext) {
        fCurrentEnabledTarget = null;
        
        if (!(evaluationContext instanceof IEvaluationContext)) {
            return;
        }
        IEvaluationContext context = (IEvaluationContext) evaluationContext;
        Object _window = context.getVariable(ISources.ACTIVE_WORKBENCH_WINDOW_NAME);
        if (_window instanceof IWorkbenchWindow) {
            IWorkbenchWindow window = (IWorkbenchWindow)_window;
            fCurrentEnabledTarget = getEnabledTarget(window);
        }
    }
    
    public boolean isEnabled() {
        if (fCurrentEnabledTarget == null) {
            return false;
        }
        return fCurrentEnabledTarget.fEnabled;
    }
    
    private EnabledTarget getEnabledTarget(IWorkbenchWindow window) {
        EnabledTarget target = (EnabledTarget)fEnabledTargetsMap.get(window);
        if (target == null) {
            target = new EnabledTarget(window);
            DebugCommandService service = DebugCommandService.getService(window);
            service.updateCommand(getCommandType(), target);
            
            DebugUITools.getDebugContextManager().getContextService(window).addDebugContextListener(target);
            
            fEnabledTargetsMap.put(window, target);
        }
        return target;
    }
    
    public Object execute(ExecutionEvent event) throws ExecutionException {
        IWorkbenchWindow window = HandlerUtil.getActiveWorkbenchWindow(event);
        if (window == null) {
            throw new ExecutionException("No active workbench window.");
        }
        fCurrentEnabledTarget = getEnabledTarget(window);

        ISelection selection = getContextService(window).getActiveContext();
        if (selection instanceof IStructuredSelection && isEnabled()) {
            IStructuredSelection ss = (IStructuredSelection) selection;
            boolean enabledAfterExecute = execute(window, ss.toArray());
            
            // enable/disable the action according to the command
            fCurrentEnabledTarget.setEnabled(enabledAfterExecute);
        }

        return null;
    }
    
    private IDebugContextService getContextService(IWorkbenchWindow window) {
        return DebugUITools.getDebugContextManager().getContextService(window);
    }
    
    /**
     * Executes this action on the given target object
     * 
     * @param target the target to perform the action on
     */
    private boolean execute(IWorkbenchWindow window, Object[] targets) {
        DebugCommandService service = DebugCommandService.getService(window); 
    	return service.executeCommand(getCommandType(), targets, getCommandParticipant(targets));
    }
    
    /**
     * Creates and returns the command participant or <code>null</code>.
     * 
     * @return command participant to use on command completion
     */
    protected ICommandParticipant getCommandParticipant(Object[] targets) {
    	return null;
    }
    
    /**
     * Returns the {@link org.eclipse.debug.core.commands.IDebugCommandHandler} 
     * command handler that type this action executes.
     * 
     * @return command class.
     * 
     * @see org.eclipse.debug.core.commands.IDebugCommandHandler
     */
    abstract protected Class getCommandType();  

    
    /**
     * Returns whether this action should be enabled when initialized
     * and there is no active debug context.
     * 
     * @return false, by default
     */
    protected boolean getInitialEnablement() {
    	return false;
    }


    /**
     * Clean up when removing
     */
    public void dispose() {
        for (Iterator itr = fEnabledTargetsMap.values().iterator(); itr.hasNext();) {
            EnabledTarget target = (EnabledTarget)itr.next();
            if (!target.isDisposed()) {
                target.dispose();
            }
        }
        fEnabledTargetsMap.clear();
        fCurrentEnabledTarget = null;
    }
}




/*******************************************************************************
 * Copyright (c) 2008 Wind River Systems 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:
 *     Wind River Systems - initial API and implementation
 *******************************************************************************/
package org.eclipse.debug.internal.ui.commands.actions;

/**
 * 
 */
public interface IEnabledTarget {
    public void setEnabled(boolean enabled);
}




/*******************************************************************************
 * Copyright (c) 2006, 2007 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.debug.ui.actions;

import org.eclipse.debug.core.IRequest;
import org.eclipse.debug.internal.ui.commands.actions.DebugCommandService;
import org.eclipse.debug.internal.ui.commands.actions.ICommandParticipant;
import org.eclipse.debug.internal.ui.commands.actions.IEnabledTarget;
import org.eclipse.debug.ui.DebugUITools;
import org.eclipse.debug.ui.contexts.DebugContextEvent;
import org.eclipse.debug.ui.contexts.IDebugContextListener;
import org.eclipse.debug.ui.contexts.IDebugContextService;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.swt.widgets.Event;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PlatformUI;

/**
 * Abstract base class for re-targeting actions which delegate execution to 
 * {@link org.eclipse.debug.core.commands.IDebugCommandHandler} handlers.  
 * The specific type of <code>IDebugCommandHandler</code> is determined by the 
 * abstract {@link #getCommandType()} method.    
 * 
 * @see org.eclipse.debug.core.commands.IDebugCommandHandler
 *
 * @since 3.6 This class was in the internal package 
 * <code>org.eclipse.debug.internal.ui.commands.actions</code> since 3.3.
 */
public abstract class DebugCommandAction extends Action implements IDebugContextListener {

    private boolean fInitialized = false;
    
	/**
	 * The window this action is working for.
	 */
    private IWorkbenchWindow fWindow;
    
    /**
     * The part this action is working for, or <code>null</code> if global to
     * a window.
     */
    private IWorkbenchPart fPart;
    
    /**
     * Command service.
     */
    private DebugCommandService fUpdateService;
    
    /**
     * Delegate this action is working for or <code>null</code> if none.
     */
    private IAction fAction;

    private IEnabledTarget fEnabledTarget = new IEnabledTarget() {
        public void setEnabled(boolean enabled) {
            DebugCommandAction.this.setEnabled(enabled);
        }
    };
    
    /**
     * Constructor
     */
    public DebugCommandAction() {
        super();
        String helpContextId = getHelpContextId();
        if (helpContextId != null)
            PlatformUI.getWorkbench().getHelpSystem().setHelp(this, helpContextId);
        setEnabled(false);
    }

	/**
     * Set the current delegate
     * @param delegate
     */
    public void setAction(IAction action) {
        fAction = action;
        fAction.setEnabled(isEnabled());
    }

    /**
     * Executes this action on the given target object
     * 
     * @param target the target to perform the action on
     */
    private boolean execute(final Object[] targets) {
    	return fUpdateService.executeCommand(
    	    getCommandType(), targets, 
    	    new ICommandParticipant() {
    	        public void requestDone(org.eclipse.debug.core.IRequest request) {
    	            DebugCommandAction.this.requestDone(targets, request);
    	        }    	      
    	    });
    }
        
    protected void requestDone(Object[] targets, IRequest request) {
        // do nothing by default
    }
    
    /**
     * Returns the {@link org.eclipse.debug.core.commands.IDebugCommandHandler} 
     * command handler that type this action executes.
     * 
     * @return command class.
     * 
     * @see org.eclipse.debug.core.commands.IDebugCommandHandler
     */
    abstract protected Class getCommandType();  

    /**
     * @see org.eclipse.debug.ui.contexts.IDebugContextListener#debugContextChanged(org.eclipse.debug.ui.contexts.DebugContextEvent)
     */
    public void debugContextChanged(DebugContextEvent event) {
    	fUpdateService.postUpdateCommand(getCommandType(), fEnabledTarget);
	}

    /**
     * @see org.eclipse.jface.action.Action#setEnabled(boolean)
     */
    public void setEnabled(boolean enabled) {
        synchronized (this) {
            if (!fInitialized) {
                fInitialized = true;
                notifyAll();
            }
        }        
        super.setEnabled(enabled);
        if (fAction != null) {
            fAction.setEnabled(enabled);
        }
    }

    /**
     * Initializes this action for a specific part.
     * 
     * @param part workbench part
     */
    public void init(IWorkbenchPart part) {
        fPart = part;
        fWindow = part.getSite().getWorkbenchWindow();
        fUpdateService = DebugCommandService.getService(fWindow);
        IDebugContextService service = getDebugContextService();
		String partId = part.getSite().getId();
		service.addDebugContextListener(this, partId);
        ISelection activeContext = service.getActiveContext(partId);
        if (activeContext != null) {
        	fUpdateService.updateCommand(getCommandType(), fEnabledTarget);
        } else {
        	setEnabled(getInitialEnablement());
        }
    }
    
    /**
     * Initializes the context action
     * @param window the window
     */
    public void init(IWorkbenchWindow window) {
        fWindow = window;
        fUpdateService = DebugCommandService.getService(fWindow);
        IDebugContextService contextService = getDebugContextService();
		contextService.addDebugContextListener(this);
        ISelection activeContext = contextService.getActiveContext();
        if (activeContext != null) {
        	fUpdateService.updateCommand(getCommandType(), fEnabledTarget);
        } else {
        	setEnabled(getInitialEnablement());
        }
    }
    
    /**
     * Returns whether this action should be enabled when initialized
     * and there is no active debug context.
     * 
     * @return false, by default
     */
    protected boolean getInitialEnablement() {
    	return false;
    }

    /**
     * Returns the most recent selection
     * 
     * @return structured selection
     */
    private ISelection getContext() {
		if (fPart != null) {
			getDebugContextService().getActiveContext(fPart.getSite().getId());
    	}
        return getDebugContextService().getActiveContext();
    }

    /*
     * (non-Javadoc)
     * @see org.eclipse.jface.action.Action#run()
     */
    public void run() {
        synchronized (this) {
            if (!fInitialized) {
                try {
                    wait();
                } catch (InterruptedException e) {
                }
            }           
        }        
        
        ISelection selection = getContext();
        if (selection instanceof IStructuredSelection && isEnabled()) {
            IStructuredSelection ss = (IStructuredSelection) selection;
            boolean enabled = execute(ss.toArray());
            // disable the action according to the command
            setEnabled(enabled);
        }
    }

    /*
     * (non-Javadoc)
     * @see org.eclipse.jface.action.Action#runWithEvent(org.eclipse.swt.widgets.Event)
     */
    public void runWithEvent(Event event) {
        run();
    }

    /**
     * Clean up when removing
     */
    public void dispose() {
        IDebugContextService service = getDebugContextService();
        if (fPart != null) {
        	service.removeDebugContextListener(this, fPart.getSite().getId());
        } else {
            service.removeDebugContextListener(this);
        }
        fWindow = null;
        fPart = null;
    }
    
    /**
     * Returns the context service this action linked to.
     * @return
     */
    protected IDebugContextService getDebugContextService() {
    	return DebugUITools.getDebugContextManager().getContextService(fWindow);
    }

    /**
     * @return The help context id for this action
     */ 
    public abstract String getHelpContextId();

    /*
     * (non-Javadoc)
     * @see org.eclipse.jface.action.Action#getId()
     */
    public abstract String getId();

    /*
     * (non-Javadoc)
     * @see org.eclipse.jface.action.Action#getText()
     */
    public abstract String getText();

    /*
     * (non-Javadoc)
     * @see org.eclipse.jface.action.Action#getToolTipText()
     */
    public abstract String getToolTipText();

    /*
     * (non-Javadoc)
     * @see org.eclipse.jface.action.Action#getDisabledImageDescriptor()
     */
    public abstract ImageDescriptor getDisabledImageDescriptor();

    /*
     * (non-Javadoc)
     * @see org.eclipse.jface.action.Action#getHoverImageDescriptor()
     */
    public abstract ImageDescriptor getHoverImageDescriptor();

    /*
     * (non-Javadoc)
     * @see org.eclipse.jface.action.Action#getImageDescriptor()
     */
    public abstract ImageDescriptor getImageDescriptor();
    
    /**
     * Returns the delegate associated with this action or <code>null</code>
     * if none.
     * 
     * @return delegate or <code>null</code>
     */
    protected IAction getAction() {
    	return fAction;
    }
}

Return to bug 284363

Removed Link Here

(-)core/org/eclipse/debug/internal/core/commands/DebugCommand.java (-324 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006, 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.debug.internal.core.commands;
12
13	import java.util.LinkedHashSet;
14
15	import org.eclipse.core.runtime.CoreException;
16	import org.eclipse.core.runtime.IProgressMonitor;
17	import org.eclipse.core.runtime.IStatus;
18	import org.eclipse.core.runtime.Status;
19	import org.eclipse.core.runtime.jobs.IJobChangeEvent;
20	import org.eclipse.core.runtime.jobs.IJobChangeListener;
21	import org.eclipse.core.runtime.jobs.ISchedulingRule;
22	import org.eclipse.core.runtime.jobs.Job;
23	import org.eclipse.debug.core.DebugPlugin;
24	import org.eclipse.debug.core.IRequest;
25	import org.eclipse.debug.core.commands.IDebugCommandHandler;
26	import org.eclipse.debug.core.commands.IDebugCommandRequest;
27	import org.eclipse.debug.core.commands.IEnabledStateRequest;
28	import org.eclipse.debug.internal.core.DebugOptions;
29
30	/**
31	* Common function for standard debug commands.
32	*
33	* @since 3.3
34	*
35	*/
36	public abstract class DebugCommand implements IDebugCommandHandler {
37
38	/**
39	* Job to update enabled state of action.
40	*/
41	class UpdateJob extends Job implements IJobChangeListener {
42
43	/**
44	* The request to update
45	*/
46	private IEnabledStateRequest request;
47
48	/**
49	* Whether this job has been run
50	*/
51	private boolean run = false;
52
53	/**
54	* Creates a new job to update the specified request
55	*
56	* @param stateRequest
57	*/
58	UpdateJob(IEnabledStateRequest stateRequest) {
59	super(getEnablementTaskName());
60	request = stateRequest;
61	setSystem(true);
62	setRule(createUpdateSchedulingRule(request));
63	getJobManager().addJobChangeListener(this);
64	}
65
66	protected IStatus run(IProgressMonitor monitor) {
67	run = true;
68	if (DebugOptions.DEBUG_COMMANDS) {
69	System.out.print("can execute command: " + DebugCommand.this); //$NON-NLS-1$
70	}
71	if (monitor.isCanceled()) {
72	if (DebugOptions.DEBUG_COMMANDS) {
73	System.out.println(" >> CANCELED <<"); //$NON-NLS-1$
74	}
75	request.cancel();
76	}
77	Object[] elements = request.getElements();
78	Object[] targets = new Object[elements.length];
79	if (!request.isCanceled()) {
80	for (int i = 0; i < elements.length; i++) {
81	targets[i] = getTarget(elements[i]);
82	if (targets[i] == null) {
83	request.setEnabled(false);
84	request.cancel();
85	if (DebugOptions.DEBUG_COMMANDS) {
86	System.out.println(" >> false (no adapter)"); //$NON-NLS-1$
87	}
88	}
89	}
90	if (monitor.isCanceled()) {
91	request.cancel();
92	}
93	}
94	if (!request.isCanceled()) {
95	targets = coalesce(targets);
96	monitor.beginTask(getEnablementTaskName(), targets.length);
97	try {
98	boolean executable = isExecutable(targets, monitor, request);
99	if (DebugOptions.DEBUG_COMMANDS) {
100	System.out.println(" >> " + executable); //$NON-NLS-1$
101	}
102	request.setEnabled(executable);
103	} catch (CoreException e) {
104	request.setStatus(e.getStatus());
105	request.setEnabled(false);
106	if (DebugOptions.DEBUG_COMMANDS) {
107	System.out.println(" >> ABORTED"); //$NON-NLS-1$
108	System.out.println("\t" + e.getStatus().getMessage()); //$NON-NLS-1$
109	}
110	}
111	}
112	monitor.setCanceled(request.isCanceled());
113	request.done();
114	monitor.done();
115	return Status.OK_STATUS;
116	}
117
118	/* (non-Javadoc)
119	* @see org.eclipse.core.runtime.jobs.Job#belongsTo(java.lang.Object)
120	*/
121	public boolean belongsTo(Object family) {
122	return getUpdateJobFamily().equals(family);
123	}
124
125	public void aboutToRun(IJobChangeEvent event) {
126	}
127
128	public void awake(IJobChangeEvent event) {
129	}
130
131	public void done(IJobChangeEvent event) {
132	if (event.getJob() == this) {
133	if (!run) {
134	request.cancel();
135	request.done();
136	if (DebugOptions.DEBUG_COMMANDS) {
137	System.out.println(" >> CANCELED <<" + DebugCommand.this); //$NON-NLS-1$
138	}
139	}
140	getJobManager().removeJobChangeListener(this);
141	}
142	}
143
144	public void running(IJobChangeEvent event) {
145	}
146
147	public void scheduled(IJobChangeEvent event) {
148	}
149
150	public void sleeping(IJobChangeEvent event) {
151	}
152
153	}
154
155	/**
156	* Scheduling rule to serialize commands on an object
157	*/
158	class SerialPerObjectRule implements ISchedulingRule {
159
160	private Object fObject = null;
161
162	public SerialPerObjectRule(Object lock) {
163	fObject = lock;
164	}
165
166	/*
167	* (non-Javadoc)
168	*
169	* @see org.eclipse.core.runtime.jobs.ISchedulingRule#contains(org.eclipse.core.runtime.jobs.ISchedulingRule)
170	*/
171	public boolean contains(ISchedulingRule rule) {
172	return rule == this;
173	}
174
175	/*
176	* (non-Javadoc)
177	*
178	* @see org.eclipse.core.runtime.jobs.ISchedulingRule#isConflicting(org.eclipse.core.runtime.jobs.ISchedulingRule)
179	*/
180	public boolean isConflicting(ISchedulingRule rule) {
181	if (rule instanceof SerialPerObjectRule) {
182	SerialPerObjectRule vup = (SerialPerObjectRule) rule;
183	return fObject == vup.fObject;
184	}
185	return false;
186	}
187
188	}
189
190	public boolean execute(final IDebugCommandRequest request) {
191	Job job = new Job(getExecuteTaskName()) {
192	protected IStatus run(IProgressMonitor monitor) {
193	if (DebugOptions.DEBUG_COMMANDS) {
194	System.out.println("execute: " + DebugCommand.this); //$NON-NLS-1$
195	}
196	Object[] elements = request.getElements();
197	Object[] targets = new Object[elements.length];
198	for (int i = 0; i < elements.length; i++) {
199	targets[i]= getTarget(elements[i]);
200	}
201	targets = coalesce(targets);
202	monitor.beginTask(getExecuteTaskName(), targets.length);
203	try {
204	doExecute(targets, monitor, request);
205	} catch (CoreException e) {
206	request.setStatus(e.getStatus());
207	if (DebugOptions.DEBUG_COMMANDS) {
208	System.out.println("\t" + e.getStatus().getMessage()); //$NON-NLS-1$
209	}
210	}
211	request.done();
212	monitor.setCanceled(request.isCanceled());
213	monitor.done();
214	return Status.OK_STATUS;
215	}
216	};
217	job.setSystem(true);
218	job.schedule();
219	return isRemainEnabled();
220	}
221
222	/**
223	* Returns whether this command should remain enabled after execution is invoked.
224	*
225	* @return whether to remain enabled
226	*/
227	protected boolean isRemainEnabled() {
228	return false;
229	}
230
231	public void canExecute(final IEnabledStateRequest request) {
232	Job job = new UpdateJob(request);
233	job.schedule();
234	}
235
236	/**
237	* Returns the name to use for jobs and progress monitor task names when checking
238	* enabled state.
239	*
240	* @return task name
241	*/
242	protected String getEnablementTaskName() {
243	// this is a system job name and does not need to be NLS'd
244	return "Check Debug Command"; //$NON-NLS-1$
245	}
246
247	/**
248	* Returns the name to use for jobs and progress monitor task names when executing
249	* a debug command
250	*
251	* @return task name
252	*/
253	protected String getExecuteTaskName() {
254	// this is a system job name and does not need to be NLS'd
255	return "Execute Debug Command"; //$NON-NLS-1$
256	}
257
258	/**
259	* Executes the actual operation.
260	*
261	* @param targets objects to perform on
262	* @param request request
263	*/
264	protected abstract void doExecute(Object[] targets, IProgressMonitor monitor, IRequest request) throws CoreException;
265
266	/**
267	* Returns whether this command is executable.
268	*
269	* @param targets objects to check command for
270	* @param monitor progress monitor
271	* @param request request
272	* @return whether this command can be executed
273	*/
274	protected abstract boolean isExecutable(Object[] targets, IProgressMonitor monitor, IEnabledStateRequest request) throws CoreException;
275
276	/**
277	* Returns the appropriate command adapter from the given object.
278	*
279	* @param element object to obtain adapter from
280	* @return adapter
281	*/
282	protected abstract Object getTarget(Object element);
283
284	/**
285	* Returns an adapter of the specified type for the given object or <code>null</code>
286	* if none. The object itself is returned if it is an instance of the specified type.
287	*
288	* @param element element to retrieve adapter for
289	* @param type adapter type
290	* @return adapter or <code>null</code>
291	*/
292	protected Object getAdapter(Object element, Class type) {
293	return DebugPlugin.getAdapter(element, type);
294	}
295
296	/**
297	* Scheduling rule for updating command enabled state.
298	*
299	* @return scheduling rule or <code>null</code>
300	*/
301	protected ISchedulingRule createUpdateSchedulingRule(IDebugCommandRequest request) {
302	return new SerialPerObjectRule(request.getElements()[0]);
303	}
304
305	private Object[] coalesce(Object[] objects) {
306	if (objects.length == 1) {
307	return objects;
308	} else {
309	LinkedHashSet set = new LinkedHashSet(objects.length);
310	for (int i = 0; i < objects.length; i++) {
311	set.add(objects[i]);
312	}
313	return set.toArray();
314	}
315	}
316
317	/**
318	* Returns the job family for this command's "can execute" job.
319	*
320	* @return the job family for this command's "can execute" job
321	*/
322	protected abstract Object getUpdateJobFamily();
323
324	}

Added Link Here

(-)core/org/eclipse/debug/core/commands/AbstractDebugCommand.java (+322 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006, 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.debug.core.commands;
12
13	import java.util.LinkedHashSet;
14
15	import org.eclipse.core.runtime.CoreException;
16	import org.eclipse.core.runtime.IProgressMonitor;
17	import org.eclipse.core.runtime.IStatus;
18	import org.eclipse.core.runtime.Status;
19	import org.eclipse.core.runtime.jobs.IJobChangeEvent;
20	import org.eclipse.core.runtime.jobs.IJobChangeListener;
21	import org.eclipse.core.runtime.jobs.ISchedulingRule;
22	import org.eclipse.core.runtime.jobs.Job;
23	import org.eclipse.debug.core.DebugPlugin;
24	import org.eclipse.debug.core.IRequest;
25	import org.eclipse.debug.internal.core.DebugOptions;
26
27	/**
28	* Common function for standard debug commands.
29	*
30	* @since 3.6 This class was in the internal package
31	* <code>org.eclipse.debug.internal.core.commands</code> since 3.3.
32	*
33	*/
34	public abstract class AbstractDebugCommand implements IDebugCommandHandler {
35
36	/**
37	* Job to update enabled state of action.
38	*/
39	private class UpdateJob extends Job implements IJobChangeListener {
40
41	/**
42	* The request to update
43	*/
44	private IEnabledStateRequest request;
45
46	/**
47	* Whether this job has been run
48	*/
49	private boolean run = false;
50
51	/**
52	* Creates a new job to update the specified request
53	*
54	* @param stateRequest
55	*/
56	UpdateJob(IEnabledStateRequest stateRequest) {
57	super(getEnablementTaskName());
58	request = stateRequest;
59	setSystem(true);
60	setRule(createUpdateSchedulingRule(request));
61	getJobManager().addJobChangeListener(this);
62	}
63
64	protected IStatus run(IProgressMonitor monitor) {
65	run = true;
66	if (DebugOptions.DEBUG_COMMANDS) {
67	System.out.print("can execute command: " + AbstractDebugCommand.this); //$NON-NLS-1$
68	}
69	if (monitor.isCanceled()) {
70	if (DebugOptions.DEBUG_COMMANDS) {
71	System.out.println(" >> CANCELED <<"); //$NON-NLS-1$
72	}
73	request.cancel();
74	}
75	Object[] elements = request.getElements();
76	Object[] targets = new Object[elements.length];
77	if (!request.isCanceled()) {
78	for (int i = 0; i < elements.length; i++) {
79	targets[i] = getTarget(elements[i]);
80	if (targets[i] == null) {
81	request.setEnabled(false);
82	request.cancel();
83	if (DebugOptions.DEBUG_COMMANDS) {
84	System.out.println(" >> false (no adapter)"); //$NON-NLS-1$
85	}
86	}
87	}
88	if (monitor.isCanceled()) {
89	request.cancel();
90	}
91	}
92	if (!request.isCanceled()) {
93	targets = coalesce(targets);
94	monitor.beginTask(getEnablementTaskName(), targets.length);
95	try {
96	boolean executable = isExecutable(targets, monitor, request);
97	if (DebugOptions.DEBUG_COMMANDS) {
98	System.out.println(" >> " + executable); //$NON-NLS-1$
99	}
100	request.setEnabled(executable);
101	} catch (CoreException e) {
102	request.setStatus(e.getStatus());
103	request.setEnabled(false);
104	if (DebugOptions.DEBUG_COMMANDS) {
105	System.out.println(" >> ABORTED"); //$NON-NLS-1$
106	System.out.println("\t" + e.getStatus().getMessage()); //$NON-NLS-1$
107	}
108	}
109	}
110	monitor.setCanceled(request.isCanceled());
111	request.done();
112	monitor.done();
113	return Status.OK_STATUS;
114	}
115
116	/* (non-Javadoc)
117	* @see org.eclipse.core.runtime.jobs.Job#belongsTo(java.lang.Object)
118	*/
119	public boolean belongsTo(Object family) {
120	return getUpdateJobFamily().equals(family);
121	}
122
123	public void aboutToRun(IJobChangeEvent event) {
124	}
125
126	public void awake(IJobChangeEvent event) {
127	}
128
129	public void done(IJobChangeEvent event) {
130	if (event.getJob() == this) {
131	if (!run) {
132	request.cancel();
133	request.done();
134	if (DebugOptions.DEBUG_COMMANDS) {
135	System.out.println(" >> CANCELED <<" + AbstractDebugCommand.this); //$NON-NLS-1$
136	}
137	}
138	getJobManager().removeJobChangeListener(this);
139	}
140	}
141
142	public void running(IJobChangeEvent event) {
143	}
144
145	public void scheduled(IJobChangeEvent event) {
146	}
147
148	public void sleeping(IJobChangeEvent event) {
149	}
150
151	}
152
153	/**
154	* Scheduling rule to serialize commands on an object
155	*/
156	private class SerialPerObjectRule implements ISchedulingRule {
157
158	private Object fObject = null;
159
160	public SerialPerObjectRule(Object lock) {
161	fObject = lock;
162	}
163
164	/*
165	* (non-Javadoc)
166	*
167	* @see org.eclipse.core.runtime.jobs.ISchedulingRule#contains(org.eclipse.core.runtime.jobs.ISchedulingRule)
168	*/
169	public boolean contains(ISchedulingRule rule) {
170	return rule == this;
171	}
172
173	/*
174	* (non-Javadoc)
175	*
176	* @see org.eclipse.core.runtime.jobs.ISchedulingRule#isConflicting(org.eclipse.core.runtime.jobs.ISchedulingRule)
177	*/
178	public boolean isConflicting(ISchedulingRule rule) {
179	if (rule instanceof SerialPerObjectRule) {
180	SerialPerObjectRule vup = (SerialPerObjectRule) rule;
181	return fObject == vup.fObject;
182	}
183	return false;
184	}
185
186	}
187
188	public boolean execute(final IDebugCommandRequest request) {
189	Job job = new Job(getExecuteTaskName()) {
190	protected IStatus run(IProgressMonitor monitor) {
191	if (DebugOptions.DEBUG_COMMANDS) {
192	System.out.println("execute: " + AbstractDebugCommand.this); //$NON-NLS-1$
193	}
194	Object[] elements = request.getElements();
195	Object[] targets = new Object[elements.length];
196	for (int i = 0; i < elements.length; i++) {
197	targets[i]= getTarget(elements[i]);
198	}
199	targets = coalesce(targets);
200	monitor.beginTask(getExecuteTaskName(), targets.length);
201	try {
202	doExecute(targets, monitor, request);
203	} catch (CoreException e) {
204	request.setStatus(e.getStatus());
205	if (DebugOptions.DEBUG_COMMANDS) {
206	System.out.println("\t" + e.getStatus().getMessage()); //$NON-NLS-1$
207	}
208	}
209	request.done();
210	monitor.setCanceled(request.isCanceled());
211	monitor.done();
212	return Status.OK_STATUS;
213	}
214	};
215	job.setSystem(true);
216	job.schedule();
217	return isRemainEnabled();
218	}
219
220	/**
221	* Returns whether this command should remain enabled after execution is invoked.
222	*
223	* @return whether to remain enabled
224	*/
225	protected boolean isRemainEnabled() {
226	return false;
227	}
228
229	public void canExecute(final IEnabledStateRequest request) {
230	Job job = new UpdateJob(request);
231	job.schedule();
232	}
233
234	/**
235	* Returns the name to use for jobs and progress monitor task names when checking
236	* enabled state.
237	*
238	* @return task name
239	*/
240	protected String getEnablementTaskName() {
241	// this is a system job name and does not need to be NLS'd
242	return "Check Debug Command"; //$NON-NLS-1$
243	}
244
245	/**
246	* Returns the name to use for jobs and progress monitor task names when executing
247	* a debug command
248	*
249	* @return task name
250	*/
251	protected String getExecuteTaskName() {
252	// this is a system job name and does not need to be NLS'd
253	return "Execute Debug Command"; //$NON-NLS-1$
254	}
255
256	/**
257	* Executes the actual operation.
258	*
259	* @param targets objects to perform on
260	* @param request request
261	*/
262	protected abstract void doExecute(Object[] targets, IProgressMonitor monitor, IRequest request) throws CoreException;
263
264	/**
265	* Returns whether this command is executable.
266	*
267	* @param targets objects to check command for
268	* @param monitor progress monitor
269	* @param request request
270	* @return whether this command can be executed
271	*/
272	protected abstract boolean isExecutable(Object[] targets, IProgressMonitor monitor, IEnabledStateRequest request) throws CoreException;
273
274	/**
275	* Returns the appropriate command adapter from the given object.
276	*
277	* @param element object to obtain adapter from
278	* @return adapter
279	*/
280	protected abstract Object getTarget(Object element);
281
282	/**
283	* Returns an adapter of the specified type for the given object or <code>null</code>
284	* if none. The object itself is returned if it is an instance of the specified type.
285	*
286	* @param element element to retrieve adapter for
287	* @param type adapter type
288	* @return adapter or <code>null</code>
289	*/
290	protected Object getAdapter(Object element, Class type) {
291	return DebugPlugin.getAdapter(element, type);
292	}
293
294	/**
295	* Scheduling rule for updating command enabled state.
296	*
297	* @return scheduling rule or <code>null</code>
298	*/
299	protected ISchedulingRule createUpdateSchedulingRule(IDebugCommandRequest request) {
300	return new SerialPerObjectRule(request.getElements()[0]);
301	}
302
303	private Object[] coalesce(Object[] objects) {
304	if (objects.length == 1) {
305	return objects;
306	} else {
307	LinkedHashSet set = new LinkedHashSet(objects.length);
308	for (int i = 0; i < objects.length; i++) {
309	set.add(objects[i]);
310	}
311	return set.toArray();
312	}
313	}
314
315	/**
316	* Returns the job family for this command's "can execute" job.
317	*
318	* @return the job family for this command's "can execute" job
319	*/
320	protected abstract Object getUpdateJobFamily();
321
322	}

Removed Link Here

(-)ui/org/eclipse/debug/internal/ui/commands/actions/DebugCommandAction.java (-269 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006, 2007 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11
12	package org.eclipse.debug.internal.ui.commands.actions;
13
14	import org.eclipse.debug.ui.DebugUITools;
15	import org.eclipse.debug.ui.contexts.DebugContextEvent;
16	import org.eclipse.debug.ui.contexts.IDebugContextListener;
17	import org.eclipse.debug.ui.contexts.IDebugContextService;
18	import org.eclipse.jface.action.Action;
19	import org.eclipse.jface.resource.ImageDescriptor;
20	import org.eclipse.jface.viewers.ISelection;
21	import org.eclipse.jface.viewers.IStructuredSelection;
22	import org.eclipse.swt.widgets.Event;
23	import org.eclipse.ui.IWorkbenchPart;
24	import org.eclipse.ui.IWorkbenchWindow;
25	import org.eclipse.ui.PlatformUI;
26
27	/**
28	* Abstract base class for actions performing debug commands
29	*
30	* @since 3.3
31	*/
32	public abstract class DebugCommandAction extends Action implements IDebugContextListener {
33
34	/**
35	* The window this action is working for.
36	*/
37	private IWorkbenchWindow fWindow;
38
39	/**
40	* The part this action is working for, or <code>null</code> if global to
41	* a window.
42	*/
43	private IWorkbenchPart fPart;
44
45	/**
46	* Command service.
47	*/
48	private DebugCommandService fUpdateService;
49
50	/**
51	* Delegate this action is working for or <code>null</code> if none.
52	*/
53	private DebugCommandActionDelegate fDelegate;
54
55	/**
56	* Constructor
57	*/
58	public DebugCommandAction() {
59	super();
60	String helpContextId = getHelpContextId();
61	if (helpContextId != null)
62	PlatformUI.getWorkbench().getHelpSystem().setHelp(this, helpContextId);
63	setEnabled(false);
64	}
65
66	/**
67	* Set the current delegate
68	* @param delegate
69	*/
70	public void setDelegate(DebugCommandActionDelegate delegate) {
71	fDelegate = delegate;
72	}
73
74	/**
75	* Executes this action on the given target object
76	*
77	* @param target the target to perform the action on
78	*/
79	protected boolean execute(Object[] targets) {
80	return fUpdateService.executeCommand(getCommandType(), targets, getCommandParticipant(targets));
81	}
82
83	/**
84	* Creates and returns the command participant or <code>null</code>.
85	*
86	* @return command participant to use on command completion
87	*/
88	protected ICommandParticipant getCommandParticipant(Object[] targets) {
89	return null;
90	}
91
92	/**
93	* Returns the command type this action executes.
94	*
95	* @return command class.
96	*/
97	abstract protected Class getCommandType();
98
99	/**
100	* @see org.eclipse.debug.ui.contexts.IDebugContextListener#debugContextChanged(org.eclipse.debug.ui.contexts.DebugContextEvent)
101	*/
102	public void debugContextChanged(DebugContextEvent event) {
103	fUpdateService.postUpdateCommand(getCommandType(), this);
104	}
105
106	/**
107	* @see org.eclipse.jface.action.Action#setEnabled(boolean)
108	*/
109	public void setEnabled(boolean enabled) {
110	super.setEnabled(enabled);
111	if (fDelegate != null) {
112	fDelegate.setEnabled(enabled);
113	}
114	}
115
116	/**
117	* Initializes this action for a specific part.
118	*
119	* @param part workbench part
120	*/
121	public void init(IWorkbenchPart part) {
122	fPart = part;
123	fWindow = part.getSite().getWorkbenchWindow();
124	fUpdateService = DebugCommandService.getService(fWindow);
125	IDebugContextService service = getDebugContextService();
126	String partId = part.getSite().getId();
127	service.addDebugContextListener(this, partId);
128	ISelection activeContext = service.getActiveContext(partId);
129	if (activeContext != null) {
130	fUpdateService.updateCommand(getCommandType(), this);
131	} else {
132	setEnabled(getInitialEnablement());
133	}
134	}
135
136	/**
137	* Initializes the context action
138	* @param window the window
139	*/
140	public void init(IWorkbenchWindow window) {
141	fWindow = window;
142	fUpdateService = DebugCommandService.getService(fWindow);
143	IDebugContextService contextService = getDebugContextService();
144	contextService.addDebugContextListener(this);
145	ISelection activeContext = contextService.getActiveContext();
146	if (activeContext != null) {
147	fUpdateService.updateCommand(getCommandType(), this);
148	} else {
149	setEnabled(getInitialEnablement());
150	}
151	}
152
153	/**
154	* Returns whether this action should be enabled when initialized
155	* and there is no active debug context.
156	*
157	* @return false, by default
158	*/
159	protected boolean getInitialEnablement() {
160	return false;
161	}
162
163	/**
164	* Returns the most recent selection
165	*
166	* @return structured selection
167	*/
168	protected ISelection getContext() {
169	if (fPart != null) {
170	getDebugContextService().getActiveContext(fPart.getSite().getId());
171	}
172	return getDebugContextService().getActiveContext();
173	}
174
175	/*
176	* (non-Javadoc)
177	* @see org.eclipse.jface.action.Action#run()
178	*/
179	public void run() {
180	ISelection selection = getContext();
181	if (selection instanceof IStructuredSelection && isEnabled()) {
182	IStructuredSelection ss = (IStructuredSelection) selection;
183	boolean enabled = execute(ss.toArray());
184	// disable the action according to the command
185	setEnabled(enabled);
186	}
187	}
188
189	/*
190	* (non-Javadoc)
191	* @see org.eclipse.jface.action.Action#runWithEvent(org.eclipse.swt.widgets.Event)
192	*/
193	public void runWithEvent(Event event) {
194	run();
195	}
196
197	/**
198	* Clean up when removing
199	*/
200	public void dispose() {
201	IDebugContextService service = getDebugContextService();
202	if (fPart != null) {
203	service.removeDebugContextListener(this, fPart.getSite().getId());
204	} else {
205	service.removeDebugContextListener(this);
206	}
207	fWindow = null;
208	fPart = null;
209	}
210
211	/**
212	* Returns the context service this action linked to.
213	* @return
214	*/
215	protected IDebugContextService getDebugContextService() {
216	return DebugUITools.getDebugContextManager().getContextService(fWindow);
217	}
218
219	/**
220	* @return The help context id for this action
221	*/
222	public abstract String getHelpContextId();
223
224	/*
225	* (non-Javadoc)
226	* @see org.eclipse.jface.action.Action#getId()
227	*/
228	public abstract String getId();
229
230	/*
231	* (non-Javadoc)
232	* @see org.eclipse.jface.action.Action#getText()
233	*/
234	public abstract String getText();
235
236	/*
237	* (non-Javadoc)
238	* @see org.eclipse.jface.action.Action#getToolTipText()
239	*/
240	public abstract String getToolTipText();
241
242	/*
243	* (non-Javadoc)
244	* @see org.eclipse.jface.action.Action#getDisabledImageDescriptor()
245	*/
246	public abstract ImageDescriptor getDisabledImageDescriptor();
247
248	/*
249	* (non-Javadoc)
250	* @see org.eclipse.jface.action.Action#getHoverImageDescriptor()
251	*/
252	public abstract ImageDescriptor getHoverImageDescriptor();
253
254	/*
255	* (non-Javadoc)
256	* @see org.eclipse.jface.action.Action#getImageDescriptor()
257	*/
258	public abstract ImageDescriptor getImageDescriptor();
259
260	/**
261	* Returns the delegate associated with this action or <code>null</code>
262	* if none.
263	*
264	* @return delegate or <code>null</code>
265	*/
266	protected DebugCommandActionDelegate getDelegate() {
267	return fDelegate;
268	}
269	}

Lines 41-47 Link Here

(-)ui/org/eclipse/debug/internal/ui/views/launch/LaunchView.java (-1 / +1 lines)
41	import org.eclipse.debug.internal.ui.IDebugHelpContextIds;	41	import org.eclipse.debug.internal.ui.IDebugHelpContextIds;
42	import org.eclipse.debug.internal.ui.actions.AddToFavoritesAction;	42	import org.eclipse.debug.internal.ui.actions.AddToFavoritesAction;
43	import org.eclipse.debug.internal.ui.actions.EditLaunchConfigurationAction;	43	import org.eclipse.debug.internal.ui.actions.EditLaunchConfigurationAction;
44	import org.eclipse.debug.internal.ui.commands.actions.DebugCommandAction;
45	import org.eclipse.debug.internal.ui.commands.actions.DisconnectCommandAction;	44	import org.eclipse.debug.internal.ui.commands.actions.DisconnectCommandAction;
46	import org.eclipse.debug.internal.ui.commands.actions.DropToFrameCommandAction;	45	import org.eclipse.debug.internal.ui.commands.actions.DropToFrameCommandAction;
47	import org.eclipse.debug.internal.ui.commands.actions.ResumeCommandAction;	46	import org.eclipse.debug.internal.ui.commands.actions.ResumeCommandAction;
Lines 72-77 Link Here
72	import org.eclipse.debug.ui.DebugUITools;	71	import org.eclipse.debug.ui.DebugUITools;
73	import org.eclipse.debug.ui.IDebugModelPresentation;	72	import org.eclipse.debug.ui.IDebugModelPresentation;
74	import org.eclipse.debug.ui.IDebugUIConstants;	73	import org.eclipse.debug.ui.IDebugUIConstants;
		74	import org.eclipse.debug.ui.actions.DebugCommandAction;
75	import org.eclipse.debug.ui.contexts.AbstractDebugContextProvider;	75	import org.eclipse.debug.ui.contexts.AbstractDebugContextProvider;
76	import org.eclipse.debug.ui.contexts.DebugContextEvent;	76	import org.eclipse.debug.ui.contexts.DebugContextEvent;
77	import org.eclipse.debug.ui.contexts.IDebugContextListener;	77	import org.eclipse.debug.ui.contexts.IDebugContextListener;

Added Link Here

(-)ui/org/eclipse/debug/ui/actions/DebugCommandHandler.java (+250 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006, 2007 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Wind River Systems - initial API and implementation
10	*******************************************************************************/
11
12	package org.eclipse.debug.ui.actions;
13
14	import java.util.Iterator;
15	import java.util.Map;
16	import java.util.WeakHashMap;
17
18	import org.eclipse.core.commands.AbstractHandler;
19	import org.eclipse.core.commands.ExecutionEvent;
20	import org.eclipse.core.commands.ExecutionException;
21	import org.eclipse.core.commands.HandlerEvent;
22	import org.eclipse.core.expressions.IEvaluationContext;
23	import org.eclipse.debug.internal.ui.commands.actions.DebugCommandService;
24	import org.eclipse.debug.internal.ui.commands.actions.ICommandParticipant;
25	import org.eclipse.debug.internal.ui.commands.actions.IEnabledTarget;
26	import org.eclipse.debug.ui.DebugUITools;
27	import org.eclipse.debug.ui.contexts.DebugContextEvent;
28	import org.eclipse.debug.ui.contexts.IDebugContextListener;
29	import org.eclipse.debug.ui.contexts.IDebugContextService;
30	import org.eclipse.jface.viewers.ISelection;
31	import org.eclipse.jface.viewers.IStructuredSelection;
32	import org.eclipse.ui.ISources;
33	import org.eclipse.ui.IWindowListener;
34	import org.eclipse.ui.IWorkbenchWindow;
35	import org.eclipse.ui.PlatformUI;
36	import org.eclipse.ui.handlers.HandlerUtil;
37
38	/**
39	* Abstract base class for re-targeting command framework handlers, which
40	* delegate execution to {@link org.eclipse.debug.core.commands.IDebugCommandHandler}
41	* handlers. The specific type of <code>IDebugCommandHandler</code> is
42	* determined by the abstract {@link #getCommandType()} method.
43	*
44	* <p> Note: This class is not an implementation of the <code>IDebugCommandHandler</code>
45	* interface, which was somewhat unfortunately named. <code>IDebugCommandHandler</code>
46	* is an interface that is internal to the debugger plugins. This class implements
47	* {@link org.eclipse.core.commands.IHandler} interface and is to be used with the
48	* platform commands framework. </p>
49	*
50	* @see org.eclipse.debug.core.commands.IDebugCommandHandler
51	* @see org.eclipse.core.commands.IHandler
52	*
53	* @since 3.6
54	*/
55	public abstract class DebugCommandHandler extends AbstractHandler {
56
57	private class EnabledTarget implements IEnabledTarget, IDebugContextListener, IWindowListener {
58	boolean fEnabled = getInitialEnablement();
59	IWorkbenchWindow fWindow;
60
61	EnabledTarget(IWorkbenchWindow window) {
62	fWindow = window;
63	DebugCommandService.getService(fWindow).updateCommand(getCommandType(), this);
64	getContextService(fWindow).addDebugContextListener(this);
65	PlatformUI.getWorkbench().addWindowListener(this);
66	}
67
68	public void setEnabled(boolean enabled) {
69	boolean oldEnabled = fEnabled;
70	fEnabled = enabled;
71	if (fEnabled != oldEnabled) {
72	fireHandlerChanged(new HandlerEvent(DebugCommandHandler.this, true, false));
73	}
74	}
75
76	public void debugContextChanged(DebugContextEvent event) {
77	DebugCommandService.getService(fWindow).postUpdateCommand(getCommandType(), this);
78	}
79
80	public void windowOpened(IWorkbenchWindow w) {
81	}
82
83	public void windowDeactivated(IWorkbenchWindow w) {
84	}
85
86	public void windowClosed(IWorkbenchWindow w) {
87	if (w.equals(fWindow)) {
88	dispose();
89	}
90	}
91
92	public void windowActivated(IWorkbenchWindow w) {
93	}
94
95	void dispose() {
96	if (isDisposed()) {
97	return;
98	}
99	PlatformUI.getWorkbench().removeWindowListener(this);
100	getContextService(fWindow).removeDebugContextListener(this);
101	fWindow = null;
102	}
103
104	boolean isDisposed() {
105	return fWindow == null;
106	}
107	}
108
109	private Map fEnabledTargetsMap = new WeakHashMap();
110
111	private EnabledTarget fCurrentEnabledTarget = null;
112
113	/**
114	* Constructor
115	*/
116	public DebugCommandHandler() {
117	super();
118	PlatformUI.getWorkbench().addWindowListener(new IWindowListener() {
119
120	public void windowOpened(IWorkbenchWindow w) {
121	}
122
123	public void windowDeactivated(IWorkbenchWindow w) {
124	}
125
126	public void windowClosed(IWorkbenchWindow w) {
127	EnabledTarget enabledTarget = (EnabledTarget)fEnabledTargetsMap.get(w);
128	if (enabledTarget != null) {
129	enabledTarget.dispose();
130	}
131	}
132
133	public void windowActivated(IWorkbenchWindow w) {
134	}
135	});
136	}
137
138	public void setEnabled(Object evaluationContext) {
139	fCurrentEnabledTarget = null;
140
141	if (!(evaluationContext instanceof IEvaluationContext)) {
142	return;
143	}
144	IEvaluationContext context = (IEvaluationContext) evaluationContext;
145	Object _window = context.getVariable(ISources.ACTIVE_WORKBENCH_WINDOW_NAME);
146	if (_window instanceof IWorkbenchWindow) {
147	IWorkbenchWindow window = (IWorkbenchWindow)_window;
148	fCurrentEnabledTarget = getEnabledTarget(window);
149	}
150	}
151
152	public boolean isEnabled() {
153	if (fCurrentEnabledTarget == null) {
154	return false;
155	}
156	return fCurrentEnabledTarget.fEnabled;
157	}
158
159	private EnabledTarget getEnabledTarget(IWorkbenchWindow window) {
160	EnabledTarget target = (EnabledTarget)fEnabledTargetsMap.get(window);
161	if (target == null) {
162	target = new EnabledTarget(window);
163	DebugCommandService service = DebugCommandService.getService(window);
164	service.updateCommand(getCommandType(), target);
165
166	DebugUITools.getDebugContextManager().getContextService(window).addDebugContextListener(target);
167
168	fEnabledTargetsMap.put(window, target);
169	}
170	return target;
171	}
172
173	public Object execute(ExecutionEvent event) throws ExecutionException {
174	IWorkbenchWindow window = HandlerUtil.getActiveWorkbenchWindow(event);
175	if (window == null) {
176	throw new ExecutionException("No active workbench window.");
177	}
178	fCurrentEnabledTarget = getEnabledTarget(window);
179
180	ISelection selection = getContextService(window).getActiveContext();
181	if (selection instanceof IStructuredSelection && isEnabled()) {
182	IStructuredSelection ss = (IStructuredSelection) selection;
183	boolean enabledAfterExecute = execute(window, ss.toArray());
184
185	// enable/disable the action according to the command
186	fCurrentEnabledTarget.setEnabled(enabledAfterExecute);
187	}
188
189	return null;
190	}
191
192	private IDebugContextService getContextService(IWorkbenchWindow window) {
193	return DebugUITools.getDebugContextManager().getContextService(window);
194	}
195
196	/**
197	* Executes this action on the given target object
198	*
199	* @param target the target to perform the action on
200	*/
201	private boolean execute(IWorkbenchWindow window, Object[] targets) {
202	DebugCommandService service = DebugCommandService.getService(window);
203	return service.executeCommand(getCommandType(), targets, getCommandParticipant(targets));
204	}
205
206	/**
207	* Creates and returns the command participant or <code>null</code>.
208	*
209	* @return command participant to use on command completion
210	*/
211	protected ICommandParticipant getCommandParticipant(Object[] targets) {
212	return null;
213	}
214
215	/**
216	* Returns the {@link org.eclipse.debug.core.commands.IDebugCommandHandler}
217	* command handler that type this action executes.
218	*
219	* @return command class.
220	*
221	* @see org.eclipse.debug.core.commands.IDebugCommandHandler
222	*/
223	abstract protected Class getCommandType();
224
225
226	/**
227	* Returns whether this action should be enabled when initialized
228	* and there is no active debug context.
229	*
230	* @return false, by default
231	*/
232	protected boolean getInitialEnablement() {
233	return false;
234	}
235
236
237	/**
238	* Clean up when removing
239	*/
240	public void dispose() {
241	for (Iterator itr = fEnabledTargetsMap.values().iterator(); itr.hasNext();) {
242	EnabledTarget target = (EnabledTarget)itr.next();
243	if (!target.isDisposed()) {
244	target.dispose();
245	}
246	}
247	fEnabledTargetsMap.clear();
248	fCurrentEnabledTarget = null;
249	}
250	}

Added Link Here

(-)ui/org/eclipse/debug/internal/ui/commands/actions/IEnabledTarget.java (+18 lines)
1	/*******************************************************************************
2	* Copyright (c) 2008 Wind River Systems and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Wind River Systems - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.debug.internal.ui.commands.actions;
12
13	/**
14	*
15	*/
16	public interface IEnabledTarget {
17	public void setEnabled(boolean enabled);
18	}