org.eclipse.cdt.dsf.debug.ui.viewmodel.breakpoints,

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

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

    }

}

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

 * 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<List<IBreakpoint>>(ImmediateExecutor.getInstance(), update) {

                @Override

                protected void handleSuccess() {

                    if (!checkUpdate(update)) return;

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

    }

}

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

 * 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<String> SET_PROP_CATEGORY_BREAKPOINTS = new HashSet<String>(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<List<IBreakpoint>>(ImmediateExecutor.getInstance(), update) {

                @Override

                protected void handleSuccess() {

                    final Set<IAdaptable> categoriesSet = new LinkedHashSet<IAdaptable>(); 

                    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<IElementLabelProvider, List<ILabelUpdate>> updatesMap = new HashMap<IElementLabelProvider, List<ILabelUpdate>>(4);

//        for (ILabelUpdate update : updates) {

//            IAdaptable category = getCategory(update);

//            IElementLabelProvider provider = null; 

//            if (category != null) {

//                provider = (IElementLabelProvider)category.getAdapter(IElementLabelProvider.class);

//            }

//            List<ILabelUpdate> updatesList = updatesMap.get(category);

//            if (updatesList == null) {

//                updatesList = new ArrayList<ILabelUpdate>(updates.length < 4 ? updates.length - 1 : 4);

//                updatesMap.put(provider, updatesList);

//            }

//            updatesList.add(update);

//        }

//        for (Map.Entry<IElementLabelProvider, List<ILabelUpdate>> 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<Map<String,Object>>(ImmediateExecutor.getInstance(), update) {

                    @Override

                    protected void handleSuccess() {

                        List<IBreakpoint> bps = (List<IBreakpoint>)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<List<IBreakpoint>>(ImmediateExecutor.getInstance(), rm) {

                @Override

                protected void handleSuccess() {

                    BreakpointOrganizerVMContext vmc = (BreakpointOrganizerVMContext)update.getElement();

                    List<IBreakpoint> parentBreakpoints = getData();

                    IAdaptable vmcCategory = vmc.getCategory();

                    List<IBreakpoint> categoryBPs = new ArrayList<IBreakpoint>(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<List<IBreakpoint>> 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<Map<String,Object>>(ImmediateExecutor.getInstance(), rm) {

                        @Override

                        protected void handleSuccess() {

                            assert getData().get(PROP_CATEGORY_BREAKPOINTS) != null;

                            rm.setData((List<IBreakpoint>)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;

    }

}

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

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

    }

}

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

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

    }

}