Attachment #146696 for bug #284363

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

Lines 1-5 Link Here

(-)ui/org/eclipse/debug/internal/ui/commands/actions/DropToFrameCommandAction.java (-1 / +2 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2005, 2007 IBM Corporation and others.	2	* Copyright (c) 2005, 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 14-19 Link Here
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;




/*******************************************************************************
 *  Copyright (c) 2004, 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

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;




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





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




/*******************************************************************************
 * Copyright (c) 2000, 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

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




/*******************************************************************************
 * Copyright (c) 2000, 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


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.setActionProxy(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, 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

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 1-5 Link Here

(-)ui/org/eclipse/debug/internal/ui/commands/actions/TerminateCommandAction.java (-1 / +2 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2006, 2007 IBM Corporation and others.	2	* Copyright (c) 2006, 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 14-19 Link Here
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	/**




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

 *******************************************************************************/
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 1-5 Link Here

(-)ui/org/eclipse/debug/internal/ui/commands/actions/ResumeCommandAction.java (-1 / +2 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2006, 2007 IBM Corporation and others.	2	* Copyright (c) 2006, 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 14-19 Link Here
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	/**




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

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 = getActionProxy();
			if (action != null) {
				action.setChecked(checked);
			}
		}		
	}

Lines 1-5 Link Here

(-)ui/org/eclipse/debug/internal/ui/commands/actions/StepOverCommandAction.java (-1 / +2 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2006, 2007 IBM Corporation and others.	2	* Copyright (c) 2006, 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 15-20 Link Here
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 1-5 Link Here

(-)ui/org/eclipse/debug/internal/ui/commands/actions/ICommandParticipant.java (-2 / +2 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2006, 2007 IBM Corporation and others.	2	* Copyright (c) 2006, 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 15-21 Link Here
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




/*******************************************************************************
 * Copyright (c) 2000, 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


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.setActionProxy(action);
        
    }

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

Lines 1-5 Link Here

(-)ui/org/eclipse/debug/internal/ui/commands/actions/StepIntoCommandAction.java (-1 / +2 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2006, 2007 IBM Corporation and others.	2	* Copyright (c) 2006, 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 14-19 Link Here
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 1-5 Link Here

(-)ui/org/eclipse/debug/internal/ui/commands/actions/DisconnectCommandAction.java (-1 / +2 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2006, 2007 IBM Corporation and others.	2	* Copyright (c) 2006, 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 15-20 Link Here
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.




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 1-5 Link Here

(-)ui/org/eclipse/debug/internal/ui/commands/actions/StepReturnCommandAction.java (-1 / +2 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2006, 2007 IBM Corporation and others.	2	* Copyright (c) 2006, 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 14-19 Link Here
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 1-5 Link Here

(-)ui/org/eclipse/debug/internal/ui/commands/actions/SuspendCommandAction.java (-1 / +2 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2006, 2007 IBM Corporation and others.	2	* Copyright (c) 2006, 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 14-19 Link Here
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 2-8 Link Here

(-)META-INF/MANIFEST.MF (-2 / +2 lines)
2	Bundle-ManifestVersion: 2	2	Bundle-ManifestVersion: 2
3	Bundle-Name: %pluginName	3	Bundle-Name: %pluginName
4	Bundle-SymbolicName: org.eclipse.debug.ui; singleton:=true	4	Bundle-SymbolicName: org.eclipse.debug.ui; singleton:=true
5	Bundle-Version: 3.5.100.qualifier	5	Bundle-Version: 3.6.0.qualifier
6	Bundle-Activator: org.eclipse.debug.internal.ui.DebugUIPlugin	6	Bundle-Activator: org.eclipse.debug.internal.ui.DebugUIPlugin
7	Bundle-Vendor: %providerName	7	Bundle-Vendor: %providerName
8	Bundle-Localization: plugin	8	Bundle-Localization: plugin
Lines 59-65 Link Here
59	org.eclipse.ui;bundle-version="[3.5.0,4.0.0)",	59	org.eclipse.ui;bundle-version="[3.5.0,4.0.0)",
60	org.eclipse.ui.console;bundle-version="[3.4.0,4.0.0)",	60	org.eclipse.ui.console;bundle-version="[3.4.0,4.0.0)",
61	org.eclipse.help;bundle-version="[3.4.0,4.0.0)",	61	org.eclipse.help;bundle-version="[3.4.0,4.0.0)",
62	org.eclipse.debug.core;bundle-version="[3.5.0,4.0.0)";visibility:=reexport,	62	org.eclipse.debug.core;bundle-version="[3.6.0,4.0.0)";visibility:=reexport,
63	org.eclipse.jface.text;bundle-version="[3.5.0,4.0.0)",	63	org.eclipse.jface.text;bundle-version="[3.5.0,4.0.0)",
64	org.eclipse.ui.workbench.texteditor;bundle-version="[3.5.0,4.0.0)",	64	org.eclipse.ui.workbench.texteditor;bundle-version="[3.5.0,4.0.0)",
65	org.eclipse.ui.ide;bundle-version="[3.5.0,4.0.0)",	65	org.eclipse.ui.ide;bundle-version="[3.5.0,4.0.0)",




/*******************************************************************************
 * 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.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 a <code>DebugCommandAction</code> to implement 
 * the needed functionality. The IActionDelegate must use {@link #setActionProxy(IAction)}
 * specifying the workbench's action that is a proxy to the action delegate. This
 * way, the workbench action can be updated visually as needed.<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>
 * <p>
 * Clients may subclass this class.
 * </p>
 * @see org.eclipse.debug.core.commands.IDebugCommandHandler
 * @since 3.6
 */
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);
    }

	/**
     * Sets the current workbench action that is a proxy to an {@link org.eclipse.ui.IActionDelegate}
     * that is using this action to perform its actual work. This only needs to be called when
     * an {@link org.eclipse.ui.IActionDelegate} is using one of these actions to perform its
     * function.
     * 
     * @param action workbench proxy action
     */
    public void setActionProxy(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 request The completed request object which was given to 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();  

    /**
     * @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. By default, <code>false</code>
     * is returned.
     * 
     * @return initial enabled state when there is no active context.
     */
    protected boolean getInitialEnablement() {
    	return false;
    }

    /**
     * Returns the context this action operates on as a selection.
     * 
     * @return the context this action operates on
     */
    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. By default, this actions is
     * associated with the context service for the window this action is operating in.
     * 
     * @return associated context service
     */
    protected IDebugContextService getDebugContextService() {
    	return DebugUITools.getDebugContextManager().getContextService(fWindow);
    }

    /**
     * Returns the help context id for this action or <code>null</code> if none.
     * 
     * @return The help context id for this action or <code>null</code>
     */ 
    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 workbench proxy associated with this action or <code>null</code>
     * if none. This is the workbench proxy to an {@link org.eclipse.ui.IActionDelegate}
     * that is using this action to perform its actual work. This is only used when
     * an {@link org.eclipse.ui.IActionDelegate} is using one of these actions to perform its
     * function.
     * 
     * @return workbench proxy action or <code>null</code>
     */
    protected IAction getActionProxy() {
    	return fAction;
    }
}




