<factory 

            class="org.eclipse.debug.internal.ui.actions.breakpoints.DefaultEditBreakpointsTargetFactory"

            adaptableType="org.eclipse.debug.core.model.IBreakpoint">

            <adapter type="org.eclipse.debug.ui.actions.IEditBreakpointTarget"/>

         </factory>

import org.eclipse.core.resources.IMarker;

import org.eclipse.core.runtime.preferences.IEclipsePreferences;

import org.eclipse.core.runtime.preferences.InstanceScope;

import org.eclipse.debug.core.DebugPlugin;

import org.eclipse.debug.core.model.IBreakpoint;

import org.eclipse.jface.text.BadLocationException;

import org.eclipse.jface.text.IDocument;

import org.eclipse.jface.text.Position;

import org.eclipse.jface.text.source.IAnnotationModel;

import org.eclipse.jface.text.source.IVerticalRulerInfo;

import org.eclipse.ui.IEditorInput;

import org.eclipse.ui.texteditor.IDocumentProvider;

import org.eclipse.ui.texteditor.ITextEditor;

import org.eclipse.ui.texteditor.SimpleMarkerAnnotation;

    /**

     * Attempts to resolve the {@link IBreakpoint} from the {@link IMarker} at the current location in the editor on the vertical ruler.

     * <br><br>

     * Returns <code>null</code> if the breakpoint cannot be resolved.

     * @param editor the backing editor

     * @param info the current {@link IVerticalRulerInfo}

     * @return the {@link IBreakpoint} backing the marker on the ruler or <code>null</code>

     * @since 3.8

     */

    public static IBreakpoint getBeakpointFromEditor(ITextEditor editor, IVerticalRulerInfo info) {

    	IDocumentProvider provider = editor.getDocumentProvider();

    	if(provider == null) {

    		return null;

    	}

    	IEditorInput input = editor.getEditorInput();

    	IAnnotationModel annotationModel = provider.getAnnotationModel(input);

		if (annotationModel != null) {

			IDocument document = provider.getDocument(input);

			Iterator iterator = annotationModel.getAnnotationIterator();

			while (iterator.hasNext()) {

				Object object = iterator.next();

				if (object instanceof SimpleMarkerAnnotation) {

					SimpleMarkerAnnotation markerAnnotation = (SimpleMarkerAnnotation) object;

					IMarker marker = markerAnnotation.getMarker();

					try {

						if (marker.isSubtypeOf(IBreakpoint.BREAKPOINT_MARKER)) {

							Position position = annotationModel.getPosition(markerAnnotation);

							int line = document.getLineOfOffset(position.getOffset());

							if (line == info.getLineOfLastMouseButtonActivity()) {

								IBreakpoint breakpoint = DebugPlugin.getDefault().getBreakpointManager().getBreakpoint(marker);

								if (breakpoint != null) {

									return breakpoint;

								}

							}

						}

					} catch (CoreException e) {

					} catch (BadLocationException e) {

					}

				}

			}

		}

    	return null;

    }

/*******************************************************************************

 * Copyright (c) 2012 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.actions.breakpoints;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.IAdapterFactory;

import org.eclipse.debug.core.model.IBreakpoint;

import org.eclipse.debug.ui.actions.IEditBreakpointTarget;

import org.eclipse.ui.IWorkbenchPart;

import org.eclipse.ui.dialogs.PreferencesUtil;

/**

 * Default action implementation to edit breakpoint properties.

 * @since 3.8

 */

public class DefaultEditBreakpointsTargetFactory implements IAdapterFactory {

    private final static IEditBreakpointTarget fgEditBreakpointsTarget = 

        new IEditBreakpointTarget() {

            public void editBreakpointProperties(IWorkbenchPart part, IBreakpoint breakpoint) throws CoreException {

                PreferencesUtil.createPropertyDialogOn(

                    part.getSite().getShell(), breakpoint, null, null, null, 0).open();        

            }

        };

    public Class[] getAdapterList() {

        return new Class[] { IEditBreakpointTarget.class };

    }

