| /******************************************************************************* |
| * Copyright (c) 2006, 2016 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.ui.viewmodel; |
| |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.LinkedList; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.concurrent.Executor; |
| import java.util.concurrent.RejectedExecutionException; |
| |
| import org.eclipse.cdt.dsf.concurrent.CountingRequestMonitor; |
| import org.eclipse.cdt.dsf.concurrent.DataRequestMonitor; |
| import org.eclipse.cdt.dsf.concurrent.IDsfStatusConstants; |
| import org.eclipse.cdt.dsf.concurrent.RequestMonitor; |
| import org.eclipse.cdt.dsf.internal.DsfPlugin; |
| import org.eclipse.cdt.dsf.internal.LoggingUtils; |
| import org.eclipse.cdt.dsf.internal.ui.DsfUIPlugin; |
| import org.eclipse.cdt.dsf.ui.concurrent.SimpleDisplayExecutor; |
| import org.eclipse.cdt.dsf.ui.concurrent.ViewerDataRequestMonitor; |
| import org.eclipse.cdt.dsf.ui.viewmodel.update.UserEditEvent; |
| import org.eclipse.core.runtime.Platform; |
| 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.IColumnPresentation; |
| import org.eclipse.debug.internal.ui.viewers.model.provisional.IColumnPresentationFactory; |
| import org.eclipse.debug.internal.ui.viewers.model.provisional.IElementContentProvider; |
| import org.eclipse.debug.internal.ui.viewers.model.provisional.IHasChildrenUpdate; |
| import org.eclipse.debug.internal.ui.viewers.model.provisional.IModelDelta; |
| import org.eclipse.debug.internal.ui.viewers.model.provisional.IModelProxy; |
| import org.eclipse.debug.internal.ui.viewers.model.provisional.IPresentationContext; |
| import org.eclipse.debug.internal.ui.viewers.model.provisional.IViewerInputProvider; |
| import org.eclipse.debug.internal.ui.viewers.model.provisional.IViewerInputUpdate; |
| import org.eclipse.swt.widgets.Display; |
| |
| /** |
| * View model provider implements the asynchronous view model functionality for |
| * a single view. This provider is just a holder which further delegates the |
| * model provider functionality to the view model nodes that need |
| * to be configured with each provider. |
| * |
| * <p/> |
| * The view model provider, often does not provide the model for the entire |
| * view. Rather, it needs to be able to plug in at any level in the viewer's |
| * content model and provide data for a sub-tree. |
| * |
| * <p/> |
| * Clients are intended to extend this class. |
| * |
| * @see IModelProxy |
| * @see IVMNode |
| * |
| * @since 1.0 |
| */ |
| abstract public class AbstractVMProvider implements IVMProvider, IVMEventListener |
| { |
| // debug flags |
| /** @since 1.1 */ |
| public static String DEBUG_PRESENTATION_ID = null; |
| |
| /** @since 1.1 */ |
| public static boolean DEBUG_CONTENT_PROVIDER = false; |
| |
| /** @since 1.1 */ |
| public static boolean DEBUG_DELTA = false; |
| |
| static { |
| DEBUG_PRESENTATION_ID = Platform.getDebugOption("org.eclipse.cdt.dsf.ui/debug/vm/presentationId"); //$NON-NLS-1$ |
| if (!DsfUIPlugin.DEBUG || "".equals(DEBUG_PRESENTATION_ID)) { //$NON-NLS-1$ |
| DEBUG_PRESENTATION_ID = null; |
| } |
| DEBUG_CONTENT_PROVIDER = DsfUIPlugin.DEBUG && Boolean.parseBoolean( |
| Platform.getDebugOption("org.eclipse.cdt.dsf.ui/debug/vm/contentProvider")); //$NON-NLS-1$ |
| |
| DEBUG_DELTA = DsfUIPlugin.DEBUG && Boolean.parseBoolean( |
| Platform.getDebugOption("org.eclipse.cdt.dsf.ui/debug/vm/delta")); //$NON-NLS-1$ |
| } |
| |
| /** Reference to the VM adapter that owns this provider */ |
| private final AbstractVMAdapter fVMAdapter; |
| |
| /** The presentation context that this provider is associated with */ |
| private final IPresentationContext fPresentationContext; |
| |
| /** |
| * The executor that this VM provider operates in. This executor will be |
| * initialized properly when we can access the display from the |
| * IPresentationContext object (bug 213629). For now utilize the |
| * assumption that there is only one display. |
| */ |
| private final Executor fExecutor = SimpleDisplayExecutor.getSimpleDisplayExecutor(Display.getDefault()); |
| |
| /** |
| * The element content provider implementation that this provider delegates to. |
| * Sub-classes may override the content strategy used for custom functionality. |
| */ |
| private final IElementContentProvider fContentStrategy; |
| |
| /** |
| * The list of active model proxies in this provider. A new model |
| * proxy is created when a viewer has a new input element |
| * (see {@link #createModelProxy(Object, IPresentationContext)}). |
| * Typically there will be only one active model proxy in a given |
| * provider. However, if a view model provider fills only a sub-tree |
| * in a viewer, and there are several sub-trees active in the same viewer |
| * at the same time, each of these sub-trees will have it's own model |
| * proxy. |
| */ |
| private List<IVMModelProxy> fActiveModelProxies = new LinkedList<IVMModelProxy>(); |
| |
| /** |
| * Convenience constant. |
| */ |
| private static final IVMNode[] EMPTY_NODES_ARRAY = new IVMNode[0]; |
| |
| |
| /** |
| * The mapping of parent to child nodes. |
| */ |
| private Map<IVMNode,IVMNode[]> fChildNodesMap = |
| new HashMap<IVMNode,IVMNode[]>(); |
| |
| /** |
| * Cached array of all the configured view model nodes. It is generated |
| * based on the child nodes map. |
| */ |
| private IVMNode[] fNodesListCache = null; |
| |
| /** |
| * Flag indicating that the provider is disposed. |
| */ |
| private boolean fDisposed = false; |
| |
| /** |
| * The root node for this model provider. The root layout node could be |
| * null when first created, to allow sub-classes to properly configure the |
| * root node in the sub-class constructor. |
| */ |
| private IRootVMNode fRootNode; |
| |
| private class EventInfo { |
| EventInfo(Object event, RequestMonitor rm) { |
| fEvent = event; |
| fClientRm = rm; |
| } |
| Object fEvent; |
| RequestMonitor fClientRm; |
| } |
| |
| private class ModelProxyEventQueue { |
| /** The event actively being handled */ |
| EventInfo fCurrentEvent; |
| |
| /** |
| * The request monitor we created to handle fCurrentEvent. It is |
| * responsible for calling <code>done</code> on the client RM of that |
| * event. |
| */ |
| RequestMonitor fCurrentRm; |
| |
| /** The queue */ |
| List<EventInfo> fEventQueue = new LinkedList<EventInfo>(); |
| } |
| |
| private Map<IVMModelProxy, ModelProxyEventQueue> fProxyEventQueues = new HashMap<IVMModelProxy, ModelProxyEventQueue>(); |
| |
| /** |
| * Constructs the view model provider for given DSF session. The |
| * constructor is thread-safe to allow VM provider to be constructed |
| * synchronously when a call to getAdapter() is made on an element |
| * in a view. |
| */ |
| public AbstractVMProvider(AbstractVMAdapter adapter, IPresentationContext presentationContext) { |
| fVMAdapter = adapter; |
| fPresentationContext = presentationContext; |
| fContentStrategy = createContentStrategy(); |
| } |
| |
| @Override |
| public IPresentationContext getPresentationContext() { |
| return fPresentationContext; |
| } |
| |
| @Override |
| public AbstractVMAdapter getVMAdapter() { |
| return fVMAdapter; |
| } |
| |
| /** |
| * Creates the strategy class that will be used to implement the content |
| * provider interface of this view model provider. This method can be |
| * overridden by sub-classes to provider custom content provider strategy. |
| * <p/> |
| * Note this method can be called by the base class constructor, therefore |
| * it should not reference any fields initialized in the sub-class. |
| * |
| * @return New content provider implementation. |
| */ |
| protected IElementContentProvider createContentStrategy() { |
| return new DefaultVMContentProviderStrategy(this); |
| } |
| |
| /** |
| * Access method for the content provider strategy. |
| * |
| * @return Content provider implementation currently being used by this |
| * class. |
| */ |
| protected IElementContentProvider getContentStrategy() { |
| return fContentStrategy; |
| } |
| |
| /** |
| * Creates the strategy class that will be used to implement the content |
| * model proxy of this view model provider. It is normally called by |
| * {@link #createModelProxy(Object, IPresentationContext)} every time the |
| * input in the viewer is updated. This method can be overridden by |
| * sub-classes to provider custom model proxy strategy. |
| * |
| * @return New model proxy implementation. |
| */ |
| protected IVMModelProxy createModelProxyStrategy(Object rootElement) { |
| return new DefaultVMModelProxyStrategy(this, rootElement); |
| } |
| |
| /** |
| * Returns the list of active proxies in this provider. The returned |
| * list is not a copy and if a sub-class modifies this list, it will |
| * modify the current list of active proxies. This allows the |
| * sub-classes to change how the active proxies are managed and |
| * retained. |
| */ |
| protected List<IVMModelProxy> getActiveModelProxies() { |
| return fActiveModelProxies; |
| } |
| |
| /** |
| * Processes the given event in the given provider, sending model |
| * deltas if necessary. |
| */ |
| public void handleEvent(final Object event) { |
| handleEvent(event, null); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * @since 1.1 |
| */ |
| @Override |
| public void handleEvent(final Object event, RequestMonitor rm) { |
| if (DEBUG_DELTA && (DEBUG_PRESENTATION_ID == null || getPresentationContext().getId().equals(DEBUG_PRESENTATION_ID))) { |
| trace(event, null, null, EventHandlerAction.received); |
| } |
| |
| CountingRequestMonitor crm = new CountingRequestMonitor(getExecutor(), rm); |
| final List<IVMModelProxy> activeModelProxies= new ArrayList<IVMModelProxy>(getActiveModelProxies()); |
| crm.setDoneCount(activeModelProxies.size()); |
| |
| for (final IVMModelProxy proxyStrategy : activeModelProxies) { |
| // If the event is generated by the model proxy, only process it for the proxy that created it. |
| if ( event instanceof ModelProxyInstalledEvent && |
| !((ModelProxyInstalledEvent)event).getModelProxy().equals(proxyStrategy) ) |
| { |
| crm.done(); |
| continue; |
| } |
| |
| // Process the event only if there are potential delta flags that may be generated. |
| // Also, process the event if it is a result of the user modifying something |
| // so that the cache is properly updated. |
| if (proxyStrategy.isDeltaEvent(event) || event instanceof UserEditEvent) { |
| if (!fProxyEventQueues.containsKey(proxyStrategy)) { |
| fProxyEventQueues.put(proxyStrategy, new ModelProxyEventQueue()); |
| } |
| // If the event queue is empty, directly handle the new event. Otherwise queue it. |
| final ModelProxyEventQueue queue = fProxyEventQueues.get(proxyStrategy); |
| if (queue.fCurrentEvent != null) { |
| assert queue.fCurrentRm != null; |
| // Iterate through the events in the queue and check if |
| // they can be skipped. If they can be skipped, then just |
| // mark their RM as done. Stop iterating through the queue |
| // if an event that cannot be skipped is encountered. |
| while (!queue.fEventQueue.isEmpty()) { |
| EventInfo eventToSkipInfo = queue.fEventQueue.get(queue.fEventQueue.size() - 1); |
| |
| if (canSkipHandlingEvent(event, eventToSkipInfo.fEvent)) { |
| if (DEBUG_DELTA && (DEBUG_PRESENTATION_ID == null || getPresentationContext().getId().equals(DEBUG_PRESENTATION_ID))) { |
| trace(event, eventToSkipInfo.fEvent, proxyStrategy, EventHandlerAction.skipped); |
| } |
| queue.fEventQueue.remove(queue.fEventQueue.size() - 1); |
| eventToSkipInfo.fClientRm.done(); |
| } else { |
| break; |
| } |
| } |
| // If the queue is empty check if the current event |
| // being processed can be skipped. If so, cancel its |
| // processing |
| if (queue.fEventQueue.isEmpty() && canSkipHandlingEvent(event, queue.fCurrentEvent.fEvent)) { |
| if (DEBUG_DELTA && (DEBUG_PRESENTATION_ID == null || getPresentationContext().getId().equals(DEBUG_PRESENTATION_ID))) { |
| trace(event, queue.fCurrentEvent.fEvent, proxyStrategy, EventHandlerAction.canceled); |
| } |
| queue.fCurrentRm.cancel(); |
| } |
| |
| if (DEBUG_DELTA && (DEBUG_PRESENTATION_ID == null || getPresentationContext().getId().equals(DEBUG_PRESENTATION_ID))) { |
| trace(event, null, proxyStrategy, EventHandlerAction.queued); |
| } |
| queue.fEventQueue.add(new EventInfo(event, crm)); |
| } else { |
| doHandleEvent(queue, proxyStrategy, new EventInfo(event, crm)); |
| } |
| } else { |
| crm.done(); |
| } |
| } |
| |
| // Discard the event queues of proxies that have been removed |
| List<IVMModelProxy> activeProxies = getActiveModelProxies(); |
| for (Iterator<IVMModelProxy> itr = fProxyEventQueues.keySet().iterator(); itr.hasNext();) { |
| if (!activeProxies.contains(itr.next())) { |
| itr.remove(); |
| } |
| } |
| } |
| |
| private void doHandleEvent(final ModelProxyEventQueue queue, final IVMModelProxy proxyStrategy, final EventInfo eventInfo) { |
| // Do handle event is a sort of a recursive asynchronous method. It |
| // calls the asynchronous handleEvent() to process the event from the |
| // eventInfo argument. When handleEvent() completes, this method |
| // (doHandleEvent) checks whether there is any more events in the queue |
| // that should be handled. If there are, doHandleEvent calls itself |
| // to process the next event in the queue. |
| assert queue.fCurrentEvent == null && queue.fCurrentRm == null; |
| |
| queue.fCurrentEvent = eventInfo; |
| queue.fCurrentRm = new RequestMonitor(getExecutor(), eventInfo.fClientRm) { |
| @Override |
| protected void handleCompleted() { |
| eventInfo.fClientRm.done(); |
| queue.fCurrentEvent = null; |
| queue.fCurrentRm = null; |
| if (!queue.fEventQueue.isEmpty() && !fDisposed) { |
| EventInfo nextEventInfo = queue.fEventQueue.remove(0); |
| doHandleEvent(queue, proxyStrategy, nextEventInfo); |
| } |
| } |
| }; |
| handleEvent(proxyStrategy, eventInfo.fEvent, queue.fCurrentRm); |
| } |
| |
| /** |
| * Handles the given event for the given proxy strategy. |
| * <p> |
| * This method is called by the base {@link #handleEvent(Object)} |
| * implementation to handle the given event using the given model proxy. |
| * The default implementation of this method checks whether the given |
| * proxy is active and if the proxy is active, it is called to generate the |
| * delta which is then sent to the viewer. |
| * </p> |
| * @param proxyStrategy Model proxy strategy to use to process this event. |
| * @param event Event to process. |
| * @param rm Request monitor to call when processing the event is |
| * completed. |
| */ |
| protected void handleEvent(final IVMModelProxy proxyStrategy, final Object event, final RequestMonitor rm) { |
| if (!proxyStrategy.isDisposed()) { |
| if (DEBUG_DELTA && (DEBUG_PRESENTATION_ID == null || getPresentationContext().getId().equals(DEBUG_PRESENTATION_ID))) { |
| trace(event, null, proxyStrategy, EventHandlerAction.processing); |
| } |
| proxyStrategy.createDelta( |
| event, |
| new DataRequestMonitor<IModelDelta>(getExecutor(), rm) { |
| @Override |
| public void handleSuccess() { |
| proxyStrategy.fireModelChanged(getData()); |
| if (DEBUG_DELTA && (DEBUG_PRESENTATION_ID == null || getPresentationContext().getId().equals(DEBUG_PRESENTATION_ID))) { |
| trace(event, null, proxyStrategy, EventHandlerAction.firedDeltaFor); |
| } |
| rm.done(); |
| } |
| @Override public String toString() { |
| return "Result of a delta for event: '" + event.toString() + "' in VMP: '" + AbstractVMProvider.this + "'" + "\n" + getData().toString(); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ |
| } |
| }); |
| } else { |
| rm.done(); |
| } |
| } |
| |
| /** |
| * Determines whether processing of a given event can be skipped. This |
| * method is called when there are multiple events waiting to be processed |
| * by the provider. As new events are received from the model, they are |
| * compared with the events in the queue using this method, events at the |
| * end of the queue are tested for removal. If this method returns that a |
| * given event can be skipped in favor of the new event, the skipped event |
| * is removed from the queue. This process is repeated with the new event |
| * until an event which cannot be stopped is found or the queue goes empty. |
| * <p> |
| * This method may be overriden by specific view model provider |
| * implementations extending this abstract class. |
| * </p> |
| * @param newEvent New event that was received from the model. |
| * @param eventToSkip Event which is currently at the end of the queue. |
| * @return True if the event at the end of the queue can be skipped in |
| * favor of the new event. |
| */ |
| protected boolean canSkipHandlingEvent(Object newEvent, Object eventToSkip) { |
| return false; |
| } |
| |
| /** @since 1.1 */ |
| @Override |
| public boolean shouldWaitHandleEventToComplete() { |
| return false; |
| } |
| |
| @Override |
| public IRootVMNode getRootVMNode() { |
| return fRootNode; |
| } |
| |
| @Override |
| public IVMNode[] getAllVMNodes() { |
| if (fNodesListCache != null) { |
| return fNodesListCache; |
| } |
| List<IVMNode> list = new ArrayList<IVMNode>(); |
| for (IVMNode node : fChildNodesMap.keySet()) { |
| if (node != null) { |
| list.add(node); |
| } |
| } |
| fNodesListCache = list.toArray(new IVMNode[list.size()]);; |
| return fNodesListCache; |
| } |
| |
| @Override |
| public IVMNode[] getChildVMNodes(IVMNode node) { |
| IVMNode[] retVal = fChildNodesMap.get(node); |
| if (retVal != null) { |
| return retVal; |
| } |
| return EMPTY_NODES_ARRAY; |
| } |
| |
| /** |
| * Configures the given array of nodes as children of the given parent node. |
| * Sub-classes should call this method to define the hierarchy of nodes. |
| */ |
| protected void addChildNodes(IVMNode parentNode, IVMNode[] childNodes) { |
| // Add to the child nodes array. |
| IVMNode[] existingChildNodes = fChildNodesMap.get(parentNode); |
| if (existingChildNodes == null) { |
| fChildNodesMap.put(parentNode, childNodes); |
| } else { |
| IVMNode[] newNodes = new IVMNode[existingChildNodes.length + childNodes.length]; |
| System.arraycopy(existingChildNodes, 0, newNodes, 0, existingChildNodes.length); |
| System.arraycopy(childNodes, 0, newNodes, existingChildNodes.length, childNodes.length); |
| fChildNodesMap.put(parentNode, newNodes); |
| } |
| |
| // Make sure that each new expression node has an entry of its own. |
| for (IVMNode childNode : childNodes) { |
| addNode(childNode); |
| } |
| |
| fNodesListCache = null; |
| } |
| |
| /** |
| * Adds the given node to configured nodes, without creating any |
| * parent-child relationship for it. It is useful for providers which do have |
| * a strict tree hierarchy of nodes. |
| */ |
| protected void addNode(IVMNode node) { |
| if (!fChildNodesMap.containsKey(node)) { |
| fChildNodesMap.put(node, EMPTY_NODES_ARRAY); |
| } |
| } |
| |
| /** |
| * Clears all configured nodes, including the root node. This allows a |
| * subclass to reset and reconfigure its nodes. |
| */ |
| protected void clearNodes() { |
| clearNodes(true); |
| for (IVMNode node : fChildNodesMap.keySet()) { |
| node.dispose(); |
| } |
| fChildNodesMap.clear(); |
| fRootNode = null; |
| } |
| |
| /** |
| * Clears all configured nodes. This allows a subclass to reset and |
| * reconfigure its nodes. |
| * |
| * @param clearRootNode Flag indicating whether to also clear the root node. |
| * @since 2.1 |
| */ |
| protected void clearNodes(boolean clearRootNode) { |
| for (IVMNode node : fChildNodesMap.keySet()) { |
| if ( !clearRootNode || !node.equals(getRootVMNode()) ) { |
| node.dispose(); |
| } |
| } |
| fChildNodesMap.clear(); |
| if (clearRootNode) { |
| fRootNode = null; |
| } else { |
| fChildNodesMap.put(getRootVMNode(), EMPTY_NODES_ARRAY); |
| } |
| } |
| |
| /** |
| * Sets the root node for this provider. |
| */ |
| protected void setRootNode(IRootVMNode rootNode) { |
| fRootNode = rootNode; |
| } |
| |
| /** Called to dispose the provider. */ |
| @Override |
| public void dispose() { |
| clearNodes(); |
| fRootNode = null; |
| fDisposed = true; |
| } |
| |
| @Override |
| public void update(final IHasChildrenUpdate[] updates) { |
| fContentStrategy.update(updates); |
| } |
| |
| @Override |
| public void update(final IChildrenCountUpdate[] updates) { |
| fContentStrategy.update(updates); |
| } |
| |
| @Override |
| public void update(final IChildrenUpdate[] updates) { |
| fContentStrategy.update(updates); |
| } |
| |
| /** |
| * Calls the given view model node to perform the given updates. This method |
| * is called by view model provider and its helper classes instead of |
| * calling the IVMNode method directly, in order to allow additional |
| * processing of the update. For example the AbstractCachingVMProvider |
| * overrides this method to optionally return the results for an update from |
| * a cache. |
| * |
| * [node] represents the type of the child element, not of the parent. In |
| * other words, the update requests are asking if one or more model elements |
| * of a particular type (thread, e.g.) have children. But [node] does not |
| * represent that type. It represents the type of the potential children |
| * (frame, e.g.) |
| */ |
| @Override |
| public void updateNode(final IVMNode node, IHasChildrenUpdate[] updates) { |
| IHasChildrenUpdate[] updateProxies = new IHasChildrenUpdate[updates.length]; |
| for (int i = 0; i < updates.length; i++) { |
| final IHasChildrenUpdate update = updates[i]; |
| if (DEBUG_CONTENT_PROVIDER && (DEBUG_PRESENTATION_ID == null || getPresentationContext().getId().equals(DEBUG_PRESENTATION_ID))) { |
| DsfUIPlugin.debug("updateNodeHasChildren(node = " + node + ", update = " + update + ")"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ |
| } |
| updateProxies[i] = new VMHasChildrenUpdate( |
| update, |
| new ViewerDataRequestMonitor<Boolean>(getExecutor(), update) { |
| @Override |
| protected void handleSuccess() { |
| update.setHasChilren(getData()); |
| update.done(); |
| } |
| |
| @Override |
| protected void handleErrorOrWarning() { |
| if (getStatus().getCode() == IDsfStatusConstants.NOT_SUPPORTED) { |
| if (DEBUG_CONTENT_PROVIDER && (DEBUG_PRESENTATION_ID == null || getPresentationContext().getId().equals(DEBUG_PRESENTATION_ID))) { |
| DsfUIPlugin.debug("not-supported:updateNodeHasChildren(node = " + node + ", update = " + update + ")"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ |
| } |
| updateNode( |
| node, |
| new VMChildrenUpdate( |
| update, -1, -1, |
| new ViewerDataRequestMonitor<List<Object>>(getExecutor(), update) { |
| @Override |
| protected void handleSuccess() { |
| update.setHasChilren( !getData().isEmpty() ); |
| update.done(); |
| } |
| }) |
| ); |
| |
| } else { |
| update.setStatus(getStatus()); |
| update.done(); |
| } |
| } |
| |
| }); |
| } |
| node.update(updateProxies); |
| } |
| |
| /** |
| * Calls the given view model node to perform the given updates. This |
| * method is called by view model provider and it's helper classes instead |
| * of calling the IVMNode method directly, in order to allow additional |
| * processing of the update. For example the AbstractCachingVMProvider |
| * overrides this method to optionally return the results for an update from |
| * a cache. |
| */ |
| @Override |
| public void updateNode(final IVMNode node, final IChildrenCountUpdate update) { |
| if (DEBUG_CONTENT_PROVIDER && (DEBUG_PRESENTATION_ID == null || getPresentationContext().getId().equals(DEBUG_PRESENTATION_ID))) { |
| DsfUIPlugin.debug("updateNodeChildCount(node = " + node + ", update = " + update + ")"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ |
| } |
| node.update(new IChildrenCountUpdate[] { |
| new VMChildrenCountUpdate( |
| update, |
| new ViewerDataRequestMonitor<Integer>(getExecutor(), update) { |
| @Override |
| protected void handleSuccess() { |
| update.setChildCount(getData()); |
| update.done(); |
| } |
| |
| @Override |
| protected void handleErrorOrWarning() { |
| if (getStatus().getCode() == IDsfStatusConstants.NOT_SUPPORTED) { |
| if (DEBUG_CONTENT_PROVIDER && (DEBUG_PRESENTATION_ID == null || getPresentationContext().getId().equals(DEBUG_PRESENTATION_ID))) { |
| DsfUIPlugin.debug("not-supported:updateNodeChildCount(node = " + node + ", update = " + update + ")"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ |
| } |
| updateNode( |
| node, |
| new VMChildrenUpdate( |
| update, -1, -1, |
| new ViewerDataRequestMonitor<List<Object>>(getExecutor(), update) { |
| @Override |
| protected void handleSuccess() { |
| update.setChildCount( getData().size() ); |
| update.done(); |
| } |
| }) |
| ); |
| } else { |
| super.handleErrorOrWarning(); |
| } |
| } |
| |
| }) |
| }); |
| } |
| |
| /** |
| * Calls the given view model node to perform the given updates. This |
| * method is called by view model provider and it's helper classes instead |
| * of calling the IVMNode method directly, in order to allow additional |
| * processing of the update. For example the AbstractCachingVMProvider |
| * overrides this method to optionally return the results for an update from |
| * a cache. |
| */ |
| @Override |
| public void updateNode(IVMNode node, IChildrenUpdate update) { |
| if (DEBUG_CONTENT_PROVIDER && (DEBUG_PRESENTATION_ID == null || getPresentationContext().getId().equals(DEBUG_PRESENTATION_ID))) { |
| DsfUIPlugin.debug("updateNodeChildren(node = " + node + ", update = " + update + ")"); //$NON-NLS-1$ //$NON-NLS-2$//$NON-NLS-3$ |
| } |
| node.update(new IChildrenUpdate[] { update }); |
| } |
| |
| |
| /** |
| * Returns whether this provider has been disposed. |
| */ |
| protected boolean isDisposed() { |
| return fDisposed; |
| } |
| |
| /** |
| * The abstract provider uses a the display-thread executor so that the |
| * provider will operate on the same thread as the viewer. This way no |
| * synchronization is necessary when the provider is called by the viewer. |
| * Also, the display thread is likely to be shut down long after any of the |
| * view models are disposed, so the users of this abstract provider do not |
| * need to worry about the executor throwing the {@link RejectedExecutionException} |
| * exception. |
| */ |
| @Override |
| public Executor getExecutor() { |
| return fExecutor; |
| } |
| |
| @Override |
| public IModelProxy createModelProxy(Object element, IPresentationContext context) { |
| |
| // Iterate through the current active proxies to try to find a proxy with the same |
| // element and re-use it if found. Only disposed proxies can be re-used because |
| // multiple viewers cannot use the same proxy. Also at this time purge other proxies |
| // that are no longer installed. |
| IVMModelProxy proxy = null; |
| for (Iterator<IVMModelProxy> itr = getActiveModelProxies().iterator(); itr.hasNext();) { |
| IVMModelProxy next = itr.next(); |
| if (next != null) { |
| if (next.getRootElement().equals(element) && next.isDisposed()) { |
| proxy = next; |
| } else if (next.isDisposed()) { |
| itr.remove(); |
| } |
| } |
| } |
| |
| if (proxy == null) { |
| proxy = createModelProxyStrategy(element); |
| getActiveModelProxies().add(proxy); |
| } else if (proxy.isDisposed()) { |
| // DSF is capable of re-using old proxies which were previously |
| // disposed. However, the viewer which installs a proxy using |
| // a background job to install the proxy calls |
| // IModelProxy.isDisposed(), to check whether the proxy was disposed |
| // before it could be installed. We need to clear the disposed flag |
| // of the re-used proxy here, otherwise the proxy will never get used. |
| // Calling init here will cause the init() method to be called twice |
| // so the IVMModelProxy needs to be prepared for that. |
| // See bug 241024. |
| proxy.init(context); |
| } |
| return proxy; |
| } |
| |
| /** |
| * Creates the column presentation for the given object. This method is meant |
| * to be overriden by deriving class to provide view-specific functionality. |
| * The default is to return null, meaning no columns. |
| * <p> |
| * The viewer only reads the column presentation for the root/input element of |
| * the tree/table, so the VMProvider must be configured to own the root element |
| * in the view in order for this setting to be effective. |
| * <p> |
| * Note: since the IColumnEditorFactory interface is synchronous, and since |
| * column info is fairly static, this method is thread-safe, and it will |
| * not be called on the executor thread. |
| * |
| * @see IColumnPresentationFactory#createColumnPresentation(IPresentationContext, Object) |
| */ |
| @Override |
| public IColumnPresentation createColumnPresentation(IPresentationContext context, Object element) { |
| return null; |
| } |
| |
| /** |
| * Returns the ID of the column presentation for the given object. This method |
| * is meant to be overriden by deriving class to provide view-specific |
| * functionality. The default is to return null, meaning no columns. |
| * <p> |
| * The viewer only reads the column presentation for the root/input element of |
| * the tree/table, so the VMProvider must be configured to own the root element |
| * in the view in order for this setting to be effective. |
| * <p> |
| * Note: since the IColumnEditorFactory interface is synchronous, and since |
| * column info is fairly static, this method is thread-safe, and it will |
| * not be called on the executor thread. |
| * |
| * @see IColumnEditorFactory#getColumnEditorId(IPresentationContext, Object) |
| */ |
| @Override |
| public String getColumnPresentationId(IPresentationContext context, Object element) { |
| return null; |
| } |
| |
| /** |
| * Calculates the proxy input object to be used for the given input in the given |
| * viewer. By default no proxy object is used an the given element is used |
| * as the input into the view. |
| * <p> |
| * Sub classes can override this method for view-specific behavior. |
| * |
| * @see IViewerInputProvider |
| */ |
| @Override |
| public void update(IViewerInputUpdate update) { |
| update.setInputElement(update.getElement()); |
| update.done(); |
| } |
| |
| /** |
| * Used for tracing event handling |
| */ |
| private enum EventHandlerAction { |
| received, |
| queued, |
| processing, |
| firedDeltaFor, |
| skipped, |
| canceled |
| } |
| |
| /** |
| * Trace that we've reached a particular phase of the handling of an event |
| * for a particular proxy. |
| * |
| * @param event |
| * the event being handled |
| * @param skippedOrCanceledEvent |
| * for a 'skip' or 'cancel' action, this is the event that is |
| * being dismissed. Otherwise null |
| * @param proxy |
| * the target proxy; n/a (null) for a 'received' action. |
| * @param action |
| * what phased of the event handling has been reached |
| */ |
| private void trace(Object event, Object skippedOrCanceledEvent, IVMModelProxy proxy, EventHandlerAction action) { |
| assert DEBUG_DELTA; |
| StringBuilder str = new StringBuilder(); |
| str.append(DsfPlugin.getDebugTime()); |
| str.append(' '); |
| if (action == EventHandlerAction.skipped || action == EventHandlerAction.canceled) { |
| str.append(LoggingUtils.toString(this)).append(' ').append(action).append(" event ").append(LoggingUtils.toString(skippedOrCanceledEvent)).append(" because of event ").append(LoggingUtils.toString(event)); //$NON-NLS-1$ //$NON-NLS-2$ |
| } |
| else { |
| str.append(LoggingUtils.toString(this)).append(' ').append(action).append(" event ").append(LoggingUtils.toString(event)); //$NON-NLS-1$ |
| } |
| |
| if (action != EventHandlerAction.received) { |
| str.append(" for proxy ").append(LoggingUtils.toString(proxy)).append(", whose root is ").append(LoggingUtils.toString(proxy.getRootElement())); //$NON-NLS-1$ //$NON-NLS-2$ |
| } |
| DsfUIPlugin.debug(str.toString()); |
| } |
| } |
