### Eclipse Workspace Patch 1.0 #P org.eclipse.cdt.dsf.ui Index: META-INF/MANIFEST.MF =================================================================== RCS file: /cvsroot/tools/org.eclipse.cdt/dsf/org.eclipse.cdt.dsf.ui/META-INF/MANIFEST.MF,v retrieving revision 1.10 diff -u -r1.10 MANIFEST.MF --- META-INF/MANIFEST.MF 18 Aug 2009 10:07:37 -0000 1.10 +++ META-INF/MANIFEST.MF 5 Oct 2009 21:01:28 -0000 @@ -29,6 +29,7 @@ org.eclipse.cdt.dsf.debug.ui.sourcelookup, org.eclipse.cdt.dsf.debug.ui.viewmodel;x-friends:="org.eclipse.cdt.dsf.gdb.ui,org.eclipse.cdt.examples.dsf,org.eclipse.cdt.examples.dsf.pda.ui", org.eclipse.cdt.dsf.debug.ui.viewmodel.actions;x-friends:="org.eclipse.cdt.dsf.gdb.ui,org.eclipse.cdt.examples.dsf,org.eclipse.cdt.examples.dsf.pda.ui", + org.eclipse.cdt.dsf.debug.ui.viewmodel.breakpoints, org.eclipse.cdt.dsf.debug.ui.viewmodel.expression;x-friends:="org.eclipse.cdt.dsf.gdb.ui,org.eclipse.cdt.examples.dsf,org.eclipse.cdt.examples.dsf.pda.ui", org.eclipse.cdt.dsf.debug.ui.viewmodel.launch;x-friends:="org.eclipse.cdt.dsf.gdb.ui,org.eclipse.cdt.examples.dsf,org.eclipse.cdt.examples.dsf.pda.ui", org.eclipse.cdt.dsf.debug.ui.viewmodel.launch.actions;x-friends:="org.eclipse.cdt.dsf.gdb.ui,org.eclipse.cdt.examples.dsf,org.eclipse.cdt.examples.dsf.pda.ui", Index: src/org/eclipse/cdt/dsf/debug/ui/viewmodel/breakpoints/BreakpointsChangedEvent.java =================================================================== RCS file: src/org/eclipse/cdt/dsf/debug/ui/viewmodel/breakpoints/BreakpointsChangedEvent.java diff -N src/org/eclipse/cdt/dsf/debug/ui/viewmodel/breakpoints/BreakpointsChangedEvent.java --- /dev/null 1 Jan 1970 00:00:00 -0000 +++ src/org/eclipse/cdt/dsf/debug/ui/viewmodel/breakpoints/BreakpointsChangedEvent.java 1 Jan 1970 00:00:00 -0000 @@ -0,0 +1,36 @@ +/******************************************************************************* + * Copyright (c) 2008 Wind River Systems and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * Wind River Systems - initial API and implementation + *******************************************************************************/ +package org.eclipse.cdt.dsf.debug.ui.viewmodel.breakpoints; + +import org.eclipse.debug.core.model.IBreakpoint; + +/** + * @since 2.1 + */ +public class BreakpointsChangedEvent { + public enum Type { ADDED, REMOVED, CHANGED }; + + private final Type fType; + private final IBreakpoint[] fBreakpoints; + + public BreakpointsChangedEvent(Type type, IBreakpoint[] breakpoints) { + fType = type; + fBreakpoints = breakpoints; + } + + public Type getType() { + return fType; + } + + public IBreakpoint[] getBreakpoints() { + return fBreakpoints; + } +} Index: src/org/eclipse/cdt/dsf/debug/ui/viewmodel/breakpoints/BreakpointVMNode.java =================================================================== RCS file: src/org/eclipse/cdt/dsf/debug/ui/viewmodel/breakpoints/BreakpointVMNode.java diff -N src/org/eclipse/cdt/dsf/debug/ui/viewmodel/breakpoints/BreakpointVMNode.java --- /dev/null 1 Jan 1970 00:00:00 -0000 +++ src/org/eclipse/cdt/dsf/debug/ui/viewmodel/breakpoints/BreakpointVMNode.java 1 Jan 1970 00:00:00 -0000 @@ -0,0 +1,102 @@ +/******************************************************************************* + * Copyright (c) 2008 Wind River Systems and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * Wind River Systems - initial API and implementation + *******************************************************************************/ +package org.eclipse.cdt.dsf.debug.ui.viewmodel.breakpoints; + +import java.util.List; + +import org.eclipse.cdt.dsf.concurrent.IDsfStatusConstants; +import org.eclipse.cdt.dsf.concurrent.ImmediateExecutor; +import org.eclipse.cdt.dsf.concurrent.RequestMonitor; +import org.eclipse.cdt.dsf.internal.ui.DsfUIPlugin; +import org.eclipse.cdt.dsf.ui.concurrent.ViewerDataRequestMonitor; +import org.eclipse.cdt.dsf.ui.viewmodel.AbstractVMNode; +import org.eclipse.cdt.dsf.ui.viewmodel.VMDelta; +import org.eclipse.cdt.dsf.ui.viewmodel.update.ICachingVMProvider; +import org.eclipse.core.runtime.IStatus; +import org.eclipse.core.runtime.Status; +import org.eclipse.debug.core.model.IBreakpoint; +import org.eclipse.debug.internal.ui.viewers.model.provisional.IChildrenCountUpdate; +import org.eclipse.debug.internal.ui.viewers.model.provisional.IChildrenUpdate; +import org.eclipse.debug.internal.ui.viewers.model.provisional.IHasChildrenUpdate; +import org.eclipse.debug.internal.ui.viewers.model.provisional.IModelDelta; + +/** + * + * + * @since 2.1 + */ +public class BreakpointVMNode extends AbstractVMNode { + + public BreakpointVMNode(ICachingVMProvider provider) { + super(provider); + } + + public void update(final IHasChildrenUpdate[] updates) { + for (IHasChildrenUpdate update : updates) { + if (!checkUpdate(update)) continue; + update.setStatus(new Status(IStatus.ERROR, DsfUIPlugin.PLUGIN_ID, IDsfStatusConstants.NOT_SUPPORTED, "Not implemented, clients should call to update all children instead.", null)); //$NON-NLS-1$ + update.done(); + } + } + + public void update(final IChildrenCountUpdate[] updates) { + for (IChildrenCountUpdate update : updates) { + if (!checkUpdate(update)) continue; + update.setStatus(new Status(IStatus.ERROR, DsfUIPlugin.PLUGIN_ID, IDsfStatusConstants.NOT_SUPPORTED, "Not implemented, clients should call to update all children instead.", null)); //$NON-NLS-1$ + update.done(); + } + } + + public void update(IChildrenUpdate[] updates) { + for (IChildrenUpdate update : updates) { + if (!checkUpdate(update)) continue; + doUpdate(update); + } + } + + private void doUpdate(final IChildrenUpdate update) { + BreakpointOrganizerVMNode.getNestingCategoryBreakpoints( + update.getElementPath(), + update.getViewerInput(), + update.getPresentationContext(), + new ViewerDataRequestMonitor>(ImmediateExecutor.getInstance(), update) { + @Override + protected void handleSuccess() { + if (!checkUpdate(update)) return; + List bps = getData(); + + int updateIdx = update.getOffset() != -1 ? update.getOffset() : 0; + int endIdx = updateIdx + (update.getLength() != -1 ? update.getLength() : bps.size()); + while (updateIdx < endIdx && updateIdx < bps.size()) { + update.setChild(bps.get(updateIdx), updateIdx); + updateIdx++; + } + update.done(); + + } + }); + } + + public void buildDelta(Object event, VMDelta parent, int nodeOffset, RequestMonitor requestMonitor) { + if (event instanceof BreakpointsChangedEvent) { + parent.setFlags(parent.getFlags() | IModelDelta.CONTENT); + } + requestMonitor.done(); + } + + public int getDeltaFlags(Object event) { + if (event instanceof BreakpointsChangedEvent) { + return IModelDelta.CONTENT; + } + return 0; + } + +} Index: src/org/eclipse/cdt/dsf/debug/ui/viewmodel/breakpoints/BreakpointOrganizerVMNode.java =================================================================== RCS file: src/org/eclipse/cdt/dsf/debug/ui/viewmodel/breakpoints/BreakpointOrganizerVMNode.java diff -N src/org/eclipse/cdt/dsf/debug/ui/viewmodel/breakpoints/BreakpointOrganizerVMNode.java --- /dev/null 1 Jan 1970 00:00:00 -0000 +++ src/org/eclipse/cdt/dsf/debug/ui/viewmodel/breakpoints/BreakpointOrganizerVMNode.java 1 Jan 1970 00:00:00 -0000 @@ -0,0 +1,407 @@ +/******************************************************************************* + * Copyright (c) 2008 Wind River Systems and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * Wind River Systems - initial API and implementation + *******************************************************************************/ +package org.eclipse.cdt.dsf.debug.ui.viewmodel.breakpoints; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashSet; +import java.util.LinkedHashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import org.eclipse.cdt.dsf.concurrent.DataRequestMonitor; +import org.eclipse.cdt.dsf.concurrent.IDsfStatusConstants; +import org.eclipse.cdt.dsf.concurrent.ImmediateExecutor; +import org.eclipse.cdt.dsf.concurrent.RequestMonitor; +import org.eclipse.cdt.dsf.internal.ui.DsfUIPlugin; +import org.eclipse.cdt.dsf.ui.concurrent.ViewerCountingRequestMonitor; +import org.eclipse.cdt.dsf.ui.concurrent.ViewerDataRequestMonitor; +import org.eclipse.cdt.dsf.ui.viewmodel.AbstractVMNode; +import org.eclipse.cdt.dsf.ui.viewmodel.VMDelta; +import org.eclipse.cdt.dsf.ui.viewmodel.properties.IElementPropertiesProvider; +import org.eclipse.cdt.dsf.ui.viewmodel.properties.IPropertiesUpdate; +import org.eclipse.cdt.dsf.ui.viewmodel.properties.VMPropertiesUpdate; +import org.eclipse.cdt.dsf.ui.viewmodel.update.ICachingVMProvider; +import org.eclipse.core.runtime.CoreException; +import org.eclipse.core.runtime.IAdaptable; +import org.eclipse.core.runtime.IStatus; +import org.eclipse.core.runtime.Status; +import org.eclipse.debug.core.DebugPlugin; +import org.eclipse.debug.core.model.IBreakpoint; +import org.eclipse.debug.internal.ui.CompositeDebugImageDescriptor; +import org.eclipse.debug.internal.ui.DebugUIPlugin; +import org.eclipse.debug.internal.ui.viewers.model.provisional.ICheckUpdate; +import org.eclipse.debug.internal.ui.viewers.model.provisional.IChildrenCountUpdate; +import org.eclipse.debug.internal.ui.viewers.model.provisional.IChildrenUpdate; +import org.eclipse.debug.internal.ui.viewers.model.provisional.IElementLabelProvider; +import org.eclipse.debug.internal.ui.viewers.model.provisional.IHasChildrenUpdate; +import org.eclipse.debug.internal.ui.viewers.model.provisional.ILabelUpdate; +import org.eclipse.debug.internal.ui.viewers.model.provisional.IModelDelta; +import org.eclipse.debug.internal.ui.viewers.model.provisional.IPresentationContext; +import org.eclipse.debug.internal.ui.viewers.model.provisional.IViewerUpdate; +import org.eclipse.debug.internal.ui.views.DebugModelPresentationContext; +import org.eclipse.debug.internal.ui.views.breakpoints.IBreakpointOrganizer; +import org.eclipse.debug.ui.IDebugModelPresentation; +import org.eclipse.jface.resource.ImageDescriptor; +import org.eclipse.jface.viewers.TreePath; +import org.eclipse.swt.graphics.Image; +import org.eclipse.ui.model.IWorkbenchAdapter; + +/** + * + * + * @since 2.1 + */ +public class BreakpointOrganizerVMNode extends AbstractVMNode implements IElementPropertiesProvider, IElementLabelProvider { + + public static final String PROP_CATEGORY_BREAKPOINTS = "categoryBreakpoints"; //$NON-NLS-1$ + + public static final Set SET_PROP_CATEGORY_BREAKPOINTS = new HashSet(2); + + static { + SET_PROP_CATEGORY_BREAKPOINTS.add(PROP_CATEGORY_BREAKPOINTS); + } + + private class OtherCategoryLabelProvider implements IElementLabelProvider { + public void update(ILabelUpdate[] updates) { + for (ILabelUpdate update : updates) { + update.setLabel(fOrganizer.getOthersLabel(), 0); + //update.setImageDescriptor(DebugPluginImages.getImageDescriptor(IDebugUIConstants.IMG_VIEW_BREAKPOINTS), 0); + update.setImageDescriptor(fOrganizer.getImageDescriptor(), 0); + } + } + } + + private final IBreakpointOrganizer fOrganizer; + private final IElementLabelProvider fOtherCategoryLabelProvider = new OtherCategoryLabelProvider(); + + public BreakpointOrganizerVMNode(ICachingVMProvider provider, IBreakpointOrganizer organizer) { + super(provider); + fOrganizer = organizer; + } + + public IBreakpointOrganizer getBreakpointOrganizer() { + return fOrganizer; + } + + public void update(final IHasChildrenUpdate[] updates) { + for (IHasChildrenUpdate update : updates) { + if (!checkUpdate(update)) continue; + update.setStatus(new Status(IStatus.ERROR, DsfUIPlugin.PLUGIN_ID, IDsfStatusConstants.NOT_SUPPORTED, "Not implemented, clients should call to update all children instead.", null)); //$NON-NLS-1$ + update.done(); + } + } + + public void update(final IChildrenCountUpdate[] updates) { + for (IChildrenCountUpdate update : updates) { + if (!checkUpdate(update)) continue; + update.setStatus(new Status(IStatus.ERROR, DsfUIPlugin.PLUGIN_ID, IDsfStatusConstants.NOT_SUPPORTED, "Not implemented, clients should call to update all children instead.", null)); //$NON-NLS-1$ + update.done(); + } + } + + public void update(IChildrenUpdate[] updates) { + for (IChildrenUpdate update : updates) { + if (!checkUpdate(update)) continue; + doUpdate(update); + } + } + + private void doUpdate(final IChildrenUpdate update) { + getNestingCategoryBreakpoints( + update.getElementPath(), + update.getViewerInput(), + update.getPresentationContext(), + new ViewerDataRequestMonitor>(ImmediateExecutor.getInstance(), update) { + @Override + protected void handleSuccess() { + final Set categoriesSet = new LinkedHashSet(); + + boolean otherBPs = false; + for (IBreakpoint bp : getData()) { + final IAdaptable[] bpCategories = fOrganizer.getCategories(bp); + if (bpCategories == null || bpCategories.length == 0) { + otherBPs = true; + } else { + for (IAdaptable category : bpCategories) { + categoriesSet.add(category); + } + } + } + + final IAdaptable[] independentCategories = fOrganizer.getCategories(); + if (independentCategories != null) { + for (IAdaptable category : independentCategories) { + categoriesSet.add(category); + } + } + + if (otherBPs) { + categoriesSet.add(null); + } + IAdaptable[] categories = categoriesSet.toArray(new IAdaptable[categoriesSet.size()]); + + int updateIdx = update.getOffset() != -1 ? update.getOffset() : 0; + int endIdx = updateIdx + (update.getLength() != -1 ? update.getLength() : (categories.length)); + while (updateIdx < endIdx && updateIdx < categoriesSet.size()) { + update.setChild( createVMContext(categories[updateIdx]) , updateIdx); + updateIdx++; + } + update.done(); + + } + }); + } + + private void fillUpdateWithBreakpointOrganizerVMContexts(IChildrenUpdate update, BreakpointOrganizerVMContext[] vmcs) { + int updateIdx = update.getOffset() != -1 ? update.getOffset() : 0; + int endIdx = updateIdx + (update.getLength() != -1 ? update.getLength() : vmcs.length); + while (updateIdx < endIdx && updateIdx < vmcs.length) { + update.setChild(vmcs[updateIdx], updateIdx); + updateIdx++; + } + update.done(); + } + + public void update(IPropertiesUpdate[] updates) { + for (IPropertiesUpdate update : updates) { + if (!checkUpdate(update)) continue; + doUpdate(update); + } + } + +// Dead end +// public void update(ILabelUpdate[] updates) { +// boolean first = true; +// IElementLabelProvider firstProvider = null; +// boolean allProvidersSame = true; +// for (ILabelUpdate update : updates) { +// IAdaptable category = getCategory(update); +// IElementLabelProvider provider = null; +// if (category != null) { +// provider = (IElementLabelProvider)category.getAdapter(IElementLabelProvider.class); +// } else { +// provider = fOtherCategoryLabelProvider; +// } +// if (first) { +// first = false; +// firstProvider = provider; +// } else if (!provider.equals(firstProvider)) { +// allProvidersSame = false; +// break; +// } +// } +// if (allProvidersSame) { +// if (firstProvider != null) {// could occur only if updates.length == 0 +// firstProvider.update(updates); +// } +// return; +// } +// +// Map> updatesMap = new HashMap>(4); +// for (ILabelUpdate update : updates) { +// IAdaptable category = getCategory(update); +// IElementLabelProvider provider = null; +// if (category != null) { +// provider = (IElementLabelProvider)category.getAdapter(IElementLabelProvider.class); +// } +// List updatesList = updatesMap.get(category); +// if (updatesList == null) { +// updatesList = new ArrayList(updates.length < 4 ? updates.length - 1 : 4); +// updatesMap.put(provider, updatesList); +// } +// updatesList.add(update); +// } +// for (Map.Entry> entry : updatesMap.entrySet()) { +// entry.getKey().update( entry.getValue().toArray(new ILabelUpdate[entry.getValue().size()]) ); +// } +// } + + public void update(ILabelUpdate[] updates) { + IPropertiesUpdate[] propertiesUpdates = new IPropertiesUpdate[updates.length]; + for (int i = 0; i < updates.length; i++) { + final ILabelUpdate update = updates[i]; + if (!checkUpdate(update)) continue; + + if ( !(update.getElement() instanceof BreakpointOrganizerVMContext) ) { + handleFailedUpdate(update); + return; + } + IAdaptable category = ((BreakpointOrganizerVMContext)update.getElement()).getCategory(); + String label = null; + ImageDescriptor desc = null; + if (category != null) { + IWorkbenchAdapter workbenchAdapter = (IWorkbenchAdapter)category.getAdapter(IWorkbenchAdapter.class); + if (workbenchAdapter != null) { + label = workbenchAdapter.getLabel(category); + desc = workbenchAdapter.getImageDescriptor(category); + } + } else { + label = fOrganizer.getOthersLabel(); + //update.setImageDescriptor(DebugPluginImages.getImageDescriptor(IDebugUIConstants.IMG_VIEW_BREAKPOINTS), 0); + desc = fOrganizer.getImageDescriptor(); + } + + if (!DebugPlugin.getDefault().getBreakpointManager().isEnabled()) { + Image image = DebugUIPlugin.getImageDescriptorRegistry().get(desc); + desc = new CompositeDebugImageDescriptor(image, CompositeDebugImageDescriptor.SKIP_BREAKPOINT); + } + + if (label != null) { + update.setLabel(label, 0); + } + update.setImageDescriptor(desc, 0); + + propertiesUpdates[i] = new VMPropertiesUpdate( + SET_PROP_CATEGORY_BREAKPOINTS, update, + new ViewerDataRequestMonitor>(ImmediateExecutor.getInstance(), update) { + @Override + protected void handleSuccess() { + List bps = (List)getData().get(PROP_CATEGORY_BREAKPOINTS); + boolean checked = bps.size() == 0; + boolean hasDisabled = false; + for (IBreakpoint bp : bps) { + try { + if (bp.isEnabled()) { + checked = true; + } else { + hasDisabled = true; + } + } catch (CoreException e) {} + } + if (update instanceof ICheckUpdate) { + ((ICheckUpdate) update).setChecked(checked, checked && hasDisabled); + } + update.done(); + } + }); + } + + ((ICachingVMProvider)getVMProvider()).update(propertiesUpdates); + } + + private IAdaptable getCategory(IViewerUpdate update) { + if ( update.getElement() instanceof BreakpointOrganizerVMContext) { + return ((BreakpointOrganizerVMContext)update.getElement()).getCategory(); + } + return null; + } + + private IDebugModelPresentation getDebugModelPresentation() { + DebugModelPresentationContext debugContext = + (DebugModelPresentationContext) getVMProvider().getPresentationContext(); + return debugContext.getModelPresentation(); + } + + private void doUpdate(IPropertiesUpdate update) { + ViewerCountingRequestMonitor countingRm = new ViewerCountingRequestMonitor(ImmediateExecutor.getInstance(), update); + int count = 0; + + if (update.getProperties().contains(PROP_CATEGORY_BREAKPOINTS)) { + fillCategoryBreakpoints(update, new RequestMonitor(ImmediateExecutor.getInstance(), countingRm)); + } + countingRm.setDoneCount(count); + } + + private void fillCategoryBreakpoints(final IPropertiesUpdate update, final RequestMonitor rm) { + if (!(update.getElement() instanceof BreakpointOrganizerVMContext)) { + rm.setStatus(new Status(IStatus.ERROR, DsfUIPlugin.PLUGIN_ID, IDsfStatusConstants.INVALID_HANDLE, "Update is not for a breakpoint organizer", null)); //$NON-NLS-1$ + rm.done(); + return; + } + + getNestingCategoryBreakpoints( + update.getElementPath().getParentPath(), + update.getViewerInput(), + update.getPresentationContext(), + new DataRequestMonitor>(ImmediateExecutor.getInstance(), rm) { + @Override + protected void handleSuccess() { + BreakpointOrganizerVMContext vmc = (BreakpointOrganizerVMContext)update.getElement(); + List parentBreakpoints = getData(); + IAdaptable vmcCategory = vmc.getCategory(); + List categoryBPs = new ArrayList(1); + for (IBreakpoint bp : parentBreakpoints) { + IAdaptable[] bpCategories = fOrganizer.getCategories(bp); + if (bpCategories == null || bpCategories.length == 0) { + // BP is in the "Other" category. Add it if the category + // from the update is null. + if (vmcCategory == null) { + categoryBPs.add(bp); + } + } else { + // Check if any of the BP categories match the update category. + for (IAdaptable bpCategory : bpCategories) { + if (bpCategory.equals(vmcCategory)) { + categoryBPs.add(bp); + break; + } + } + } + } + update.setProperty(PROP_CATEGORY_BREAKPOINTS, categoryBPs); + rm.done(); + } + }); + } + + static void getNestingCategoryBreakpoints(TreePath path, Object viewerInput, IPresentationContext presentationContext, final DataRequestMonitor> rm) { + BreakpointOrganizerVMContext nestingOrganizerVmc = null; + while (path.getSegmentCount() > 0) { + if (path.getLastSegment() instanceof BreakpointOrganizerVMContext) { + nestingOrganizerVmc = (BreakpointOrganizerVMContext)path.getLastSegment(); + break; + } + path = path.getParentPath(); + } + if (nestingOrganizerVmc == null) { + rm.setData(Arrays.asList(DebugPlugin.getDefault().getBreakpointManager().getBreakpoints())); + rm.done(); + return; + } else { + IElementPropertiesProvider propertiesProvider = (IElementPropertiesProvider) + nestingOrganizerVmc.getAdapter(IElementPropertiesProvider.class); + propertiesProvider.update(new IPropertiesUpdate[] { + new VMPropertiesUpdate( + SET_PROP_CATEGORY_BREAKPOINTS, path, viewerInput, presentationContext, + new DataRequestMonitor>(ImmediateExecutor.getInstance(), rm) { + @Override + protected void handleSuccess() { + assert getData().get(PROP_CATEGORY_BREAKPOINTS) != null; + rm.setData((List)getData().get(PROP_CATEGORY_BREAKPOINTS)); + rm.done(); + } + }) + }); + } + } + + private BreakpointOrganizerVMContext createVMContext(IAdaptable category) { + return new BreakpointOrganizerVMContext(this, category); + } + + public void buildDelta(Object event, VMDelta parent, int nodeOffset, RequestMonitor requestMonitor) { + if (event instanceof BreakpointsChangedEvent) { + parent.setFlags(parent.getFlags() | IModelDelta.CONTENT); + } + requestMonitor.done(); + } + + public int getDeltaFlags(Object event) { + if (event instanceof BreakpointsChangedEvent) { + return IModelDelta.CONTENT; + } + return 0; + } + + +} Index: src/org/eclipse/cdt/dsf/debug/ui/viewmodel/breakpoints/BreakpointOrganizerVMContext.java =================================================================== RCS file: src/org/eclipse/cdt/dsf/debug/ui/viewmodel/breakpoints/BreakpointOrganizerVMContext.java diff -N src/org/eclipse/cdt/dsf/debug/ui/viewmodel/breakpoints/BreakpointOrganizerVMContext.java --- /dev/null 1 Jan 1970 00:00:00 -0000 +++ src/org/eclipse/cdt/dsf/debug/ui/viewmodel/breakpoints/BreakpointOrganizerVMContext.java 1 Jan 1970 00:00:00 -0000 @@ -0,0 +1,56 @@ +/******************************************************************************* + * Copyright (c) 2008 Wind River Systems and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * Wind River Systems - initial API and implementation + *******************************************************************************/ +package org.eclipse.cdt.dsf.debug.ui.viewmodel.breakpoints; + +import org.eclipse.cdt.dsf.ui.viewmodel.AbstractVMContext; +import org.eclipse.core.runtime.IAdaptable; +import org.eclipse.debug.internal.ui.views.breakpoints.IBreakpointOrganizer; + +/** + * + * + * @since 2.1 + */ +public class BreakpointOrganizerVMContext extends AbstractVMContext { + + private final IAdaptable fCategory; + + BreakpointOrganizerVMContext(BreakpointOrganizerVMNode vmNode, IAdaptable category) { + super(vmNode); + fCategory = category; + } + + @Override + public boolean equals(Object obj) { + return obj instanceof BreakpointOrganizerVMContext && + getBreakpointOrganizer().equals( ((BreakpointOrganizerVMContext)obj).getBreakpointOrganizer() ) && + ( (fCategory == null && ((BreakpointOrganizerVMContext)obj).fCategory == null) || + fCategory != null && (fCategory.equals(((BreakpointOrganizerVMContext)obj).fCategory)) ); + } + + @Override + public int hashCode() { + return getBreakpointOrganizer().hashCode() + (fCategory != null ? fCategory.hashCode() : 0); + } + + public BreakpointOrganizerVMNode getBreakpointOrganizerVMNode() { + return (BreakpointOrganizerVMNode)getVMNode(); + } + + public IBreakpointOrganizer getBreakpointOrganizer() { + return getBreakpointOrganizerVMNode().getBreakpointOrganizer(); + } + + public IAdaptable getCategory() { + return fCategory; + } + +} Index: src/org/eclipse/cdt/dsf/debug/ui/viewmodel/breakpoints/BreakpiontsVMProvider.java =================================================================== RCS file: src/org/eclipse/cdt/dsf/debug/ui/viewmodel/breakpoints/BreakpiontsVMProvider.java diff -N src/org/eclipse/cdt/dsf/debug/ui/viewmodel/breakpoints/BreakpiontsVMProvider.java --- /dev/null 1 Jan 1970 00:00:00 -0000 +++ src/org/eclipse/cdt/dsf/debug/ui/viewmodel/breakpoints/BreakpiontsVMProvider.java 1 Jan 1970 00:00:00 -0000 @@ -0,0 +1,152 @@ +/******************************************************************************* + * Copyright (c) 2006, 2008 Wind River Systems and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * Wind River Systems - initial API and implementation + *******************************************************************************/ +package org.eclipse.cdt.dsf.debug.ui.viewmodel.breakpoints; + +import org.eclipse.cdt.dsf.concurrent.DsfRunnable; +import org.eclipse.cdt.dsf.debug.service.IRunControl.ISuspendedDMEvent; +import org.eclipse.cdt.dsf.debug.ui.viewmodel.expression.ExpressionColumnPresentation; +import org.eclipse.cdt.dsf.debug.ui.viewmodel.expression.IExpressionVMNode; +import org.eclipse.cdt.dsf.ui.viewmodel.AbstractVMAdapter; +import org.eclipse.cdt.dsf.ui.viewmodel.IRootVMNode; +import org.eclipse.cdt.dsf.ui.viewmodel.IVMNode; +import org.eclipse.cdt.dsf.ui.viewmodel.datamodel.RootDMVMNode; +import org.eclipse.cdt.dsf.ui.viewmodel.update.AbstractCachingVMProvider; +import org.eclipse.core.resources.IMarkerDelta; +import org.eclipse.debug.core.DebugPlugin; +import org.eclipse.debug.core.IBreakpointsListener; +import org.eclipse.debug.core.model.IBreakpoint; +import org.eclipse.debug.internal.ui.viewers.model.provisional.IColumnPresentation; +import org.eclipse.debug.internal.ui.viewers.model.provisional.IPresentationContext; +import org.eclipse.debug.internal.ui.views.breakpoints.FlexBreakpointsView; +import org.eclipse.debug.internal.ui.views.breakpoints.IBreakpointOrganizer; +import org.eclipse.jface.util.IPropertyChangeListener; +import org.eclipse.jface.util.PropertyChangeEvent; + +/** + * The expression provider is used to populate the contents of the expressions + * view. The node hierarchy in this view is a little different than in a typical + * provider: the expression manager node should be registered as the single child + * of the root node and no nodes should be registered as children of expression node. + * Instead the top level expression nodes should be registered with a call to + * {@link #setExpressionNodes(IExpressionVMNode[])}. And each expression node can + * have its own sub-hierarchy of elements as needed. However all nodes configured + * with this provider (with the exception of the root and the expression manager) + * should implement {@link IExpressionVMNode}. + * + * @since 2.1 + */ +@SuppressWarnings("restriction") +public class BreakpiontsVMProvider extends AbstractCachingVMProvider +{ + private IPropertyChangeListener fPresentationContextListener = new IPropertyChangeListener() { + public void propertyChange(PropertyChangeEvent event) { + + if (event.getProperty().equals(FlexBreakpointsView.BREAKPOINT_ORGANIZERS)) { + clearNodes(); + configureLayout(); + refresh(); + } else { + handleEvent(event); + } + } + }; + + private IBreakpointsListener fBreakpointsListener = new IBreakpointsListener() { + public void breakpointsRemoved(IBreakpoint[] breakpoints, IMarkerDelta[] deltas) { + handleEventInExecThread(new BreakpointsChangedEvent(BreakpointsChangedEvent.Type.REMOVED, breakpoints)); + } + + public void breakpointsChanged(IBreakpoint[] breakpoints, IMarkerDelta[] deltas) { + handleEventInExecThread(new BreakpointsChangedEvent(BreakpointsChangedEvent.Type.CHANGED, breakpoints)); + } + + public void breakpointsAdded(IBreakpoint[] breakpoints) { + handleEventInExecThread(new BreakpointsChangedEvent(BreakpointsChangedEvent.Type.ADDED, breakpoints)); + } + + private void handleEventInExecThread(final BreakpointsChangedEvent event) { + getExecutor().execute(new DsfRunnable() { + public void run() { + handleEvent(event); + } + }); + } + }; + + public BreakpiontsVMProvider(AbstractVMAdapter adapter, IPresentationContext context) { + super(adapter, context); + + context.addPropertyChangeListener(fPresentationContextListener); + DebugPlugin.getDefault().getBreakpointManager().addBreakpointListener(fBreakpointsListener); + + // TODO: synchronize on executor thread. + configureLayout(); + } + + + /** + * Configures the nodes of this provider. This method may be over-ridden by + * sub classes to create an alternate configuration in this provider. + */ + protected void configureLayout() { + /* + * Create the top level node which provides the anchor starting point. + */ + IRootVMNode rootNode = new RootDMVMNode(this); + + IBreakpointOrganizer[] organizers = (IBreakpointOrganizer[]) + getPresentationContext().getProperty(FlexBreakpointsView.BREAKPOINT_ORGANIZERS); + + IVMNode parentNode = rootNode; + if (organizers != null) { + for (IBreakpointOrganizer organizer : organizers) { + IVMNode organizerNode = new BreakpointOrganizerVMNode(this, organizer); + addChildNodes(parentNode, new IVMNode[] {organizerNode}); + parentNode = organizerNode; + } + } + + IVMNode bpsNode = new BreakpointVMNode(this); + addChildNodes(parentNode, new IVMNode[] {bpsNode}); + + /* + * Let the work know which is the top level node. + */ + setRootNode(rootNode); + } + + + @Override + public void dispose() { + getPresentationContext().removePropertyChangeListener(fPresentationContextListener); + DebugPlugin.getDefault().getBreakpointManager().removeBreakpointListener(fBreakpointsListener); + super.dispose(); + } + + @Override + public IColumnPresentation createColumnPresentation(IPresentationContext context, Object element) { + return new ExpressionColumnPresentation(); + } + + @Override + public String getColumnPresentationId(IPresentationContext context, Object element) { + return ExpressionColumnPresentation.ID; + } + + @Override + protected boolean canSkipHandlingEvent(Object newEvent, Object eventToSkip) { + // To optimize the performance of the view when stepping rapidly, skip all + // other events when a suspended event is received, including older suspended + // events. + return newEvent instanceof ISuspendedDMEvent; + } + +}