    public Object getAdapter(Object adaptableObject, Class adapterType) {

        if (adaptableObject instanceof IBreakpoint && IEditBreakpointTarget.class.equals(adapterType)) {

            return fgEditBreakpointsTarget;

        }

        return null;

    }

}

/*******************************************************************************

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

 *     Wind River Systems - added support for IToggleBreakpointsTargetFactory

 *******************************************************************************/

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

import org.eclipse.core.runtime.CoreException;

import org.eclipse.debug.internal.ui.DebugUIPlugin;

import org.eclipse.debug.internal.ui.actions.ActionMessages;

import org.eclipse.debug.internal.ui.actions.IToggleBreakpointsTargetManagerListener;

import org.eclipse.debug.internal.ui.actions.ToggleBreakpointsTargetManager;

import org.eclipse.debug.ui.actions.IToggleBreakpointsTarget;

import org.eclipse.debug.ui.actions.IToggleBreakpointsTargetExtension2;

import org.eclipse.jface.action.Action;

import org.eclipse.jface.text.BadLocationException;

import org.eclipse.jface.text.IDocument;

import org.eclipse.jface.text.IRegion;

import org.eclipse.jface.text.ITextSelection;

import org.eclipse.jface.text.TextSelection;

import org.eclipse.jface.text.source.IVerticalRulerInfo;

import org.eclipse.jface.viewers.ISelection;

import org.eclipse.jface.viewers.ISelectionProvider;

import org.eclipse.ui.IWorkbenchPart;

import org.eclipse.ui.texteditor.IDocumentProvider;

import org.eclipse.ui.texteditor.ITextEditor;

import org.eclipse.ui.texteditor.IUpdate;

/**

 * Action to interactively create a breakpoint from vertical ruler of a 

 * workbench part containing a document. The part must provide an 

 * <code>IToggleBreakpointsTargetExtension2</code> adapter.

 * <p>

 * Clients may instantiate this class. 

 * </p>

 * @since 3.8

 * @see org.eclipse.debug.ui.actions.RulerToggleBreakpointActionDelegate

 */

public class RulerCreateBreakpointInteractiveAction extends Action implements IUpdate {

	private IWorkbenchPart fPart;

	private IDocument fDocument;

	private IVerticalRulerInfo fRulerInfo;

	private IToggleBreakpointsTargetManagerListener fListener = new IToggleBreakpointsTargetManagerListener() {

	    public void preferredTargetsChanged() {

	        update();	        

	    }

	};

	/**

	 * Constructs a new action to toggle a breakpoint in the given

	 * part containing the given document and ruler.

	 * 

	 * @param part the part in which to toggle the breakpoint - provides

	 *  an <code>IToggleBreakpointsTarget</code> adapter

	 * @param document the document breakpoints are being set in or

	 * <code>null</code> when the document should be derived from the

	 * given part

	 * @param rulerInfo specifies location the user has double-clicked

	 */

	public RulerCreateBreakpointInteractiveAction(IWorkbenchPart part, IDocument document, IVerticalRulerInfo rulerInfo) {

		super(ActionMessages.ToggleBreakpointAction_0);

		fPart = part;

		fDocument = document;

		fRulerInfo = rulerInfo;

		ToggleBreakpointsTargetManager.getDefault().addChangedListener(fListener);

	}

	/*

	 *  (non-Javadoc)

	 * @see org.eclipse.jface.action.IAction#run()

	 */

	public void run() {

		IDocument document= getDocument();

		if (document == null) {

			return;

		}

		int line = fRulerInfo.getLineOfLastMouseButtonActivity();

		// Test if line is valid

		if (line == -1)

			return;

		try {

			ITextSelection selection = getTextSelection(document, line);

			IToggleBreakpointsTarget toggleTarget = 

			    ToggleBreakpointsTargetManager.getDefault().getToggleBreakpointsTarget(fPart, selection);

			if (toggleTarget instanceof IToggleBreakpointsTargetExtension2) {

                IToggleBreakpointsTargetExtension2 extension = (IToggleBreakpointsTargetExtension2) toggleTarget;

                if (extension.canCreateBreakpointsInteractive(fPart, selection)) {

                    extension.createBreakpointsInteractive(fPart, selection);

                }                    

            } 

		} catch (BadLocationException e) {

			reportException(e);

		} catch (CoreException e) {

			reportException(e);

		}

	}

