Bug 510100 - [cleanup] Get rid of trailing white space in platform.debugY20170119-1000I20170119-2000I20170119-1010I20170119-0345I20170118-2000I20170118-1215I20170117-2000I20170116-2000I20170115-2000I20170114-2000I20170113-2000

Also enabled "cleanup whitespace on save" actions for debug.ui and
debug.tests bundles.

Change-Id: I755b879ab1d49144a1bec3f4318dbb8b29521bb3
Signed-off-by: Andrey Loskutov <loskutov@gmx.de>

23 files changed, 431 insertions, 431 deletions

diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointContainer.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointContainer.java
index 565ff4855..a1df06ca9 100644
--- a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointContainer.java
+++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointContainer.java
@@ -4,7 +4,7 @@
  * 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
  *     Patrick Chuong (Texas Instruments) - Improve usability of the breakpoint view (Bug 238956)
@@ -40,45 +40,45 @@ public class BreakpointContainer extends ElementContentProvider implements IAdap
 	 * Child breakpoints - inserting new element into this collection should use the insertBreakpoint method
 	 */
 	final private List<IBreakpoint> fBreakpoints = new ArrayList<IBreakpoint>();
-    
+
     /**
      * Child containers - inserting new element into this container should use the insertChildContainer method
      */
 	final private List<BreakpointContainer> fChildContainers = new ArrayList<BreakpointContainer>();
-	
+
     /**
      * The category for this container
      */
     private IAdaptable fCategory;
-    
+
     /**
      * The breakpoint organizer for this container
      */
     private IBreakpointOrganizer fOrganizer;
-    
+
     /**
      * The nested breakpoint organizer
      */
     private IBreakpointOrganizer[] fNesting;
-    
+
     /**
      * A flag to indicate this is the default container
      */
     private boolean fDefaultContainer;
-    
+
     /**
      * Parent container
      */
     private BreakpointContainer fParent;
-    
+
     /**
      * The comparator, will be use to compare the order for inserting new element into this container
      */
     private ElementComparator fComparator;
-    
+
     /**
      * Constructor, intended to be call when creating the root container.
-     * 
+     *
      * @param organizers the breakpoint organizer for this container
      * @param comparator the element comparator, can be <code>null</code>. If <code>null</code> than new element
      * will be added to the end of the list.
@@ -87,39 +87,39 @@ public class BreakpointContainer extends ElementContentProvider implements IAdap
     	fNesting = organizers;
     	fComparator = comparator;
     }
-    
+
     /**
      * Constructor, intended to be call within this class only.
-     * 
+     *
      * @param parent the parent breakpoint container
      * @param category the category for this container
      * @param organizer the organizer for this container
      * @param comparator the element comparator
      * @param nesting the nested breakpoint organizer
      */
-    private BreakpointContainer(BreakpointContainer parent, IAdaptable category, IBreakpointOrganizer organizer, 
-    		ElementComparator comparator, IBreakpointOrganizer[] nesting) {     	
+    private BreakpointContainer(BreakpointContainer parent, IAdaptable category, IBreakpointOrganizer organizer,
+    		ElementComparator comparator, IBreakpointOrganizer[] nesting) {
     	this(category, organizer, nesting);
     	fParent = parent;
     	fComparator = comparator;
     }
-    
+
     /**
      * Constructor, intended to be call when reorganizing the content.
-     * 
+     *
      * @param category the breakpoint category
      * @param organizer the breakpoint organizer
      * @param nesting the nested breakpoint organizer
      */
-    BreakpointContainer(IAdaptable category, IBreakpointOrganizer organizer, IBreakpointOrganizer[] nesting) {    	
+    BreakpointContainer(IAdaptable category, IBreakpointOrganizer organizer, IBreakpointOrganizer[] nesting) {
     	fCategory = category;
     	fOrganizer = organizer;
     	fNesting = nesting;
     }
-    
+
     /**
      * Initialize the default containers.
-     * 
+     *
      * @param parentDelta the parent delta, addition child delta will be added to the parent
      */
     public void initDefaultContainers(ModelDelta parentDelta) {
@@ -144,11 +144,11 @@ public class BreakpointContainer extends ElementContentProvider implements IAdap
     			}
     		}
     	}
-    }    
-    
+    }
+
     /**
      * Insert the breakpoint to this container.
-     * 
+     *
      * @param breakpoint the new breakpoint
      * @return the index of the breakpoint in the cache, -1 if the breakpoint already exist
      */
@@ -166,12 +166,12 @@ public class BreakpointContainer extends ElementContentProvider implements IAdap
     		index = 0;
     	}
     	fBreakpoints.add(index, breakpoint);
-    	return index;   	
+    	return index;
     }
-    
+
     /**
      * Insert the child container this container.
-     * 
+     *
      * @param container the child container
      * @return the index of the container in the cache, -1 if the child container already exist
      */
@@ -182,46 +182,46 @@ public class BreakpointContainer extends ElementContentProvider implements IAdap
 				break;
 			}
     	}
-    	
+
     	if (index < 0) {
 			index = 0;
 		}
     	fChildContainers.add(index, container);
-    	
+
     	return index;
     }
-    
-    
+
+
     /**
      * Returns the element comparator.
-     * 
+     *
      * @return the element comparator
      */
     public ElementComparator getElementComparator() {
     	return fComparator;
-    }    
-    
+    }
+
     /**
      * Returns the parent container, can be <code>null</code>.
-     * 
+     *
      * @return the parent container
      */
     public BreakpointContainer getParent() {
     	return fParent;
     }
-    
+
     /**
      * Determine whether there is any nested container.
-     * 
+     *
      * @return true if has nested container
      */
     private boolean hasNesting() {
     	return fNesting != null && fNesting.length > 0;
     }
-    
+
     /**
      * Get the categories for the breakpoint with the given organizer.
-     * 
+     *
      * @param breakpoint the breakpoint
      * @param organizer the organizer
      * @return the categories
@@ -233,10 +233,10 @@ public class BreakpointContainer extends ElementContentProvider implements IAdap
 		}
     	return categories;
     }
-    
+
     /**
      * Find existing breakpoint container in the container array the given category.
-     * 
+     *
      * @param containers the container array
      * @param category the category
      * @return the breakpoint container, can be <code>null</code>.
@@ -249,36 +249,36 @@ public class BreakpointContainer extends ElementContentProvider implements IAdap
     	}
     	return null;
     }
-    
+
     // TODO [pchuong]: can be remove if BreakpointsContentProvider no longer uses this class
     void addBreakpoint(IBreakpoint breakpoint) {
     	addBreakpoint(breakpoint, new ModelDelta(null, IModelDelta.NO_CHANGE));
-    }    
-    
+    }
+
     /**
-     * Add a breakpoint to the container, additional delta will be added to the root delta. 
-     * 
+     * Add a breakpoint to the container, additional delta will be added to the root delta.
+     *
      * @param breakpoint the breakpoint to added
      * @param rootDelta the root delta of this container
      * @see #removeBreakpoint
      */
-    public void addBreakpoint(IBreakpoint breakpoint, ModelDelta rootDelta) {    	
+    public void addBreakpoint(IBreakpoint breakpoint, ModelDelta rootDelta) {
     	final int bpIndex = insertBreakpoint(breakpoint);
     	if (bpIndex < 0) {
 			return;
 		}
-    	
+
         if (hasNesting()) {
             IBreakpointOrganizer organizer = fNesting[0];
-            
+
             // get the breakpoint categories from the organizer
-            IAdaptable[] categories = getCategories(breakpoint, organizer);            
-            
+            IAdaptable[] categories = getCategories(breakpoint, organizer);
+
             for (int i = 0; i < categories.length; ++i) {
             	ModelDelta childDelta = null;
             	IAdaptable category = categories[i];
-            	BreakpointContainer container = findExistingContainer(fChildContainers, category);            	
-            	
+            	BreakpointContainer container = findExistingContainer(fChildContainers, category);
+
             	// create a new container if it doesn't exist
             	if (container == null) {
             		IBreakpointOrganizer[] nesting = null;
@@ -289,7 +289,7 @@ public class BreakpointContainer extends ElementContentProvider implements IAdap
             		container = new BreakpointContainer(this, category, organizer, fComparator, nesting);
             		insertChildContainer(container);
             		childDelta = rootDelta.addNode(container, fChildContainers.indexOf(container), IModelDelta.INSERTED|IModelDelta.INSTALL, -1);
-            	
+
             	} else {
 					childDelta = rootDelta.addNode(container, fChildContainers.indexOf(container), IModelDelta.STATE, -1);
             	}
@@ -297,23 +297,23 @@ public class BreakpointContainer extends ElementContentProvider implements IAdap
            		container.addBreakpoint(breakpoint, childDelta);
            		childDelta.setChildCount(container.getChildren().length);
             }
-        
+
         } else {
-        	// TODO [pchuong]: There seems to be some kind of problem when the INSERTED flag is used, 
+        	// TODO [pchuong]: There seems to be some kind of problem when the INSERTED flag is used,
         	//				   there is a additional checkbox added to the end of the tree.
         	//				   Also the tree seems to have a strange visual effect when using the INSERTED
         	//				   flag for the child node instead of ADDED flag. Note: all breakpoint delta
         	//				   is using the ADDED flag in this class.
        		rootDelta.addNode(breakpoint, bpIndex, IModelDelta.ADDED|IModelDelta.INSTALL, 0);
        		// rootDelta.addNode(breakpoint, bpIndex, IModelDelta.INSERTED|IModelDelta.INSTALL, 0);
-       		
+
         	rootDelta.setFlags(rootDelta.getFlags() | IModelDelta.EXPAND);
         }
     }
-    
+
     /**
      * Remove a breakpoint from the container, additional delta will be added to the root delta.
-     * 
+     *
      * @param breakpoint the breakpoint to remove
      * @param rootDelta the root delta of this container
      * @return if the breakpoint was successfully removed
@@ -321,10 +321,10 @@ public class BreakpointContainer extends ElementContentProvider implements IAdap
      */
     public boolean removeBreakpoint(IBreakpoint breakpoint, ModelDelta rootDelta) {
     	boolean removed = fBreakpoints.remove(breakpoint);
-    	
+
     	if (removed) {
     		boolean addRemoveBpDelta = getContainers().length == 0;
-        	
+
 			Iterator<BreakpointContainer> it = fChildContainers.iterator();
     		while (it.hasNext()) {
     			BreakpointContainer container = it.next();
@@ -335,25 +335,25 @@ public class BreakpointContainer extends ElementContentProvider implements IAdap
     				if ((!container.isDefaultContainer()) && (container.getBreakpoints().length <= 1)) {
 	    				it.remove();
 	    				childDelta = rootDelta.addNode(container, IModelDelta.REMOVED|IModelDelta.UNINSTALL);
-	    				 
+
 	    			} else {
 	    				childDelta = rootDelta.addNode(container, IModelDelta.STATE);
 	    			}
     				// remove the breakpoint from the nested containers
 	    			container.removeBreakpoint(breakpoint, childDelta);
     			}
-    		} 
-    		
+    		}
+
     		if (addRemoveBpDelta) {
     			rootDelta.addNode(breakpoint, IModelDelta.REMOVED|IModelDelta.UNINSTALL);
     		}
     	}
     	return removed;
-    } 
-    
+    }
+
     /**
      * A helper method to copy the organizers between two containers.
-     * 
+     *
      * @param destContainer the destination container
      * @param sourceContainer the source container
      */
@@ -362,10 +362,10 @@ public class BreakpointContainer extends ElementContentProvider implements IAdap
     	destContainer.fOrganizer = sourceContainer.fOrganizer;
 		destContainer.fCategory = sourceContainer.fCategory;
     }
-    
+
     /**
      * A helper method to update the breakpoint cache of the container and it's ancestors.
-     * 
+     *
      * @param container the breakpoint container
      * @param breakpoints the breakpoint to update
      * @param add true if breakpoint should be added to the cache, otherwise remove the breakpoint from the cache
@@ -379,10 +379,10 @@ public class BreakpointContainer extends ElementContentProvider implements IAdap
     		updateSelfAndAncestorsBreakpointCache(container.getParent(), breakpoints, add);
     	}
     }
-    
+
     /**
      * A helper method to add a breakpoint to an existing container.
-     * 
+     *
      * @param destContainer the destination container
      * @param breakpoint the breakpoint to add
      * @param destContainerDelta the destination container delta, additional delta will be added to this delta
@@ -390,18 +390,18 @@ public class BreakpointContainer extends ElementContentProvider implements IAdap
     static public void addBreakpoint(BreakpointContainer destContainer, IBreakpoint breakpoint, ModelDelta destContainerDelta) {
     	int index = destContainer.insertBreakpoint(breakpoint);
     	Assert.isTrue(index >= 0);
-    	
+
 		List<IBreakpoint> breakpoints = destContainer.fBreakpoints;
     	destContainerDelta.addNode(breakpoint, index/*breakpoints.indexOf(breakpoint)*/, IModelDelta.ADDED|IModelDelta.INSTALL, 0);
     	destContainerDelta.setFlags(destContainerDelta.getFlags() | IModelDelta.EXPAND);
 
