Skip to main content
aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorDarin Wright2004-12-01 22:23:29 +0000
committerDarin Wright2004-12-01 22:23:29 +0000
commiteb40d3397adad4967b16b2db9bbc984f24f3ef3f (patch)
tree6fb7e449de0d2d8723f96cffc6f75a299327eb3d
parent3340d43c9eafa47b61a991fb57d199ae2ba00a32 (diff)
downloadeclipse.platform.debug-eb40d3397adad4967b16b2db9bbc984f24f3ef3f.tar.gz
eclipse.platform.debug-eb40d3397adad4967b16b2db9bbc984f24f3ef3f.tar.xz
eclipse.platform.debug-eb40d3397adad4967b16b2db9bbc984f24f3ef3f.zip
Bug 79913 - Concurrency support
-rw-r--r--org.eclipse.debug.core/core/org/eclipse/debug/core/DebugPlugin.java83
-rw-r--r--org.eclipse.debug.core/core/org/eclipse/debug/internal/core/DebugElement.java137
-rw-r--r--org.eclipse.debug.core/core/org/eclipse/debug/internal/core/DefaultDebugRuleFactory.java91
-rw-r--r--org.eclipse.debug.core/core/org/eclipse/debug/internal/core/IDebugRuleFactory.java38
-rw-r--r--org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/LazyModelPresentation.java51
-rw-r--r--org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/actions/AbstractDebugActionDelegate.java57
-rw-r--r--org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/AbstractDebugEventHandler.java67
-rw-r--r--org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/DebugViewLabelDecorator.java11
-rw-r--r--org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/launch/DeferredDebugElementWorkbenchAdapter.java47
-rw-r--r--org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/launch/DeferredTarget.java20
-rw-r--r--org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/launch/DeferredThread.java19
-rw-r--r--org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/launch/LaunchViewEventHandler.java132
-rw-r--r--org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/variables/VariablesViewEventHandler.java4
13 files changed, 628 insertions, 129 deletions
diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/core/DebugPlugin.java b/org.eclipse.debug.core/core/org/eclipse/debug/core/DebugPlugin.java
index 9bf9d4eb9..e7a2b1158 100644
--- a/org.eclipse.debug.core/core/org/eclipse/debug/core/DebugPlugin.java
+++ b/org.eclipse.debug.core/core/org/eclipse/debug/core/DebugPlugin.java
@@ -40,13 +40,16 @@ import org.eclipse.core.runtime.MultiStatus;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Plugin;
import org.eclipse.core.runtime.Status;
+import org.eclipse.core.runtime.jobs.ISchedulingRule;
import org.eclipse.core.runtime.jobs.Job;
+import org.eclipse.debug.core.model.IDebugElement;
import org.eclipse.debug.core.model.IProcess;
import org.eclipse.debug.core.model.IValue;
import org.eclipse.debug.core.model.RuntimeProcess;
import org.eclipse.debug.internal.core.BreakpointManager;
import org.eclipse.debug.internal.core.DebugCoreMessages;
import org.eclipse.debug.internal.core.ExpressionManager;
+import org.eclipse.debug.internal.core.IDebugRuleFactory;
import org.eclipse.debug.internal.core.LaunchManager;
import org.eclipse.debug.internal.core.ListenerList;
import org.eclipse.debug.internal.core.LogicalStructureManager;
@@ -286,6 +289,52 @@ public class DebugPlugin extends Plugin {
*/
private static final int NOTIFY_FILTERS = 0;
private static final int NOTIFY_EVENTS = 1;
+
+ private List fEventQueue = new ArrayList();
+ private EventDispatchJob fEventDispatchJob = new EventDispatchJob();
+
+ class EventDispatchJob extends Job {
+
+ /**
+ * Creates a new event dispatch job.
+ */
+ public EventDispatchJob() {
+ super("Debug Event Dispatch");
+ setPriority(Job.INTERACTIVE);
+ }
+ /* (non-Javadoc)
+ * @see org.eclipse.core.runtime.jobs.Job#run(org.eclipse.core.runtime.IProgressMonitor)
+ */
+ protected IStatus run(IProgressMonitor monitor) {
+
+ while (!fEventQueue.isEmpty()) {
+ DebugEvent[] events = null;
+ synchronized (fEventQueue) {
+ if (!fEventQueue.isEmpty()) {
+ events = (DebugEvent[]) fEventQueue.remove(0);
+ }
+ }
+ if (events != null) {
+ getEventNotifier().dispatch(events);
+ }
+ }
+ return Status.OK_STATUS;
+ }
+
+ /* (non-Javadoc)
+ * @see org.eclipse.core.runtime.jobs.Job#shouldRun()
+ */
+ public boolean shouldRun() {
+ return shouldSchedule();
+ }
+ /* (non-Javadoc)
+ * @see org.eclipse.core.internal.jobs.InternalJob#shouldSchedule()
+ */
+ public boolean shouldSchedule() {
+ return !(isShuttingDown() || fEventListeners == null);
+ }
+
+ }
/**
* Returns the singleton instance of the debug plug-in.
@@ -352,7 +401,10 @@ public class DebugPlugin extends Plugin {
public void fireDebugEventSet(DebugEvent[] events) {
if (isShuttingDown() || events == null || fEventListeners == null)
return;
- getEventNotifier().dispatch(events);
+ synchronized (fEventQueue) {
+ fEventQueue.add(events);
+ }
+ fEventDispatchJob.schedule();
}
/**
@@ -1229,6 +1281,35 @@ public class DebugPlugin extends Plugin {
return res;
}
+
+ /**
+ *
+ * @param element
+ * @return
+ * @since 3.1
+ */
+ public static ISchedulingRule accessRule(IDebugElement element) {
+ IDebugRuleFactory factory = (IDebugRuleFactory) element.getAdapter(IDebugRuleFactory.class);
+ if (factory != null) {
+ return factory.accessRule(element);
+ }
+ return null;
+ }
+
+ /**
+ *
+ * @param element
+ * @return
+ * @since 3.1
+ */
+ public static ISchedulingRule modificationRule(IDebugElement element) {
+ IDebugRuleFactory factory = (IDebugRuleFactory) element.getAdapter(IDebugRuleFactory.class);
+ if (factory != null) {
+ return factory.modificationRule(element);
+ }
+ return null;
+ }
+
}
diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/internal/core/DebugElement.java b/org.eclipse.debug.core/core/org/eclipse/debug/internal/core/DebugElement.java
new file mode 100644
index 000000000..d3a0f9c6e
--- /dev/null
+++ b/org.eclipse.debug.core/core/org/eclipse/debug/internal/core/DebugElement.java
@@ -0,0 +1,137 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2004 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Common Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.debug.internal.core;
+
+import org.eclipse.core.runtime.PlatformObject;
+import org.eclipse.debug.core.DebugEvent;
+import org.eclipse.debug.core.DebugPlugin;
+import org.eclipse.debug.core.ILaunch;
+import org.eclipse.debug.core.model.IDebugElement;
+import org.eclipse.debug.core.model.IDebugTarget;
+import org.eclipse.debug.core.model.IProcess;
+import org.eclipse.debug.core.model.IStepFilters;
+
+/**
+ * Implementation of common function for debug elements.
+ * <p>
+ * Clients may subclass this class.
+ * </p>
+ * @since 3.1
+ */
+public abstract class DebugElement extends PlatformObject implements IDebugElement {
+
+ private IDebugTarget fTarget;
+
+ /**
+ * Constructs a debug element referring to an artifact in the given
+ * debug target.
+ *
+ * @param target debug target containing this element
+ */
+ public DebugElement(IDebugTarget target) {
+ fTarget = target;
+ }
+
+ /* (non-Javadoc)
+ * @see org.eclipse.debug.core.model.IDebugElement#getDebugTarget()
+ */
+ public IDebugTarget getDebugTarget() {
+ return fTarget;
+ }
+
+ /* (non-Javadoc)
+ * @see org.eclipse.debug.core.model.IDebugElement#getLaunch()
+ */
+ public ILaunch getLaunch() {
+ return getDebugTarget().getLaunch();
+ }
+
+ /* (non-Javadoc)
+ * @see org.eclipse.core.runtime.IAdaptable#getAdapter(java.lang.Class)
+ */
+ public Object getAdapter(Class adapter) {
+ if (adapter == IDebugElement.class) {
+ return this;
+ }
+ if (adapter == IStepFilters.class) {
+ return getDebugTarget();
+ }
+ if (adapter == IDebugTarget.class) {
+ return getDebugTarget();
+ }
+ if (adapter == IDebugRuleFactory.class) {
+ return DefaultDebugRuleFactory.getDefault();
+ }
+ if (adapter == ILaunch.class) {
+ return getLaunch();
+ }
+ if (adapter == IProcess.class) {
+ return getDebugTarget().getProcess();
+ }
+ return super.getAdapter(adapter);
+ }
+
+ /**
+ * Fires a debug event.
+ *
+ * @param event debug event to fire
+ */
+ protected void fireEvent(DebugEvent event) {
+ DebugPlugin.getDefault().fireDebugEventSet(new DebugEvent[] {event});
+ }
+
+ /**
+ * Fires a change event for this debug element
+ * with the specified detail code.
+ *
+ * @param detail detail code for the change event,
+ * such as <code>DebugEvent.STATE</code> or <code>DebugEvent.CONTENT</code>
+ */
+ public void fireChangeEvent(int detail) {
+ fireEvent(new DebugEvent(this, DebugEvent.CHANGE, detail));
+ }
+
+ /**
+ * Fires a creation event for this debug element.
+ */
+ protected void fireCreationEvent() {
+ fireEvent(new DebugEvent(this, DebugEvent.CREATE));
+ }
+
+ /**
+ * Fires a resume for this debug element with
+ * the specified detail code.
+ *
+ * @param detail detail code for the resume event, such
+ * as <code>DebugEvent.STEP_OVER</code>
+ */
+ protected void fireResumeEvent(int detail) {
+ fireEvent(new DebugEvent(this, DebugEvent.RESUME, detail));
+ }
+
+ /**
+ * Fires a suspend event for this debug element with
+ * the specified detail code.
+ *
+ * @param detail detail code for the suspend event, such
+ * as <code>DebugEvent.BREAKPOINT</code>
+ */
+ protected void fireSuspendEvent(int detail) {
+ fireEvent(new DebugEvent(this, DebugEvent.SUSPEND, detail));
+ }
+
+ /**
+ * Fires a terminate event for this debug element.
+ */
+ protected void fireTerminateEvent() {
+ fireEvent(new DebugEvent(this, DebugEvent.TERMINATE));
+ }
+}
diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/internal/core/DefaultDebugRuleFactory.java b/org.eclipse.debug.core/core/org/eclipse/debug/internal/core/DefaultDebugRuleFactory.java
new file mode 100644
index 000000000..7f1a6a7d5
--- /dev/null
+++ b/org.eclipse.debug.core/core/org/eclipse/debug/internal/core/DefaultDebugRuleFactory.java
@@ -0,0 +1,91 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2004 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Common Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.debug.internal.core;
+
+import org.eclipse.core.runtime.jobs.ISchedulingRule;
+import org.eclipse.debug.core.model.IDebugElement;
+import org.eclipse.debug.core.model.IDebugTarget;
+
+/**
+ * Default rule factory returns rules that serialzie access and modification of
+ * debug elements.
+ *
+ * @since 3.1
+ */
+public class DefaultDebugRuleFactory implements IDebugRuleFactory {
+
+ private static IDebugRuleFactory fgDefault;
+
+ class PessimisticRule implements ISchedulingRule {
+
+ private IDebugElement fElement;
+
+ PessimisticRule(IDebugElement element) {
+ fElement = element;
+ }
+
+ /* (non-Javadoc)
+ * @see org.eclipse.core.runtime.jobs.ISchedulingRule#contains(org.eclipse.core.runtime.jobs.ISchedulingRule)
+ */
+ public boolean contains(ISchedulingRule rule) {
+ if (rule instanceof PessimisticRule) {
+ return isSameTarget((PessimisticRule) rule, this);
+ }
+ return false;
+ }
+
+ /* (non-Javadoc)
+ * @see org.eclipse.core.runtime.jobs.ISchedulingRule#isConflicting(org.eclipse.core.runtime.jobs.ISchedulingRule)
+ */
+ public boolean isConflicting(ISchedulingRule rule) {
+ if (rule instanceof PessimisticRule) {
+ return isSameTarget((PessimisticRule) rule, this);
+ }
+ return false;
+ }
+
+ private boolean isSameTarget(PessimisticRule a, PessimisticRule b) {
+ IDebugTarget t1 = a.fElement.getDebugTarget();
+ IDebugTarget t2 = b.fElement.getDebugTarget();
+ return t1 != null && t1.equals(t2);
+ }
+
+ }
+
+ public static IDebugRuleFactory getDefault() {
+ if (fgDefault == null) {
+ fgDefault = new DefaultDebugRuleFactory();
+ }
+ return fgDefault;
+ }
+
+ /**
+ * Constucts a rule factory.
+ */
+ DefaultDebugRuleFactory() {
+ super();
+ }
+
+ /* (non-Javadoc)
+ * @see org.eclipse.debug.internal.core.IDebugRuleFactory#accessRule(org.eclipse.debug.core.model.IDebugElement)
+ */
+ public ISchedulingRule accessRule(IDebugElement debugElement) {
+ return new PessimisticRule(debugElement);
+ }
+
+ /* (non-Javadoc)
+ * @see org.eclipse.debug.internal.core.IDebugRuleFactory#modificationRule(org.eclipse.debug.core.model.IDebugElement)
+ */
+ public ISchedulingRule modificationRule(IDebugElement debugElement) {
+ return new PessimisticRule(debugElement);
+ }
+
+}
diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/internal/core/IDebugRuleFactory.java b/org.eclipse.debug.core/core/org/eclipse/debug/internal/core/IDebugRuleFactory.java
new file mode 100644
index 000000000..83a875278
--- /dev/null
+++ b/org.eclipse.debug.core/core/org/eclipse/debug/internal/core/IDebugRuleFactory.java
@@ -0,0 +1,38 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2004 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Common Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.debug.internal.core;
+
+import org.eclipse.core.runtime.jobs.ISchedulingRule;
+import org.eclipse.debug.core.model.IDebugElement;
+
+/**
+ * Creates scheduling rules for debug elements.
+ *
+ * @since 3.1
+ */
+public interface IDebugRuleFactory {
+
+ /**
+ * Returns a scheduling rule used to schedule a job that accesses a debug element.
+ *
+ * @param debugElement debug element to be accessed
+ * @return rule used to schedule a job that accesses a debug element.
+ */
+ public ISchedulingRule accessRule(IDebugElement debugElement);
+
+ /**
+ * Returns a scheduling rule used to schedule a job that modifies the state of
+ * a debug element
+ * @param debugElement debug element to be modified
+ * @return rule used to schedule a job that modifies a debug element
+ */
+ public ISchedulingRule modificationRule(IDebugElement debugElement);
+}
diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/LazyModelPresentation.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/LazyModelPresentation.java
index b59c5e37b..2be3c4c74 100644
--- a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/LazyModelPresentation.java
+++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/LazyModelPresentation.java
@@ -18,10 +18,16 @@ import java.util.Map;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
+import org.eclipse.core.runtime.Platform;
+import org.eclipse.core.runtime.jobs.ISchedulingRule;
+import org.eclipse.debug.core.DebugPlugin;
+import org.eclipse.debug.core.model.IDebugElement;
+import org.eclipse.debug.core.model.IDebugTarget;
import org.eclipse.debug.core.model.IMemoryBlock;
import org.eclipse.debug.core.model.IStackFrame;
import org.eclipse.debug.core.model.IThread;
import org.eclipse.debug.core.model.IValue;
+import org.eclipse.debug.internal.core.IDebugRuleFactory;
import org.eclipse.debug.internal.core.ListenerList;
import org.eclipse.debug.internal.ui.views.memory.IMemoryBlockModelPresentation;
import org.eclipse.debug.internal.ui.views.memory.IMemoryRenderingType;
@@ -99,17 +105,58 @@ public class LazyModelPresentation implements IDebugModelPresentation, IDebugEdi
* @see IDebugModelPresentation#getImage(Object)
*/
public Image getImage(Object element) {
- return getPresentation().getImage(element);
+ Image image = null;
+ // TODO: causes UI job blocking dialog to appear
+// ISchedulingRule rule = null;
+// try {
+// rule = beginRule(element);
+ image = getPresentation().getImage(element);
+// } finally {
+// endRule(rule);
+// }
+ return image;
}
/**
* @see IDebugModelPresentation#getText(Object)
*/
public String getText(Object element) {
- return getPresentation().getText(element);
+ String text = null;
+ ISchedulingRule rule = null;
+ try {
+ rule = beginRule(element);
+ text = getPresentation().getText(element);
+ } finally {
+ endRule(rule);
+ }
+ return text;
}
/**
+ * @param rule
+ */
+ private void endRule(ISchedulingRule rule) {
+ if (rule != null) {
+ Platform.getJobManager().endRule(rule);
+ }
+ }
+
+ /**
+ * @param element
+ * @return
+ */
+ private ISchedulingRule beginRule(Object object) {
+ ISchedulingRule rule = null;
+ if (object instanceof IDebugElement) {
+ rule = DebugPlugin.accessRule((IDebugElement)object);
+ if (rule != null) {
+ Platform.getJobManager().beginRule(rule, null);
+ }
+ }
+ return rule;
+ }
+
+ /**
* @see IDebugModelPresentation#computeDetail(IValue, IValueDetailListener)
*/
public void computeDetail(IValue value, IValueDetailListener listener) {
diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/actions/AbstractDebugActionDelegate.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/actions/AbstractDebugActionDelegate.java
index 77d8399b5..7326ebe2d 100644
--- a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/actions/AbstractDebugActionDelegate.java
+++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/actions/AbstractDebugActionDelegate.java
@@ -16,8 +16,12 @@ import java.util.Iterator;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.MultiStatus;
+import org.eclipse.core.runtime.Status;
+import org.eclipse.core.runtime.jobs.ISchedulingRule;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.debug.core.DebugException;
+import org.eclipse.debug.core.model.IDebugElement;
+import org.eclipse.debug.internal.core.IDebugRuleFactory;
import org.eclipse.debug.internal.ui.DebugUIPlugin;
import org.eclipse.debug.ui.IDebugUIConstants;
import org.eclipse.jface.action.IAction;
@@ -65,14 +69,9 @@ public abstract class AbstractDebugActionDelegate implements IWorkbenchWindowAct
*/
protected IWorkbenchWindow fWindow;
- /**
- * Background job for this action, or <code>null</code> if none.
- */
- private DebugRequestJob fBackgroundJob = null;
-
class DebugRequestJob extends Job {
- private Object[] fElements = null;
+ private Object fElement;
/**
* Constructs a new job to perform a debug request (for example, step)
@@ -80,35 +79,22 @@ public abstract class AbstractDebugActionDelegate implements IWorkbenchWindowAct
*
* @param name job name
*/
- public DebugRequestJob(String name) {
+ public DebugRequestJob(String name, Object target) {
super(name);
setPriority(Job.INTERACTIVE);
+ fElement = target;
}
/* (non-Javadoc)
* @see org.eclipse.core.runtime.jobs.Job#run(org.eclipse.core.runtime.IProgressMonitor)
*/
protected IStatus run(IProgressMonitor monitor) {
- MultiStatus status=
- new MultiStatus(DebugUIPlugin.getUniqueIdentifier(), DebugException.REQUEST_FAILED, getStatusMessage(), null);
- for (int i = 0; i < fElements.length; i++) {
- Object element= fElements[i];
- try {
- doAction(element);
- } catch (DebugException e) {
- status.merge(e.getStatus());
- }
+ try {
+ doAction(fElement);
+ } catch (DebugException e) {
+ return e.getStatus();
}
- return status;
- }
-
- /**
- * Sets the selection to operate on.
- *
- * @param elements
- */
- public void setTargets(Object[] elements) {
- fElements = elements;
+ return Status.OK_STATUS;
}
}
@@ -128,7 +114,6 @@ public abstract class AbstractDebugActionDelegate implements IWorkbenchWindowAct
if (getWindow() != null) {
getWindow().getSelectionService().removeSelectionListener(IDebugUIConstants.ID_DEBUG_VIEW, this);
}
- fBackgroundJob = null;
}
/* (non-Javadoc)
@@ -163,11 +148,21 @@ public abstract class AbstractDebugActionDelegate implements IWorkbenchWindowAct
private void runInBackground(IAction action, IStructuredSelection selection) {
// disable the action
action.setEnabled(false);
- if (fBackgroundJob == null) {
- fBackgroundJob = new DebugRequestJob(action.getText());
+ Iterator iterator = selection.iterator();
+ while (iterator.hasNext()) {
+ Object target = iterator.next();
+ ISchedulingRule rule = null;
+ if (target instanceof IDebugElement) {
+ IDebugElement element = (IDebugElement) target;
+ IDebugRuleFactory ruleFactory = (IDebugRuleFactory) element.getAdapter(IDebugRuleFactory.class);
+ if (ruleFactory != null) {
+ rule = ruleFactory.modificationRule(element);
+ }
+ }
+ DebugRequestJob job = new DebugRequestJob(action.getText(), target);
+ job.setRule(rule);
+ job.schedule();
}
- fBackgroundJob.setTargets(selection.toArray());
- fBackgroundJob.schedule();
}
/**
diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/AbstractDebugEventHandler.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/AbstractDebugEventHandler.java
index 769f3dbcf..94f0bbf6a 100644
--- a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/AbstractDebugEventHandler.java
+++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/AbstractDebugEventHandler.java
@@ -16,10 +16,13 @@ import java.util.List;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Status;
+import org.eclipse.core.runtime.jobs.ISchedulingRule;
import org.eclipse.debug.core.DebugEvent;
import org.eclipse.debug.core.DebugPlugin;
import org.eclipse.debug.core.IDebugEventSetListener;
+import org.eclipse.debug.core.model.IDebugElement;
import org.eclipse.debug.ui.AbstractDebugView;
import org.eclipse.jface.viewers.IBasicPropertyConstants;
import org.eclipse.jface.viewers.ITreeContentProvider;
@@ -31,6 +34,8 @@ import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.progress.UIJob;
+import com.ibm.xslt4j.bcel.generic.FADD;
+
/**
* Handles debug events, updating a view and viewer.
*/
@@ -42,11 +47,16 @@ public abstract class AbstractDebugEventHandler implements IDebugEventSetListene
private AbstractDebugView fView;
/**
- * Queued debug event sets (arrays of events) to process, or <code>null</code> if none.
+ * Queued debug event sets (arrays of events) to process.
*/
private List fEventSetQueue = new ArrayList();
/**
+ * Queued data associated with event sets. Entries may be <code>null</code>.
+ */
+ private List fDataQueue = new ArrayList();
+
+ /**
* Update job
*/
private EventProcessingJob fUpdateJob = new EventProcessingJob();
@@ -56,6 +66,8 @@ public abstract class AbstractDebugEventHandler implements IDebugEventSetListene
*/
protected static final DebugEvent[] EMPTY_EVENT_SET = new DebugEvent[0];
+ private Object NULL = new Object();
+
/**
* Job to dispatch debug event sets
*/
@@ -75,6 +87,7 @@ public abstract class AbstractDebugEventHandler implements IDebugEventSetListene
// to avoid blocking the UI thread, process a max of 50 event sets at once
while (more && (count < 50)) {
DebugEvent[] eventSet = null;
+ Object data = null;
synchronized (fEventSetQueue) {
if (fEventSetQueue.isEmpty()) {
return Status.OK_STATUS;
@@ -82,11 +95,17 @@ public abstract class AbstractDebugEventHandler implements IDebugEventSetListene
eventSet = (DebugEvent[]) fEventSetQueue.remove(0);
more = !fEventSetQueue.isEmpty();
}
+ synchronized (fDataQueue) {
+ data = fDataQueue.remove(0);
+ if (data == NULL) {
+ data = null;
+ }
+ }
if (isAvailable()) {
if (isViewVisible()) {
- doHandleDebugEvents(eventSet);
+ doHandleDebugEvents(eventSet, data);
}
- updateForDebugEvents(eventSet);
+ updateForDebugEvents(eventSet, data);
}
count++;
}
@@ -132,13 +151,32 @@ public abstract class AbstractDebugEventHandler implements IDebugEventSetListene
if (events.length == 0) {
return;
}
+ events = doPreprocessEvents(events);
+ if (events.length == 0) {
+ return;
+ }
// add the event set to the queue and schedule update
synchronized (fEventSetQueue) {
fEventSetQueue.add(events);
+ synchronized (fDataQueue) {
+ if (fDataQueue.size() < fEventSetQueue.size()) {
+ fDataQueue.add(NULL);
+ }
+ }
}
fUpdateJob.schedule();
}
+ protected void queueData(Object data) {
+ synchronized (fDataQueue) {
+ fDataQueue.add(data);
+ }
+ }
+
+ protected DebugEvent[] doPreprocessEvents(DebugEvent[] events) {
+ return events;
+ }
+
/**
* Filters the given events before processing.
*
@@ -156,14 +194,14 @@ public abstract class AbstractDebugEventHandler implements IDebugEventSetListene
* updating that must always be performed, even when the view is not
* visible.
*/
- protected void updateForDebugEvents(DebugEvent[] events) {
+ protected void updateForDebugEvents(DebugEvent[] events, Object data) {
}
/**
* Implementation specific handling of debug events.
* Subclasses should override.
*/
- protected abstract void doHandleDebugEvents(DebugEvent[] events);
+ protected abstract void doHandleDebugEvents(DebugEvent[] events, Object data);
/**
* Helper method for inserting the given element - must be called in UI thread
@@ -316,5 +354,24 @@ public abstract class AbstractDebugEventHandler implements IDebugEventSetListene
protected void viewBecomesHidden() {
}
+ /**
+ *
+ * @param element
+ * @return
+ * @since 3.1
+ */
+ protected ISchedulingRule beginAccessRule(IDebugElement element) {
+ ISchedulingRule rule = DebugPlugin.accessRule(element);
+ if (rule != null) {
+ Platform.getJobManager().beginRule(rule, null);
+ }
+ return rule;
+ }
+
+ protected void endRule(ISchedulingRule rule) {
+ if (rule != null) {
+ Platform.getJobManager().endRule(rule);
+ }
+ }
}
diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/DebugViewLabelDecorator.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/DebugViewLabelDecorator.java
index 71f2a6737..6c6119eed 100644
--- a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/DebugViewLabelDecorator.java
+++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/DebugViewLabelDecorator.java
@@ -258,7 +258,8 @@ public class DebugViewLabelDecorator extends LabelProvider implements ILabelDeco
public LabelJob(String name, IDebugModelPresentation presentation) {
super(name);
fJobPresentation= presentation;
- setRule(this);
+ // TODO: why was this rule needed?
+ //setRule(this);
setSystem(true);
}
@@ -284,17 +285,13 @@ public class DebugViewLabelDecorator extends LabelProvider implements ILabelDeco
* @see org.eclipse.core.runtime.jobs.Job#run(org.eclipse.core.runtime.IProgressMonitor)
*/
public IStatus run(IProgressMonitor monitor) {
- synchronized(DebugViewLabelDecorator.this) {
- fNextJob= null;
- }
-
int numElements= fElementQueue.size();
monitor.beginTask(MessageFormat.format(DebugUIViewsMessages.getString("DebugViewLabelDecorator.1"), new String[] { Integer.toString(numElements) }), numElements); //$NON-NLS-1$
while (!fElementQueue.isEmpty() && !monitor.isCanceled()) {
StringBuffer message= new StringBuffer(MessageFormat.format(DebugUIViewsMessages.getString("DebugViewLabelDecorator.1"), new String[] { Integer.toString(fElementQueue.size()) })); //$NON-NLS-1$
- if (fNextJob != null) {
+ //if (fNextJob != null) {
message.append(MessageFormat.format(DebugUIViewsMessages.getString("DebugViewLabelDecorator.2"), new String[] { Integer.toString(fNextJob.fElementQueue.size()) })); //$NON-NLS-1$
- }
+ //}
monitor.setTaskName(message.toString());
int blockSize= 10;
if (fElementQueue.size() < blockSize) {
diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/launch/DeferredDebugElementWorkbenchAdapter.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/launch/DeferredDebugElementWorkbenchAdapter.java
new file mode 100644
index 000000000..30acb0c2d
--- /dev/null
+++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/launch/DeferredDebugElementWorkbenchAdapter.java
@@ -0,0 +1,47 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2004 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Common Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.debug.internal.ui.views.launch;
+
+import org.eclipse.core.runtime.jobs.ISchedulingRule;
+import org.eclipse.debug.core.model.IDebugElement;
+import org.eclipse.debug.internal.core.IDebugRuleFactory;
+import org.eclipse.debug.ui.DebugElementWorkbenchAdapter;
+import org.eclipse.ui.progress.IDeferredWorkbenchAdapter;
+
+
+/**
+ * Default deferred content provider for a debug target
+ */
+public abstract class DeferredDebugElementWorkbenchAdapter extends DebugElementWorkbenchAdapter implements IDeferredWorkbenchAdapter {
+
+ /* (non-Javadoc)
+ * @see org.eclipse.ui.progress.IDeferredWorkbenchAdapter#isContainer()
+ */
+ public boolean isContainer() {
+ return true;
+ }
+
+ /* (non-Javadoc)
+ * @see org.eclipse.ui.progress.IDeferredWorkbenchAdapter#getRule(java.lang.Object)
+ */
+ public ISchedulingRule getRule(Object object) {
+ if (object instanceof IDebugElement) {
+ IDebugElement element = (IDebugElement)object;
+ IDebugRuleFactory factory = (IDebugRuleFactory) element.getAdapter(IDebugRuleFactory.class);
+ if (factory != null) {
+ return factory.accessRule(element);
+ }
+ }
+ return null;
+ }
+
+
+}
diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/launch/DeferredTarget.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/launch/DeferredTarget.java
index 42cc72345..dcc0b8f9d 100644
--- a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/launch/DeferredTarget.java
+++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/launch/DeferredTarget.java
@@ -11,11 +11,9 @@
package org.eclipse.debug.internal.ui.views.launch;
import org.eclipse.core.runtime.IProgressMonitor;
-import org.eclipse.core.runtime.jobs.ISchedulingRule;
import org.eclipse.debug.core.DebugException;
import org.eclipse.debug.core.model.IDebugTarget;
import org.eclipse.debug.core.model.IThread;
-import org.eclipse.debug.ui.DebugElementWorkbenchAdapter;
import org.eclipse.ui.progress.IDeferredWorkbenchAdapter;
import org.eclipse.ui.progress.IElementCollector;
@@ -23,7 +21,7 @@ import org.eclipse.ui.progress.IElementCollector;
/**
* Default deferred content provider for a debug target
*/
-public class DeferredTarget extends DebugElementWorkbenchAdapter implements IDeferredWorkbenchAdapter {
+public class DeferredTarget extends DeferredDebugElementWorkbenchAdapter implements IDeferredWorkbenchAdapter {
/* (non-Javadoc)
* @see org.eclipse.ui.progress.IDeferredWorkbenchAdapter#fetchDeferredChildren(java.lang.Object, org.eclipse.ui.progress.IElementCollector, org.eclipse.core.runtime.IProgressMonitor)
@@ -37,20 +35,4 @@ public class DeferredTarget extends DebugElementWorkbenchAdapter implements IDef
}
collector.done();
}
-
- /* (non-Javadoc)
- * @see org.eclipse.ui.progress.IDeferredWorkbenchAdapter#isContainer()
- */
- public boolean isContainer() {
- return true;
- }
-
- /* (non-Javadoc)
- * @see org.eclipse.ui.progress.IDeferredWorkbenchAdapter#getRule(java.lang.Object)
- */
- public ISchedulingRule getRule(Object object) {
- return null;
- }
-
-
}
diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/launch/DeferredThread.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/launch/DeferredThread.java
index 375d774f1..f7781c945 100644
--- a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/launch/DeferredThread.java
+++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/launch/DeferredThread.java
@@ -11,11 +11,9 @@
package org.eclipse.debug.internal.ui.views.launch;
import org.eclipse.core.runtime.IProgressMonitor;
-import org.eclipse.core.runtime.jobs.ISchedulingRule;
import org.eclipse.debug.core.DebugException;
import org.eclipse.debug.core.model.IStackFrame;
import org.eclipse.debug.core.model.IThread;
-import org.eclipse.debug.ui.DebugElementWorkbenchAdapter;
import org.eclipse.ui.progress.IDeferredWorkbenchAdapter;
import org.eclipse.ui.progress.IElementCollector;
@@ -23,7 +21,7 @@ import org.eclipse.ui.progress.IElementCollector;
/**
* Default deferred content provider for a debug target
*/
-public class DeferredThread extends DebugElementWorkbenchAdapter implements IDeferredWorkbenchAdapter {
+public class DeferredThread extends DeferredDebugElementWorkbenchAdapter implements IDeferredWorkbenchAdapter {
/* (non-Javadoc)
* @see org.eclipse.ui.progress.IDeferredWorkbenchAdapter#fetchDeferredChildren(java.lang.Object, org.eclipse.ui.progress.IElementCollector, org.eclipse.core.runtime.IProgressMonitor)
@@ -38,19 +36,4 @@ public class DeferredThread extends DebugElementWorkbenchAdapter implements IDef
collector.done();
}
- /* (non-Javadoc)
- * @see org.eclipse.ui.progress.IDeferredWorkbenchAdapter#isContainer()
- */
- public boolean isContainer() {
- return true;
- }
-
- /* (non-Javadoc)
- * @see org.eclipse.ui.progress.IDeferredWorkbenchAdapter#getRule(java.lang.Object)
- */
- public ISchedulingRule getRule(Object object) {
- return null;
- }
-
-
}
diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/launch/LaunchViewEventHandler.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/launch/LaunchViewEventHandler.java
index 9c97c3df9..657ba051d 100644
--- a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/launch/LaunchViewEventHandler.java
+++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/launch/LaunchViewEventHandler.java
@@ -16,6 +16,7 @@ import java.util.HashSet;
import java.util.Map;
import java.util.Set;
+import org.eclipse.core.runtime.jobs.ISchedulingRule;
import org.eclipse.debug.core.DebugEvent;
import org.eclipse.debug.core.DebugException;
import org.eclipse.debug.core.DebugPlugin;
@@ -29,7 +30,6 @@ import org.eclipse.debug.core.model.IStackFrame;
import org.eclipse.debug.core.model.IThread;
import org.eclipse.debug.internal.ui.DebugUIPlugin;
import org.eclipse.debug.internal.ui.views.AbstractDebugEventHandler;
-import org.eclipse.jface.viewers.ITreeContentProvider;
/**
* Handles debug events, updating the launch view and viewer.
@@ -84,7 +84,7 @@ public class LaunchViewEventHandler extends AbstractDebugEventHandler implements
/**
* @see AbstractDebugEventHandler#doHandleDebugEvents(DebugEvent[])
*/
- protected void doHandleDebugEvents(DebugEvent[] events) {
+ protected void doHandleDebugEvents(DebugEvent[] events, Object data) {
fThreadTimer.handleDebugEvents(events);
Object suspendee = null;
for (int i = 0; i < events.length; i++) {
@@ -103,19 +103,24 @@ public class LaunchViewEventHandler extends AbstractDebugEventHandler implements
fThreadTimer.getTimedOutThreads().remove(source);
remove(source);
} else {
+ Object parent = null;
if (source instanceof IDebugTarget) {
clearSourceSelection(source);
+ parent = ((IDebugTarget)source).getLaunch();
+ } else if (source instanceof IProcess) {
+ parent = ((IProcess)source).getLaunch();
+ }
+ if (parent != null) {
+ refresh(parent);
}
- Object parent = ((ITreeContentProvider)getTreeViewer().getContentProvider()).getParent(source);
- refresh(parent);
}
break;
case DebugEvent.RESUME :
- doHandleResumeEvent(event, source);
+ doHandleResumeEvent(event, source, data);
break;
case DebugEvent.SUSPEND :
if (suspendee == null || !suspendee.equals(source)) {
- doHandleSuspendEvent(source, event);
+ doHandleSuspendEvent(source, event, data);
suspendee = source;
}
break;
@@ -146,7 +151,7 @@ public class LaunchViewEventHandler extends AbstractDebugEventHandler implements
/**
* Handles the given resume event with the given source.
*/
- protected void doHandleResumeEvent(DebugEvent event, Object source) {
+ protected void doHandleResumeEvent(DebugEvent event, Object source, Object data) {
if (!event.isEvaluation()) {
clearSourceSelection(source);
}
@@ -161,18 +166,9 @@ public class LaunchViewEventHandler extends AbstractDebugEventHandler implements
}
refresh(source);
if (source instanceof IThread) {
- // When a thread resumes, try to select another suspended thread
- // in the same target.
- try {
- IThread[] threads= ((IThread) source).getDebugTarget().getThreads();
- for (int i = 0; i < threads.length; i++) {
- IStackFrame frame = threads[i].getTopStackFrame();
- if (frame != null) {
- selectAndReveal(frame);
- return;
- }
- }
- } catch (DebugException e) {
+ if (data instanceof IStackFrame) {
+ selectAndReveal(data);
+ return;
}
selectAndReveal(source);
return;
@@ -191,7 +187,7 @@ public class LaunchViewEventHandler extends AbstractDebugEventHandler implements
clearSourceSelection(thread);
}
- protected void doHandleSuspendEvent(Object element, DebugEvent event) {
+ protected void doHandleSuspendEvent(Object element, DebugEvent event, Object data) {
IThread thread= getThread(element);
if (thread != null) {
fThreadTimer.stopTimer(thread);
@@ -205,7 +201,7 @@ public class LaunchViewEventHandler extends AbstractDebugEventHandler implements
}
}
if (element instanceof IThread) {
- doHandleSuspendThreadEvent((IThread)element, event, wasTimedOut);
+ doHandleSuspendThreadEvent((IThread)element, event, wasTimedOut, data);
return;
}
refresh(element);
@@ -214,7 +210,7 @@ public class LaunchViewEventHandler extends AbstractDebugEventHandler implements
/**
* Updates the given thread for the given suspend event.
*/
- protected void doHandleSuspendThreadEvent(IThread thread, DebugEvent event, boolean wasTimedOut) {
+ protected void doHandleSuspendThreadEvent(IThread thread, DebugEvent event, boolean wasTimedOut, Object data) {
// if the thread has already resumed, do nothing
if (!thread.isSuspended() || !isAvailable()) {
return;
@@ -223,48 +219,48 @@ public class LaunchViewEventHandler extends AbstractDebugEventHandler implements
// do not update source selection for evaluation events
boolean evaluationEvent = event.isEvaluation();
+ // get the top frame
+ IStackFrame frame = null;
+ if (data instanceof IStackFrame) {
+ frame = (IStackFrame) data;
+ }
+
// if the top frame is the same, only update labels and images, and re-select
// the frame to display source
- try {
- IStackFrame frame = thread.getTopStackFrame();
- if (frame != null && frame.equals(fLastStackFrame)) {
- if (wasTimedOut) {
- getLaunchViewer().updateStackFrameImages(thread);
- }
- getLaunchViewer().update(new Object[] {thread, frame}, null);
- if (!evaluationEvent) {
- getLaunchViewer().deferExpansion(thread);
- getLaunchViewer().setDeferredSelection(frame);
- } else if (wasTimedOut) {
- getLaunchView().showEditorForCurrentSelection();
- }
- return;
+ if (frame != null && frame.equals(fLastStackFrame)) {
+ if (wasTimedOut) {
+ getLaunchViewer().updateStackFrameImages(thread);
+ }
+ getLaunchViewer().update(new Object[] {thread, frame}, null);
+ if (!evaluationEvent) {
+ getLaunchViewer().deferExpansion(thread);
+ getLaunchViewer().setDeferredSelection(frame);
+ } else if (wasTimedOut) {
+ getLaunchView().showEditorForCurrentSelection();
}
- } catch (DebugException e) {
+ return;
}
- try {
- fLastStackFrame = thread.getTopStackFrame();
+ if (frame != null) {
+ fLastStackFrame = frame;
// Auto-expand the thread. Only select the thread if this wasn't the end
// of an evaluation
getLaunchView().autoExpand(thread, false);
if (fLastStackFrame != null) {
getLaunchView().autoExpand(fLastStackFrame, !evaluationEvent);
}
- } catch (DebugException e) {
- fLastStackFrame = null;
}
}
/**
* @see AbstractDebugEventHandler#updateForDebugEvents(DebugEvent[])
*/
- protected void updateForDebugEvents(DebugEvent[] events) {
- super.updateForDebugEvents(events);
+ protected void updateForDebugEvents(DebugEvent[] events, Object data) {
+ super.updateForDebugEvents(events, data);
if (isViewVisible()) {
return;
}
- doHandleDebugEvents(events);
+ doHandleDebugEvents(events, null);
}
/**
@@ -579,4 +575,52 @@ public class LaunchViewEventHandler extends AbstractDebugEventHandler implements
getView().asyncExec(r);
}
+ /* (non-Javadoc)
+ * @see org.eclipse.debug.internal.ui.views.AbstractDebugEventHandler#doPreprocessEvents(org.eclipse.debug.core.DebugEvent[])
+ */
+ protected DebugEvent[] doPreprocessEvents(DebugEvent[] events) {
+ for (int i = 0; i < events.length; i++) {
+ DebugEvent event = events[i];
+ Object source = event.getSource();
+ switch (event.getKind()) {
+ case DebugEvent.SUSPEND:
+ if (source instanceof IThread) {
+ IThread thread = (IThread)source;
+ ISchedulingRule rule = null;
+ try {
+ rule = beginAccessRule(thread);
+ IStackFrame frame = thread.getTopStackFrame();
+ queueData(frame);
+ } catch (DebugException e) {
+ } finally {
+ endRule(rule);
+ }
+ }
+ break;
+ case DebugEvent.RESUME:
+ if (source instanceof IThread) {
+ // When a thread resumes, try to select another suspended thread
+ // in the same target.
+ ISchedulingRule rule = null;
+ try {
+ IDebugTarget target = ((IThread) source).getDebugTarget();
+ rule = beginAccessRule(target);
+ IThread[] threads= target.getThreads();
+ for (int j = 0; j < threads.length; j++) {
+ IStackFrame frame = threads[j].getTopStackFrame();
+ if (frame != null) {
+ queueData(frame);
+ break;
+ }
+ }
+ } catch (DebugException e) {
+ } finally {
+ endRule(rule);
+ }
+ }
+ break;
+ }
+ }
+ return events;
+ }
}
diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/variables/VariablesViewEventHandler.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/variables/VariablesViewEventHandler.java
index 5f6a831d8..57436cff4 100644
--- a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/variables/VariablesViewEventHandler.java
+++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/variables/VariablesViewEventHandler.java
@@ -35,7 +35,7 @@ public class VariablesViewEventHandler extends AbstractDebugEventHandler {
/**
* @see AbstractDebugEventHandler#handleDebugEvents(DebugEvent[])
*/
- protected void doHandleDebugEvents(DebugEvent[] events) {
+ protected void doHandleDebugEvents(DebugEvent[] events, Object data) {
for (int i = 0; i < events.length; i++) {
DebugEvent event = events[i];
switch (event.getKind()) {
@@ -55,7 +55,7 @@ public class VariablesViewEventHandler extends AbstractDebugEventHandler {
/**
* @see AbstractDebugEventHandler#updateForDebugEvents(DebugEvent[])
*/
- protected void updateForDebugEvents(DebugEvent[] events) {
+ protected void updateForDebugEvents(DebugEvent[] events, Object data) {
for (int i = 0; i < events.length; i++) {
DebugEvent event = events[i];
switch (event.getKind()) {

Back to the top