	/**

	 * Report an error to the user.

	 * 

	 * @param e underlying exception

	 */

	private void reportException(Exception e) {

		DebugUIPlugin.errorDialog(fPart.getSite().getShell(), ActionMessages.ToggleBreakpointAction_1, ActionMessages.ToggleBreakpointAction_2, e); //

	}

	/**

	 * Disposes this action. Clients must call this method when

	 * this action is no longer needed.

	 */

	public void dispose() {

		fDocument = null;

		fPart = null;

		fRulerInfo = null;

	    ToggleBreakpointsTargetManager.getDefault().removeChangedListener(fListener);

	}

	/**

	 * Returns the document on which this action operates.

	 * 

	 * @return the document or <code>null</code> if none

	 */

	private IDocument getDocument() {

		if (fDocument != null)

			return fDocument;

		if (fPart instanceof ITextEditor) {

			ITextEditor editor= (ITextEditor)fPart;

			IDocumentProvider provider = editor.getDocumentProvider();

			if (provider != null)

				return provider.getDocument(editor.getEditorInput());

		}

		IDocument doc = (IDocument) fPart.getAdapter(IDocument.class);

		if (doc != null) {

			return doc;

		}

		return null;

	}

	/* (non-Javadoc)

	 * @see org.eclipse.ui.texteditor.IUpdate#update()

	 */

	public void update() {

		IDocument document= getDocument();

		if (document != null) {

		    int line = fRulerInfo.getLineOfLastMouseButtonActivity();

		    if (line > -1) {

		        try {

		            ITextSelection selection = getTextSelection(document, line);

                    IToggleBreakpointsTarget adapter = 

                        ToggleBreakpointsTargetManager.getDefault().getToggleBreakpointsTarget(fPart, selection);

                    if (adapter == null) {

                        setEnabled(false);

                        return;

                    }

                    if (adapter instanceof IToggleBreakpointsTargetExtension2) {

                        IToggleBreakpointsTargetExtension2 extension = (IToggleBreakpointsTargetExtension2) adapter;

                        if (extension.canCreateBreakpointsInteractive(fPart, selection)) {

                            setEnabled(true);

                            return;

                        }

                    }

                } catch (BadLocationException e) {

                    reportException(e);

                }

			}

		}

		setEnabled(false);

	}

	/**

	 * Determines the text selection for the breakpoint action.  If clicking on the ruler inside

	 * the highlighted text, return the text selection for the highlighted text.  Otherwise, 

	 * return a text selection representing the start of the line.

	 * 

	 * @param document	The IDocument backing the Editor.

	 * @param line	The line clicked on in the ruler.

	 * @return	An ITextSelection as described.

	 * @throws BadLocationException	If underlying operations throw.

	 */

	private ITextSelection getTextSelection(IDocument document, int line) throws BadLocationException {

		IRegion region = document.getLineInformation(line);

		ITextSelection textSelection = new TextSelection(document, region.getOffset(), 0);

		ISelectionProvider provider = fPart.getSite().getSelectionProvider();

		if (provider != null){

			ISelection selection = provider.getSelection();

			if (selection instanceof ITextSelection

					&& ((ITextSelection) selection).getStartLine() <= line

					&& ((ITextSelection) selection).getEndLine() >= line) {

				textSelection = (ITextSelection) selection;

			} 

		}

		return textSelection;

	}

}

/*******************************************************************************

 * Copyright (c) 2012 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.ui.actions;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.debug.core.model.IBreakpoint;

import org.eclipse.ui.IWorkbenchPart;

/**

 * Allows the UI to edit a breakpoint(s) properties.  The implementation of this 

 * interface is to be registered as an adapter to a breakpoint.   

 * 

 * @since 3.8

 */

public interface IEditBreakpointTarget {