-    	// add the breakpoints to the parent containers.    	
+    	// add the breakpoints to the parent containers.
     	updateSelfAndAncestorsBreakpointCache(destContainer.getParent(), breakpoints, true);
     }
-    
+
     /**
      * A helper method to add a child container to an existing container.
-     * 
+     *
      * @param destContainer the destination container
      * @param sourceContainer the source container
      * @param destContainerDelta the delta of the destination container, additional delta will be added to this delta
@@ -409,21 +409,21 @@ public class BreakpointContainer extends ElementContentProvider implements IAdap
     static public void addChildContainer(BreakpointContainer destContainer, BreakpointContainer sourceContainer, ModelDelta destContainerDelta) {
     	destContainer.insertChildContainer(sourceContainer);
     	sourceContainer.fParent = destContainer;
-    	
+
     	// add the breakpoints to the parent containers.
 		List<IBreakpoint> breakpoints = Arrays.asList(sourceContainer.getBreakpoints());
     	updateSelfAndAncestorsBreakpointCache(destContainer, breakpoints, true);
-    	
+
     	int index = destContainer.fChildContainers.indexOf(sourceContainer);
     	int size = sourceContainer.getChildren().length;
     	ModelDelta childDelta  = destContainerDelta.addNode(sourceContainer, index, IModelDelta.INSERTED|IModelDelta.INSTALL|IModelDelta.EXPAND, size);
-    	
+
     	appendContainerDelta(sourceContainer, childDelta);
     }
-    
+
     /**
      * A helper method to append delta to the breakpoint container. This method is used by addContainer only.
-     * 
+     *
      * @param container the container to append child delta
      * @param containerDelta the delta of the breakpoint container, additional delta will be added to this delta
      */
@@ -431,21 +431,21 @@ public class BreakpointContainer extends ElementContentProvider implements IAdap
     	Object[] children = container.getChildren();
     	for (int i = 0; i < children.length; ++i) {
     		boolean isBreakpoint = children[0] instanceof IBreakpoint;
-    		int numChild =  isBreakpoint ? 0 : children.length;     		
-    		int flag = isBreakpoint ? IModelDelta.ADDED|IModelDelta.INSTALL 
+    		int numChild =  isBreakpoint ? 0 : children.length;
+    		int flag = isBreakpoint ? IModelDelta.ADDED|IModelDelta.INSTALL
     				: IModelDelta.INSERTED|IModelDelta.INSTALL|IModelDelta.EXPAND;
     		ModelDelta childDelta = containerDelta.addNode(children[i], i, flag, numChild);
-    		
-    		if (children[i] instanceof BreakpointContainer) {    
-    			BreakpointContainer childContainer = (BreakpointContainer) children[i];			
+
+    		if (children[i] instanceof BreakpointContainer) {
+    			BreakpointContainer childContainer = (BreakpointContainer) children[i];
     			appendContainerDelta(childContainer, childDelta);
-    		} 
+    		}
     	}
     }
-    
+
     /**
      * A helper method to remove the breakpoint from the container.
-     * 
+     *
      * @param container the container to remove the breakpoint
      * @param breakpoint the breakpoint to remove
      * @param containerDelta the delta of the breakpoint container, additional delta will be added to this delta
@@ -456,10 +456,10 @@ public class BreakpointContainer extends ElementContentProvider implements IAdap
     	breakpoints.add(breakpoint);
     	updateSelfAndAncestorsBreakpointCache(container.getParent(), breakpoints, false);
     }
-    
+
     /**
      * Remove all child elements including the given container itself.
-     * 
+     *
      * @param container the breakpoint container
      * @param delta the parent delta
      */
@@ -469,7 +469,7 @@ public class BreakpointContainer extends ElementContentProvider implements IAdap
     		parent.fChildContainers.remove(container);
     		delta = delta.addNode(container, IModelDelta.UNINSTALL|IModelDelta.REMOVED);
     	}
-    	
+
     	if (container.fChildContainers.size() == 0) {
 			List<IBreakpoint> breakpoints = new ArrayList<IBreakpoint>();
 			Iterator<IBreakpoint> iterator = container.fBreakpoints.iterator();
@@ -477,67 +477,67 @@ public class BreakpointContainer extends ElementContentProvider implements IAdap
 				IBreakpoint obj = iterator.next();
 				breakpoints.add(obj);
 				delta.addNode(obj, IModelDelta.UNINSTALL|IModelDelta.REMOVED);
-				iterator.remove();				
+				iterator.remove();
     		}
-    		
+
 	    	// remove the breakpoints from the parent containers.
-			updateSelfAndAncestorsBreakpointCache(container.getParent(), breakpoints, false);     		
+			updateSelfAndAncestorsBreakpointCache(container.getParent(), breakpoints, false);
     		return;
     	}
-    	
+
 		Iterator<BreakpointContainer> iterator = container.fChildContainers.iterator();
     	while (iterator.hasNext()) {
-    		BreakpointContainer childContainer = iterator.next();    		
-    		ModelDelta childDelta = delta.addNode(childContainer, IModelDelta.REMOVED|IModelDelta.UNINSTALL);    		
+    		BreakpointContainer childContainer = iterator.next();
+    		ModelDelta childDelta = delta.addNode(childContainer, IModelDelta.REMOVED|IModelDelta.UNINSTALL);
     		iterator.remove();
     		removeAll(childContainer, childDelta);
     	}
     }
-    
+
     /**
      * Returns whether this is the default container.
-     * 
+     *
      * @return true if it is a default container
      */
     boolean isDefaultContainer() {
     	return fDefaultContainer;
     }
-    
+
     /**
      * Returns the breakpoints in this container
-     * 
+     *
      * @return the breakpoints in this container
      */
     @Override
 	public IBreakpoint[] getBreakpoints() {
         return fBreakpoints.toArray(new IBreakpoint[fBreakpoints.size()]);
     }
-    
+
     /**
      * Returns this container's category.
-     * 
+     *
      * @return container category
      */
     @Override
 	public IAdaptable getCategory() {
         return fCategory;
     }
-    
+
     /**
      * Returns children as breakpoints or nested containers.
-     * 
+     *
      * @return children as breakpoints or nested containers
      */
     public Object[] getChildren() {
         if (fChildContainers.isEmpty()) {
             return getBreakpoints();
         }
-        return getContainers(); 
-    }    
+        return getContainers();
+    }
 
     /**
      * Returns the index of the given child element (breakpoint or container.
-     * 
+     *
      * @param child Child to calculate index of.
      * @return index of child
      */
@@ -547,40 +547,40 @@ public class BreakpointContainer extends ElementContentProvider implements IAdap
         }
         return fChildContainers.indexOf(child);
     }
-    
+
     /**
      * Returns the containers nested in this container, possibly empty.
-     * 
+     *
      * @return the containers nested in this container, can be empty.
      */
     public BreakpointContainer[] getContainers() {
         return fChildContainers.toArray(new BreakpointContainer[fChildContainers.size()]);
     }
-    
+
     /**
      * Returns this container's organizer.
-     * 
+     *
      * @return this container's organizer
      */
     @Override
 	public IBreakpointOrganizer getOrganizer() {
         return fOrganizer;
     }
-    
+
     /**
      * Returns whether this container contains the given breakpoint.
-     * 
+     *
      * @param breakpoint the breakpoint to check
      * @return true if this container contains the given breakpoint
      */
     @Override
 	public boolean contains(IBreakpoint breakpoint) {
         return fBreakpoints.contains(breakpoint);
-    }    
-    
+    }
+
     /**
      * Returns the child containers for the given breakpoint.
-     *  
+     *
      * @param breakpoint the breakpoint to get containers for
      * @return child containers
      */
@@ -604,7 +604,7 @@ public class BreakpointContainer extends ElementContentProvider implements IAdap
         }
         return new BreakpointContainer[0];
     }
-    
+
 	/*
 	 * (non-Javadoc)
 	 * @see java.lang.Object#equals(java.lang.Object)
@@ -615,11 +615,11 @@ public class BreakpointContainer extends ElementContentProvider implements IAdap
         	BreakpointContainer container = (BreakpointContainer) obj;
             // With Group by "Advanced" the same category can contain a different subset of breakpoints,
             // therefore to have the same category is not enough to be equal.
-            if (! (fParent != null && container.fParent != null && fParent.equals(container.fParent) || 
+            if (! (fParent != null && container.fParent != null && fParent.equals(container.fParent) ||
             		fParent == null && container.fParent == null) ) {
                 return false;
             }
-        	if (getCategory() != null && container.getCategory() != null) {        		
+        	if (getCategory() != null && container.getCategory() != null) {
         		return getCategory().equals(container.getCategory());
         	} else {
         		return true;
@@ -642,10 +642,10 @@ public class BreakpointContainer extends ElementContentProvider implements IAdap
 	 * @see org.eclipse.debug.internal.ui.model.elements.ElementContentProvider#getChildren(java.lang.Object, int, int, org.eclipse.debug.internal.ui.viewers.model.provisional.IPresentationContext, org.eclipse.debug.internal.ui.viewers.model.provisional.IViewerUpdate)
 	 */
 	@Override
-	protected Object[] getChildren(Object parent, int index, int length, IPresentationContext context, IViewerUpdate monitor) throws CoreException {		
+	protected Object[] getChildren(Object parent, int index, int length, IPresentationContext context, IViewerUpdate monitor) throws CoreException {
 		return getElements(getChildren(), index, length);
 	}
-	
+
 	/*
 	 * (non-Javadoc)
 	 * @see org.eclipse.debug.internal.ui.model.elements.ElementContentProvider#supportsContextId(java.lang.String)
@@ -653,8 +653,8 @@ public class BreakpointContainer extends ElementContentProvider implements IAdap
 	@Override
 	protected boolean supportsContextId(String id) {
 		return id.equals(IDebugUIConstants.ID_BREAKPOINT_VIEW);
-	}	
-	
+	}
+
 	/*
 	 * (non-Javadoc)
 	 * @see org.eclipse.core.runtime.IAdaptable#getAdapter(java.lang.Class)
diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointContainerWorkbenchAdapter.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointContainerWorkbenchAdapter.java
index 1aededf79..9120325b8 100644
--- a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointContainerWorkbenchAdapter.java
+++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointContainerWorkbenchAdapter.java
@@ -4,7 +4,7 @@
  * 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
  *     Patrick Chuong (Texas Instruments) - Improve usability of the breakpoint view (Bug 238956)
@@ -92,7 +92,7 @@ public class BreakpointContainerWorkbenchAdapter implements IWorkbenchAdapter, I
             if (adapter != null) {
                 return adapter.getForeground(category);
             }
-        }        
+        }
         return null;
     }
 
@@ -108,7 +108,7 @@ public class BreakpointContainerWorkbenchAdapter implements IWorkbenchAdapter, I
             if (adapter != null) {
                 return adapter.getBackground(category);
             }
-        }        
+        }
         return null;
     }
 
@@ -124,7 +124,7 @@ public class BreakpointContainerWorkbenchAdapter implements IWorkbenchAdapter, I
             if (adapter != null) {
                 return adapter.getFont(category);
             }
-        }        
+        }
         return null;
     }
 
diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointFactory.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointFactory.java
index b7a88d77d..8281f8c69 100644
--- a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointFactory.java
+++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointFactory.java
@@ -4,7 +4,7 @@
  * 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
  *******************************************************************************/
diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointOrganizerExtension.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointOrganizerExtension.java
index 36b064707..907f0d23d 100644
--- a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointOrganizerExtension.java
+++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointOrganizerExtension.java
@@ -26,25 +26,25 @@ import org.eclipse.jface.util.IPropertyChangeListener;
  * A contributed breakpoint organizer.
  */
 public class BreakpointOrganizerExtension implements IBreakpointOrganizer, IBreakpointOrganizerDelegateExtension {
-	
+
 	private IConfigurationElement fElement;
 	private IBreakpointOrganizerDelegate fDelegate;
 	private ImageDescriptor fDescriptor;
-	
+
 	// attributes
 	public static final String ATTR_LABEL = "label"; //$NON-NLS-1$
 	public static final String ATTR_CLASS = "class"; //$NON-NLS-1$
 	public static final String ATTR_ID = "id"; //$NON-NLS-1$
 	public static final String ATTR_ICON = "icon"; //$NON-NLS-1$
     public static final String ATTR_OTHERS_LABEL = "othersLabel"; //$NON-NLS-1$
-	
+
 	public BreakpointOrganizerExtension(IConfigurationElement element) {
 		fElement = element;
 	}
-	
+
 	/**
 	 * Returns the image descriptor for this organizer.
-	 * 
+	 *
 	 * @return image descriptor
 	 */
 	@Override
@@ -55,32 +55,32 @@ public class BreakpointOrganizerExtension implements IBreakpointOrganizer, IBrea
 				fDescriptor = ImageDescriptor.getMissingImageDescriptor();
 			}
 		}