/*******************************************************************************
 * Copyright (c) 2008, 2009 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, 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:
 *     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 the debugger plug-ins.  This class implements 
 * {@link org.eclipse.core.commands.IHandler} interface and is to be used with the 
 * platform commands framework. </p>
 * 
 * <p>
 * Clients may subclass this class.
 * </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);
    }
    
    /* (non-Javadoc)
     * @see org.eclipse.core.commands.AbstractHandler#setEnabled(java.lang.Object)
     */
    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);
        }
    }
    
    /* (non-Javadoc)
     * @see org.eclipse.core.commands.AbstractHandler#isEnabled()
     */
    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;
    }
    
    /* (non-Javadoc)
     * @see org.eclipse.core.commands.AbstractHandler#execute(org.eclipse.core.commands.ExecutionEvent)
     */
    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;
    }
}




package org.eclipse.debug.internal.core.commands;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.debug.core.commands.IDebugCommandRequest;
import org.eclipse.debug.core.commands.IResumeHandler;
import org.eclipse.debug.core.model.ISuspendResume;


	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.debug.internal.core.commands.SuspendCommand#getEnabledStateJobFamily(org.eclipse.debug.core.commands.IDebugCommandRequest)
	 */
	protected Object getEnabledStateJobFamily(IDebugCommandRequest request) {
		return IResumeHandler.class;
	}





package org.eclipse.debug.internal.core.commands;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.debug.core.commands.IDebugCommandRequest;
import org.eclipse.debug.core.commands.ITerminateHandler;
import org.eclipse.debug.core.model.ITerminate;


	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.commands.AbstractDebugCommand#getEnabledStateJobFamily(org.eclipse.debug.core.commands.IDebugCommandRequest)
	 */
	protected Object getEnabledStateJobFamily(IDebugCommandRequest request) {
		return ITerminateHandler.class;
	}
}




package org.eclipse.debug.internal.core.commands;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.debug.core.commands.IDebugCommandRequest;
import org.eclipse.debug.core.commands.IStepOverHandler;
import org.eclipse.debug.core.model.IStep;


	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.commands.AbstractDebugCommand#getEnabledStateJobFamily(org.eclipse.debug.core.commands.IDebugCommandRequest)
	 */
	protected Object getEnabledStateJobFamily(IDebugCommandRequest request) {
		return IStepOverHandler.class;
	}