    /**

     * Opens a dialog to edit the given breakpoint properties. 

     * @param part Workbench part where this action target is invoked from.

     * @param breakpoint Breakpoint to be edited. 

     * @throws CoreException if unable to edit breakpoint properties.  Should not 

     * be thrown if user cancels the edit action.

     */

    public void editBreakpointProperties(IWorkbenchPart part, IBreakpoint breakpoint) throws CoreException;

}

/*******************************************************************************

 * Copyright (c) 2000, 2005 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.core.runtime.CoreException;

import org.eclipse.jface.viewers.ISelection;

import org.eclipse.ui.IWorkbenchPart;

/**

 * Second extension interface for {@link org.eclipse.debug.ui.actions.IToggleBreakpointsTarget}.

 * This interface provides the ability open edit a breakpoint's properties and 

 * to create a breakpoint in the given context with additional user input 

 * (such as using a dialog or a wizard).

 * <p>

 * Clients implementing <code>IToggleBreakpointsTarget</code> may optionally

 * implement this interface.

 * </p>

 * @since 3.8

 * @see org.eclipse.debug.ui.actions.ToggleBreakpointAction

 */

public interface IToggleBreakpointsTargetExtension2 extends IToggleBreakpointsTargetExtension {

    /**

     * Returns whether the toggle target can create a a breakpoint at the 

     * given location.  If the implementation does not support creating the 

     * breakpoint interactively then it should return <code>false</code>.

     * <p>

     * The selection varies depending on the given part. For example,

     * a text selection is provided for text editors, and a structured

     * selection is provided for tree views, and may be a multi-selection.

     * </p>

     * @param part the part on which the action has been invoked  

     * @param selection selection on which line breakpoints should be toggled

     * @return Returns <code>true</code> if toggle target is able interactively

     * create a breakpoint(s) at the given location.

     */

    public boolean canCreateBreakpointsInteractive(IWorkbenchPart part, ISelection selection);

	/**

     * Creates new breakpoints interactively.  The implementation should allows

     * the user to edit all of the breakpoint's settings prior to creating the 

     * breakpoint.  

     * <p>

     * The selection varies depending on the given part. For example,

     * a text selection is provided for text editors, and a structured

     * selection is provided for tree views, and may be a multi-selection.

     * </p>

     * @param part the part on which the action has been invoked  

     * @param selection selection on which line breakpoints should be toggled

     * @throws CoreException if unable to perform the action 

     */

    public void createBreakpointsInteractive(IWorkbenchPart part, ISelection selection) throws CoreException;

}

import org.eclipse.debug.internal.ui.actions.ToggleBreakpointsTargetManager;

/*******************************************************************************

 * Copyright (c) 2005, 2012 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.internal.ui.actions.breakpoints.RulerCreateBreakpointInteractiveAction;

import org.eclipse.jface.action.IAction;

import org.eclipse.jface.text.source.IVerticalRulerInfo;

import org.eclipse.ui.IActionDelegate2;

import org.eclipse.ui.IEditorPart;

import org.eclipse.ui.texteditor.AbstractRulerActionDelegate;

import org.eclipse.ui.texteditor.ITextEditor;

/**

 * Creates a breakpoint interactively, that is with user input as well as context 

 * information gathered from editor location. This action delegate can be 

 * contributed to an editor with the <code>editorActions</code> extension point.

 * This action is as a factory that creates another action that performs the

 * actual breakpoint toggling. The created action acts on the editor's

 * <code>IToggleBreakpointsTagretExtension2</code> to create the breakpoint.

 * <p>

 * This action should be be contributed to a vertical ruler context menu via the

 * <code>popupMenus</code> extension point, by referencing the ruler's context

 * menu identifier in the <code>targetID</code> attribute.

 * <pre>

 * <extension point="org.eclipse.ui.popupMenus">

 *   <viewerContribution

 *     targetID="example.rulerContextMenuId"

 *     id="example.RulerPopupActions">

 *       <action

 *         label="Toggle Breakpoint"

 *         class="org.eclipse.debug.ui.actions.RulerCreateBreakpointInteractiveActionDelegate"

 *         menubarPath="additions"

 *         id="example.rulerContextMenu.createBreakpointAction">

 *       </action>

 *   </viewerContribution>

 * </pre>

 * </p>

 * <p>

 * Clients may refer to this class as an action delegate in plug-in XML. 

 * </p>

 * @see IToggleBreakpointsTargetExtension2

 * @since 3.8

 * @noextend This class is not intended to be sub-classed by clients.

 * @noinstantiate This class is not intended to be instantiated by clients.

 */

