1 files changed, 185 insertions, 185 deletions

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 e7c438e79..7672e1aed 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
@@ -35,182 +35,182 @@ import org.eclipse.jface.viewers.Viewer;
  */
 public class BreakpointsContentProvider implements ITreeContentProvider, IPropertyChangeListener {
 
-    private IBreakpointOrganizer[] fOrganizers = null;
-    private BreakpointsViewer fViewer;
-    private Object[] fElements;
-    private boolean fDisposed = false;
+	private IBreakpointOrganizer[] fOrganizers = null;
+	private BreakpointsViewer fViewer;
+	private Object[] fElements;
+	private boolean fDisposed = false;
 
-    @Override
+	@Override
 	public Object[] getChildren(Object parentElement) {
-        if (parentElement.equals(DebugPlugin.getDefault().getBreakpointManager())) {
-        	return fElements;
-        } else if (parentElement instanceof BreakpointContainer) {
-        	return ((BreakpointContainer)parentElement).getChildren();
-        }
-        return new Object[0];
-    }
+		if (parentElement.equals(DebugPlugin.getDefault().getBreakpointManager())) {
+			return fElements;
+		} else if (parentElement instanceof BreakpointContainer) {
+			return ((BreakpointContainer)parentElement).getChildren();
+		}
+		return new Object[0];
+	}
 
-    @Override
+	@Override
 	public Object getParent(Object element) {
-        return null;
-    }
+		return null;
+	}
 
-    @Override
+	@Override
 	public boolean hasChildren(Object element) {
-    	return getChildren(element).length > 0;
-    }
+		return getChildren(element).length > 0;
+	}
 
-    @Override
+	@Override
 	public Object[] getElements(Object inputElement) {
-        return getChildren(inputElement);
-    }
+		return getChildren(inputElement);
+	}
 
-    @Override
+	@Override
 	public void dispose() {
-        fDisposed = true;
-        fElements = null;
-        setOrganizers(null);
-    }
+		fDisposed = true;
+		fElements = null;
+		setOrganizers(null);
+	}
 
-    @Override
+	@Override
 	public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