-		return fDescriptor;		
+		return fDescriptor;
 	}
-	
+
 	/**
 	 * Returns this organizer's label.
-	 * 
+	 *
 	 * @return this organizer's label
 	 */
 	@Override
 	public String getLabel() {
 		return fElement.getAttribute(ATTR_LABEL);
 	}
-    
+
     /**
      * Returns this organizer's identifier.
-     * 
+     *
      * @return this organizer's identifier
      */
     @Override
 	public String getIdentifier() {
         return fElement.getAttribute(ATTR_ID);
     }
-	
+
 	/**
 	 * Returns this organizer's delegate, instantiating it if required.
-	 * 
+	 *
 	 * @return this organizer's delegate
 	 */
 	protected IBreakpointOrganizerDelegate getOrganizer() {
@@ -168,7 +168,7 @@ public class BreakpointOrganizerExtension implements IBreakpointOrganizer, IBrea
 	public String getOthersLabel() {
         String attribute = fElement.getAttribute(ATTR_OTHERS_LABEL);
         if (attribute == null) {
-            return DebugUIViewsMessages.OtherBreakpointOrganizer_0; 
+            return DebugUIViewsMessages.OtherBreakpointOrganizer_0;
         }
         return attribute;
     }
@@ -209,6 +209,6 @@ public class BreakpointOrganizerExtension implements IBreakpointOrganizer, IBrea
 				removeBreakpoint(breakpoints[i], category);
 			}
 		}
-		
+
 	}
 }
diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointOrganizerManager.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointOrganizerManager.java
index eb09e90a9..a83b56c86 100644
--- a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointOrganizerManager.java
+++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointOrganizerManager.java
@@ -4,7 +4,7 @@
  * 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
  *******************************************************************************/
@@ -38,9 +38,9 @@ import org.eclipse.jface.util.PropertyChangeEvent;
  * @since 3.1
  */
 public class BreakpointOrganizerManager {
-	
+
 	private static BreakpointOrganizerManager fgManager;
-	
+
 	// map for lookup by id
 	private Map<String, IBreakpointOrganizer> fOrganizers = new HashMap<String, IBreakpointOrganizer>();
     // cached sorted list by label
@@ -57,7 +57,7 @@ public class BreakpointOrganizerManager {
 		}
 		return fgManager;
 	}
-	
+
 	/**
 	 * Creates and initializes a new breakpoint container factory.
 	 */
@@ -67,10 +67,10 @@ public class BreakpointOrganizerManager {
         start("org.eclipse.debug.ui.workingSetOrganizer"); //$NON-NLS-1$
         start("org.eclipse.debug.ui.breakpointWorkingSetOrganizer"); //$NON-NLS-1$
 	}
-	
+
 	/**
 	 * Forces instantiation of organizer delegate.
-	 * 
+	 *
 	 * @param organizerId organizer to start
 	 */
 	private void start(String organizerId) {
@@ -81,9 +81,9 @@ public class BreakpointOrganizerManager {
             }
         };
         organizer.addPropertyChangeListener(listener);
-        organizer.removePropertyChangeListener(listener);		
+        organizer.removePropertyChangeListener(listener);
 	}
-    
+
     /**
      * Loads all contributed breakpoint organizers.
      */
@@ -97,8 +97,8 @@ public class BreakpointOrganizerManager {
                 fOrganizers.put(organizer.getIdentifier(), organizer);
             }
         }
-    }    
-	
+    }
+
     /**
      * Validates the given organizer. Checks that certain required attributes
      * are available.
@@ -109,11 +109,11 @@ public class BreakpointOrganizerManager {
         String id = organizer.getIdentifier();
         String label = organizer.getLabel();
         return id != null && id.length() > 0 && label != null && label.length() > 0;
-    }    
-	
+    }
+
     /**
      * Returns all contributed breakpoint organizers.
-     * 
+     *
      * @return all contributed breakpoint organizers
      */
     public IBreakpointOrganizer[] getOrganizers() {
@@ -132,7 +132,7 @@ public class BreakpointOrganizerManager {
     	}
     	return fSorted.toArray(new IBreakpointOrganizer[fSorted.size()]);
     }
-    
+
     /**
      * Returns the specified breakpoint organizer or <code>null</code>
      * @param id organizer identifier
@@ -141,7 +141,7 @@ public class BreakpointOrganizerManager {
     public IBreakpointOrganizer getOrganizer(String id) {
         return fOrganizers.get(id);
     }
-    
+
     /**
      * Shuts down the organizer manager, disposing organizers.
      */
diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointPersistableElementAdapter.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointPersistableElementAdapter.java
index 3ff9bc666..e563bf9c7 100644
--- a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointPersistableElementAdapter.java
+++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointPersistableElementAdapter.java
@@ -4,7 +4,7 @@
  * 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
  *******************************************************************************/
@@ -20,15 +20,15 @@ import org.eclipse.ui.IPersistableElement;
  * Adapter to save and restore breakpoints for a working set.
  */
 public class BreakpointPersistableElementAdapter implements IPersistableElement {
-    
+
     private IBreakpoint fBreakpoint;
-    
+
     public static final String TAG_MARKER_ID = "TAG_MARKER_ID"; //$NON-NLS-1$
     public static final String TAG_RESOURCE_FACTORY_ID = "TAG_RESOURCE_FACTORY_ID"; //$NON-NLS-1$
-    
+
     /**
      * Constructs a new persitable element adapter for the given breakpoint.
-     * 
+     *
      * @param breakpoint the backing {@link IBreakpoint}
      */
     public BreakpointPersistableElementAdapter(IBreakpoint breakpoint) {
@@ -58,7 +58,7 @@ public class BreakpointPersistableElementAdapter implements IPersistableElement
                 memento.putString(TAG_MARKER_ID, longString);
                 memento.putString(TAG_RESOURCE_FACTORY_ID, pe.getFactoryId());
                 pe.saveState(memento);
-            }            
+            }
         }
     }
 
diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointSetOrganizer.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointSetOrganizer.java
index ec22c8ff2..46ebc1f89 100644
--- a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointSetOrganizer.java
+++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointSetOrganizer.java
@@ -45,23 +45,23 @@ import org.osgi.service.prefs.BackingStoreException;
 
 /**
  * Breakpoint organizers for breakpoint working sets.
- * 
+ *
  * @since 3.1
  */
 public class BreakpointSetOrganizer extends AbstractBreakpointOrganizerDelegate implements IBreakpointOrganizerDelegateExtension, IPropertyChangeListener, IBreakpointsListener {
 
 	private IWorkingSetManager fWorkingSetManager = PlatformUI.getWorkbench().getWorkingSetManager();
-	
+
 	/**
 	 * A cache for mapping markers to the working set they belong to
 	 * @since 3.2
 	 */
 	private BreakpointWorkingSetCache fCache = null;
-	
+
 	// Cache of the default working set, so we can know when it changes name
 	private static IWorkingSet fDefaultWorkingSet = null;
-	
-	
+
+
 	/**
 	 * Constructs a working set breakpoint organizer. Listens for changes in
 	 * working sets and fires property change notification.
@@ -76,7 +76,7 @@ public class BreakpointSetOrganizer extends AbstractBreakpointOrganizerDelegate
 
 	/*
 	 * (non-Javadoc)
-	 * 
+	 *
 	 * @see org.eclipse.debug.ui.IBreakpointOrganizerDelegate#getCategories(org.eclipse.debug.core.model.IBreakpoint)
 	 */
 	@Override
@@ -101,7 +101,7 @@ public class BreakpointSetOrganizer extends AbstractBreakpointOrganizerDelegate
 
 	/*
 	 * (non-Javadoc)
-	 * 
+	 *
 	 * @see org.eclipse.debug.ui.IBreakpointOrganizerDelegate#dispose()
 	 */
 	@Override
@@ -115,7 +115,7 @@ public class BreakpointSetOrganizer extends AbstractBreakpointOrganizerDelegate
 
 	/*
 	 * (non-Javadoc)
-	 * 
+	 *
 	 * @see org.eclipse.jface.util.IPropertyChangeListener#propertyChange(org.eclipse.jface.util.PropertyChangeEvent)
 	 */
 	@Override
@@ -169,7 +169,7 @@ public class BreakpointSetOrganizer extends AbstractBreakpointOrganizerDelegate
 
 	/*
 	 * (non-Javadoc)
-	 * 
+	 *
 	 * @see org.eclipse.debug.core.IBreakpointsListener#breakpointsAdded(org.eclipse.debug.core.model.IBreakpoint[])
 	 */
 	@Override
@@ -198,7 +198,7 @@ public class BreakpointSetOrganizer extends AbstractBreakpointOrganizerDelegate
 			addBreakpointsToSet(list.toArray(new IBreakpoint[list.size()]), set);
 		}
 	}
-	
+
 	private void queueToSet(IBreakpoint breakpoint, IWorkingSet set, Map<IWorkingSet, List<IBreakpoint>> queue) {
 		List<IBreakpoint> list = queue.get(set);
 		if (list == null) {
@@ -207,12 +207,12 @@ public class BreakpointSetOrganizer extends AbstractBreakpointOrganizerDelegate
 		}
 		list.add(breakpoint);
 	}
-	
+
 	/**
 	 * Adds a breakpoint to a working set
 	 * @param breakpoints the breakpoints to add
 	 * @param set the set to add it to or <code>null</code> if none
-	 * 
+	 *
 	 * @since 3.2
 	 */
 	private void addBreakpointsToSet(IBreakpoint[] breakpoints, IWorkingSet set) {
@@ -228,17 +228,17 @@ public class BreakpointSetOrganizer extends AbstractBreakpointOrganizerDelegate
 				IBreakpoint breakpoint = breakpoints[i];
 				if (!collection.contains(breakpoint)) {
 					list.add(breakpoint);
-					fCache.addEntry(breakpoint.getMarker(), set.getName()); //fix for bug 103731	
+					fCache.addEntry(breakpoint.getMarker(), set.getName()); //fix for bug 103731
 					fCache.flushMarkerCache(breakpoint.getMarker());
 				}
 			}
 			set.setElements(list.toArray(new IAdaptable[list.size()]));
 		}
-	}	
-	
+	}
+
 	/*
 	 * (non-Javadoc)
-	 * 
+	 *
 	 * @see org.eclipse.debug.core.IBreakpointsListener#breakpointsRemoved(org.eclipse.debug.core.model.IBreakpoint[],
 	 *      org.eclipse.core.resources.IMarkerDelta[])
 	 */
@@ -257,7 +257,7 @@ public class BreakpointSetOrganizer extends AbstractBreakpointOrganizerDelegate
 
 	/**
 	 * Removes deleted breakpoints from the given working set.
-	 * 
+	 *
 	 * @param workingSet
 	 *            breakpoint working set
 	 */
@@ -289,7 +289,7 @@ public class BreakpointSetOrganizer extends AbstractBreakpointOrganizerDelegate
 
 	/*
 	 * (non-Javadoc)
-	 * 
+	 *
 	 * @see org.eclipse.debug.core.IBreakpointsListener#breakpointsChanged(org.eclipse.debug.core.model.IBreakpoint[],
 	 *      org.eclipse.core.resources.IMarkerDelta[])
 	 */