public class RulerCreateBreakpointInteractiveActionDelegate extends AbstractRulerActionDelegate implements IActionDelegate2 {

	private IEditorPart fEditor = null;

	private RulerCreateBreakpointInteractiveAction fDelegate = null;

	/* (non-Javadoc)

	 * @see org.eclipse.ui.texteditor.AbstractRulerActionDelegate#createAction(org.eclipse.ui.texteditor.ITextEditor, org.eclipse.jface.text.source.IVerticalRulerInfo)

	 */

	protected IAction createAction(ITextEditor editor, IVerticalRulerInfo rulerInfo) {

		fDelegate = new RulerCreateBreakpointInteractiveAction(editor, null, rulerInfo);

		return fDelegate;

	}

	/* (non-Javadoc)

	 * @see org.eclipse.ui.IEditorActionDelegate#setActiveEditor(org.eclipse.jface.action.IAction, org.eclipse.ui.IEditorPart)

	 */

	public void setActiveEditor(IAction callerAction, IEditorPart targetEditor) {

		if (fEditor != null) {

			if (fDelegate != null) {

				fDelegate.dispose();

				fDelegate = null;

			}

		}

		fEditor = targetEditor;

		super.setActiveEditor(callerAction, targetEditor);

	}

	/* (non-Javadoc)

	 * @see org.eclipse.ui.IActionDelegate2#init(org.eclipse.jface.action.IAction)

	 */

	public void init(IAction action) {

	}

	/* (non-Javadoc)

	 * @see org.eclipse.ui.IActionDelegate2#dispose()

	 */

	public void dispose() {

		if (fDelegate != null) {

			fDelegate.dispose();

		}

		fDelegate = null;

		fEditor = null;

	}

}

import org.eclipse.debug.core.model.IBreakpoint;

import org.eclipse.swt.SWT;

import org.eclipse.swt.widgets.Event;

	    run(false, false);

	}	    

	public void runWithEvent(Event event) {

	    run( (event.stateMask & SWT.MOD1) > 0, (event.stateMask & SWT.MOD2) > 0);

	}

	private void run(boolean mod1, boolean mod2) {

            //Ctrl+click to enable / disable

	        if(mod1) {

	            toggleBreakpointEnable();

	            return;

	        }

	        // Shift+click to edit breakpoint properties (if breakpoint already exists).

	        if (mod2) {

                if (tryEditBreakpointProperties()) {

                    return;

                }

	        }	        

	private void toggleBreakpointEnable() {

        if(fPart instanceof ITextEditor) {

            IBreakpoint bp = ToggleBreakpointsTargetManager.getBeakpointFromEditor((ITextEditor) fPart, fRulerInfo);

            if(bp != null) {

                try {

                    bp.setEnabled(!bp.isEnabled());

                } catch (CoreException e) {

                    DebugUIPlugin.log(e);

                }

            }

        }	    

	}

    private boolean tryEditBreakpointProperties() {

        if(fPart instanceof ITextEditor) {

            IBreakpoint bp = ToggleBreakpointsTargetManager.getBeakpointFromEditor((ITextEditor) fPart, fRulerInfo);

            if(bp != null) {

                try {

                    IEditBreakpointTarget editTarget = (IEditBreakpointTarget)bp.getAdapter(IEditBreakpointTarget.class);

                    if (editTarget != null) {

                        editTarget.editBreakpointProperties(fPart, bp);

                    }

                } catch (CoreException e) {

                    DebugUIPlugin.log(e);

                }

                return true;

            }

        }       

        return false;

    }