@Override protected void handleLateSuspend(DebugEvent suspend, DebugEvent resume) { IThread thread = queueSuspendedThread(suspend); if (suspend.isEvaluation() && suspend.getDetail() == DebugEvent.EVALUATION_IMPLICIT) { // late implicit evaluation - update thread and frame ModelDelta delta = buildRootDelta(); ModelDelta node = addPathToThread(delta, thread); node = node.addNode(thread, IModelDelta.STATE); try { IStackFrame frame = thread.getTopStackFrame(); if (frame != null) { node.addNode(frame, IModelDelta.STATE); fireDelta(delta); } } catch (DebugException e) { } } else { fireDeltaUpdatingSelectedFrame(thread, IModelDelta.STATE | IModelDelta.EXPAND, suspend); } }
private void fireDeltaAndClearTopFrame(IThread thread, int flags) { ModelDelta delta = buildRootDelta(); ModelDelta node = addPathToThread(delta, thread); node.addNode(thread, indexOf(thread), flags); synchronized (this) { fLastTopFrame.remove(thread); } fireDelta(delta); }
@Override protected void handleResume(DebugEvent event) { IThread thread = removeSuspendedThread(event); fireDeltaAndClearTopFrame(thread, IModelDelta.STATE | IModelDelta.CONTENT | IModelDelta.SELECT); thread = getNextSuspendedThread(); if (thread != null) { fireDeltaUpdatingSelectedFrame(thread, IModelDelta.NO_CHANGE | IModelDelta.REVEAL, event); } }
@Override protected void handleSuspendTimeout(DebugEvent event) { IThread thread = removeSuspendedThread(event); // don't collapse thread when waiting for long step or evaluation to complete fireDeltaUpdatingThread(thread, IModelDelta.STATE); }
private void fireDeltaUpdatingSelectedFrame(IThread thread, int flags, DebugEvent event) { ModelDelta delta = buildRootDelta(); ModelDelta node = addPathToThread(delta, thread); IStackFrame prev = null; synchronized (this) { int threadIndex = indexOf(thread); int childCount = childCount(thread); if (isEqual(frame, prev)) { if (frame == null) { if (thread.isSuspended()) { node.addNode(frame, indexOf(frame), IModelDelta.STATE | IModelDelta.SELECT, childCount(frame)); if (!isDisposed()) { fLastTopFrame.put(thread, frame); fireDelta(delta);
private void fireDeltaUpdatingThread(IThread thread, int flags) { ModelDelta delta = buildRootDelta(); ModelDelta node = addPathToThread(delta, thread); node = node.addNode(thread, flags); fireDelta(delta); }
/** * Returns the index of the given frame, relative to its parent in the view. * * @param frame stack frame * @return index of the frame, relative to its thread */ protected int indexOf(IStackFrame frame) { try { return indexOf(frame.getThread().getStackFrames(), frame); } catch (DebugException e) { return -1; } }
/** * Adds nodes into the delta up to but not including the given thread. * * @param delta root delta for the view (includes viewer input) * @param thread thread for which path is requested * @return */ protected ModelDelta addPathToThread(ModelDelta delta, IThread thread) { ILaunch launch = thread.getLaunch(); Object[] children = launch.getChildren(); delta = delta.addNode(launch, indexOf(getLaunchManager().getLaunches(), launch), IModelDelta.NO_CHANGE, children.length); IDebugTarget debugTarget = thread.getDebugTarget(); int numThreads = -1; try { numThreads = debugTarget.getThreads().length; } catch (DebugException e) { } return delta.addNode(debugTarget, indexOf(children, debugTarget), IModelDelta.NO_CHANGE, numThreads); }
@Override protected void handleChange(DebugEvent event) { IStackFrame frame = (IStackFrame) event.getSource(); ModelDelta root = fThreadHandler.buildRootDelta(); ModelDelta delta = fThreadHandler.addPathToThread(root, frame.getThread()); delta = delta.addNode(frame.getThread(), IModelDelta.NO_CHANGE); int flags = IModelDelta.NO_CHANGE; if (event.getDetail() == DebugEvent.CONTENT) { flags = flags | IModelDelta.CONTENT; } else if (event.getDetail() == DebugEvent.STATE) { flags = flags | IModelDelta.STATE; } delta = delta.addNode(frame, flags); fireDelta(root); }
return super.addPathToThread(delta, thread);
@Override protected void handleCreate(DebugEvent event) { fireDeltaAndClearTopFrame((IThread) event.getSource(), IModelDelta.ADDED | IModelDelta.STATE); }
@Override protected void handleChange(DebugEvent event) { if (event.getDetail() == DebugEvent.STATE) { fireDeltaUpdatingThread((IThread) event.getSource(), IModelDelta.STATE); } else { fireDeltaUpdatingThread((IThread) event.getSource(), IModelDelta.CONTENT); } }
@Override protected DebugEventHandler[] createEventHandlers() { ThreadEventHandler threadEventHandler = new ThreadEventHandler(this); return new DebugEventHandler[] { new DebugTargetEventHandler(this), threadEventHandler, new StackFrameEventHandler(this, threadEventHandler) }; }
public synchronized void dispose() { if (fTree != null) { fTree.removeTreeListener(this); } IPreferenceStore preferenceStore = JDIDebugUIPlugin.getDefault().getPreferenceStore(); preferenceStore.removePropertyChangeListener(this); super.dispose(); }
/** * Returns the index of the given thread, relative to its parent in the view. * * @param thread thread * @return index of the thread, relative to its parent */ protected int indexOf(IThread thread) { try { return indexOf(thread.getDebugTarget().getThreads(), thread); } catch (DebugException e) { } return -1; }
@Override protected void handleTerminate(DebugEvent event) { IThread thread = (IThread) event.getSource(); IDebugTarget target = thread.getDebugTarget(); // ignore thread termination if target is terminated/disconnected if (!(target.isTerminated() || target.isDisconnected())) { fireDeltaAndClearTopFrame(thread, IModelDelta.REMOVED); } }
IThread thread = (IThread) event.getSource(); if (event.isEvaluation()) { ModelDelta delta = buildRootDelta(); ModelDelta node = addPathToThread(delta, thread); node = node.addNode(thread, IModelDelta.STATE); try { fireDelta(delta); queueSuspendedThread(event); int extras = IModelDelta.STATE; switch (event.getDetail()) { waitForProxyInitialization(); fireDeltaUpdatingSelectedFrame(thread, IModelDelta.NO_CHANGE | extras, event);
protected int indexOf(IThread thread) { if (JavaElementContentProvider.isDisplayThreadGroups()) { IJavaThread javaThread = (IJavaThread) thread; try { return indexOf(javaThread.getThreadGroup().getThreads(), javaThread); } catch (CoreException e) { return -1; } } return super.indexOf(thread); }
protected int indexOf(IStackFrame frame) { if (isDisplayMonitors()) { if (((IJavaDebugTarget)frame.getDebugTarget()).supportsMonitorInformation()) { IJavaThread thread = (IJavaThread)frame.getThread(); int index = 0; try { index = thread.getOwnedMonitors().length; if (thread.getContendedMonitor() != null) { index++; } } catch (DebugException e) { } return index; } else { // make room for the 'no monitor info' element return 1; } } else { return super.indexOf(frame); } }