@@ -300,7 +300,7 @@ public class BreakpointSetOrganizer extends AbstractBreakpointOrganizerDelegate
 	/**
 	 * Returns the active default breakpoint working set, or <code>null</code>
 	 * if none.
-	 * 
+	 *
 	 * @return the active default breakpoint working set, or <code>null</code>
 	 */
 	public static IWorkingSet getDefaultWorkingSet() {
@@ -315,7 +315,7 @@ public class BreakpointSetOrganizer extends AbstractBreakpointOrganizerDelegate
 	/**
 	 * Sets the active default breakpoint working set, or <code>null</code> if
 	 * none.
-	 * 
+	 *
 	 * @param set
 	 *            default working set or <code>null</code>
 	 */
@@ -341,7 +341,7 @@ public class BreakpointSetOrganizer extends AbstractBreakpointOrganizerDelegate
 
 	/*
 	 * (non-Javadoc)
-	 * 
+	 *
 	 * @see org.eclipse.debug.ui.IBreakpointOrganizerDelegate#canRemove(org.eclipse.debug.core.model.IBreakpoint,
 	 *      org.eclipse.core.runtime.IAdaptable)
 	 */
@@ -356,7 +356,7 @@ public class BreakpointSetOrganizer extends AbstractBreakpointOrganizerDelegate
 
 	/*
 	 * (non-Javadoc)
-	 * 
+	 *
 	 * @see org.eclipse.debug.ui.IBreakpointOrganizerDelegate#canAdd(org.eclipse.debug.core.model.IBreakpoint,
 	 *      org.eclipse.core.runtime.IAdaptable)
 	 */
@@ -371,7 +371,7 @@ public class BreakpointSetOrganizer extends AbstractBreakpointOrganizerDelegate
 
 	/*
 	 * (non-Javadoc)
-	 * 
+	 *
 	 * @see org.eclipse.debug.ui.IBreakpointOrganizerDelegate#addBreakpoint(org.eclipse.debug.core.model.IBreakpoint,
 	 *      org.eclipse.core.runtime.IAdaptable)
 	 */
@@ -379,14 +379,14 @@ public class BreakpointSetOrganizer extends AbstractBreakpointOrganizerDelegate
 	public void addBreakpoint(IBreakpoint breakpoint, IAdaptable category) {
 		addBreakpoints(new IBreakpoint[]{breakpoint}, category);
 	}
-	
+
 	/**
 	 * Gets the working set names from the marker
-	 * 
+	 *
 	 * @param marker them marker to get the names from
 	 * @param type the type attribute to look up
 	 * @return the listing of markers or an empty String array, never <code>null</code>
-	 * 
+	 *
 	 * @since 3.2
 	 */
 	private String[] getWorkingsetAttributeFromMarker(IMarker marker, String type) {
@@ -402,7 +402,7 @@ public class BreakpointSetOrganizer extends AbstractBreakpointOrganizerDelegate
 
 	/*
 	 * (non-Javadoc)
-	 * 
+	 *
 	 * @see org.eclipse.debug.ui.IBreakpointOrganizerDelegate#removeBreakpoint(org.eclipse.debug.core.model.IBreakpoint,
 	 *      org.eclipse.core.runtime.IAdaptable)
 	 */
@@ -426,7 +426,7 @@ public class BreakpointSetOrganizer extends AbstractBreakpointOrganizerDelegate
 
 	/*
 	 * (non-Javadoc)
-	 * 
+	 *
 	 * @see org.eclipse.debug.ui.IBreakpointOrganizerDelegate#getCategories()
 	 */
 	@Override
diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointTypeOrganizer.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointTypeOrganizer.java
index f90031689..f071ae559 100644
--- a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointTypeOrganizer.java
+++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointTypeOrganizer.java
@@ -4,7 +4,7 @@
  * 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
  *******************************************************************************/
@@ -22,11 +22,11 @@ import org.eclipse.debug.ui.IBreakpointTypeCategory;
 
 /**
  * Breakpoint organizers for breakpoint types.
- * 
+ *
  * @since 3.1
  */
 public class BreakpointTypeOrganizer extends AbstractBreakpointOrganizerDelegate {
-	
+
 	private Map<String, IAdaptable[]> fTypes = new HashMap<String, IAdaptable[]>();
 
     /* (non-Javadoc)
@@ -49,7 +49,7 @@ public class BreakpointTypeOrganizer extends AbstractBreakpointOrganizerDelegate
     	}
     	return null;
     }
-    
+
     /* (non-Javadoc)
      * @see org.eclipse.debug.ui.IBreakpointOrganizerDelegate#dispose()
      */
diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointWorkingSetCache.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointWorkingSetCache.java
index 6d843d2b4..2b021c97e 100644
--- a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointWorkingSetCache.java
+++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointWorkingSetCache.java
@@ -27,7 +27,7 @@ import org.eclipse.ui.PlatformUI;
  * Class to cache the breakpoint to working set information in its underlying
  * marker as breakpoints are moved between breakpoint working sets. It resolves
  * the need for constant attribute lookup and parsing to fix bug 103731
- * 
+ *
  * @since 3.2
  */
 public class BreakpointWorkingSetCache {
@@ -38,14 +38,14 @@ public class BreakpointWorkingSetCache {
 	 * value: vector of working sets the marker belongs to
 	 */
 	HashMap<IMarker, Vector<Object>> fCache = null;
-	
+
 	/**
 	 * Default constructor
 	 */
 	public BreakpointWorkingSetCache() {
 		fCache = new HashMap<IMarker, Vector<Object>>(15);
 	}
-	
+
 	/**
 	 * Adds an entry into the cache
 	 * @param marker the marker to add the workingset information about
@@ -64,7 +64,7 @@ public class BreakpointWorkingSetCache {
 			}
 		}
 	}
-	
+
 	/**
 	 * Removes an item from the list contained under the marker key, not the marker entry
 	 * @param marker the marker key to remove the item from
@@ -76,7 +76,7 @@ public class BreakpointWorkingSetCache {
 			list.remove(entry);
 		}
 	}
-	
+
 	/**
 	 * Flushes the cache of only the specified marker
 	 * @param marker the marker whose cache is to be flushed
@@ -102,5 +102,5 @@ public class BreakpointWorkingSetCache {
 			catch(CoreException e) {DebugPlugin.log(e);}
 		}
 	}
-	
+
 }
diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointWorkingSetElementAdapter.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointWorkingSetElementAdapter.java
index b82c79975..194bc91fd 100644
--- a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointWorkingSetElementAdapter.java
+++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointWorkingSetElementAdapter.java
@@ -23,7 +23,7 @@ import org.eclipse.ui.IWorkingSetElementAdapter;
  * Consulted by workbench pull down actions that add/remove selected elements to/from
  * working sets. Allows breakpoint working sets to select which elements are applicable
  * for adding/removing.
- *  
+ *
  * @since 3.3
  */
 public class BreakpointWorkingSetElementAdapter implements IWorkingSetElementAdapter {
@@ -34,18 +34,18 @@ public class BreakpointWorkingSetElementAdapter implements IWorkingSetElementAda
 	@Override
 	public IAdaptable[] adaptElements(IWorkingSet ws, IAdaptable[] elements) {
 		for (int i = 0; i < elements.length; i++) {
-	        IBreakpoint breakpoint = (IBreakpoint)DebugPlugin.getAdapter(elements[i], IBreakpoint.class);			
+	        IBreakpoint breakpoint = (IBreakpoint)DebugPlugin.getAdapter(elements[i], IBreakpoint.class);
 			if (breakpoint != null) {
 				return selectBreakpoints(elements);
 			}
 		}
 		return elements;
 	}
-	
+
 	private IAdaptable[] selectBreakpoints(IAdaptable[] elements) {
 		List<IBreakpoint> breakpoints = new ArrayList<IBreakpoint>(elements.length);
 		for (int i = 0; i < elements.length; i++) {
-            IBreakpoint breakpoint = (IBreakpoint)DebugPlugin.getAdapter(elements[i], IBreakpoint.class);            
+            IBreakpoint breakpoint = (IBreakpoint)DebugPlugin.getAdapter(elements[i], IBreakpoint.class);
 			if (breakpoint != null) {
 				breakpoints.add(breakpoint);
 			}
diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointWorkingSetPage.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointWorkingSetPage.java
index f141d634e..3ef157f10 100644
--- a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointWorkingSetPage.java
+++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointWorkingSetPage.java
@@ -47,14 +47,14 @@ import org.eclipse.ui.dialogs.IWorkingSetPage;
 /**
  * The Breakpoint working set page allows the user to create
  * and edit a Breakpoint working set.
- * 
+ *
  * @since 3.1
  */
 public class BreakpointWorkingSetPage extends WizardPage implements IWorkingSetPage {
 
-	final private static String PAGE_TITLE= DebugUIViewsMessages.BreakpointWorkingSetPage_0; 
+	final private static String PAGE_TITLE= DebugUIViewsMessages.BreakpointWorkingSetPage_0;
 	final private static String PAGE_ID= "breakpointWorkingSetPage"; //$NON-NLS-1$
-	
+
 	private Text fWorkingSetName;
 	private EmbeddedBreakpointsViewer fTViewer;
 	private boolean fFirstCheck;
@@ -65,7 +65,7 @@ public class BreakpointWorkingSetPage extends WizardPage implements IWorkingSetP
 	 */
 	public BreakpointWorkingSetPage() {
 		super(PAGE_ID, PAGE_TITLE, DebugPluginImages.getImageDescriptor(IDebugUIConstants.IMG_WIZBAN_DEBUG));
-		setDescription(DebugUIViewsMessages.BreakpointWorkingSetPage_1); 
+		setDescription(DebugUIViewsMessages.BreakpointWorkingSetPage_1);
 		fFirstCheck= true;
 	}
 
@@ -80,7 +80,7 @@ public class BreakpointWorkingSetPage extends WizardPage implements IWorkingSetP
 		composite.setLayoutData(new GridData(GridData.HORIZONTAL_ALIGN_FILL));
 		setControl(composite);
 		Label label= new Label(composite, SWT.WRAP);
-		label.setText(DebugUIViewsMessages.BreakpointWorkingSetPage_2); 
+		label.setText(DebugUIViewsMessages.BreakpointWorkingSetPage_2);
 		GridData gd= new GridData(GridData.GRAB_HORIZONTAL | GridData.HORIZONTAL_ALIGN_FILL | GridData.VERTICAL_ALIGN_CENTER);
 		label.setLayoutData(gd);
 		fWorkingSetName= new Text(composite, SWT.SINGLE | SWT.BORDER);
@@ -95,11 +95,11 @@ public class BreakpointWorkingSetPage extends WizardPage implements IWorkingSetP
 		);
 		fWorkingSetName.setFocus();
 		label= new Label(composite, SWT.WRAP);
-		label.setText(DebugUIViewsMessages.BreakpointWorkingSetPage_3); 
+		label.setText(DebugUIViewsMessages.BreakpointWorkingSetPage_3);
 		gd = new GridData(GridData.GRAB_HORIZONTAL | GridData.HORIZONTAL_ALIGN_FILL | GridData.VERTICAL_ALIGN_CENTER);
 		label.setLayoutData(gd);
 		IViewPart viewpart = DebugUIPlugin.getActiveWorkbenchWindow().getActivePage().findView(IDebugUIConstants.ID_BREAKPOINT_VIEW);
-		IStructuredSelection selection; 
+		IStructuredSelection selection;
 		if (viewpart == null) {
 			selection = new StructuredSelection();
 		} else {
@@ -190,31 +190,31 @@ public class BreakpointWorkingSetPage extends WizardPage implements IWorkingSetP
 	 * validates the current input of the page to determine if the finish button can be enabled
 	 */
 	private void validateInput() {
-		String errorMessage= null; 
+		String errorMessage= null;
 		String newText= fWorkingSetName.getText();
 
 		if (newText.equals(newText.trim()) == false) {
 			errorMessage = DebugUIViewsMessages.BreakpointWorkingSetPage_4;
-		} 
+		}
 		if (newText.equals(IInternalDebugCoreConstants.EMPTY_STRING)) {
 			if (fFirstCheck) {
 				setPageComplete(false);
 				fFirstCheck= false;
 				return;
-			}		
-			errorMessage= DebugUIViewsMessages.BreakpointWorkingSetPage_5; 
+			}
+			errorMessage= DebugUIViewsMessages.BreakpointWorkingSetPage_5;
 		}
 		fFirstCheck= false;
 		if (errorMessage == null && (fWorkingSet == null || newText.equals(fWorkingSet.getName()) == false)) {
 			IWorkingSet[] workingSets= PlatformUI.getWorkbench().getWorkingSetManager().getWorkingSets();
 			for (int i= 0; i < workingSets.length; i++) {
 				if (newText.equals(workingSets[i].getName())) {
-					errorMessage= DebugUIViewsMessages.BreakpointWorkingSetPage_6; 
+					errorMessage= DebugUIViewsMessages.BreakpointWorkingSetPage_6;
 				}
 			}
 		}
 		setErrorMessage(errorMessage);
 		setPageComplete(errorMessage == null);
 	}
-	
+
 }
diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointsComparator.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointsComparator.java
index 6d087385e..1d6b122cd 100644
--- a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointsComparator.java
+++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointsComparator.java
@@ -38,21 +38,21 @@ public class BreakpointsComparator extends ViewerComparator {
 	public boolean isSorterProperty(Object element,String propertyId) {
 		return propertyId.equals(IBasicPropertyConstants.P_TEXT);
 	}
-	
+
 	/**
 	 * Returns a negative, zero, or positive number depending on whether
 	 * the first element is less than, equal to, or greater than
 	 * the second element.
 	 * <p>
 	 * Group breakpoints by debug model
-	 * 	within debug model, group breakpoints by type 
+	 * 	within debug model, group breakpoints by type
 	 * 		within type groups, sort by line number (if applicable) and then
 	 * 		alphabetically by label
-	 * 
+	 *
 	 * @param viewer the viewer
 	 * @param e1 the first element
 	 * @param e2 the second element
-	 * @return a negative number if the first element is less than the 
+	 * @return a negative number if the first element is less than the
 	 *  second element; the value <code>0</code> if the first element is
 	 *  equal to the second element; and a positive number if the first
 	 *  element is greater than the second element
@@ -87,21 +87,21 @@ public class BreakpointsComparator extends ViewerComparator {
 			if (!marker2.exists()) {
 				return 0;
 			}
-			type2= marker2.getType();	
+			type2= marker2.getType();
 		} catch (CoreException e) {
 			DebugUIPlugin.log(e);
 		}
-	
+
 		result= type1.compareTo(type2);
 		if (result != 0) {
 			return result;
 		}
 
-		// model and type are the same		
+		// model and type are the same
 		ILabelProvider lprov = (ILabelProvider) ((StructuredViewer)viewer).getLabelProvider();
 		String name1= lprov.getText(e1);
 		String name2= lprov.getText(e2);
-		
+
 		result = numericalStringCompare(name1, name2);
 
 		if (result != 0) {
@@ -114,14 +114,14 @@ public class BreakpointsComparator extends ViewerComparator {
 		// Note: intentionally using line 0 if not a line breakpoint or if ILineBreakpoint.getLineNumber throws.
 		if (b1 instanceof ILineBreakpoint) {
 			try {
-				l1 = ((ILineBreakpoint)b1).getLineNumber();	
+				l1 = ((ILineBreakpoint)b1).getLineNumber();
 			} catch (CoreException e) {
 				DebugUIPlugin.log(e);
 			}
 		}
 		if (b2 instanceof ILineBreakpoint) {
 			try {
-				l2 = ((ILineBreakpoint)b2).getLineNumber();	
+				l2 = ((ILineBreakpoint)b2).getLineNumber();
 			} catch (CoreException e) {
 				DebugUIPlugin.log(e);
 			}
@@ -131,20 +131,20 @@ public class BreakpointsComparator extends ViewerComparator {
 		}
 		return result;
 	}
-	
+
 	/**
 	 * Utility routine to order strings with respect to numerical values.
-	 * 
+	 *
 	 * E.g.
 	 * <p><code>
 	 * "0", "1", "9", "11"
      * <p></code>
 	 *
-	 * Note that String.compareTo orders "11" before "9". 
+	 * Note that String.compareTo orders "11" before "9".
 	 *
 	 * The function also supports mixed numbers and values. It uses the string comparison except when both strings differ by a number only,
-	 * in this case the numerical value is compared. 
-	 * E.g. 
+	 * in this case the numerical value is compared.
+	 * E.g.
 	 * <p><code>
      * stringNumberCompareTo("a_01", "a_1") returns 0.
      * <p></code>
@@ -152,7 +152,7 @@ public class BreakpointsComparator extends ViewerComparator {
      *
 	 * @param n1 the first string to compare
 	 * @param n2 the second string to compare
-	 * @return 
+	 * @return
 	 * 			< 0, negative - if n1 < n2
 	 * 			== 0, zero - if n1 == n2 (with a a special comparison, not identical or equals)
 	 * 			> 0, negative - if n1 > n2
@@ -164,23 +164,23 @@ public class BreakpointsComparator extends ViewerComparator {
 		for (; index1 < n1.length() && index2 < n2.length(); ) {
 		    char c1 = n1.charAt(index1);
 		    char c2 = n2.charAt(index2);
-		    
+
 			if (c1 != c2) {
 				// Strings are different starting at index.
 				// If both strings have a number at this location, compare it.
 				boolean isDig1 = Character.isDigit(c1);
 				boolean isDig2 = Character.isDigit(c2);
-				
+
 				if (isDig1 && isDig2 || digitLen > 0 && (isDig1 || isDig2)) {
 					// Have 2 numbers if either the different characters are both digits or if there are common digits before the difference.
-					DecimalFormat format = new DecimalFormat();					
+					DecimalFormat format = new DecimalFormat();
 					ParsePosition p1 = new ParsePosition(index1 - digitLen);
 					Number num1 = format.parse(n1, p1);
 					ParsePosition p2 = new ParsePosition(index2 - digitLen);
 					Number num2 = format.parse(n2, p2);
 					if (num1 == null || num2 == null) {
 						// Failed to parse number. Should not happen
-						return c1 - c2;						
+						return c1 - c2;
 					}
 					int cmp;
 					if (num1 instanceof Long && num2 instanceof Long) {
diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointsContentProvider.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointsContentProvider.java
index 72c065a97..6b79da330 100644
--- a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointsContentProvider.java
+++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointsContentProvider.java
@@ -31,12 +31,12 @@ import org.eclipse.jface.viewers.Viewer;
  * Content provider for the breakpoints view
  */
 public class BreakpointsContentProvider implements ITreeContentProvider, IPropertyChangeListener {
-    
+
     private IBreakpointOrganizer[] fOrganizers = null;
     private BreakpointsViewer fViewer;
     private Object[] fElements;
     private boolean fDisposed = false;
-    
+
     /* (non-Javadoc)
      * @see org.eclipse.jface.viewers.ITreeContentProvider#getChildren(java.lang.Object)
      */
@@ -94,13 +94,13 @@ public class BreakpointsContentProvider implements ITreeContentProvider, IProper
             reorganize();
         }
     }
-    
+
     /**
      * Sets the nested order of breakpoint organizers, or <code>null</code>
      * if none.
-     * 
+     *
      * @param organizers the nested order of breakpoint organizers, or <code>null</code>
-     * if none 
+     * if none
      */
     public void setOrganizers(IBreakpointOrganizer[] organizers) {
     	// remove previous listeners
@@ -138,17 +138,17 @@ public class BreakpointsContentProvider implements ITreeContentProvider, IProper
                             break;
                         }
                     }
-                    
+
                 }
             }
             fViewer.getControl().setRedraw(true);
         }
     }
-    
+
     /**
      * Returns the root containers containing the given breakpoint, or <code>null</code>
      * if none
-     * 
+     *
      * @param breakpoint the breakpoint to get containers for
      * @return root containers containing the given breakpoint or <code>null</code>
      */
@@ -165,18 +165,18 @@ public class BreakpointsContentProvider implements ITreeContentProvider, IProper
         }
         return null;
     }