package org.eclipse.debug.internal.core.commands;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.debug.core.commands.IDebugCommandRequest;
import org.eclipse.debug.core.commands.IDisconnectHandler;
import org.eclipse.debug.core.model.IDisconnect;


	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.commands.AbstractDebugCommand#getEnabledStateJobFamily(org.eclipse.debug.core.commands.IDebugCommandRequest)
	 */
	protected Object getEnabledStateJobFamily(IDebugCommandRequest request) {
		return IDisconnectHandler.class;
	}
}




package org.eclipse.debug.internal.core.commands;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.debug.core.commands.IDebugCommandRequest;
import org.eclipse.debug.core.commands.IStepIntoHandler;
import org.eclipse.debug.core.model.IStep;


	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.commands.AbstractDebugCommand#getEnabledStateJobFamily(org.eclipse.debug.core.commands.IDebugCommandRequest)
	 */
	protected Object getEnabledStateJobFamily(IDebugCommandRequest request) {
		return IStepIntoHandler.class;
	}





package org.eclipse.debug.internal.core.commands;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.debug.core.commands.IDebugCommandRequest;
import org.eclipse.debug.core.commands.IStepReturnHandler;
import org.eclipse.debug.core.model.IStep;


		((IStep)target).stepReturn();
	}


	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.commands.AbstractDebugCommand#getEnabledStateJobFamily(org.eclipse.debug.core.commands.IDebugCommandRequest)
	 */
	protected Object getEnabledStateJobFamily(IDebugCommandRequest request) {
		return IStepReturnHandler.class;
	}





package org.eclipse.debug.internal.core.commands;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.debug.core.commands.IDebugCommandRequest;
import org.eclipse.debug.core.commands.ISuspendHandler;
import org.eclipse.debug.core.model.ISuspendResume;


	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.commands.AbstractDebugCommand#getEnabledStateJobFamily(org.eclipse.debug.core.commands.IDebugCommandRequest)
	 */
	protected Object getEnabledStateJobFamily(IDebugCommandRequest request) {
		return ISuspendHandler.class;
	}
}




import org.eclipse.core.runtime.CoreException;
import org.eclipse.debug.core.DebugPlugin;
import org.eclipse.debug.core.ILaunch;
import org.eclipse.debug.core.commands.IDebugCommandRequest;
import org.eclipse.debug.core.commands.IStepFiltersHandler;
import org.eclipse.debug.core.model.IDebugElement;
import org.eclipse.debug.core.model.IDebugTarget;

	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.commands.AbstractDebugCommand#getEnabledStateJobFamily(org.eclipse.debug.core.commands.IDebugCommandRequest)
	 */
	protected Object getEnabledStateJobFamily(IDebugCommandRequest request) {
		return IStepFiltersHandler.class;
	}	
}




package org.eclipse.debug.internal.core.commands;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.debug.core.commands.IDebugCommandRequest;
import org.eclipse.debug.core.commands.IDropToFrameHandler;
import org.eclipse.debug.core.model.IDropToFrame;


	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.commands.AbstractDebugCommand#getEnabledStateJobFamily(org.eclipse.debug.core.commands.IDebugCommandRequest)
	 */
	protected Object getEnabledStateJobFamily(IDebugCommandRequest request) {
		return IDropToFrameHandler.class;
	}
}




