Attachment #146333 for bug #284363

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

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	*




import org.eclipse.debug.internal.ui.actions.ActionMessages;
import org.eclipse.debug.internal.ui.actions.RelaunchActionDelegate;
import org.eclipse.debug.internal.ui.launchConfigurations.LaunchConfigurationManager;
import org.eclipse.debug.ui.actions.DebugCommandAction;
import org.eclipse.debug.ui.contexts.DebugContextEvent;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.viewers.ISelection;

 */
public class TerminateAndRelaunchAction extends DebugCommandAction {
	
    public void postExecute(IRequest request, final Object[] targets) {
        if (request.getStatus() == null || request.getStatus().isOK()) {
            DebugUIPlugin.getStandardDisplay().asyncExec(new Runnable() {
                public void run() {
                    // Must be run in the UI thread since the launch can require
                    // prompting to proceed
                    for (int i = 0; i < targets.length; i++) {
                        ILaunch launch = RelaunchActionDelegate.getLaunch(targets[i]);
                        RelaunchActionDelegate.relaunch(launch.getLaunchConfiguration(), launch.getLaunchMode());
                    }
                }
            }); 
        }
    }
		            public void run() {
		                // Must be run in the UI thread since the launch can require
		                // prompting to proceed
		            	for (int i = 0; i < fTargets.length; i++) {
		            		ILaunch launch = RelaunchActionDelegate.getLaunch(fTargets[i]);
		            		RelaunchActionDelegate.relaunch(launch.getLaunchConfiguration(), launch.getLaunchMode());
						}
		            }
		        });	
			}
		}
		
	}

	protected ICommandParticipant getCommandParticipant(Object[] targets) {
		return new Participant(targets);
	}

	protected Class getCommandType() {
		return ITerminateHandler.class;





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);
    }
}




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 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	/**

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 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	/**




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 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.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.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 used only by thedebugger 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 {

    /**
     * The DebugCommandService is able to evaluate the command handler 
     * enablement in each workbench window separately, however the workbench
     * command framework uses only a single handler instance for all windows.
     * This IEnabledTarget implementation tracks enablement of the command
     * for a given window.  When the handler enablement is tested, the 
     * currently active window is used to determine which enabled target 
     * to use.  
     */
    private class EnabledTarget implements IEnabledTarget, IDebugContextListener {
        boolean fEnabled = getInitialEnablement();
        IWorkbenchWindow fWindow;
        
        EnabledTarget(IWorkbenchWindow window) {
            fWindow = window;
            DebugCommandService.getService(fWindow).updateCommand(getCommandType(), this);
            getContextService(fWindow).addDebugContextListener(this);
        }
        
        public void setEnabled(boolean enabled) {
            boolean oldEnabled = fEnabled;
            fEnabled = enabled;
            if (fEnabled != oldEnabled && fCurrentEnabledTarget == this) {
                fireHandlerChanged(new HandlerEvent(DebugCommandHandler.this, true, false));
            }
        }
        
        public void debugContextChanged(DebugContextEvent event) {
            DebugCommandService.getService(fWindow).postUpdateCommand(getCommandType(), this);
        }
        
        void dispose() {
            if (isDisposed()) {
                return;
            }
            getContextService(fWindow).removeDebugContextListener(this);
            fWindow = null;
        }
        
        boolean isDisposed() {
            return fWindow == null;
        }
    }

    /**
     * Window listener is used to make sure that the handler enablement 
     * is updated when the active workbench window is changed.
     */
    private IWindowListener fWindowListener =  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) {
            fCurrentEnabledTarget = (EnabledTarget)fEnabledTargetsMap.get(w);
            fireHandlerChanged(new HandlerEvent(DebugCommandHandler.this, true, false));
        }
    };
    
    /**
     * Map of enabled targets keyed by workbench window.
     */
    private Map fEnabledTargetsMap = new WeakHashMap();

    /**
     * The current enabled target, based on the active
     * workbench window.
     */
    private EnabledTarget fCurrentEnabledTarget = null;
    
    /**
      * The constructor adds the handler as the 
     */
    public DebugCommandHandler() {
        super();
        PlatformUI.getWorkbench().addWindowListener(fWindowListener);
    }
    
    public void setEnabled(Object evaluationContext) {
        // This method is called with the current evaluation context
        // just prior to the isEnabled() being called.  Check the active
        // window and update the current enabled target based on it 
        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);
            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, final Object[] targets) {
        DebugCommandService service = DebugCommandService.getService(window); 
    	return service.executeCommand(
    	    getCommandType(), targets, 
            new ICommandParticipant() {
                public void requestDone(org.eclipse.debug.core.IRequest request) {
                    DebugCommandHandler.this.postExecute(request, targets);
                }             
            });
    }

    /**
     * This method is called after the completion of the execution of this 
     * command.  Extending classes may override this method to perform additional
     * operation after command execution. 
     * 
     * @param request The completed request object which was given the the 
     * debug command handler.
     * @param targets Objects which were the targets of this action
     */
    protected void postExecute(IRequest request, Object[] targets) {
        // 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();  

    
    /**
     * 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() {
        PlatformUI.getWorkbench().removeWindowListener(fWindowListener);        
        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.    
 * <p>
 * This base class is an action which can be instantiated directly by views, 
 * etc.  In order to contribute an action using an extension point, a class 
 * implementing {@link org.eclipse.ui.IActionDelegate} should be created first.
 * The delegate should then use the <code>DebugCommandAction</code> implement 
 * the needed delegate functionality. <br>
 * Note: <code>IDebugCommandHandler</code> command typically act on the active
 * debug context as opposed to the active selection in view or window.  The 
 * action delegate should ignore the active window selection, and instead allow 
 * the <code>DebugCommandAction</code> to update itself based on the active 
 * debug context. 
 * </p>
 * 
 * @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.postExecute(request, targets);
    	        }    	      
    	    });
    }
        
    /**
     * This method is called after the completion of the execution of this 
     * command.  Extending classes may override this method to perform additional
     * operation after command execution. 
     * 
     * @param targets Objects which were the targets of this action
     * @param request The completed request object which was given the the 
     * debug command handler.
     */
    protected void postExecute(IRequest request, Object[] targets) {
        // 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;
    }
}