-    
+
     /**
      * Returns the nested order of breakpoint organizers being used, or <code>null</code>
      * if none.
-     * 
+     *
      * @return the nested order of breakpoint organizers being used, or <code>null</code>
      * if none
      */
     IBreakpointOrganizer[] getOrganizers() {
         return fOrganizers;
     }
-    
+
     /**
      * Organizes the breakpoints based on nested categories, if any.
      */
@@ -237,10 +237,10 @@ public class BreakpointsContentProvider implements ITreeContentProvider, IProper
 			reorganize();
 		}
 	}
-    
+
     /**
      * Returns the existing containers the given breakpoint is contained in, or <code>null</code>.
-     * 
+     *
      * @param breakpoint the breakpoint to get containers for
      * @return the existing containers the given breakpoint is contained in, or <code>null</code>
      */
@@ -269,7 +269,7 @@ public class BreakpointsContentProvider implements ITreeContentProvider, IProper
 
     /**
      * Returns whether content is grouped by categories.
-     * 
+     *
      * @return whether content is grouped by categories
      */
     protected boolean isShowingGroups() {
diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointsDragAdapter.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointsDragAdapter.java
index ef2443bd9..6123c0136 100644
--- a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointsDragAdapter.java
+++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointsDragAdapter.java
@@ -28,7 +28,7 @@ import org.eclipse.swt.widgets.Item;
  * A drag adapter for the breakpoints viewer
  */
 public class BreakpointsDragAdapter extends DragSourceAdapter implements TransferDragSourceListener {
-    
+
     /**
      * the associated viewer for the adapter
      */
@@ -37,7 +37,7 @@ public class BreakpointsDragAdapter extends DragSourceAdapter implements Transfe
 
     private BreakpointsView fView;
     private TreePath[] fTreePaths = null;
-    
+
     /**
      * Constructor
      * @param viewer the associated viewer, which acts as the selection provider and therefore <b>must</b> implement <code>ISelectionProvider</code>
@@ -59,7 +59,7 @@ public class BreakpointsDragAdapter extends DragSourceAdapter implements Transfe
 	public Transfer getTransfer() {
         return LocalSelectionTransfer.getTransfer();
     }
-    
+
     /* non Java-doc
      * @see org.eclipse.swt.dnd.DragSourceListener#dragStart
      */
@@ -69,7 +69,7 @@ public class BreakpointsDragAdapter extends DragSourceAdapter implements Transfe
         LocalSelectionTransfer.getTransfer().setSelection(selection);
         LocalSelectionTransfer.getTransfer().setSelectionSetTime(event.time & 0xFFFFFFFFL);
         if (fViewer instanceof BreakpointsViewer) {
-        	BreakpointsViewer viewer = (BreakpointsViewer)fViewer; 
+        	BreakpointsViewer viewer = (BreakpointsViewer)fViewer;
 	        fItems = viewer.getSelectedItems();
 	        event.doit = viewer.canDrag(fItems);
         } else {
@@ -78,13 +78,13 @@ public class BreakpointsDragAdapter extends DragSourceAdapter implements Transfe
         	} else {
         		fTreePaths = new TreePath[0];
         	}
-	        event.doit = fView.canDrag(fTreePaths); 	
+	        event.doit = fView.canDrag(fTreePaths);
         }
     }
-   
+
     /* non Java-doc
      * @see org.eclipse.swt.dnd.DragSourceListener#dragSetData
-     */     
+     */
     @Override
 	public void dragSetData(DragSourceEvent event) {
         // For consistency set the data to the selection even though
@@ -95,20 +95,20 @@ public class BreakpointsDragAdapter extends DragSourceAdapter implements Transfe
 
     /* non Java-doc
      * @see org.eclipse.swt.dnd.DragSourceListener#dragFinished
-     */ 
+     */
     @Override
 	public void dragFinished(DragSourceEvent event) {
         if (event.detail == DND.DROP_MOVE) {
             // remove from source on move operation
             if (fViewer instanceof BreakpointsViewer) {
-            	BreakpointsViewer viewer = (BreakpointsViewer)fViewer; 
+            	BreakpointsViewer viewer = (BreakpointsViewer)fViewer;
             	viewer.performDrag(fItems);
             } else {
-            	fView.performDrag(fTreePaths);            	
+            	fView.performDrag(fTreePaths);
             }
         }
         fItems = null;
         LocalSelectionTransfer.getTransfer().setSelection(null);
         LocalSelectionTransfer.getTransfer().setSelectionSetTime(0);
-    }   
+    }
 }
diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointsDropAdapter.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointsDropAdapter.java
index 5f2276fde..16d026853 100644
--- a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointsDropAdapter.java
+++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointsDropAdapter.java
@@ -4,7 +4,7 @@
  * 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
  *     Patrick Chuong (Texas Instruments) - Improve usability of the breakpoint view (Bug 238956)
@@ -34,7 +34,7 @@ public class BreakpointsDropAdapter extends ViewerDropAdapter {
 	private Item fTarget = null;
 	private TreePath fPath = null;
 	private BreakpointsView fView;
-	
+
     /**
      * Constructor
      * @param viewer the backing viewer
@@ -87,7 +87,7 @@ public class BreakpointsDropAdapter extends ViewerDropAdapter {
 		}
 		return fTarget;
 	}
-	
+
     /**
      * @see org.eclipse.jface.viewers.ViewerDropAdapter#validateDrop(java.lang.Object, int, org.eclipse.swt.dnd.TransferData)
      */
diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointsLabelProvider.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointsLabelProvider.java
index 63b875639..a1ff4cc13 100644
--- a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointsLabelProvider.java
+++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointsLabelProvider.java
@@ -29,7 +29,7 @@ public class BreakpointsLabelProvider extends LabelProvider implements IFontProv
 
     private WorkbenchLabelProvider fWorkbenchLabelProvider;
     private IDebugModelPresentation fPresentation;
-    
+
     /**
      * Constructs a new label provide for the breakpoints view.
      */
@@ -37,7 +37,7 @@ public class BreakpointsLabelProvider extends LabelProvider implements IFontProv
         fWorkbenchLabelProvider = new WorkbenchLabelProvider();
         fPresentation = DebugUITools.newDebugModelPresentation();
     }
-    
+
     /* (non-Javadoc)
      * @see org.eclipse.jface.viewers.IBaseLabelProvider#dispose()
      */
@@ -47,7 +47,7 @@ public class BreakpointsLabelProvider extends LabelProvider implements IFontProv
         fPresentation.dispose();
         super.dispose();
     }
-    
+
     /* (non-Javadoc)
      * @see org.eclipse.jface.viewers.ILabelProvider#getImage(java.lang.Object)
      */
@@ -64,12 +64,12 @@ public class BreakpointsLabelProvider extends LabelProvider implements IFontProv
                 return DebugUIPlugin.getImageDescriptorRegistry().get(descriptor);
             }
         }
-        return image;        
+        return image;
     }