/*******************************************************************************
 * 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 1-5 Link Here

(-)core/org/eclipse/debug/internal/core/commands/ForEachCommand.java (-2 / +3 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2007 IBM Corporation and others.	2	* Copyright (c) 2007, 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 13-18 Link Here
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 1-5 Link Here

(-)core/org/eclipse/debug/core/commands/IDebugCommandHandler.java (-2 / +2 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2006, 2008 IBM Corporation and others.	2	* Copyright (c) 2006, 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 66-72 Link Here
66	* given request. Errors can reported by setting an appropriate status	66	* given request. Errors can reported by setting an appropriate status
67	* on the given request. A request can be canceled by this handler or the caller.	67	* on the given request. A request can be canceled by this handler or the caller.
68	* A <code>null</code> status is equivalent to an OK status. When a request is	68	* A <code>null</code> status is equivalent to an OK status. When a request is
69	* complete, has encountered an error, or cancelled, implementations must call	69	* complete, has encountered an error, or canceled, implementations must call
70	* <code>done()</code> on the given collector.	70	* <code>done()</code> on the given collector.
71	* </p>	71	* </p>
72	* <p>	72	* <p>

Lines 2-8 Link Here

(-)META-INF/MANIFEST.MF (-1 / +1 lines)
2	Bundle-ManifestVersion: 2	2	Bundle-ManifestVersion: 2
3	Bundle-Name: %pluginName	3	Bundle-Name: %pluginName
4	Bundle-SymbolicName: org.eclipse.debug.core; singleton:=true	4	Bundle-SymbolicName: org.eclipse.debug.core; singleton:=true
5	Bundle-Version: 3.5.100.qualifier	5	Bundle-Version: 3.6.0.qualifier
6	Bundle-ClassPath: .	6	Bundle-ClassPath: .
7	Bundle-Activator: org.eclipse.debug.core.DebugPlugin	7	Bundle-Activator: org.eclipse.debug.core.DebugPlugin
8	Bundle-Vendor: %providerName	8	Bundle-Vendor: %providerName





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

/**
 * Abstract implementation of a debug command handler. Handles {@link IDebugCommandRequest}
 * and {@link IEnabledStateRequest} updates asynchronously using jobs.
 * <p>
 * Clients may subclass this class.
 * </p>
 * @since 3.6
 */
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(getEnabledStateTaskName());
			request = stateRequest;
			setSystem(true);
			setRule(getEnabledStateSchedulingRule(request));
			getJobManager().addJobChangeListener(this);
		}
		
		/* (non-Javadoc)
		 * @see org.eclipse.core.runtime.jobs.Job#run(org.eclipse.core.runtime.IProgressMonitor)
		 */
		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(getEnabledStateTaskName(), 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) {
			Object myFamily = getEnabledStateJobFamily(request);
			if (myFamily != null) {
				return myFamily.equals(family);
			}
			return false;
		}

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

	}
   
	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.commands.IDebugCommandHandler#execute(org.eclipse.debug.core.commands.IDebugCommandRequest)
	 */
	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;
			}
			public boolean belongsTo(Object family) {
				Object jobFamily = getExecuteJobFamily(request);
				if (jobFamily != null) {
					return jobFamily.equals(family);
				}
				return false;
			}
		};
		job.setSystem(true);
		job.setRule(getExecuteSchedulingRule(request));
		job.schedule();
		return isRemainEnabled(request);
	}	
	
	/**
	 * Returns whether this command should remain enabled after starting execution of the specified request.
	 * 
	 * @param request the request being executed
	 * @return whether to remain enabled while executing the request
	 */
	protected boolean isRemainEnabled(IDebugCommandRequest request) {
		return false;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.commands.IDebugCommandHandler#canExecute(org.eclipse.debug.core.commands.IEnabledStateRequest)
	 */
	public void canExecute(final IEnabledStateRequest request) {
		Job job = new UpdateJob(request);
		job.schedule();
	}
	
	/**
	 * Returns the name to use for a job and progress monitor task names when performing
	 * an {@link IEnabledStateRequest}.
	 * 
	 * @return task name
	 */
	protected String getEnabledStateTaskName() {
		// 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
	 * an {@link IDebugCommandRequest}.
	 * 
	 * @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 this command synchronously on the specified targets, reporting progress. This method
	 * is called by a job. If an exception is thrown, the calling job will set the associated status
	 * on the request object. The calling job also calls #done() on the request object after this method
	 * is called, and sets a cancel status on the progress monitor if the request is canceled. 
	 * <p>
	 * Handlers must override this method.
	 * </p>
	 * @param targets objects to perform this command on
	 * @param monitor progress monitor
	 * @param request can be used to cancel this command
	 * @exception CoreException if this handler fails to perform the request
	 */
	protected abstract void doExecute(Object[] targets, IProgressMonitor monitor, IRequest request) throws CoreException;

	/**
	 * Returns whether this command is executable on the specified targets, reporting progress. This method
	 * is called by a job. If an exception is thrown, the calling job will set the associated status
	 * on the request object and report that this command is not enabled. The calling job also calls #done()
	 * on the request object after this method is called, and sets a cancel status on the progress monitor if
	 * the request is canceled. Enabled state is set to <code>false</code> if the request is canceled. 
	 * <p>
	 * Handlers must override this method.
	 * </p>
	 * @param targets objects to check command enabled state for
	 * @param monitor progress monitor
	 * @param request can be used to cancel this update request
	 * @return whether this command can be executed for the given targets
	 */
	protected abstract boolean isExecutable(Object[] targets, IProgressMonitor monitor, IEnabledStateRequest request) throws CoreException;
	
	/**
	 * Returns the appropriate target for this command handler for the given object.
	 * This method is called to map each element in a command request to the target
	 * object that is used in {@link #doExecute(Object[], IProgressMonitor, IRequest)}
	 * and {@link #isExecutable(Object[], IProgressMonitor, IEnabledStateRequest)}.
	 * The target may be the element itself, or some other object. Allows for redirection.
	 * <p>
	 * Clients must override this method.
	 * </p>
	 * @param element element from a {@link IDebugCommandRequest} 
	 * @return associated target object for execution or enabled state update. Cannot return <code>null</code>.
	 */
	protected abstract Object getTarget(Object element); 
	
	/**
	 * Convenience method to return an adapter of the specified type for the given object or <code>null</code>
	 * if none.
	 * 
	 * @param element element to retrieve adapter for
	 * @param type adapter type
	 * @return adapter or <code>null</code>
	 * @see {@link DebugPlugin#getAdapter(Object, Class)}
	 */
	protected Object getAdapter(Object element, Class type) {
    	return DebugPlugin.getAdapter(element, type);	
	}	
	
	/**
	 * Returns a scheduling rule for this command's {@link IEnabledStateRequest} update job
	 * or <code>null</code> if none. By default a rule is created to serialize
	 * jobs on the first element in the request.
	 * <p>
	 * Clients may override this method as required.
	 * </p>
	 * @param request request that a scheduling rule is required for
	 * @return scheduling rule or <code>null</code>
	 */
	protected ISchedulingRule getEnabledStateSchedulingRule(IDebugCommandRequest request) {
		return new SerialPerObjectRule(request.getElements()[0]);
	}
	
	/**
	 * Returns a scheduling rule for this command's {@link IDebugCommandRequest} execute job
	 * or <code>null</code> if none. By default, execution jobs have no scheduling rule.
	 * <p>
	 * Clients may override this method as required.
	 * </p>
	 * @param request request that a scheduling rule is required for
	 * @return scheduling rule or <code>null</code>
	 */
	protected ISchedulingRule getExecuteSchedulingRule(IDebugCommandRequest request) {
		return null;
	}
	
	/**
	 * Returns the job family for the this command's {@link IEnabledStateRequest} update job
	 * or <code>null</code> if none. The default implementation returns <code>null</code>.
	 * <p>
	 * Clients may override this method as required.
	 * </p>
	 * @param request request the job family is required for
	 * @return job family object or <code>null</code> if none
	 */
	protected Object getEnabledStateJobFamily(IDebugCommandRequest request) {
		return null;
	}	
	
	/**
	 * Returns the job family for the this command's {@link IDebugCommandRequest} execute job
	 * or <code>null</code> if none. The default implementation returns <code>null</code>.
	 * <p>
	 * Clients may override this method as required.
	 * </p>
	 * @param request request the job family is required for
	 * @return job family object or <code>null</code> if none
	 */
	protected Object getExecuteJobFamily(IDebugCommandRequest request) {
		return null;
	}	
	
	/**
	 * Returns an array of objects with duplicates removed, if any.
	 * 
	 * @param objects array of objects
	 * @return array of object in same order with duplicates removed, if any.
	 */
	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();
		}
	}
	
}