/*******************************************************************************
 * 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++) {





<h2>Summary of API changes in 3.6</h2>

<h3>DebugCommandAction base class</h3>
<p><strong>What is affected:</strong>
<ul>
  <li>Class addition: <code>org.eclipse.debug.ui.actions.DebugCommandAction</code> </li>
  <li>Class addition: <code>org.eclipse.debug.ui.actions.DebugCommandHandler</code> </li>
</ul>
</p>
<p><strong>Description:</strong>The <code>IDebugCommandHandler</code> interface allows debugger to implement debug action handlers which execute asynchronously.  Most of the debugger actions user this interface to communicate with the debug model.  However, debuggers which need to add their own asynchronous actions had to duplicate the debug framework actions which invoke the <code>IDebugCommandHandler</code> handlers.  <code>DebugCommandAction</code> and <code>DebugCommandHandler</code> are base classes which can be extended by debuggers to implement new types of actions with asynchronous execution handlers.</p>
<p><strong>Action required:</strong> This is a backwards compatible change. No action required. </p>

<p>&nbsp;</p>
</body>
</html>




/*******************************************************************************
 * 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();
	
}

Return to bug 284363

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 (+267 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.core.IRequest;
24	import org.eclipse.debug.internal.ui.commands.actions.DebugCommandService;
25	import org.eclipse.debug.internal.ui.commands.actions.ICommandParticipant;
26	import org.eclipse.debug.internal.ui.commands.actions.IEnabledTarget;
27	import org.eclipse.debug.ui.DebugUITools;
28	import org.eclipse.debug.ui.contexts.DebugContextEvent;
29	import org.eclipse.debug.ui.contexts.IDebugContextListener;
30	import org.eclipse.debug.ui.contexts.IDebugContextService;
31	import org.eclipse.jface.viewers.ISelection;
32	import org.eclipse.jface.viewers.IStructuredSelection;
33	import org.eclipse.ui.ISources;
34	import org.eclipse.ui.IWindowListener;
35	import org.eclipse.ui.IWorkbenchWindow;
36	import org.eclipse.ui.PlatformUI;
37	import org.eclipse.ui.handlers.HandlerUtil;
38
39	/**
40	* Abstract base class for re-targeting command framework handlers, which
41	* delegate execution to {@link org.eclipse.debug.core.commands.IDebugCommandHandler}
42	* handlers. The specific type of <code>IDebugCommandHandler</code> is
43	* determined by the abstract {@link #getCommandType()} method.
44	*
45	* <p> Note: This class is not an implementation of the <code>IDebugCommandHandler</code>
46	* interface, which was somewhat unfortunately named. <code>IDebugCommandHandler</code>
47	* is an interface that used only by thedebugger plugins. This class implements
48	* {@link org.eclipse.core.commands.IHandler} interface and is to be used with the
49	* platform commands framework. </p>
50	*
51	* @see org.eclipse.debug.core.commands.IDebugCommandHandler
52	* @see org.eclipse.core.commands.IHandler
53	*
54	* @since 3.6
55	*/
56	public abstract class DebugCommandHandler extends AbstractHandler {
57
58	/**
59	* The DebugCommandService is able to evaluate the command handler
60	* enablement in each workbench window separately, however the workbench
61	* command framework uses only a single handler instance for all windows.
62	* This IEnabledTarget implementation tracks enablement of the command
63	* for a given window. When the handler enablement is tested, the
64	* currently active window is used to determine which enabled target
65	* to use.
66	*/
67	private class EnabledTarget implements IEnabledTarget, IDebugContextListener {
68	boolean fEnabled = getInitialEnablement();
69	IWorkbenchWindow fWindow;
70
71	EnabledTarget(IWorkbenchWindow window) {
72	fWindow = window;
73	DebugCommandService.getService(fWindow).updateCommand(getCommandType(), this);
74	getContextService(fWindow).addDebugContextListener(this);
75	}
76
77	public void setEnabled(boolean enabled) {
78	boolean oldEnabled = fEnabled;
79	fEnabled = enabled;
80	if (fEnabled != oldEnabled && fCurrentEnabledTarget == this) {
81	fireHandlerChanged(new HandlerEvent(DebugCommandHandler.this, true, false));
82	}
83	}
84
85	public void debugContextChanged(DebugContextEvent event) {
86	DebugCommandService.getService(fWindow).postUpdateCommand(getCommandType(), this);
87	}
88
89	void dispose() {
90	if (isDisposed()) {
91	return;
92	}
93	getContextService(fWindow).removeDebugContextListener(this);
94	fWindow = null;
95	}
96
97	boolean isDisposed() {
98	return fWindow == null;
99	}
100	}
101
102	/**
103	* Window listener is used to make sure that the handler enablement
104	* is updated when the active workbench window is changed.
105	*/
106	private IWindowListener fWindowListener = new IWindowListener() {
107
108	public void windowOpened(IWorkbenchWindow w) {
109	}
110
111	public void windowDeactivated(IWorkbenchWindow w) {
112	}
113
114	public void windowClosed(IWorkbenchWindow w) {
115	EnabledTarget enabledTarget = (EnabledTarget)fEnabledTargetsMap.get(w);
116	if (enabledTarget != null) {
117	enabledTarget.dispose();
118	}
119	}
120
121	public void windowActivated(IWorkbenchWindow w) {
122	fCurrentEnabledTarget = (EnabledTarget)fEnabledTargetsMap.get(w);
123	fireHandlerChanged(new HandlerEvent(DebugCommandHandler.this, true, false));
124	}
125	};
126
127	/**
128	* Map of enabled targets keyed by workbench window.
129	*/
130	private Map fEnabledTargetsMap = new WeakHashMap();
131
132	/**
133	* The current enabled target, based on the active
134	* workbench window.
135	*/
136	private EnabledTarget fCurrentEnabledTarget = null;
137
138	/**
139	* The constructor adds the handler as the
140	*/
141	public DebugCommandHandler() {
142	super();
143	PlatformUI.getWorkbench().addWindowListener(fWindowListener);
144	}
145
146	public void setEnabled(Object evaluationContext) {
147	// This method is called with the current evaluation context
148	// just prior to the isEnabled() being called. Check the active
149	// window and update the current enabled target based on it
150	fCurrentEnabledTarget = null;
151
152	if (!(evaluationContext instanceof IEvaluationContext)) {
153	return;
154	}
155	IEvaluationContext context = (IEvaluationContext) evaluationContext;
156	Object _window = context.getVariable(ISources.ACTIVE_WORKBENCH_WINDOW_NAME);
157	if (_window instanceof IWorkbenchWindow) {
158	IWorkbenchWindow window = (IWorkbenchWindow)_window;
159	fCurrentEnabledTarget = getEnabledTarget(window);
160	}
161	}
162
163	public boolean isEnabled() {
164	if (fCurrentEnabledTarget == null) {
165	return false;
166	}
167	return fCurrentEnabledTarget.fEnabled;
168	}
169
170	private EnabledTarget getEnabledTarget(IWorkbenchWindow window) {
171	EnabledTarget target = (EnabledTarget)fEnabledTargetsMap.get(window);
172	if (target == null) {
173	target = new EnabledTarget(window);
174	fEnabledTargetsMap.put(window, target);
175	}
176	return target;
177	}
178
179	public Object execute(ExecutionEvent event) throws ExecutionException {
180	IWorkbenchWindow window = HandlerUtil.getActiveWorkbenchWindow(event);
181	if (window == null) {
182	throw new ExecutionException("No active workbench window.");
183	}
184	fCurrentEnabledTarget = getEnabledTarget(window);
185
186	ISelection selection = getContextService(window).getActiveContext();
187	if (selection instanceof IStructuredSelection && isEnabled()) {
188	IStructuredSelection ss = (IStructuredSelection) selection;
189	boolean enabledAfterExecute = execute(window, ss.toArray());
190
191	// enable/disable the action according to the command
192	fCurrentEnabledTarget.setEnabled(enabledAfterExecute);
193	}
194
195	return null;
196	}
197
198	private IDebugContextService getContextService(IWorkbenchWindow window) {
199	return DebugUITools.getDebugContextManager().getContextService(window);
200	}
201
202	/**
203	* Executes this action on the given target object
204	*
205	* @param target the target to perform the action on
206	*/
207	private boolean execute(IWorkbenchWindow window, final Object[] targets) {
208	DebugCommandService service = DebugCommandService.getService(window);
209	return service.executeCommand(
210	getCommandType(), targets,
211	new ICommandParticipant() {
212	public void requestDone(org.eclipse.debug.core.IRequest request) {
213	DebugCommandHandler.this.postExecute(request, targets);
214	}
215	});
216	}
217
218	/**
219	* This method is called after the completion of the execution of this
220	* command. Extending classes may override this method to perform additional
221	* operation after command execution.
222	*
223	* @param request The completed request object which was given the the
224	* debug command handler.
225	* @param targets Objects which were the targets of this action
226	*/
227	protected void postExecute(IRequest request, Object[] targets) {
228	// do nothing by default
229	}
230
231	/**
232	* Returns the {@link org.eclipse.debug.core.commands.IDebugCommandHandler}
233	* command handler that type this action executes.
234	*
235	* @return command class.
236	*
237	* @see org.eclipse.debug.core.commands.IDebugCommandHandler
238	*/
239	abstract protected Class getCommandType();
240
241
242	/**
243	* Returns whether this action should be enabled when initialized
244	* and there is no active debug context.
245	*
246	* @return false, by default
247	*/
248	protected boolean getInitialEnablement() {
249	return false;
250	}
251
252
253	/**
254	* Clean up when removing
255	*/
256	public void dispose() {
257	PlatformUI.getWorkbench().removeWindowListener(fWindowListener);
258	for (Iterator itr = fEnabledTargetsMap.values().iterator(); itr.hasNext();) {
259	EnabledTarget target = (EnabledTarget)itr.next();
260	if (!target.isDisposed()) {
261	target.dispose();
262	}
263	}
264	fEnabledTargetsMap.clear();
265	fCurrentEnabledTarget = null;
266	}
267	}

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	}

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	}