-    	fViewer = (BreakpointsViewer)viewer;
-        if (newInput != null) {
-            reorganize();
-        }
-    }
+		fViewer = (BreakpointsViewer)viewer;
+		if (newInput != null) {
+			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
-     */
-    public void setOrganizers(IBreakpointOrganizer[] organizers) {
-    	// remove previous listeners
-    	if (fOrganizers != null) {
-    		for (int i = 0; i < fOrganizers.length; i++) {
+	/**
+	 * 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
+	 */
+	public void setOrganizers(IBreakpointOrganizer[] organizers) {
+		// remove previous listeners
+		if (fOrganizers != null) {
+			for (int i = 0; i < fOrganizers.length; i++) {
 				fOrganizers[i].removePropertyChangeListener(this);
 			}
-    	}
+		}
 		fOrganizers = organizers;
 		if (organizers != null && organizers.length == 0) {
 			fOrganizers = null;
 		}
-        // add listeners
-        if (fOrganizers != null) {
-        	for (int i = 0; i < fOrganizers.length; i++) {
+		// add listeners
+		if (fOrganizers != null) {
+			for (int i = 0; i < fOrganizers.length; i++) {
 				fOrganizers[i].addPropertyChangeListener(this);
 			}
-        }
-        if (!fDisposed) {
-            fViewer.getControl().setRedraw(false);
-            // maintain expansion based on visible breakpoints
-            IBreakpoint[] breakpoints = null;
-            if (isShowingGroups()) {
-                breakpoints = fViewer.getVisibleBreakpoints();
-            }
-            reorganize();
-            if (isShowingGroups() && breakpoints != null) {
-                // restore expansion
-                for (int i = 0; i < fElements.length; i++) {
-                    BreakpointContainer container = (BreakpointContainer) fElements[i];
-                    for (int j = 0; j < breakpoints.length; j++) {
-                        if (container.contains(breakpoints[j])) {
-                            fViewer.expandToLevel(container, AbstractTreeViewer.ALL_LEVELS);
-                            fViewer.updateCheckedState(container);
-                            break;
-                        }
-                    }
+		}
+		if (!fDisposed) {
+			fViewer.getControl().setRedraw(false);
+			// maintain expansion based on visible breakpoints
+			IBreakpoint[] breakpoints = null;
+			if (isShowingGroups()) {
+				breakpoints = fViewer.getVisibleBreakpoints();
+			}
+			reorganize();
+			if (isShowingGroups() && breakpoints != null) {
+				// restore expansion
+				for (int i = 0; i < fElements.length; i++) {
+					BreakpointContainer container = (BreakpointContainer) fElements[i];
+					for (int j = 0; j < breakpoints.length; j++) {
+						if (container.contains(breakpoints[j])) {
+							fViewer.expandToLevel(container, AbstractTreeViewer.ALL_LEVELS);
+							fViewer.updateCheckedState(container);
+							break;
+						}
+					}
 
-                }
-            }
-            fViewer.getControl().setRedraw(true);
-        }
-    }
+				}
+			}
+			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>
-     */
-    public BreakpointContainer[] getRoots(IBreakpoint breakpoint) {
-        if (isShowingGroups()) {
+	/**
+	 * 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>
+	 */
+	public BreakpointContainer[] getRoots(IBreakpoint breakpoint) {
+		if (isShowingGroups()) {
 			List<BreakpointContainer> list = new ArrayList<>();
-            for (int i = 0; i < fElements.length; i++) {
-                BreakpointContainer container = (BreakpointContainer) fElements[i];
-                if (container.contains(breakpoint)) {
-                    list.add(container);
-                }
-            }
-            return list.toArray(new BreakpointContainer[list.size()]);
-        }
-        return null;
-    }
+			for (int i = 0; i < fElements.length; i++) {
+				BreakpointContainer container = (BreakpointContainer) fElements[i];
+				if (container.contains(breakpoint)) {
+					list.add(container);
+				}
+			}
+			return list.toArray(new BreakpointContainer[list.size()]);
+		}
+		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;
-    }
+	/**
+	 * 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.
-     */
-    protected void reorganize() {
-        IBreakpoint[] breakpoints = DebugPlugin.getDefault().getBreakpointManager().getBreakpoints();
-        if (fOrganizers == null) {
-            fElements = breakpoints;
-        } else {
-            IBreakpointOrganizer organizer = fOrganizers[0];
+	/**
+	 * Organizes the breakpoints based on nested categories, if any.
+	 */
+	protected void reorganize() {
+		IBreakpoint[] breakpoints = DebugPlugin.getDefault().getBreakpointManager().getBreakpoints();
+		if (fOrganizers == null) {
+			fElements = breakpoints;
+		} else {
+			IBreakpointOrganizer organizer = fOrganizers[0];
 			Map<IAdaptable, BreakpointContainer> categoriesToContainers = new HashMap<>();
-            for (int i = 0; i < breakpoints.length; i++) {
-                IBreakpoint breakpoint = breakpoints[i];
-                IAdaptable[] categories = organizer.getCategories(breakpoint);
-                if (categories == null || categories.length == 0) {
-                	categories = OtherBreakpointCategory.getCategories(organizer);
-                }
-                for (int j = 0; j < categories.length; j++) {
-                    IAdaptable category = categories[j];
-                    BreakpointContainer container = categoriesToContainers.get(category);
-                    if (container == null) {
-                        IBreakpointOrganizer[] nesting = null;
-                        if (fOrganizers.length > 1) {
-                            nesting = new IBreakpointOrganizer[fOrganizers.length - 1];
-                            System.arraycopy(fOrganizers, 1, nesting, 0, nesting.length);
-                        }
-                        container = new BreakpointContainer(category, organizer, nesting);
-                        categoriesToContainers.put(category, container);
-                    }
-                    container.addBreakpoint(breakpoint);
-                }
-            }
-            // add empty categories
-            IAdaptable[] emptyCategories = organizer.getCategories();
-            if (emptyCategories != null) {
-                for (int i = 0; i < emptyCategories.length; i++) {
-                    IAdaptable category = emptyCategories[i];
-                    BreakpointContainer container = categoriesToContainers.get(category);
-                    if (container == null) {
-                        container = new BreakpointContainer(category, organizer, null);
-                        categoriesToContainers.put(category, container);
-                    }
-                }
-            }
-            fElements = categoriesToContainers.values().toArray();
-        }
-        fViewer.getControl().setRedraw(false);
-        fViewer.refresh();
-        fViewer.getControl().setRedraw(true);
-    }
+			for (int i = 0; i < breakpoints.length; i++) {
+				IBreakpoint breakpoint = breakpoints[i];
+				IAdaptable[] categories = organizer.getCategories(breakpoint);
+				if (categories == null || categories.length == 0) {
+					categories = OtherBreakpointCategory.getCategories(organizer);
+				}
+				for (int j = 0; j < categories.length; j++) {
+					IAdaptable category = categories[j];
+					BreakpointContainer container = categoriesToContainers.get(category);
+					if (container == null) {
+						IBreakpointOrganizer[] nesting = null;
+						if (fOrganizers.length > 1) {
+							nesting = new IBreakpointOrganizer[fOrganizers.length - 1];
+							System.arraycopy(fOrganizers, 1, nesting, 0, nesting.length);
+						}
+						container = new BreakpointContainer(category, organizer, nesting);
+						categoriesToContainers.put(category, container);
+					}
+					container.addBreakpoint(breakpoint);
+				}
+			}
+			// add empty categories
+			IAdaptable[] emptyCategories = organizer.getCategories();
+			if (emptyCategories != null) {
+				for (int i = 0; i < emptyCategories.length; i++) {
+					IAdaptable category = emptyCategories[i];
+					BreakpointContainer container = categoriesToContainers.get(category);
+					if (container == null) {
+						container = new BreakpointContainer(category, organizer, null);
+						categoriesToContainers.put(category, container);
+					}
+				}
+			}
+			fElements = categoriesToContainers.values().toArray();
+		}
+		fViewer.getControl().setRedraw(false);
+		fViewer.refresh();
+		fViewer.getControl().setRedraw(true);
+	}
 
 	@Override
 	public void propertyChange(PropertyChangeEvent event) {
@@ -220,41 +220,41 @@ public class BreakpointsContentProvider implements ITreeContentProvider, IProper
 		}
 	}
 
-    /**
-     * 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>
-     */
-    protected BreakpointContainer[] getContainers(IBreakpoint breakpoint) {
-        if (isShowingGroups()) {
-            IAdaptable[] categories = fOrganizers[0].getCategories(breakpoint);
-            if (categories == null || categories.length == 0) {
-                categories = OtherBreakpointCategory.getCategories(fOrganizers[0]);
-            }
-            BreakpointContainer[] containers = new BreakpointContainer[categories.length];
-            int index = 0;
-            for (int i = 0; i < fElements.length; i++) {
-                BreakpointContainer container = (BreakpointContainer)fElements[i];
-                for (int j = 0; j < categories.length; j++) {
-                    IAdaptable category = categories[j];
-                    if (container.getCategory().equals(category)) {
-                        containers[index] = container;
-                        index++;
-                    }
-                }
-            }
-            return containers;
-        }
-        return null;
-    }
+	/**
+	 * 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>
+	 */
+	protected BreakpointContainer[] getContainers(IBreakpoint breakpoint) {
+		if (isShowingGroups()) {
+			IAdaptable[] categories = fOrganizers[0].getCategories(breakpoint);
+			if (categories == null || categories.length == 0) {
+				categories = OtherBreakpointCategory.getCategories(fOrganizers[0]);
+			}
+			BreakpointContainer[] containers = new BreakpointContainer[categories.length];
+			int index = 0;
+			for (int i = 0; i < fElements.length; i++) {
+				BreakpointContainer container = (BreakpointContainer)fElements[i];
+				for (int j = 0; j < categories.length; j++) {
+					IAdaptable category = categories[j];
+					if (container.getCategory().equals(category)) {
+						containers[index] = container;
+						index++;
+					}
+				}
+			}
+			return containers;
+		}
+		return null;
+	}
 
-    /**
-     * Returns whether content is grouped by categories.
-     *
-     * @return whether content is grouped by categories
-     */
-    protected boolean isShowingGroups() {
-        return fOrganizers != null;
-    }
+	/**
+	 * Returns whether content is grouped by categories.
+	 *
+	 * @return whether content is grouped by categories
+	 */
+	protected boolean isShowingGroups() {
+		return fOrganizers != null;
+	}
 }