Return to bug 284363

Lines 24-30 Link Here

(-)ui/org/eclipse/debug/internal/ui/commands/actions/DebugCommandService.java (-6 / +5 lines)
24	import org.eclipse.debug.ui.contexts.DebugContextEvent;	24	import org.eclipse.debug.ui.contexts.DebugContextEvent;
25	import org.eclipse.debug.ui.contexts.IDebugContextListener;	25	import org.eclipse.debug.ui.contexts.IDebugContextListener;
26	import org.eclipse.debug.ui.contexts.IDebugContextService;	26	import org.eclipse.debug.ui.contexts.IDebugContextService;
27	import org.eclipse.jface.action.Action;
28	import org.eclipse.jface.action.IAction;	27	import org.eclipse.jface.action.IAction;
29	import org.eclipse.jface.viewers.ISelection;	28	import org.eclipse.jface.viewers.ISelection;
30	import org.eclipse.jface.viewers.IStructuredSelection;	29	import org.eclipse.jface.viewers.IStructuredSelection;
Lines 111-117 Link Here
111	* @param commandType	110	* @param commandType
112	* @param monitor	111	* @param monitor
113	*/	112	*/
114	public void postUpdateCommand(Class commandType, Action action) {	113	public void postUpdateCommand(Class commandType, IEnabledTarget action) {
115	synchronized (fCommandUpdates) {	114	synchronized (fCommandUpdates) {
116	Job.getJobManager().cancel(commandType);	115	Job.getJobManager().cancel(commandType);
117	List actions = (List) fCommandUpdates.get(commandType);	116	List actions = (List) fCommandUpdates.get(commandType);
Lines 129-139 Link Here
129	* @param commandType	128	* @param commandType
130	* @param requestMonitor	129	* @param requestMonitor
131	*/	130	*/
132	public void updateCommand(Class commandType, IAction action) {	131	public void updateCommand(Class commandType, IEnabledTarget action) {
133	ISelection context = fContextService.getActiveContext();	132	ISelection context = fContextService.getActiveContext();
134	if (context instanceof IStructuredSelection && !context.isEmpty()) {	133	if (context instanceof IStructuredSelection && !context.isEmpty()) {
135	Object[] elements = ((IStructuredSelection)context).toArray();	134	Object[] elements = ((IStructuredSelection)context).toArray();
136	updateCommand(commandType, elements, new IAction[]{action});	135	updateCommand(commandType, elements, new IEnabledTarget[]{action});
137	} else {	136	} else {
138	action.setEnabled(false);	137	action.setEnabled(false);
139	}	138	}
Lines 152-158 Link Here
152	Entry entry = (Entry) iterator.next();	151	Entry entry = (Entry) iterator.next();
153	Class commandType = (Class)entry.getKey();	152	Class commandType = (Class)entry.getKey();
154	List actions = (List) entry.getValue();	153	List actions = (List) entry.getValue();
155	updateCommand(commandType, elements, (IAction[]) actions.toArray(new IAction[actions.size()]));	154	updateCommand(commandType, elements, (IEnabledTarget[]) actions.toArray(new IEnabledTarget[actions.size()]));
156	}	155	}
157	} else {	156	} else {
158	Iterator iterator = commands.values().iterator();	157	Iterator iterator = commands.values().iterator();
Lines 174-180 Link Here
174	* @param elements elements to update for	173	* @param elements elements to update for
175	* @param monitor status monitor	174	* @param monitor status monitor
176	*/	175	*/
177	private void updateCommand(Class handlerType, Object[] elements, IAction[] actions) {	176	private void updateCommand(Class handlerType, Object[] elements, IEnabledTarget[] actions) {
178	if (elements.length == 1) {	177	if (elements.length == 1) {
179	// usual case - one element	178	// usual case - one element
180	Object element = elements[0];	179	Object element = elements[0];

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/DebugCommandAction.java (+343 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
12	package org.eclipse.debug.ui.actions;
13
14	import org.eclipse.debug.core.IRequest;
15	import org.eclipse.debug.internal.ui.commands.actions.DebugCommandService;
16	import org.eclipse.debug.internal.ui.commands.actions.ICommandParticipant;
17	import org.eclipse.debug.internal.ui.commands.actions.IEnabledTarget;
18	import org.eclipse.debug.ui.DebugUITools;
19	import org.eclipse.debug.ui.contexts.DebugContextEvent;
20	import org.eclipse.debug.ui.contexts.IDebugContextListener;
21	import org.eclipse.debug.ui.contexts.IDebugContextService;
22	import org.eclipse.jface.action.Action;
23	import org.eclipse.jface.action.IAction;
24	import org.eclipse.jface.resource.ImageDescriptor;
25	import org.eclipse.jface.viewers.ISelection;
26	import org.eclipse.jface.viewers.IStructuredSelection;
27	import org.eclipse.swt.widgets.Event;
28	import org.eclipse.ui.IWorkbenchPart;
29	import org.eclipse.ui.IWorkbenchWindow;
30	import org.eclipse.ui.PlatformUI;
31
32	/**
33	* Abstract base class for re-targeting actions which delegate execution to
34	* {@link org.eclipse.debug.core.commands.IDebugCommandHandler} handlers.
35	* The specific type of <code>IDebugCommandHandler</code> is determined by the
36	* abstract {@link #getCommandType()} method.
37	* <p>
38	* This base class is an action which can be instantiated directly by views,
39	* etc. In order to contribute an action using an extension point, a class
40	* implementing {@link org.eclipse.ui.IActionDelegate} should be created first.
41	* The delegate should then use a <code>DebugCommandAction</code> to implement
42	* the needed functionality. The IActionDelegate must use {@link #setActionProxy(IAction)}
43	* specifying the workbench's action that is a proxy to the action delegate. This
44	* way, the workbench action can be updated visually as needed.<br>
45	* Note: <code>IDebugCommandHandler</code> command typically act on the active
46	* debug context as opposed to the active selection in view or window. The
47	* action delegate should ignore the active window selection, and instead allow
48	* the <code>DebugCommandAction</code> to update itself based on the active
49	* debug context.
50	* </p>
51	* <p>
52	* Clients may subclass this class.
53	* </p>
54	* @see org.eclipse.debug.core.commands.IDebugCommandHandler
55	* @since 3.6
56	*/
57	public abstract class DebugCommandAction extends Action implements IDebugContextListener {
58
59	private boolean fInitialized = false;
60
61	/**
62	* The window this action is working for.
63	*/
64	private IWorkbenchWindow fWindow;
65
66	/**
67	* The part this action is working for, or <code>null</code> if global to
68	* a window.
69	*/
70	private IWorkbenchPart fPart;
71
72	/**
73	* Command service.
74	*/
75	private DebugCommandService fUpdateService;
76
77	/**
78	* Delegate this action is working for or <code>null</code> if none.
79	*/
80	private IAction fAction;
81
82	private IEnabledTarget fEnabledTarget = new IEnabledTarget() {
83	public void setEnabled(boolean enabled) {
84	DebugCommandAction.this.setEnabled(enabled);
85	}
86	};
87
88	/**
89	* Constructor
90	*/
91	public DebugCommandAction() {
92	super();
93	String helpContextId = getHelpContextId();
94	if (helpContextId != null)
95	PlatformUI.getWorkbench().getHelpSystem().setHelp(this, helpContextId);
96	setEnabled(false);
97	}
98
99	/**
100	* Sets the current workbench action that is a proxy to an {@link org.eclipse.ui.IActionDelegate}
101	* that is using this action to perform its actual work. This only needs to be called when
102	* an {@link org.eclipse.ui.IActionDelegate} is using one of these actions to perform its
103	* function.
104	*
105	* @param action workbench proxy action
106	*/
107	public void setActionProxy(IAction action) {
108	fAction = action;
109	fAction.setEnabled(isEnabled());
110	}
111
112	/**
113	* Executes this action on the given target object
114	*
115	* @param target the target to perform the action on
116	*/
117	private boolean execute(final Object[] targets) {
118	return fUpdateService.executeCommand(
119	getCommandType(), targets,
120	new ICommandParticipant() {
121	public void requestDone(org.eclipse.debug.core.IRequest request) {
122	DebugCommandAction.this.postExecute(request, targets);
123	}
124	});
125	}
126
127	/**
128	* This method is called after the completion of the execution of this
129	* command. Extending classes may override this method to perform additional
130	* operation after command execution.
131	*
132	* @param request The completed request object which was given to the
133	* debug command handler.
134	* @param targets Objects which were the targets of this action
135	*/
136	protected void postExecute(IRequest request, Object[] targets) {
137	// do nothing by default
138	}
139
140	/**
141	* Returns the {@link org.eclipse.debug.core.commands.IDebugCommandHandler}
142	* command handler that type this action executes.
143	*
144	* @return command class.
145	*
146	* @see org.eclipse.debug.core.commands.IDebugCommandHandler
147	*/
148	abstract protected Class getCommandType();
149
150	/**
151	* @see org.eclipse.debug.ui.contexts.IDebugContextListener#debugContextChanged(org.eclipse.debug.ui.contexts.DebugContextEvent)
152	*/
153	public void debugContextChanged(DebugContextEvent event) {
154	fUpdateService.postUpdateCommand(getCommandType(), fEnabledTarget);
155	}
156
157	/**
158	* @see org.eclipse.jface.action.Action#setEnabled(boolean)
159	*/
160	public void setEnabled(boolean enabled) {
161	synchronized (this) {
162	if (!fInitialized) {
163	fInitialized = true;
164	notifyAll();
165	}
166	}
167	super.setEnabled(enabled);
168	if (fAction != null) {
169	fAction.setEnabled(enabled);
170	}
171	}
172
173	/**
174	* Initializes this action for a specific part.
175	*
176	* @param part workbench part
177	*/
178	public void init(IWorkbenchPart part) {
179	fPart = part;
180	fWindow = part.getSite().getWorkbenchWindow();
181	fUpdateService = DebugCommandService.getService(fWindow);
182	IDebugContextService service = getDebugContextService();
183	String partId = part.getSite().getId();
184	service.addDebugContextListener(this, partId);
185	ISelection activeContext = service.getActiveContext(partId);
186	if (activeContext != null) {
187	fUpdateService.updateCommand(getCommandType(), fEnabledTarget);
188	} else {
189	setEnabled(getInitialEnablement());
190	}
191	}
192
193	/**
194	* Initializes the context action
195	* @param window the window
196	*/
197	public void init(IWorkbenchWindow window) {
198	fWindow = window;
199	fUpdateService = DebugCommandService.getService(fWindow);
200	IDebugContextService contextService = getDebugContextService();
201	contextService.addDebugContextListener(this);
202	ISelection activeContext = contextService.getActiveContext();
203	if (activeContext != null) {
204	fUpdateService.updateCommand(getCommandType(), fEnabledTarget);
205	} else {
206	setEnabled(getInitialEnablement());
207	}
208	}
209
210	/**
211	* Returns whether this action should be enabled when initialized
212	* and there is no active debug context. By default, <code>false</code>
213	* is returned.
214	*
215	* @return initial enabled state when there is no active context.
216	*/
217	protected boolean getInitialEnablement() {
218	return false;
219	}
220
221	/**
222	* Returns the context this action operates on as a selection.
223	*
224	* @return the context this action operates on
225	*/
226	private ISelection getContext() {
227	if (fPart != null) {
228	getDebugContextService().getActiveContext(fPart.getSite().getId());
229	}
230	return getDebugContextService().getActiveContext();
231	}
232
233	/*
234	* (non-Javadoc)
235	* @see org.eclipse.jface.action.Action#run()
236	*/
237	public void run() {
238	synchronized (this) {
239	if (!fInitialized) {
240	try {
241	wait();
242	} catch (InterruptedException e) {
243	}
244	}
245	}
246
247	ISelection selection = getContext();
248	if (selection instanceof IStructuredSelection && isEnabled()) {
249	IStructuredSelection ss = (IStructuredSelection) selection;
250	boolean enabled = execute(ss.toArray());
251	// disable the action according to the command
252	setEnabled(enabled);
253	}
254	}
255
256	/*
257	* (non-Javadoc)
258	* @see org.eclipse.jface.action.Action#runWithEvent(org.eclipse.swt.widgets.Event)
259	*/
260	public void runWithEvent(Event event) {
261	run();
262	}
263
264	/**
265	* Clean up when removing
266	*/
267	public void dispose() {
268	IDebugContextService service = getDebugContextService();
269	if (fPart != null) {
270	service.removeDebugContextListener(this, fPart.getSite().getId());
271	} else {
272	service.removeDebugContextListener(this);
273	}
274	fWindow = null;
275	fPart = null;
276	}
277
278	/**
279	* Returns the context service this action linked to. By default, this actions is
280	* associated with the context service for the window this action is operating in.
281	*
282	* @return associated context service
283	*/
284	protected IDebugContextService getDebugContextService() {
285	return DebugUITools.getDebugContextManager().getContextService(fWindow);
286	}
287
288	/**
289	* Returns the help context id for this action or <code>null</code> if none.
290	*
291	* @return The help context id for this action or <code>null</code>
292	*/
293	public abstract String getHelpContextId();
294
295	/*
296	* (non-Javadoc)
297	* @see org.eclipse.jface.action.Action#getId()
298	*/
299	public abstract String getId();
300
301	/*
302	* (non-Javadoc)
303	* @see org.eclipse.jface.action.Action#getText()
304	*/
305	public abstract String getText();
306
307	/*
308	* (non-Javadoc)
309	* @see org.eclipse.jface.action.Action#getToolTipText()
310	*/
311	public abstract String getToolTipText();
312
313	/*
314	* (non-Javadoc)
315	* @see org.eclipse.jface.action.Action#getDisabledImageDescriptor()
316	*/
317	public abstract ImageDescriptor getDisabledImageDescriptor();
318
319	/*
320	* (non-Javadoc)
321	* @see org.eclipse.jface.action.Action#getHoverImageDescriptor()
322	*/
323	public abstract ImageDescriptor getHoverImageDescriptor();
324
325	/*
326	* (non-Javadoc)
327	* @see org.eclipse.jface.action.Action#getImageDescriptor()
328	*/
329	public abstract ImageDescriptor getImageDescriptor();
330
331	/**
332	* Returns the workbench proxy associated with this action or <code>null</code>
333	* if none. This is the workbench proxy to an {@link org.eclipse.ui.IActionDelegate}
334	* that is using this action to perform its actual work. This is only used when
335	* an {@link org.eclipse.ui.IActionDelegate} is using one of these actions to perform its
336	* function.
337	*
338	* @return workbench proxy action or <code>null</code>
339	*/
340	protected IAction getActionProxy() {
341	return fAction;
342	}
343	}

Added Link Here

(-)ui/org/eclipse/debug/internal/ui/commands/actions/IEnabledTarget.java (+18 lines)
1	/*******************************************************************************
2	* Copyright (c) 2008, 2009 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	}

Lines 11-16 Link Here

(-)core/org/eclipse/debug/internal/core/commands/ResumeCommand.java (-2 / +3 lines)
11	package org.eclipse.debug.internal.core.commands;	11	package org.eclipse.debug.internal.core.commands;
12		12
13	import org.eclipse.core.runtime.CoreException;	13	import org.eclipse.core.runtime.CoreException;
		14	import org.eclipse.debug.core.commands.IDebugCommandRequest;
14	import org.eclipse.debug.core.commands.IResumeHandler;	15	import org.eclipse.debug.core.commands.IResumeHandler;
15	import org.eclipse.debug.core.model.ISuspendResume;	16	import org.eclipse.debug.core.model.ISuspendResume;
16		17
Lines 30-38 Link Here
30	}	31	}
31		32
32	/* (non-Javadoc)	33	/* (non-Javadoc)
33	* @see org.eclipse.debug.internal.core.commands.SuspendCommand#getUpdateJobFamily()	34	* @see org.eclipse.debug.internal.core.commands.SuspendCommand#getEnabledStateJobFamily(org.eclipse.debug.core.commands.IDebugCommandRequest)
34	*/	35	*/
35	protected Object getUpdateJobFamily() {	36	protected Object getEnabledStateJobFamily(IDebugCommandRequest request) {
36	return IResumeHandler.class;	37	return IResumeHandler.class;
37	}	38	}
38		39

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>