-    
+
 	/**
      * Computes and return common adornment flags for the given category.
-     * 
+     *
      * @return adornment flags defined in CompositeDebugImageDescriptor
      */
     private int computeAdornmentFlags() {
@@ -77,8 +77,8 @@ public class BreakpointsLabelProvider extends LabelProvider implements IFontProv
             return CompositeDebugImageDescriptor.SKIP_BREAKPOINT;
         }
         return 0;
-    }    
-    
+    }
+
     /* (non-Javadoc)
      * @see org.eclipse.jface.viewers.ILabelProvider#getText(java.lang.Object)
      */
@@ -100,10 +100,10 @@ public class BreakpointsLabelProvider extends LabelProvider implements IFontProv
         }
         return fWorkbenchLabelProvider.getFont(element);
     }
-    
+
     /**
      * Returns the debug model presentation used by this label provider.
-     * 
+     *
      * @return the debug model presentation used by this label provider
      */
     public IDebugModelPresentation getPresentation() {
diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointsView.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointsView.java
index 368ae3243..557eaeb62 100644
--- a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointsView.java
+++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointsView.java
@@ -84,25 +84,25 @@ import org.eclipse.ui.operations.UndoActionHandler;
 /**
  * This class implements the breakpoints view.
  */
-public class BreakpointsView extends VariablesView implements IBreakpointManagerListener {	
+public class BreakpointsView extends VariablesView implements IBreakpointManagerListener {
 	private static final String ACTION_GOTO_MARKER				= "GotoMarker";				//$NON-NLS-1$
 	private static final String ACTION_SKIP_BREAKPOINTS			= "SkipBreakpoints";		//$NON-NLS-1$
 	private static final String ACTION_SHOW_MODEL_BREAKPOINT	= "ShowBreakpointsForModel";//$NON-NLS-1$
 	private static final String ACTION_REMOVE_FROM_GROUP 		= "RemoveFromGroup"; 		//$NON-NLS-1$
-	
-	
+
+
 	private static final String KEY_VALUE						= "value";					//$NON-NLS-1$
 
-	private Clipboard fClipboard;	
+	private Clipboard fClipboard;
 	private IBreakpointOrganizer[] fOrganizers;
 
 	/**
-	 * Flag used to determine whether the viewer input is being set for the 
+	 * Flag used to determine whether the viewer input is being set for the
 	 * fist time.  If this is the case the view contents are expanded.
 	 * (bug 297762)
 	 */
 	private boolean fFirstInputSet = false;
-	
+
 	private UndoActionHandler fUndoAction;
 	private RedoActionHandler fRedoAction;
 
@@ -111,7 +111,7 @@ public class BreakpointsView extends VariablesView implements IBreakpointManager
 	public void dispose() {
 		if (fClipboard != null) {
 			fClipboard.dispose();
-		}		
+		}
 		DebugPlugin.getDefault().getBreakpointManager().removeBreakpointManagerListener(this);
 
 		fUndoAction.dispose();
@@ -119,7 +119,7 @@ public class BreakpointsView extends VariablesView implements IBreakpointManager
 
 		super.dispose();
 	}
-	
+
 	/*
 	 * (non-Javadoc)
 	 * @see org.eclipse.debug.internal.ui.views.variables.VariablesView#getDetailPanePreferenceKey()
@@ -128,7 +128,7 @@ public class BreakpointsView extends VariablesView implements IBreakpointManager
 	protected String getDetailPanePreferenceKey() {
 		return IDebugPreferenceConstants.BREAKPOINTS_DETAIL_PANE_ORIENTATION;
 	}
-	
+
 	/*
 	 * (non-Javadoc)
 	 * @see org.eclipse.debug.internal.ui.views.variables.VariablesView#getHelpContextId()
@@ -153,11 +153,11 @@ public class BreakpointsView extends VariablesView implements IBreakpointManager
 	 */
 	@Override
 	public Viewer createViewer(Composite parent) {
-		TreeModelViewer viewer = (TreeModelViewer) super.createViewer(parent);		
-		
+		TreeModelViewer viewer = (TreeModelViewer) super.createViewer(parent);
+
 		initBreakpointOrganizers(getMemento());
 
-		IPresentationContext presentationContext = viewer.getPresentationContext(); 
+		IPresentationContext presentationContext = viewer.getPresentationContext();
 		presentationContext.setProperty(IBreakpointUIConstants.PROP_BREAKPOINTS_ORGANIZERS, fOrganizers);
         presentationContext.setProperty(IBreakpointUIConstants.PROP_BREAKPOINTS_ELEMENT_COMPARATOR, new ElementComparator(presentationContext));
 
@@ -176,7 +176,7 @@ public class BreakpointsView extends VariablesView implements IBreakpointManager
 				 * Undo double slashes.
 				 */
 				@Override
-				public String getText(Object element) {					
+				public String getText(Object element) {
 			    	IDebugModelPresentation lp= getConfiguredPresentation(element);
 			    	if (lp != null) {
 			    		return lp.getText(element);
@@ -187,7 +187,7 @@ public class BreakpointsView extends VariablesView implements IBreakpointManager
 		}
 		return fModelPresentation;
 	}
-	
+
 	/**
 	 * Returns the tree model viewer.
 	 * @return the backin gviewer
@@ -195,7 +195,7 @@ public class BreakpointsView extends VariablesView implements IBreakpointManager
 	public TreeModelViewer getTreeModelViewer() {
 		return (TreeModelViewer) getViewer();
 	}
-	
+
 	/*
 	 * (non-Javadoc)
 	 * @see org.eclipse.debug.internal.ui.views.variables.VariablesView#configureToolBar(org.eclipse.jface.action.IToolBarManager)
@@ -203,7 +203,7 @@ public class BreakpointsView extends VariablesView implements IBreakpointManager
 	@Override
 	protected void configureToolBar(IToolBarManager tbm) {
 		tbm.add(new Separator(IDebugUIConstants.BREAKPOINT_GROUP));
-		tbm.add(getAction(ACTION_SHOW_MODEL_BREAKPOINT)); 
+		tbm.add(getAction(ACTION_SHOW_MODEL_BREAKPOINT));
 		tbm.add(getAction(ACTION_GOTO_MARKER));
 		tbm.add(getAction(ACTION_SKIP_BREAKPOINTS));
 		tbm.add(new Separator(IDebugUIConstants.RENDER_GROUP));
@@ -252,7 +252,7 @@ public class BreakpointsView extends VariablesView implements IBreakpointManager
         DebugPlugin.getDefault().getBreakpointManager().addBreakpointManagerListener(this);
 
 		fClipboard = new Clipboard(getSite().getShell().getDisplay());
-		        
+
 		PasteBreakpointsAction paste = new PasteBreakpointsAction(this);
 		setAction(PASTE_ACTION, paste);
 		paste.setActionDefinitionId(ActionFactory.PASTE.getCommandId());
@@ -260,11 +260,11 @@ public class BreakpointsView extends VariablesView implements IBreakpointManager
 		setGlobalAction(PASTE_ACTION, paste);
         getViewer().addSelectionChangedListener(paste);
         paste.setImageDescriptor(PlatformUI.getWorkbench().getSharedImages().getImageDescriptor(ISharedImages.IMG_TOOL_PASTE));
-		        
+
 		SelectionListenerAction remove = new RemoveFromWorkingSetAction(this);
 		setAction(ACTION_REMOVE_FROM_GROUP, remove);
 		getViewer().addSelectionChangedListener(remove);
-		
+
 		IUndoContext undoContext= DebugUITools.getBreakpointsUndoContext();
 		fUndoAction= new UndoActionHandler(getSite(), undoContext);
 		fUndoAction.setActionDefinitionId(IWorkbenchCommandConstants.EDIT_UNDO);
@@ -279,7 +279,7 @@ public class BreakpointsView extends VariablesView implements IBreakpointManager
 
 	/*
 	 * (non-Javadoc)
-	 * 
+	 *
 	 * @seeorg.eclipse.debug.internal.ui.views.variables.VariablesView#getToggleActionLabel()
 	 */
 	@Override
@@ -289,7 +289,7 @@ public class BreakpointsView extends VariablesView implements IBreakpointManager
 
 	/*
 	 * (non-Javadoc)
-	 * 
+	 *
 	 * @see org.eclipse.debug.internal.ui.views.variables.VariablesView#getPresentationContextId()
 	 */
 	@Override
@@ -299,13 +299,13 @@ public class BreakpointsView extends VariablesView implements IBreakpointManager
 
 	/*
 	 * (non-Javadoc)
-	 * 
+	 *
 	 * @see org.eclipse.debug.internal.ui.views.variables.VariablesView#contextActivated(org.eclipse.jface.viewers.ISelection)
 	 */
 	@Override
 	protected void contextActivated(ISelection selection) {
 	    IPresentationContext presentationContext = getTreeModelViewer().getPresentationContext();
-	    
+
 		if (selection == null || selection.isEmpty()) {
 			Object input = new DefaultBreakpointsViewInput(presentationContext);
 			super.contextActivated(new StructuredSelection(input));
@@ -319,7 +319,7 @@ public class BreakpointsView extends VariablesView implements IBreakpointManager
 
 	/*
 	 * (non-Javadoc)
-	 * 
+	 *
 	 * @see org.eclipse.debug.internal.ui.views.variables.VariablesView#setViewerInput(java.lang.Object)
 	 */
 	@Override
@@ -332,23 +332,23 @@ public class BreakpointsView extends VariablesView implements IBreakpointManager
 		if (current != null && current.equals(context)) {
 			return;
 		}
-		
+
 		showViewer();
 		getViewer().setInput(context);
-		
+
 		// Expand all elements when the view is first shown. (bug 297762)
 		if (!fFirstInputSet) {
 		    fFirstInputSet = true;
 		    expandAllElementsInViewer();
 		}
 	}
-		
+
 	/*
 	 * (non-Javadoc)
 	 * @see org.eclipse.debug.internal.ui.views.variables.VariablesView#viewerInputUpdateComplete(org.eclipse.debug.internal.ui.viewers.model.provisional.IViewerInputUpdate)
 	 */
 	@Override
-	protected void viewerInputUpdateComplete(IViewerInputUpdate update) {		
+	protected void viewerInputUpdateComplete(IViewerInputUpdate update) {
 		// handles non-standard debug model
 	    IStatus status = update.getStatus();
         if ( (status == null || status.isOK()) && update.getElement() != null) {
@@ -357,17 +357,17 @@ public class BreakpointsView extends VariablesView implements IBreakpointManager
             setViewerInput(new DefaultBreakpointsViewInput(getTreeModelViewer().getPresentationContext()));
         }
 	}
-	
-	
+
+
 	/**
 	 * Returns whether this view is currently tracking the selection from the debug view.
-	 * 
+	 *
 	 * @return whether this view is currently tracking the debug view's selection
 	 */
 	public boolean isTrackingSelection() {
         final TreeModelViewer viewer = getTreeModelViewer();
         if (viewer != null) {
-            return Boolean.TRUE.equals( 
+            return Boolean.TRUE.equals(
                 viewer.getPresentationContext().getProperty(IBreakpointUIConstants.PROP_BREAKPOINTS_TRACK_SELECTION) );
         }
         return false;
@@ -375,7 +375,7 @@ public class BreakpointsView extends VariablesView implements IBreakpointManager
 
 	/**
 	 * Sets whether this view should track the selection from the debug view.
-	 * 
+	 *
 	 * @param trackSelection whether or not this view should track the debug view's selection.
 	 */
 	public void setTrackSelection(boolean trackSelection) {
@@ -383,14 +383,14 @@ public class BreakpointsView extends VariablesView implements IBreakpointManager
 		final TreeModelViewer viewer = getTreeModelViewer();
 		if (viewer != null) {
 			viewer.getPresentationContext().setProperty(
-			    IBreakpointUIConstants.PROP_BREAKPOINTS_TRACK_SELECTION, 
+			    IBreakpointUIConstants.PROP_BREAKPOINTS_TRACK_SELECTION,
 			    trackSelection ? Boolean.TRUE : Boolean.FALSE);
 		}
 	}
-	
+
 	/**
 	 * Initializes the persisted breakpoints organizers.
-	 * @param memento the memento to read 
+	 * @param memento the memento to read
 	 */
 	private void initBreakpointOrganizers(IMemento memento) {
 		if (memento != null) {
@@ -410,7 +410,7 @@ public class BreakpointsView extends VariablesView implements IBreakpointManager
                         }
                     }
                     fOrganizers = organziers.toArray(new IBreakpointOrganizer[organziers.size()]);
-                    
+
                     for (int i = 0; i < fOrganizers.length; i++) {
 						fOrganizers[i].addPropertyChangeListener(this);
 					}
@@ -418,7 +418,7 @@ public class BreakpointsView extends VariablesView implements IBreakpointManager
 			}
 		}
 	}
-	
+
     /**
      * Initializes drag and drop for the breakpoints viewer
      * @param viewer the viewer to add drag and drop support to
@@ -431,7 +431,7 @@ public class BreakpointsView extends VariablesView implements IBreakpointManager
         // Drag
         viewer.addDragSupport(ops, new Transfer[] {LocalSelectionTransfer.getTransfer()}, new BreakpointsDragAdapter(viewer, this));
     }
- 
+
 	/*
 	 * (non-Javadoc)
 	 * @see org.eclipse.debug.internal.ui.views.variables.VariablesView#saveViewerState(org.eclipse.ui.IMemento)
@@ -452,10 +452,10 @@ public class BreakpointsView extends VariablesView implements IBreakpointManager
         }
 		super.saveViewerState(memento);
 	}
-	
+
 	/**
 	 * Preserves the selection.
-	 * 
+	 *
 	 * @param selection the selection
 	 */
 	public void preserveSelection(IStructuredSelection selection) {
@@ -494,23 +494,23 @@ public class BreakpointsView extends VariablesView implements IBreakpointManager
 
 	/**
 	 * Sets the breakpoint organizers for this view.
-	 * 
+	 *
 	 * @param organizers the organizers, can be <code>null</code>.
 	 */
 	public void setBreakpointOrganizers(IBreakpointOrganizer[] organizers) {
 		fOrganizers = organizers;
-		
+
 		TreeModelViewer viewer = getTreeModelViewer();
 		if (viewer != null) {
 			// update the presentation context organizer
-			viewer.getPresentationContext().setProperty(IBreakpointUIConstants.PROP_BREAKPOINTS_ORGANIZERS, fOrganizers);			
+			viewer.getPresentationContext().setProperty(IBreakpointUIConstants.PROP_BREAKPOINTS_ORGANIZERS, fOrganizers);
 		}
 		System.out.println();
 	}
 
 	/**
 	 * Sets the breakpoint filter for this view.
-	 * @param filter the selection to act as a filter 
+	 * @param filter the selection to act as a filter
 	 */
 	public void setFilterSelection(boolean filter) {
 		TreeModelViewer viewer = getTreeModelViewer();
@@ -536,16 +536,16 @@ public class BreakpointsView extends VariablesView implements IBreakpointManager
 			}
 		});
 	}
-	
+
 	/**
 	 * Expands all elements in the viewer.
 	 */
 	public void expandAllElementsInViewer() {
-        Display display = getSite().getShell().getDisplay(); 
-        
+        Display display = getSite().getShell().getDisplay();
+
         final VirtualTreeModelViewer virtualViewer = new VirtualTreeModelViewer(
             display, 0, ((ITreeModelViewer)getViewer()).getPresentationContext());
-        
+
         virtualViewer.setAutoExpandLevel(-1);
         virtualViewer.addViewerUpdateListener(new IViewerUpdateListener() {
             @Override
@@ -567,17 +567,17 @@ public class BreakpointsView extends VariablesView implements IBreakpointManager
         });
         virtualViewer.setInput(getViewer().getInput());
 	}
-	
-	
+
+
 	/**
 	 * Returns the breakpoint organizers for this view.
-	 * 
+	 *
 	 * @return the breakpoint organizers.
 	 */
 	public IBreakpointOrganizer[] getBreakpointOrganizers() {
 		return fOrganizers;
 	}
-	
+
 	/**
      * Returns whether the given selection can be pasted into the given target.
      * <p>
@@ -588,11 +588,11 @@ public class BreakpointsView extends VariablesView implements IBreakpointManager
      * <li>Breakpoints can only be pasted into containers, not other breakpoints</li>
      * </ul>
      * </p>
-     * 
+     *
      * @param target target of the paste
      * @param selection the selection to paste
      * @return whether the given selection can be pasted into the given target
-     * 
+     *
      * TODO Remove in favor of using <code>TreeItem</code>s and <code>TreePath</code>s to determine paste targets
      */
     public boolean canPaste(Object target, ISelection selection) {
@@ -611,21 +611,21 @@ public class BreakpointsView extends VariablesView implements IBreakpointManager
             }
     	}
         return true;
-    }   
-	
-    /** 
+    }
+
+    /**
      * Pastes the selection into the given target
-     * 
+     *
      * @param target target of the paste, either a IBreakpointContainer,
      * or a Breakpoint within a IBreakpointContainer
      * @param selection breakpoints
      * @return whether successful
-     * 
-     * TODO remove in favor of using <code>TreeItem</code> as paste target 
+     *
+     * TODO remove in favor of using <code>TreeItem</code> as paste target
      */
     public boolean performPaste(Object target, ISelection selection) {
         if (target instanceof IBreakpointContainer && selection instanceof IStructuredSelection) {
-            IBreakpointContainer container = (IBreakpointContainer) target;            
+            IBreakpointContainer container = (IBreakpointContainer) target;
             Object[] objects = ((IStructuredSelection)selection).toArray();
             for (int i = 0; i < objects.length; i++) {
                 IBreakpoint breakpoint = (IBreakpoint)DebugPlugin.getAdapter(objects[i], IBreakpoint.class);
@@ -637,10 +637,10 @@ public class BreakpointsView extends VariablesView implements IBreakpointManager
         }
         return false;
     }
-    
+
 	/**
      * Returns the container from within the specified path that is the container the breakpoint can be removed from
-	 * @param path the path to get the container from 
+	 * @param path the path to get the container from
      * @return the first found container that includes the breakpoint that allows removal, or <code>null</code> if none found
      * @since 3.3
      */
@@ -650,11 +650,11 @@ public class BreakpointsView extends VariablesView implements IBreakpointManager
         	if (breakpoint != null) {
 		    	IBreakpointContainer container = null;
 		    	for(int i = path.getSegmentCount()-2; i > -1; i--) {
-		    	    Object segment = path.getSegment(i); 
+		    	    Object segment = path.getSegment(i);
 		    	    if (segment instanceof IBreakpointContainer) {
     		    		container = (IBreakpointContainer) segment;
-    		    		if(container.contains(breakpoint) && 
-    		    			container.getOrganizer() != null && 
+    		    		if(container.contains(breakpoint) &&
+    		    			container.getOrganizer() != null &&
     		    			container.getOrganizer().canRemove(breakpoint, container.getCategory())) {
     		    			return container;
     		    		}
@@ -667,7 +667,7 @@ public class BreakpointsView extends VariablesView implements IBreakpointManager
 
     /**
      * Returns the addable breakpoint container of the specified tree path
-     * @param path the path to get the container for 
+     * @param path the path to get the container for
      * @return the first found addable container for the specified tree path or <code>null</code> if none found
      * @since 3.3
      */
@@ -681,7 +681,7 @@ public class BreakpointsView extends VariablesView implements IBreakpointManager
 	    	if (breakpoint != null) {
 		    	IBreakpointContainer container = null;
 		    	for (int i = path.getSegmentCount()-2; i > -1; i--) {
-                    Object segment = path.getSegment(i); 
+                    Object segment = path.getSegment(i);
                     if (segment instanceof IBreakpointContainer) {
                         container = (IBreakpointContainer) segment;
     		    		if (container.contains(breakpoint) && container.getOrganizer().canAdd(breakpoint, container.getCategory())) {
@@ -697,7 +697,7 @@ public class BreakpointsView extends VariablesView implements IBreakpointManager
 	 * This method is used to determine if there is an addable parent container available for the specified drop target.
 	 * <p>
 	 * A drop target can be either a <code>IBreakpointContainer</code> or an <code>IBreakpoint</code>. This method always checks the entire hierarchy
-	 * of the tree path for the specified target in the event one of the parent element does not support dropping. 
+	 * of the tree path for the specified target in the event one of the parent element does not support dropping.
 	 * </p>
 	 * @param path the path
 	 * @param breakpoint the breakpoint
@@ -718,7 +718,7 @@ public class BreakpointsView extends VariablesView implements IBreakpointManager
 		}
 		return true;
 	}
-	
+
     /**
      * Returns if the selected item in the tree can be dragged
      * <p>
@@ -746,10 +746,10 @@ public class BreakpointsView extends VariablesView implements IBreakpointManager
     	}
     	return true;
     }
-    
+
     /**
      * Performs the actual removal of breakpoints from their respective (removable) containers on a successful drag operation
-     * @param paths the tree paths to drag 
+     * @param paths the tree paths to drag
      * @since 3.3
      */
     void performDrag(TreePath[] paths) {
@@ -785,8 +785,8 @@ public class BreakpointsView extends VariablesView implements IBreakpointManager
 				}
 			}
     	}
-    }	
-    
+    }
+
 	/**
      * Performs the actual addition of the selected breakpoints to the specified target
      * @param target the target to add the selection of breakpoints to
@@ -802,7 +802,7 @@ public class BreakpointsView extends VariablesView implements IBreakpointManager
     	if (container == null) {
 			return false;
 		}
-    	
+
     	IBreakpointOrganizer organizer = container.getOrganizer();
 		List<IBreakpoint> breakpoints = new ArrayList<IBreakpoint>(selection.size());
 		for (Iterator<?> iter = selection.iterator(); iter.hasNext();) {
@@ -814,7 +814,7 @@ public class BreakpointsView extends VariablesView implements IBreakpointManager
     	if (organizer instanceof IBreakpointOrganizerDelegateExtension) {
     		IBreakpointOrganizerDelegateExtension extension = (IBreakpointOrganizerDelegateExtension) organizer;
     		extension.addBreakpoints(
-    		    breakpoints.toArray(new IBreakpoint[breakpoints.size()]), 
+    		    breakpoints.toArray(new IBreakpoint[breakpoints.size()]),
     		    container.getCategory());
     	} else {
 	    	for (int i = 0; i < breakpoints.size(); i++) {
@@ -835,7 +835,7 @@ public class BreakpointsView extends VariablesView implements IBreakpointManager
      * </ul>
      * </p>
      * @param target the target for the drop
-     * @param selection the selection to see if we can drop 
+     * @param selection the selection to see if we can drop
      * @return true if the specified element can be dropped into the specified target, false otherwise
      * @since 3.3
      */
diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointsViewer.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointsViewer.java
index 4ffb30c12..4c3d619bb 100644
--- a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointsViewer.java
+++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointsViewer.java
@@ -4,7 +4,7 @@
  * 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
  *     Patrick Chuong (Texas Instruments) - Improve usability of the breakpoint view (Bug 238956)
@@ -39,47 +39,47 @@ import org.eclipse.swt.widgets.Widget;
  * Breakpoints viewer.
  */
 public class BreakpointsViewer extends CheckboxTreeViewer {
-	
+
     /**
      * Constructs a new breakpoints viewer with the given tree.
-     * 
+     *
      * @param tree the backing tree widget
      */
     public BreakpointsViewer(Tree tree) {
         super(tree);
     }
-    
+
     /**
      * Returns the selected items.
-     * 
+     *
      * @return selected items
      */
     public Item[] getSelectedItems() {
         return getSelection(getControl());
     }
-    
+
     /**
      * Returns the item associated with the given element, or <code>null</code>.
-     * 
+     *
      * @param element element in breakpoints view
      * @return item associated with the given element, or <code>null</code>
      */
     public Widget searchItem(Object element) {
         return findItem(element);
     }
-    
+
     /**
      * Refreshes the given item in the tree.
-     * 
+     *
      * @param item item to refresh
      */
     public void refreshItem(TreeItem item) {
         updateItem(item, item.getData());
     }
-    
+
     /**
      * Returns a collection of currently visible breakpoints.
-     * 
+     *
      * @return collection of currently visible breakpoints
      */
     public IBreakpoint[] getVisibleBreakpoints() {
@@ -98,7 +98,7 @@ public class BreakpointsViewer extends CheckboxTreeViewer {
     /**
      * Adds expanded breakpoints to the list. Traverses children of the given
      * tree item if any.
-     * 
+     *
      * @param item the item to get breakpoints from
      * @param list collection of visible breakpoints
      */
@@ -118,7 +118,7 @@ public class BreakpointsViewer extends CheckboxTreeViewer {
 
     /**
      * Sets the selection to a specific tree item
-     * 
+     *
      * @param item the item to set as the current tree selection
      */
     protected void setSelection(TreeItem item) {
@@ -151,7 +151,7 @@ public class BreakpointsViewer extends CheckboxTreeViewer {
     	}
     	return null;
     }
-	
+
     /**
      * Returns the addable breakpoint container of the specified breakpoint
      * @param item the item to get the container for
@@ -175,7 +175,7 @@ public class BreakpointsViewer extends CheckboxTreeViewer {
     	}
     	return null;
     }
-    
+
     /**
      * Returns if the selected item in the tree can be dragged
      * <p>
@@ -203,7 +203,7 @@ public class BreakpointsViewer extends CheckboxTreeViewer {
     	}
     	return true;
     }
-    
+
     /**
      * Performs the actual removal of breakpoints from their respective (removable) containers on a successful drag operation
      * @param items the items involved in the drag
@@ -245,7 +245,7 @@ public class BreakpointsViewer extends CheckboxTreeViewer {
 			}
     	}
     }
-    
+
     /**
      * Determines if the specified element can be dropped into the specified target
      * <p>
@@ -277,7 +277,7 @@ public class BreakpointsViewer extends CheckboxTreeViewer {
 	 * This method is used to determine if there is an addable parent container available for the specified drop target.
 	 * <p>
 	 * A drop target can be either a <code>BreakpointContainer</code> or an <code>IBreakpoint</code>. This method always checks the entire hierarchy
-	 * of the tree path for the specified target in the event one of the parent element does not support dropping. 
+	 * of the tree path for the specified target in the event one of the parent element does not support dropping.
 	 * </p>
 	 * @param target the target to check
 	 * @param breakpoint the breakpoint we would like to drop
@@ -334,7 +334,7 @@ public class BreakpointsViewer extends CheckboxTreeViewer {
     	expandToLevel(target.getData(), ALL_LEVELS);
     	return true;
     }
-    
+
 	/* (non-Javadoc)
 	 * @see org.eclipse.jface.viewers.Viewer#refresh()
 	 */
@@ -352,11 +352,11 @@ public class BreakpointsViewer extends CheckboxTreeViewer {
 		for (int i = 0; i < items.length; i++) {
 			updateCheckedState(items[i]);
 		}
-	}    
-    
+	}
+
     /**
      * Update the checked state up the given element and all of its children.
-     * 
+     *
      * @param element the element to update
      */
 	public void updateCheckedState(Object element) {
@@ -368,7 +368,7 @@ public class BreakpointsViewer extends CheckboxTreeViewer {
             }
         }
 	}
-   
+
 	/**
 	 * finds all occurrences of a widget to update
 	 * @param element the element to search for when finding occurrences
@@ -382,7 +382,7 @@ public class BreakpointsViewer extends CheckboxTreeViewer {
         }
         return list.toArray(new Widget[0]);
     }
-    
+
     /**
      * performs the actual search for items in the tree
      * @param list the list to add matches to
@@ -398,10 +398,10 @@ public class BreakpointsViewer extends CheckboxTreeViewer {
         	findAllOccurrences(items[i], element, list);
         }
     }
-    
+
     /**
      * Update the checked state up the given element and all of its children.
-     * 
+     *
      * @param item the item to update
      */
     public void updateCheckedState(TreeItem item) {
@@ -445,5 +445,5 @@ public class BreakpointsViewer extends CheckboxTreeViewer {
                 updateCheckedState(items[i]);
             }
         }
-    }        
+    }
 }
diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/ElementComparator.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/ElementComparator.java
index 8537258b4..4d00ee655 100644
--- a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/ElementComparator.java
+++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/ElementComparator.java
@@ -29,40 +29,40 @@ import org.eclipse.debug.internal.ui.views.DebugModelPresentationContext;
 
 /**
  * Breakpoint element comparator.
- * 
+ *
  * @since 3.6
  */
 public class ElementComparator implements Comparator<Object> {
 	final private static String SPACE = " "; //$NON-NLS-1$
-	
+
 	protected DebugModelPresentationContext fContext;
-	
+
 	public ElementComparator(IPresentationContext context) {
 		if (context instanceof DebugModelPresentationContext) {
 			fContext = (DebugModelPresentationContext) context;
 		}
 	}
-	
-	
+
+
 	/* (non-Javadoc)
 	 * @see java.util.Comparator#compare(java.lang.Object, java.lang.Object)
 	 */
 	@Override
 	public int compare(Object arg0, Object arg1) {
-        IBreakpoint bp0 = (IBreakpoint)DebugPlugin.getAdapter(arg0, IBreakpoint.class);            
-        IBreakpoint bp1 = (IBreakpoint)DebugPlugin.getAdapter(arg1, IBreakpoint.class);            
+        IBreakpoint bp0 = (IBreakpoint)DebugPlugin.getAdapter(arg0, IBreakpoint.class);
+        IBreakpoint bp1 = (IBreakpoint)DebugPlugin.getAdapter(arg1, IBreakpoint.class);
 	    if (bp0 != null && bp1 != null) {
 			return doCompare(bp0, bp1);
 		} else if (arg0 instanceof IBreakpointContainer && arg1 instanceof IBreakpointContainer) {
 			return doCompare((IBreakpointContainer) arg0, (IBreakpointContainer) arg1);
-		} else {		
+		} else {
 			return -1; // just return -1 if the two objects are not IBreakpoint type
 		}
 	}
-    
+
 	/**
 	 * Compares two breakpoint containers.
-	 * 
+	 *
 	 * @param c1
 	 * @param c2
 	 * @return
@@ -78,21 +78,21 @@ public class ElementComparator implements Comparator<Object> {
 	    } else if (c2.getCategory() instanceof OtherBreakpointCategory) {
 	        return -1;
 	    }
-	    
+
 	    // Rest of categories should be listed alphabetically.
 		if (fContext != null) {
 			String name1 = fContext.getModelPresentation().getText(c1);
 			String name2 = fContext.getModelPresentation().getText(c2);
-			
+
 			return name1.compareTo(name2);
 		}
-		
+
 		return -1;
-	}	
-	
+	}
+
 	/**
 	 * Compares two breakpoints.
-	 * 
+	 *
 	 * @param b1
 	 * @param b2
 	 * @return
@@ -118,12 +118,12 @@ public class ElementComparator implements Comparator<Object> {
 		}
 		String text1 = IInternalDebugCoreConstants.EMPTY_STRING;
 		String text2 = IInternalDebugCoreConstants.EMPTY_STRING;
-		
+
 		text1 += b1.getModelIdentifier();
 		text2 += b2.getModelIdentifier();
-		
 
-		try {		
+
+		try {
 			if (marker1.exists() && marker2.exists()) {
 				text1 += SPACE + marker1.getType();
 				text2 += SPACE + marker2.getType();
@@ -131,17 +131,17 @@ public class ElementComparator implements Comparator<Object> {
 		} catch (CoreException e) {
 			DebugUIPlugin.log(e);
 		}
-	
+
 		int result = text1.compareTo(text2);
 		if (result != 0) {
 			return result;
 		}
-	
-		// model and type are the same	
+
+		// model and type are the same
 		if (fContext != null) {
 			String name1 = fContext.getModelPresentation().getText(b1);
 			String name2 = fContext.getModelPresentation().getText(b2);
-	
+
 			boolean lineBreakpoint = false;
 			try {
 				lineBreakpoint = marker1.isSubtypeOf(IBreakpoint.LINE_BREAKPOINT_MARKER);
@@ -149,17 +149,17 @@ public class ElementComparator implements Comparator<Object> {
 			}
 			if (lineBreakpoint) {
 				return compareLineBreakpoints(b1, b2, name1,name2);
-			} 
-			
+			}
+
 			return name1.compareTo(name2);
 		}
-		
+
 		return result;
 	}
-	
+
 	/**
 	 * Compares two line breakpoints.
-	 * 
+	 *
 	 * @param b1
 	 * @param b2
 	 * @param name1
@@ -176,12 +176,12 @@ public class ElementComparator implements Comparator<Object> {
 					int l1 = 0;
 					int l2 = 0;
 					try {
-						l1 = ((ILineBreakpoint)b1).getLineNumber();	
+						l1 = ((ILineBreakpoint)b1).getLineNumber();
 					} catch (CoreException e) {
 						DebugUIPlugin.log(e);
 					}
 					try {
-						l2 = ((ILineBreakpoint)b2).getLineNumber();	
+						l2 = ((ILineBreakpoint)b2).getLineNumber();
 					} catch (CoreException e) {
 						DebugUIPlugin.log(e);
 					}
@@ -190,6 +190,6 @@ public class ElementComparator implements Comparator<Object> {
 			}
 		}
 		return name1.compareTo(name2);
-	}     
+	}
 
 }
diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/FileBreakpointOrganizer.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/FileBreakpointOrganizer.java
index 656899ba0..df31a71fb 100644
--- a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/FileBreakpointOrganizer.java
+++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/FileBreakpointOrganizer.java
@@ -4,7 +4,7 @@
  * 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
  *******************************************************************************/
@@ -19,7 +19,7 @@ import org.eclipse.debug.ui.AbstractBreakpointOrganizerDelegate;
 
 /**
  * Breakpoint organizers for files.
- * 
+ *
  * @since 3.1
  */
 public class FileBreakpointOrganizer extends AbstractBreakpointOrganizerDelegate {
diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/ProjectBreakpointOrganizer.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/ProjectBreakpointOrganizer.java
index 5aaef21e4..49b25a2a0 100644
--- a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/ProjectBreakpointOrganizer.java
+++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/ProjectBreakpointOrganizer.java
@@ -4,7 +4,7 @@
  * 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
  *******************************************************************************/
@@ -18,7 +18,7 @@ import org.eclipse.debug.ui.AbstractBreakpointOrganizerDelegate;
 
 /**
  * Breakpoint organizers for projects.
- * 
+ *
  * @since 3.1
  */
 public class ProjectBreakpointOrganizer extends AbstractBreakpointOrganizerDelegate {
diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/WorkingSetBreakpointOrganizer.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/WorkingSetBreakpointOrganizer.java
index 972e41ed2..05a74768d 100644
--- a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/WorkingSetBreakpointOrganizer.java
+++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/WorkingSetBreakpointOrganizer.java
@@ -4,7 +4,7 @@
  * 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
  *******************************************************************************/
@@ -26,18 +26,18 @@ import org.eclipse.ui.PlatformUI;
 
 /**
  * Breakpoint organizers for resource working sets.
- * 
+ *
  * @since 3.1
  */
 public class WorkingSetBreakpointOrganizer extends AbstractBreakpointOrganizerDelegate implements IPropertyChangeListener {
-    
+
     IWorkingSetManager fWorkingSetManager = PlatformUI.getWorkbench().getWorkingSetManager();
-    
+
     /**
      * Constructs a working set breakpoint organizer. Listens for changes in
      * working sets and fires property change notification.
      */
-    public WorkingSetBreakpointOrganizer() {    
+    public WorkingSetBreakpointOrganizer() {
         fWorkingSetManager.addPropertyChangeListener(this);
     }
 
@@ -83,7 +83,7 @@ public class WorkingSetBreakpointOrganizer extends AbstractBreakpointOrganizerDe
         fWorkingSetManager = null;
         super.dispose();
     }
-    
+
     /* (non-Javadoc)
      * @see org.eclipse.jface.util.IPropertyChangeListener#propertyChange(org.eclipse.jface.util.PropertyChangeEvent)
      */
diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/WorkingSetCategory.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/WorkingSetCategory.java
index 7dd94a277..ed32a154a 100644
--- a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/WorkingSetCategory.java
+++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/WorkingSetCategory.java
@@ -25,18 +25,18 @@ import org.eclipse.ui.model.IWorkbenchAdapter2;
  * Represents a breakpoint category for a specific working set.
  */
 public class WorkingSetCategory extends PlatformObject implements IWorkbenchAdapter, IWorkbenchAdapter2 {
-    
+
     private IWorkingSet fWorkingSet;
 
     /**
      * Constructs a new workings set category for the given working set.
-     * 
+     *
      * @param workingSet
      */
     public WorkingSetCategory(IWorkingSet workingSet) {
         fWorkingSet = workingSet;
     }
-    
+
     /* (non-Javadoc)
      * @see org.eclipse.ui.model.IWorkbenchAdapter#getChildren(java.lang.Object)
      */
@@ -60,7 +60,7 @@ public class WorkingSetCategory extends PlatformObject implements IWorkbenchAdap
 	public String getLabel(Object o) {
         StringBuffer name = new StringBuffer(fWorkingSet.getName());
         if (isDefault()) {
-            name.append(DebugUIViewsMessages.WorkingSetCategory_0); 
+            name.append(DebugUIViewsMessages.WorkingSetCategory_0);
         }
         return name.toString();
     }
@@ -72,10 +72,10 @@ public class WorkingSetCategory extends PlatformObject implements IWorkbenchAdap
 	public Object getParent(Object o) {
         return null;
     }
-    
+
     /**
      * Returns the working set for this category.
-     * 
+     *
      * @return
      */
     public IWorkingSet getWorkingSet() {
@@ -93,7 +93,7 @@ public class WorkingSetCategory extends PlatformObject implements IWorkbenchAdap
         }
         return false;
     }
-    
+
     /* (non-Javadoc)
      * @see java.lang.Object#hashCode()
      */
@@ -133,16 +133,16 @@ public class WorkingSetCategory extends PlatformObject implements IWorkbenchAdap
         }
         return null;
     }
-    
+
     /**
      * Whether this is the default breakpoint working set.
-     * 
+     *
      * @return whether this is the default breakpoint working set
      */
     private boolean isDefault() {
         return fWorkingSet.equals(BreakpointSetOrganizer.getDefaultWorkingSet());
     }
-    
+
     @Override
 	public String toString() {
         return fWorkingSet.getName();