Lines 11-16 Link Here

(-)buildnotes_platform-debug.html (+10 lines)
11		11
12	<h2>Summary of API changes in 3.6</h2>	12	<h2>Summary of API changes in 3.6</h2>
13		13
		14	<h3>DebugCommandAction base class</h3>
		15	<p><strong>What is affected:</strong>
		16	<ul>
		17	<li>Class addition: <code>org.eclipse.debug.ui.actions.DebugCommandAction</code> </li>
		18	<li>Class addition: <code>org.eclipse.debug.ui.actions.DebugCommandHandler</code> </li>
		19	</ul>
		20	</p>
		21	<p><strong>Description:</strong>The <code>IDebugCommandHandler</code> interface allows debugger to implement debug action handlers which execute asynchronously. Most of the debugger actions user this interface to communicate with the debug model. However, debuggers which need to add their own asynchronous actions had to duplicate the debug framework actions which invoke the <code>IDebugCommandHandler</code> handlers. <code>DebugCommandAction</code> and <code>DebugCommandHandler</code> are base classes which can be extended by debuggers to implement new types of actions with asynchronous execution handlers.</p>
		22	<p><strong>Action required:</strong> This is a backwards compatible change. No action required. </p>
		23
14	<p> </p>	24	<p> </p>
15	</body>	25	</body>
16	</html>	26	</html>

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	}