Attachment #57139 for bug #128229

This Bugzilla instance is a read-only archive of historic NetBeans bug reports. To report a bug in NetBeans please follow the project's instructions for reporting issues.

View | Details | Raw Unified | Return to bug 128229
Collapse All | Expand All

Lines 37-42 Link Here

(-)a/ant.debugger/nbproject/project.properties (+2 lines)
37	# Version 2 license, then the option applies only if the new code is	37	# Version 2 license, then the option applies only if the new code is
38	# made subject to such option by the copyright holder.	38	# made subject to such option by the copyright holder.
39		39
		40	javac.compilerargs=-Xlint -Xlint:-serial
		41	javac.source=1.5
40	spec.version.base=1.9.0	42	spec.version.base=1.9.0
41	test.unit.run.cp.extra=${tools.jar}	43	test.unit.run.cp.extra=${tools.jar}
42	# Make the debugger find it, even if it is not on the startup debug classpath:	44	# Make the debugger find it, even if it is not on the startup debug classpath:

Lines 118-125 public class AntDebugger extends Actions Link Here

(-)a/ant.debugger/src/org/netbeans/modules/ant/debugger/AntDebugger.java (-2 / +1 lines)
118	this.contextProvider = contextProvider;	118	this.contextProvider = contextProvider;
119		119
120	// init antCookie	120	// init antCookie
121	antCookie = (AntProjectCookie) contextProvider.lookupFirst	121	antCookie = contextProvider.lookupFirst(null, AntProjectCookie.class);
122	(null, AntProjectCookie.class);
123		122
124	// init engineProvider	123	// init engineProvider
125	engineProvider = (AntDebuggerEngineProvider) contextProvider.lookupFirst	124	engineProvider = (AntDebuggerEngineProvider) contextProvider.lookupFirst

Lines 75-82 NodeActionsProvider, TableModel { Link Here

(-)a/ant.debugger/src/org/netbeans/modules/ant/debugger/CallStackModel.java (-2 / +1 lines)
75		75
76		76
77	public CallStackModel (ContextProvider contextProvider) {	77	public CallStackModel (ContextProvider contextProvider) {
78	debugger = (AntDebugger) contextProvider.lookupFirst	78	debugger = contextProvider.lookupFirst(null, AntDebugger.class);
79	(null, AntDebugger.class);
80	}	79	}
81		80
82		81

Lines 370-376 public class DebuggerAntLogger extends A Link Here

(-)a/ant.debugger/src/org/netbeans/modules/ant/debugger/DebuggerAntLogger.java (-1 / +1 lines)
370	);	370	);
371	DebuggerEngine[] es = DebuggerManager.getDebuggerManager ().	371	DebuggerEngine[] es = DebuggerManager.getDebuggerManager ().
372	startDebugging (di);	372	startDebugging (di);
373	AntDebugger debugger = (AntDebugger) es [0].lookupFirst (null, AntDebugger.class);	373	AntDebugger debugger = es[0].lookupFirst(null, AntDebugger.class);
374	debugger.setExecutor(execTask);	374	debugger.setExecutor(execTask);
375	return debugger;	375	return debugger;
376	}	376	}




        DebuggerEngine currentEngine = DebuggerManager.getDebuggerManager ().
            getCurrentEngine ();
        if (currentEngine == null) return null;
        AntDebugger d = currentEngine.lookupFirst(null, AntDebugger.class);
            (null, AntDebugger.class);
        if (d == null) return null;

        Part lp = (Part)

        DataObject dob = DataEditorSupport.findDataObject (line);
        if (dob == null) return null;
        EditorCookie ec = 
            dob.getCookie(EditorCookie.class);
            (EditorCookie.class);

        if (ec == null) return null;
        this.lp = lp;

        DebuggerEngine currentEngine = DebuggerManager.getDebuggerManager ().
            getCurrentEngine ();
        if (currentEngine == null) return;
        AntDebugger d = currentEngine.lookupFirst(null, AntDebugger.class);
            (null, AntDebugger.class);
        if (d == null) return;
        String value = d.evaluate (expression);
        if ( value == null ||

Lines 66-73 public class VariablesModel implements T Link Here

(-)a/ant.debugger/src/org/netbeans/modules/ant/debugger/VariablesModel.java (-2 / +1 lines)
66		66
67		67
68	public VariablesModel (ContextProvider contextProvider) {	68	public VariablesModel (ContextProvider contextProvider) {
69	debugger = (AntDebugger) contextProvider.lookupFirst	69	debugger = contextProvider.lookupFirst(null, AntDebugger.class);
70	(null, AntDebugger.class);
71	}	70	}
72		71
73		72

Lines 73-80 public class WatchesModel implements Nod Link Here

(-)a/ant.debugger/src/org/netbeans/modules/ant/debugger/WatchesModel.java (-2 / +1 lines)
73		73
74		74
75	public WatchesModel (ContextProvider contextProvider) {	75	public WatchesModel (ContextProvider contextProvider) {
76	debugger = (AntDebugger) contextProvider.lookupFirst	76	debugger = contextProvider.lookupFirst(null, AntDebugger.class);
77	(null, AntDebugger.class);
78	}	77	}
79		78
80		79

Lines 254-259 public class BreakpointModel implements Link Here

(-)a/ant.debugger/src/org/netbeans/modules/ant/debugger/breakpoints/BreakpointModel.java (-1 / +1 lines)
254	DebuggerEngine engine = DebuggerManager.getDebuggerManager ().	254	DebuggerEngine engine = DebuggerManager.getDebuggerManager ().
255	getCurrentEngine ();	255	getCurrentEngine ();
256	if (engine == null) return null;	256	if (engine == null) return null;
257	return (AntDebugger) engine.lookupFirst (null, AntDebugger.class);	257	return engine.lookupFirst(null, AntDebugger.class);
258	}	258	}
259	}	259	}




            );
        int i, k = es.length;
        for (i = 0; i < k; i++) {
            JPDADebugger d = es[i].lookupFirst(null, JPDADebugger.class);
                (null, JPDADebugger.class);
            if (d == null) continue;
            d.waitRunning ();
            return d;

            );
        int i, k = es.length;
        for (i = 0; i < k; i++) {
            JPDADebugger d = es[i].lookupFirst(null, JPDADebugger.class);
                (null, JPDADebugger.class);
            if (d == null) continue;
            d.waitRunning ();
            return d;

            );
        int i, k = es.length;
        for (i = 0; i < k; i++) {
            JPDADebugger d = es[i].lookupFirst(null, JPDADebugger.class);
                (null, JPDADebugger.class);
            d.waitRunning ();
            if (d == null) continue;
            return d;




<!-- ACTUAL CHANGES BEGIN HERE: -->

<changes>
    <change id="generification">
        <api name="DebuggerCoreAPI"/>
        <summary>Use of some generic types in API; <code>ContextProvider</code> implemented more broadly</summary>
        <version major="1" minor="13"/>
        <date day="1" month="3" year="2008"/>
        <author login="jglick"/>
        <compatibility binary="compatible" source="incompatible" modification="yes" semantic="compatible">
            <p>
                As with any generification, it is possible for old code to no longer compile. E.g.
            </p>
            <pre>List&lt;X&gt; = lookup.lookup(folder, X.class);</pre>
            <p>
                must be changed to:
            </p>
            <pre>List&lt;? extends X&gt; = lookup.lookup(folder, X.class);</pre>
        </compatibility>
        <description>
            <p>
                <code>ContextProvider</code> is now properly generified, and implemented also by:
            </p>
            <ul>
                <li><code>DebuggerEngine</code></li>
                <li><code>DebuggerInfo</code></li>
                <li><code>DebuggerManager</code></li>
                <li><code>Session</code></li>
            </ul>
        </description>
        <class package="org.netbeans.api.debugger" name="DebuggerEngine"/>
        <class package="org.netbeans.api.debugger" name="DebuggerInfo"/>
        <class package="org.netbeans.api.debugger" name="DebuggerManager"/>
        <class package="org.netbeans.api.debugger" name="Session"/>
        <issue number="128229"/>
    </change>
    <change id="debugger-dual-actions">
        <api name="DebuggerCoreAPI"/>
        <summary>Support for "dual" actions added.</summary>

Lines 1-5 Manifest-Version: 1.0 Link Here

(-)a/api.debugger/manifest.mf (-1 / +1 lines)
1	Manifest-Version: 1.0	1	Manifest-Version: 1.0
2	OpenIDE-Module: org.netbeans.api.debugger/1	2	OpenIDE-Module: org.netbeans.api.debugger/1
3	OpenIDE-Module-Localizing-Bundle: org/netbeans/api/debugger/Bundle.properties	3	OpenIDE-Module-Localizing-Bundle: org/netbeans/api/debugger/Bundle.properties
4	OpenIDE-Module-Specification-Version: 1.12	4	OpenIDE-Module-Specification-Version: 1.13
5		5

Lines 418-426 public final class ActionsManager { Link Here

(-)a/api.debugger/src/org/netbeans/api/debugger/ActionsManager.java (-3 / +1 lines)
418		418
419	private void initActionImpls () {	419	private void initActionImpls () {
420	actionProviders = new HashMap ();	420	actionProviders = new HashMap ();
421	Iterator i = lookup.lookup (null, ActionsProvider.class).iterator ();	421	for (ActionsProvider ap : lookup.lookup(null, ActionsProvider.class)) {
422	while (i.hasNext ()) {
423	ActionsProvider ap = (ActionsProvider) i.next ();
424	Iterator ii = ap.getActions ().iterator ();	422	Iterator ii = ap.getActions ().iterator ();
425	while (ii.hasNext ())	423	while (ii.hasNext ())
426	registerActionsProvider (ii.next (), ap);	424	registerActionsProvider (ii.next (), ap);





package org.netbeans.api.debugger;

import java.util.List;
import org.netbeans.spi.debugger.ContextProvider;
import java.util.*;

/**
 * Debugger Engine represents implementation of one debugger (Java Debugger,

 *
 * @author   Jan Jancura
 */
public final class DebuggerEngine implements ContextProvider {
    
    
    // variables ...............................................................

     * @param service a type of service to look for
     * @return list of services of given type
     */
    public <T> List<? extends T> lookup(String folder, Class<T> service) {
        return lookup.lookup (folder, service);
    }
    

     * @param service a type of service to look for
     * @return ne service of given type
     */
    public <T> T lookupFirst(String folder, Class<T> service) {
        return lookup.lookupFirst (folder, service);
    }
    




package org.netbeans.api.debugger;

import java.util.List;
import org.netbeans.spi.debugger.ContextProvider;


/**

 *
 * @author   Jan Jancura
 */
public final class DebuggerInfo implements ContextProvider {

    private Lookup lookup;


     * @param service a type of service to look for
     * @return list of services of given type
     */
    public <T> List<? extends T> lookup(String folder, Class<T> service) {
        return lookup.lookup (folder, service);
    }
    

     * @param service a type of service to look for
     * @return ne service of given type
     */
    public <T> T lookupFirst(String folder, Class<T> service) {
        return lookup.lookupFirst (folder, service);
    }
    




import org.openide.util.Cancellable;
import org.openide.util.Task;

import org.netbeans.spi.debugger.ContextProvider;
import org.netbeans.spi.debugger.DelegatingDebuggerEngineProvider;
import org.netbeans.spi.debugger.DelegatingSessionProvider;
import org.netbeans.spi.debugger.DebuggerEngineProvider;
import org.netbeans.spi.debugger.SessionProvider;
import org.openide.modules.ModuleInfo;
import org.openide.util.WeakListeners;
import org.openide.util.WeakSet;


/**

 *
 * @author Jan Jancura
 */
public final class DebuggerManager implements ContextProvider {
    
    // TODO: deprecate all these properties. They are useless, since there are
    //       dedicated methods in DebuggerManagerListener

     * @param service a type of service to look for
     * @return list of services of given type
     */
    public <T> List<? extends T> lookup(String folder, Class<T> service) {
        return lookup.lookup (folder, service);
    }
    

     * @param service a type of service to look for
     * @return ne service of given type
     */
    public <T> T lookupFirst(String folder, Class<T> service) {
        return lookup.lookupFirst (folder, service);
    }
    

    // helper methods ....................................................
    
    private Set<LazyDebuggerManagerListener> loadedListeners;
    private List<? extends LazyDebuggerManagerListener> listenersLookupList;
    
    private void initDebuggerManagerListeners () {
        synchronized (listenersMap) {

                ((Customizer) listenersLookupList).addPropertyChangeListener(new PropertyChangeListener() {

                    public void propertyChange(PropertyChangeEvent evt) {
                        refreshDebuggerManagerListeners((List<? extends LazyDebuggerManagerListener>) evt.getSource());
                    }
                });
            }

        }
    }
    
    private void refreshDebuggerManagerListeners(List<? extends LazyDebuggerManagerListener> listenersLookupList) {
        //System.err.println("\n refreshDebuggerManagerListeners()");
        //It's neccessary to pay attention on the order in which the listeners and breakpoints are registered!
        //Annotation listeners must be unregistered AFTER breakpoints are removed




import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;

import java.util.logging.Level;
import java.util.logging.Logger;
import org.netbeans.spi.debugger.ContextProvider;
import org.openide.ErrorManager;
import org.openide.modules.ModuleInfo;

    public static final String NOTIFY_UNLOAD_FIRST = "unload first";
    public static final String NOTIFY_UNLOAD_LAST = "unload last";
    
    public <T> T lookupFirst(String folder, Class<T> service) {
        List<? extends T> l = lookup(folder, service);
        synchronized (l) {
            if (l.isEmpty ()) return null;
            return l.get (0);
        }
    }
    
    public abstract <T> List<? extends T> lookup(String folder, Class<T> service);
    
    
    private static boolean verbose = 

            this.services = services;
        }
        
        public <T> List<? extends T> lookup(String folder, Class<T> service) {
            List<T> l = new ArrayList<T>();
            for (Object s : services) {
                if (service.isInstance(s)) {
                    l.add(service.cast(s));
                    l.add (services [i]);
                    if (verbose)
                        System.out.println("\nR  instance " + s + " found");
                            " found");
                }
            }
            return l;
        }
        
    }
    
    static class Compound extends Lookup {

            setContext (this);
        }
        
        public <T> List<? extends T> lookup(String folder, Class<T> service) {
            return new CompoundLookupList<T>(folder, service);
            /*List l = new LookupList(null);
            l.addAll (l1.lookup (folder, service));
            l.addAll (l2.lookup (folder, service));

            if (l2 instanceof MetaInf) ((MetaInf) l2).setContext (context);
        }
        
        private class CompoundLookupList<T> extends LookupList<T> implements Customizer,
                                                                       PropertyChangeListener {
            
            private String folder;
            private Class<T> service;
            private List<PropertyChangeListener> propertyChangeListeners;
            private Customizer sublist1, sublist2;
            
            public CompoundLookupList(String folder, Class<T> service) {
                super(null);
                this.folder = folder;
                this.service = service;

            
            private synchronized void setUp() {
                clear();
                List<? extends T> list1 = l1.lookup(folder, service);
                List<? extends T> list2 = l2.lookup(folder, service);
                addAll (list1);
                addAll (list2);
                sublist1 = (list1 instanceof Customizer) ? (Customizer) list1 : null;

        private static final String HIDDEN = "-hidden"; // NOI18N
        
        private String rootFolder;
        private Map<String,List<String>> registrationCache = new HashMap<String,List<String>>();
        private HashMap<String, Object> instanceCache = new HashMap<String, Object>();
        private Lookup context;
        private org.openide.util.Lookup.Result<ModuleInfo> moduleLookupResult;

        
        MetaInf (String rootFolder) {
            this.rootFolder = rootFolder;
            moduleLookupResult = org.openide.util.Lookup.getDefault().lookupResult(ModuleInfo.class);
                    new org.openide.util.Lookup.Template(ModuleInfo.class));
            //System.err.println("\nModules = "+moduleLookupResult.allInstances().size()+"\n");
            modulesChangeListener = new ModuleChangeListener(null);
            moduleLookupResult.addLookupListener(

            this.context = context;
        }
        
        public <T> List<? extends T> lookup(String folder, Class<T> service) {
            MetaInfLookupList<T> mll = new MetaInfLookupList<T>(folder, service);
            synchronized (lookupLists) {
                lookupLists.add(mll);
            }
            return mll;
        }
        
        private List<String> list(String folder, Class<?> service) {
            String name = service.getName ();
            String resourceName = "META-INF/debugger/" +
                ((rootFolder == null) ? "" : rootFolder + "/") + 
                ((folder == null) ? "" : folder + "/") + 
                name;
            synchronized(registrationCache) {
                List<String> l = registrationCache.get(resourceName);
                if (l == null) {
                    l = loadMetaInf(resourceName);
                    registrationCache.put(resourceName, l);
                }
                return l;
            }
        }
    

         * Loads instances of given class from META-INF/debugger from given
         * folder. Given context isused as the parameter to constructor.
         */
        private List<String> loadMetaInf(String resourceName) {
            List<String> l = new ArrayList<String>();
        ) {
            ArrayList l = new ArrayList ();
            try {
                ClassLoader cl = org.openide.util.Lookup.getDefault().lookup(ClassLoader.class);
                    getDefault ().lookup (ClassLoader.class);
                String v = "\nR lookup " + resourceName;
                Enumeration<URL> e = cl.getResources(resourceName);
                Set<URL> urls = new HashSet<URL>();
                while (e.hasMoreElements ()) {
                    URL url = e.nextElement();
                    // Ignore duplicated URLs, necessary because of tests
                    if (urls.contains(url)) continue;
                    urls.add(url);

        
        private Object createInstance (String service) {
            try {
                ClassLoader cl = org.openide.util.Lookup.getDefault().lookup(ClassLoader.class);
                    getDefault ().lookup (ClassLoader.class);
                String method = null;
                if (service.endsWith("()")) {
                    int lastdot = service.lastIndexOf('.');

         * The refreshing is performed under a lock on this list object so that
         * clients have consistent data under synchronization on this.
         */
        private final class MetaInfLookupList<T> extends LookupList<T> implements Customizer {
            
            private String folder;
            private final Class<T> service;
            private List<PropertyChangeListener> propertyChangeListeners;
            public int notifyLoadOrder = 0;
            public int notifyUnloadOrder = 0;
            
            public MetaInfLookupList(String folder, Class<T> service) {
                this(list(folder, service), service);
                this.folder = folder;
                this.service = service;
            }
            
            private MetaInfLookupList(List<String> l, Class<T> service) {
                this(l, getHiddenClassNames(l), service);
            }
            
            private MetaInfLookupList(List<String> l, Set<String> s, Class<T> service) {
                super(s);
                assert service != null;
                this.service = service;
                fillInstances(l, s);
                listenOnDisabledModules();
            }
            
            private void fillInstances(List<String> l, Set<String> s) {
                for (String className : l) {
                for (i = 0; i < k; i++) {
                    String className = (String) l.get (i);
                    if (className.endsWith(HIDDEN)) continue;
                    if (s != null && s.contains (className)) continue;
                    Object instance = null;

                        }
                    }
                    if (instance != null) {
                        try {
                            add(service.cast(instance), className);
                        } catch (ClassCastException cce) {
                            Logger.getLogger(Lookup.class.getName()).log(Level.WARNING, null, cce);
                        }
                        listenOn(instance.getClass().getClassLoader());
                    }
                }

                // Perform changes under a lock so that iterators reading this list
                // can sync on it
                clear();
                List<String> l = list(folder, service);
                Set<String> s = getHiddenClassNames(l);
                hiddenClassNames = s;
                fillInstances(l, s);

     * A special List implementation, which ensures that hidden elements
     * are removed when adding items into the list.
     */
    private static class LookupList<T> extends ArrayList<T> {

        protected Set<String> hiddenClassNames;
        private LinkedHashMap<T, String> instanceClassNames = new LinkedHashMap<T, String>();

        public LookupList(Set<String> hiddenClassNames) {
            this.hiddenClassNames = hiddenClassNames;
        }
        
        void add(T instance, String className) {
            super.add(instance);
            instanceClassNames.put(instance, className);
        }
        
        @Override
        public boolean addAll(Collection<? extends T> c) {
            if (c instanceof LookupList) {
                @SuppressWarnings("unchecked") // XXX possible to remove using more clever pattern with Class.cast
                LookupList<? extends T> ll = (LookupList<? extends T>) c;
                synchronized (ll) {
                synchronized (this) {
                    Set<String> newHiddenClassNames = ll.hiddenClassNames;

                    }
                    ensureCapacity(size() + ll.size());
                    boolean addedAnything = false;
                    for (T instance : ll) {
                        Object instance = it.next();
                        String className = ll.instanceClassNames.get(instance);
                        if (hiddenClassNames == null || !hiddenClassNames.contains(className)) {
                            add(instance, className);

Lines 489-495 public abstract class Properties { Link Here

(-)a/api.debugger/src/org/netbeans/api/debugger/Properties.java (-1 / +1 lines)
489	private static final Collection BAD_COLLECTION = new ArrayList ();	489	private static final Collection BAD_COLLECTION = new ArrayList ();
490	private static final Object[] BAD_ARRAY = new Object [0];	490	private static final Object[] BAD_ARRAY = new Object [0];
491		491
492	private List<Reader> readersList;	492	private List<? extends Reader> readersList;
493	private HashMap<String, Reader> register;	493	private HashMap<String, Reader> register;
494		494
495		495




import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import org.netbeans.spi.debugger.ContextProvider;


/** Session visually represents one process or application. It should

 *
 * @author Jan Jancura
 */
public final class Session implements ContextProvider {
    
    /** Name of property for current language. */
    public static final String PROP_CURRENT_LANGUAGE = "currentLanguage";

     * @param service a type of service to look for
     * @return list of services of given type
     */
    public <T> List<? extends T> lookup(String folder, Class<T> service) {
        return lookup.lookup (folder, service);
    }
    

     * @param service a type of service to look for
     * @return ne service of given type
     */
    public <T> T lookupFirst(String folder, Class<T> service) {
        return lookup.lookupFirst (folder, service);
    }
    

Lines 58-64 public interface ContextProvider { Link Here

(-)a/api.debugger/src/org/netbeans/spi/debugger/ContextProvider.java (-2 / +2 lines)
58	* @param service a type of service to look for	58	* @param service a type of service to look for
59	* @return list of services of given type	59	* @return list of services of given type
60	*/	60	*/
61	public abstract List lookup (String folder, Class service);	61	<T> List<? extends T> lookup(String folder, Class<T> service);
62		62
63	/**	63	/**
64	* Returns one service of given type from given folder.	64	* Returns one service of given type from given folder.
Lines 67-72 public interface ContextProvider { Link Here
67	* @param service a type of service to look for	67	* @param service a type of service to look for
68	* @return ne service of given type	68	* @return ne service of given type
69	*/	69	*/
70	public abstract Object lookupFirst (String folder, Class service);	70	<T> T lookupFirst(String folder, Class<T> service);
71	}	71	}
72		72




      if (provider == null) {
        throw new IllegalArgumentException("Can't return tracer for null");// NOI18N
      }
      return getTracer (provider.lookupFirst(null, Session.class));
    }

    /**

    private static TracerFactory getTracerFactory() {
        if (ourTracerFactory == null) {
            ourTracerFactory =
              DebuggerManager.getDebuggerManager().lookupFirst(null, TracerFactory.class);
                null, TracerFactory.class
              );
            assert ourTracerFactory != null : "Can't find Tracer Factory"; // NOI18N
        }
        return ourTracerFactory;

Lines 107-114 public class CurrentPositionAnnotationLi Link Here

(-)a/bpel.debugger.ui/src/org/netbeans/modules/bpel/debugger/ui/CurrentPositionAnnotationListener.java (-3 / +2 lines)
107	return null;	107	return null;
108	}	108	}
109		109
110	return (BpelDebugger) currentEngine.lookupFirst(	110	return currentEngine.lookupFirst(null, BpelDebugger.class);
111	null, BpelDebugger.class);
112	}	111	}
113		112
114	private static SourcePath getCurrentSourcePath() {	113	private static SourcePath getCurrentSourcePath() {
Lines 119-125 public class CurrentPositionAnnotationLi Link Here
119	return null;	118	return null;
120	}	119	}
121		120
122	return (SourcePath)currentEngine.lookupFirst(null, SourcePath.class);	121	return currentEngine.lookupFirst(null, SourcePath.class);
123	}	122	}
124		123
125	private void updateCurrentPosition() {	124	private void updateCurrentPosition() {

Lines 73-79 public class CurrentProcessInstanceListe Link Here

(-)a/bpel.debugger.ui/src/org/netbeans/modules/bpel/debugger/ui/CurrentProcessInstanceListener.java (-2 / +2 lines)
73	return;	73	return;
74	}	74	}
75		75
76	debugger = (BpelDebugger) engine.lookupFirst(null, BpelDebugger.class);	76	debugger = engine.lookupFirst(null, BpelDebugger.class);
77		77
78	if (debugger == null) {	78	if (debugger == null) {
79	return;	79	return;
Lines 81-87 public class CurrentProcessInstanceListe Link Here
81		81
82	debugger.addPropertyChangeListener(this);	82	debugger.addPropertyChangeListener(this);
83		83
84	sourcePath = (SourcePath) engine.lookupFirst(null, SourcePath.class);	84	sourcePath = engine.lookupFirst(null, SourcePath.class);
85		85
86	if (sourcePath == null) {	86	if (sourcePath == null) {
87	return;	87	return;

Lines 109-115 public class ExecutionAnnotationsListene Link Here

(-)a/bpel.debugger.ui/src/org/netbeans/modules/bpel/debugger/ui/ExecutionAnnotationsListener.java (-2 / +2 lines)
109	if (currentEngine == null) {	109	if (currentEngine == null) {
110	return null;	110	return null;
111	}	111	}
112	return (BpelDebugger)currentEngine.lookupFirst(null, BpelDebugger.class);	112	return currentEngine.lookupFirst(null, BpelDebugger.class);
113	}	113	}
114		114
115	private static SourcePath getCurrentSourcePath() {	115	private static SourcePath getCurrentSourcePath() {
Lines 118-124 public class ExecutionAnnotationsListene Link Here
118	if (currentEngine == null) {	118	if (currentEngine == null) {
119	return null;	119	return null;
120	}	120	}
121	return (SourcePath)currentEngine.lookupFirst(null, SourcePath.class);	121	return currentEngine.lookupFirst(null, SourcePath.class);
122	}	122	}
123		123
124	private void updateCurrentProcessInstance() {	124	private void updateCurrentProcessInstance() {

Lines 37-43 abstract class Action extends ActionsPro Link Here

(-)a/bpel.debugger.ui/src/org/netbeans/modules/bpel/debugger/ui/action/Action.java (-1 / +1 lines)
37	{	37	{
38	Action(ContextProvider provider, Object action) {	38	Action(ContextProvider provider, Object action) {
39	myAction = action;	39	myAction = action;
40	myDebugger = (BpelDebugger) provider.lookupFirst (null, BpelDebugger.class);	40	myDebugger = provider.lookupFirst(null, BpelDebugger.class);
41	myDebugger.addPropertyChangeListener(BpelDebugger.PROP_STATE, this);	41	myDebugger.addPropertyChangeListener(BpelDebugger.PROP_STATE, this);
42	}	42	}
43		43

Lines 48-54 public abstract class BpelActionsProvide Link Here

(-)a/bpel.debugger.ui/src/org/netbeans/modules/bpel/debugger/ui/action/BpelActionsProviderSupport.java (-1 / +1 lines)
48	mLookupProvider = lookupProvider;	48	mLookupProvider = lookupProvider;
49	mAction = action;	49	mAction = action;
50	mDebugger =	50	mDebugger =
51	(BpelDebugger) mLookupProvider.lookupFirst(null, BpelDebugger.class);	51	mLookupProvider.lookupFirst(null, BpelDebugger.class);
52	setEnabled(true);	52	setEnabled(true);
53	}	53	}
54		54

Lines 273-281 public class Breakpoint extends ActionsP Link Here

(-)a/bpel.debugger.ui/src/org/netbeans/modules/bpel/debugger/ui/action/Breakpoint.java (-3 / +1 lines)
273		273
274	private BpelBreakpointListener getBreakpointAnnotationListener() {	274	private BpelBreakpointListener getBreakpointAnnotationListener() {
275	if (myBreakpointAnnotationListener == null) {	275	if (myBreakpointAnnotationListener == null) {
276	myBreakpointAnnotationListener = (BpelBreakpointListener)	276	myBreakpointAnnotationListener = DebuggerManager.getDebuggerManager().lookupFirst(null, BpelBreakpointListener.class);
277	DebuggerManager.getDebuggerManager().lookupFirst
278	(null, BpelBreakpointListener.class);
279	}	277	}
280		278
281	return myBreakpointAnnotationListener;	279	return myBreakpointAnnotationListener;

Lines 148-156 public class BreakpointEnableAction exte Link Here

(-)a/bpel.debugger.ui/src/org/netbeans/modules/bpel/debugger/ui/action/BreakpointEnableAction.java (-3 / +1 lines)
148		148
149	private BpelBreakpointListener getBreakpointAnnotationListener () {	149	private BpelBreakpointListener getBreakpointAnnotationListener () {
150	if (myBreakpointAnnotationListener == null) {	150	if (myBreakpointAnnotationListener == null) {
151	myBreakpointAnnotationListener = (BpelBreakpointListener)	151	myBreakpointAnnotationListener = DebuggerManager.getDebuggerManager().lookupFirst(null, BpelBreakpointListener.class);
152	DebuggerManager.getDebuggerManager ().lookupFirst
153	(null, BpelBreakpointListener.class);
154	}	152	}
155	return myBreakpointAnnotationListener;	153	return myBreakpointAnnotationListener;
156	}	154	}

Lines 130-138 public class BpelLineBreakpointView exte Link Here

(-)a/bpel.debugger.ui/src/org/netbeans/modules/bpel/debugger/ui/breakpoint/BpelLineBreakpointView.java (-3 / +1 lines)
130		130
131	private BpelBreakpointListener getBreakpointListener() {	131	private BpelBreakpointListener getBreakpointListener() {
132	if (myBreakpointListener == null) {	132	if (myBreakpointListener == null) {
133	myBreakpointListener = (BpelBreakpointListener)	133	myBreakpointListener = DebuggerManager.getDebuggerManager().lookupFirst(null, BpelBreakpointListener.class);
134	DebuggerManager.getDebuggerManager().lookupFirst
135	(null, BpelBreakpointListener.class);
136	}	134	}
137		135
138	return myBreakpointListener;	136	return myBreakpointListener;

Lines 126-134 public class DebuggerHelperImpl implemen Link Here

(-)a/bpel.debugger.ui/src/org/netbeans/modules/bpel/debugger/ui/breakpoint/DebuggerHelperImpl.java (-3 / +1 lines)
126		126
127	private BpelBreakpointListener getBreakpointAnnotationListener () {	127	private BpelBreakpointListener getBreakpointAnnotationListener () {
128	if (myBreakpointAnnotationListener == null) {	128	if (myBreakpointAnnotationListener == null) {
129	myBreakpointAnnotationListener = (BpelBreakpointListener)	129	myBreakpointAnnotationListener = DebuggerManager.getDebuggerManager().lookupFirst(null, BpelBreakpointListener.class);
130	DebuggerManager.getDebuggerManager ().lookupFirst
131	(null, BpelBreakpointListener.class);
132	}	130	}
133		131
134	return myBreakpointAnnotationListener;	132	return myBreakpointAnnotationListener;

Lines 56-63 public class ProcessExecutionTreeModel i Link Here

(-)a/bpel.debugger.ui/src/org/netbeans/modules/bpel/debugger/ui/execution/ProcessExecutionTreeModel.java (-2 / +1 lines)
56	*/	56	*/
57	public ProcessExecutionTreeModel(	57	public ProcessExecutionTreeModel(
58	final ContextProvider contextProvider) {	58	final ContextProvider contextProvider) {
59	myDebugger = (BpelDebugger) contextProvider.lookupFirst(	59	myDebugger = contextProvider.lookupFirst(null, BpelDebugger.class);
60	null, BpelDebugger.class);
61	}	60	}
62		61
63	/*{@inheritDoc}/	62	/*{@inheritDoc}/




        Models.setModelsToView(myView, Models.createCompoundModel(models));
    }

    // XXX copy-paste programming!
    private <T> List<? extends T> lookup(
            final DebuggerEngine engine,
            final DebuggerManager manager,
            final Class<T> service) {
        final List<? extends T> engineService = engine.lookup(myViewType, service);
        final List<? extends T> managerService = manager.lookup(myViewType, service);
        final List<T> joined = new ArrayList<T>();
        
        add(joined, engineService);
        add(joined, managerService);

        return joined;
    }
    
    private <T> void add(
            final List<T> source, 
            final List<? extends T> collection) {
        for (T element : collection) {

        for (Object element : elements) {
          if (!source.contains(element)) {
              source.add(element);
          }

Lines 59-66 public class PLinksTableModel implements Link Here

(-)a/bpel.debugger.ui/src/org/netbeans/modules/bpel/debugger/ui/plinks/PLinksTableModel.java (-2 / +1 lines)
59	public PLinksTableModel(	59	public PLinksTableModel(
60	final ContextProvider contextProvider) {	60	final ContextProvider contextProvider) {
61		61
62	myDebugger = (BpelDebugger) contextProvider.lookupFirst(	62	myDebugger = contextProvider.lookupFirst(null, BpelDebugger.class);
63	null, BpelDebugger.class);
64	}	63	}
65		64
66	/*{@inheritDoc}/	65	/*{@inheritDoc}/

Lines 71-78 public class PLinksTreeModel implements Link Here

(-)a/bpel.debugger.ui/src/org/netbeans/modules/bpel/debugger/ui/plinks/PLinksTreeModel.java (-2 / +1 lines)
71	*/	71	*/
72	public PLinksTreeModel(	72	public PLinksTreeModel(
73	final ContextProvider contextProvider) {	73	final ContextProvider contextProvider) {
74	myDebugger = (BpelDebugger) contextProvider.lookupFirst(	74	myDebugger = contextProvider.lookupFirst(null, BpelDebugger.class);
75	null, BpelDebugger.class);
76	}	75	}
77		76
78	/*{@inheritDoc}/	77	/*{@inheritDoc}/




        Models.setModelsToView(myView, Models.createCompoundModel(models));
    }

    // XXX copy-paste programming!
    private <T> List<? extends T> lookup(
            final DebuggerEngine engine,
            final DebuggerManager manager,
            final Class<T> service) {
        final List<? extends T> engineService = engine.lookup(myViewType, service);
        final List<? extends T> managerService = manager.lookup(myViewType, service);
        final List<T> joined = new ArrayList<T>();
        
        add(joined, engineService);
        add(joined, managerService);

        return joined;
    }
    
    private <T> void add(
            final List<T> source, 
            final List<? extends T> collection) {
        for (T element : collection) {

        for (Object element : elements) {
          if (!source.contains(element)) {
              source.add(element);
          }

Lines 118-125 public class ProcessesActionProvider imp Link Here

(-)a/bpel.debugger.ui/src/org/netbeans/modules/bpel/debugger/ui/process/ProcessesActionProvider.java (-2 / +1 lines)
118	public ProcessesActionProvider(	118	public ProcessesActionProvider(
119	final ContextProvider contextProvider) {	119	final ContextProvider contextProvider) {
120		120
121	myDebugger = (BpelDebugger)	121	myDebugger = contextProvider.lookupFirst(null, BpelDebugger.class);
122	contextProvider.lookupFirst(null, BpelDebugger.class);
123	}	122	}
124		123
125	/*{@inheritDoc}/	124	/*{@inheritDoc}/

Lines 45-52 public final class ProcessesColumnModel_ Link Here

(-)a/bpel.debugger.ui/src/org/netbeans/modules/bpel/debugger/ui/process/ProcessesColumnModel_Value.java (-2 / +1 lines)
45	public ProcessesColumnModel_Value(final ContextProvider context) {	45	public ProcessesColumnModel_Value(final ContextProvider context) {
46	super();	46	super();
47		47
48	myDebugger = (BpelDebugger) context.lookupFirst(	48	myDebugger = context.lookupFirst(null, BpelDebugger.class);
49	null, BpelDebugger.class);
50		49
51	myId = COLUMN_ID;	50	myId = COLUMN_ID;
52	myName = "CTL_Process_Column_Value"; // NOI18N	51	myName = "CTL_Process_Column_Value"; // NOI18N

Lines 54-61 public class ProcessesNodeModel implemen Link Here

(-)a/bpel.debugger.ui/src/org/netbeans/modules/bpel/debugger/ui/process/ProcessesNodeModel.java (-2 / +1 lines)
54	public ProcessesNodeModel(	54	public ProcessesNodeModel(
55	final ContextProvider contextProvider) {	55	final ContextProvider contextProvider) {
56		56
57	myDebugger = (BpelDebugger)	57	myDebugger = contextProvider.lookupFirst(null, BpelDebugger.class);
58	contextProvider.lookupFirst(null, BpelDebugger.class);
59	myVariablesUtil = new VariablesUtil(myDebugger);	58	myVariablesUtil = new VariablesUtil(myDebugger);
60	}	59	}
61		60

Lines 55-62 public class ProcessesTableModel impleme Link Here

(-)a/bpel.debugger.ui/src/org/netbeans/modules/bpel/debugger/ui/process/ProcessesTableModel.java (-2 / +1 lines)
55	public ProcessesTableModel(	55	public ProcessesTableModel(
56	final ContextProvider lookupProvider) {	56	final ContextProvider lookupProvider) {
57		57
58	myDebugger = (BpelDebugger)	58	myDebugger = lookupProvider.lookupFirst(null, BpelDebugger.class);
59	lookupProvider.lookupFirst(null, BpelDebugger.class);
60	myVariablesUtil = new VariablesUtil(myDebugger);	59	myVariablesUtil = new VariablesUtil(myDebugger);
61	}	60	}
62		61

Lines 42-49 public class ProcessesTreeExpansionModel Link Here

(-)a/bpel.debugger.ui/src/org/netbeans/modules/bpel/debugger/ui/process/ProcessesTreeExpansionModel.java (-2 / +1 lines)
42	public ProcessesTreeExpansionModel(	42	public ProcessesTreeExpansionModel(
43	final ContextProvider lookupProvider) {	43	final ContextProvider lookupProvider) {
44		44
45	myDebugger = (BpelDebugger)	45	myDebugger = lookupProvider.lookupFirst(null, BpelDebugger.class);
46	lookupProvider.lookupFirst(null, BpelDebugger.class);
47	}	46	}
48		47
49	/*{@inheritDoc}/	48	/*{@inheritDoc}/

Lines 73-80 public class ProcessesTreeModel implemen Link Here

(-)a/bpel.debugger.ui/src/org/netbeans/modules/bpel/debugger/ui/process/ProcessesTreeModel.java (-2 / +1 lines)
73	public ProcessesTreeModel(	73	public ProcessesTreeModel(
74	final ContextProvider lookupProvider) {	74	final ContextProvider lookupProvider) {
75		75
76	myDebugger = (BpelDebugger)	76	myDebugger = lookupProvider.lookupFirst(null, BpelDebugger.class);
77	lookupProvider.lookupFirst(null, BpelDebugger.class);
78	myVariablesUtil = new VariablesUtil(myDebugger);	77	myVariablesUtil = new VariablesUtil(myDebugger);
79	}	78	}
80		79




        Models.setModelsToView (myView, Models.createCompoundModel (models));
    }

    // XXX copy-paste programming!
    private <T> List<? extends T> lookup(
            final DebuggerEngine engine,
            final DebuggerManager manager,
            final Class<T> service) {
        final List<? extends T> engineService = engine.lookup(myViewType, service);
        final List<? extends T> managerService = manager.lookup(myViewType, service);
        final List<T> joined = new ArrayList<T>();
        
        add(joined, engineService);
        add(joined, managerService);
        
        return joined;
    }
    
    private <T> void add(
            final List<T> source, 
            final List<? extends T> collection) {
        for (T element : collection) {
          if (!source.contains(element)) {
              source.add(element);
          }
        }
    }

    private String myViewType;

Lines 41-48 public class BpelSessionView Link Here

(-)a/bpel.debugger.ui/src/org/netbeans/modules/bpel/debugger/ui/session/BpelSessionView.java (-3 / +2 lines)
41	private Vector listeners = new Vector();	41	private Vector listeners = new Vector();
42		42
43	public BpelSessionView(ContextProvider contextProvider) {	43	public BpelSessionView(ContextProvider contextProvider) {
44	BpelDebugger debugger = (BpelDebugger) contextProvider.	44	BpelDebugger debugger = contextProvider.lookupFirst(null, BpelDebugger.class);
45	lookupFirst (null, BpelDebugger.class);
46	debugger.addPropertyChangeListener(debugger.PROP_STATE, this);	45	debugger.addPropertyChangeListener(debugger.PROP_STATE, this);
47	}	46	}
48		47
Lines 55-61 public class BpelSessionView Link Here
55	if (e == null) {	54	if (e == null) {
56	return "";	55	return "";
57	}	56	}
58	BpelDebugger d = (BpelDebugger)e.lookupFirst(null, BpelDebugger.class);	57	BpelDebugger d = e.lookupFirst(null, BpelDebugger.class);
59	if (d != null) {	58	if (d != null) {
60	switch (d.getState()) {	59	switch (d.getState()) {
61	case BpelDebugger.STATE_DISCONNECTED:	60	case BpelDebugger.STATE_DISCONNECTED:




     */
    public SourcePathImpl(ContextProvider lookupProvider) {
        myLookupProvider = lookupProvider;
        myDebugger = lookupProvider.lookupFirst(null, BpelDebugger.class);
        mySourcesRegistry = Lookup.getDefault().lookup(BpelSourcesRegistry.class);
        mySourcesRegistry = (BpelSourcesRegistry)Lookup.
                getDefault().lookup(BpelSourcesRegistry.class);
        updateAvailableSources();
    }
    

    
    private synchronized SessionCookie getSessionCookie() {
        if (mySessionCookie == null) {
            mySessionCookie = myLookupProvider.lookupFirst(null, SessionCookie.class);
                    null, SessionCookie.class);
        }
        return mySessionCookie;
    }
    
    private synchronized SourcePathSelectionProvider getSelectionProvider() {
        if (mySelectionProvider == null) {
            mySelectionProvider = myLookupProvider.lookupFirst(null, SourcePathSelectionProvider.class);
                    null, SourcePathSelectionProvider.class);
        }
        return mySelectionProvider;
    }

Lines 61-70 NodeActionsProvider { Link Here

(-)a/bpel.debugger.ui/src/org/netbeans/modules/bpel/debugger/ui/source/SourcesModel.java (-4 / +2 lines)
61	private Set disabledSourceRoots = new HashSet ();	61	private Set disabledSourceRoots = new HashSet ();
62		62
63	public SourcesModel (ContextProvider lookupProvider) {	63	public SourcesModel (ContextProvider lookupProvider) {
64	sourcePath = (SourcePath) lookupProvider.	64	sourcePath = lookupProvider.lookupFirst(null, SourcePath.class);
65	lookupFirst (null, SourcePath.class);	65	debugger = lookupProvider.lookupFirst(null, BpelDebugger.class);
66	debugger = (BpelDebugger) lookupProvider.
67	lookupFirst (null, BpelDebugger.class);
68	}	66	}
69		67
70		68

Lines 68-75 public class ThreadsActionProvider imple Link Here

(-)a/bpel.debugger.ui/src/org/netbeans/modules/bpel/debugger/ui/threads/ThreadsActionProvider.java (-2 / +1 lines)
68	public ThreadsActionProvider(	68	public ThreadsActionProvider(
69	final ContextProvider contextProvider) {	69	final ContextProvider contextProvider) {
70		70
71	myDebugger = (BpelDebugger)	71	myDebugger = contextProvider.lookupFirst(null, BpelDebugger.class);
72	contextProvider.lookupFirst(null, BpelDebugger.class);
73	}	72	}
74		73
75	/*{@inheritDoc}/	74	/*{@inheritDoc}/

Lines 41-48 public class ThreadsNodeModel implements Link Here

(-)a/bpel.debugger.ui/src/org/netbeans/modules/bpel/debugger/ui/threads/ThreadsNodeModel.java (-2 / +1 lines)
41		41
42	public ThreadsNodeModel(	42	public ThreadsNodeModel(
43	final ContextProvider contextProvider) {	43	final ContextProvider contextProvider) {
44	myDebugger = (BpelDebugger) contextProvider.lookupFirst(	44	myDebugger = contextProvider.lookupFirst(null, BpelDebugger.class);
45	null, BpelDebugger.class);
46	}	45	}
47		46
48	/*{@inheritDoc}/	47	/*{@inheritDoc}/

Lines 45-52 public class ThreadsTableModel implement Link Here

(-)a/bpel.debugger.ui/src/org/netbeans/modules/bpel/debugger/ui/threads/ThreadsTableModel.java (-2 / +1 lines)
45	public ThreadsTableModel(	45	public ThreadsTableModel(
46	final ContextProvider contextProvider) {	46	final ContextProvider contextProvider) {
47		47
48	myDebugger = (BpelDebugger) contextProvider.lookupFirst(	48	myDebugger = contextProvider.lookupFirst(null, BpelDebugger.class);
49	null, BpelDebugger.class);
50	}	49	}
51		50
52	/*{@inheritDoc}/	51	/*{@inheritDoc}/

Lines 52-59 public class ThreadsTreeModel implements Link Here

(-)a/bpel.debugger.ui/src/org/netbeans/modules/bpel/debugger/ui/threads/ThreadsTreeModel.java (-2 / +1 lines)
52	*/	52	*/
53	public ThreadsTreeModel(	53	public ThreadsTreeModel(
54	final ContextProvider contextProvider) {	54	final ContextProvider contextProvider) {
55	myDebugger = (BpelDebugger) contextProvider.lookupFirst(	55	myDebugger = contextProvider.lookupFirst(null, BpelDebugger.class);
56	null, BpelDebugger.class);
57	}	56	}
58		57
59	/*{@inheritDoc}/	58	/*{@inheritDoc}/

Lines 74-80 public final class ModelUtil { Link Here

(-)a/bpel.debugger.ui/src/org/netbeans/modules/bpel/debugger/ui/util/ModelUtil.java (-1 / +1 lines)
74	}	74	}
75		75
76	final SourcePath sourcePath =	76	final SourcePath sourcePath =
77	(SourcePath) engine.lookupFirst(null, SourcePath.class);	77	engine.lookupFirst(null, SourcePath.class);
78		78
79	if (sourcePath == null) {	79	if (sourcePath == null) {
80	return null;	80	return null;

Lines 895-901 public class VariablesUtil { Link Here

(-)a/bpel.debugger.ui/src/org/netbeans/modules/bpel/debugger/ui/util/VariablesUtil.java (-1 / +1 lines)
895	}	895	}
896		896
897	final SourcePath sourcePath =	897	final SourcePath sourcePath =
898	(SourcePath) engine.lookupFirst(null, SourcePath.class);	898	engine.lookupFirst(null, SourcePath.class);
899	final ProcessInstance instance = myDebugger.getCurrentProcessInstance();	899	final ProcessInstance instance = myDebugger.getCurrentProcessInstance();
900		900
901	if ((sourcePath == null) \|\| (instance == null)) {	901	if ((sourcePath == null) \|\| (instance == null)) {

Lines 39-46 public final class LocalsColumnModel_Typ Link Here

(-)a/bpel.debugger.ui/src/org/netbeans/modules/bpel/debugger/ui/variable/LocalsColumnModel_Type.java (-2 / +1 lines)
39	public LocalsColumnModel_Type(final ContextProvider context) {	39	public LocalsColumnModel_Type(final ContextProvider context) {
40	super();	40	super();
41		41
42	myDebugger = (BpelDebugger) context.lookupFirst(	42	myDebugger = context.lookupFirst(null, BpelDebugger.class);
43	null, BpelDebugger.class);
44		43
45	myId = Constants.LOCALS_TYPE_COLUMN_ID;	44	myId = Constants.LOCALS_TYPE_COLUMN_ID;
46	myName = "CTL_Variable_Column_Type";	45	myName = "CTL_Variable_Column_Type";

Lines 48-55 public final class LocalsColumnModel_Val Link Here

(-)a/bpel.debugger.ui/src/org/netbeans/modules/bpel/debugger/ui/variable/LocalsColumnModel_Value.java (-2 / +1 lines)
48	public LocalsColumnModel_Value(final ContextProvider context) {	48	public LocalsColumnModel_Value(final ContextProvider context) {
49	super();	49	super();
50		50
51	myDebugger = (BpelDebugger) context.lookupFirst(	51	myDebugger = context.lookupFirst(null, BpelDebugger.class);
52	null, BpelDebugger.class);
53		52
54	myId = Constants.LOCALS_VALUE_COLUMN_ID;	53	myId = Constants.LOCALS_VALUE_COLUMN_ID;
55	myName = "CTL_Variable_Column_Value";	54	myName = "CTL_Variable_Column_Value";

Lines 41-48 public class LocalsNodeModel implements Link Here

(-)a/bpel.debugger.ui/src/org/netbeans/modules/bpel/debugger/ui/variable/LocalsNodeModel.java (-2 / +1 lines)
41	public LocalsNodeModel(	41	public LocalsNodeModel(
42	final ContextProvider contextProvider) {	42	final ContextProvider contextProvider) {
43		43
44	myDebugger = (BpelDebugger) contextProvider.lookupFirst(	44	myDebugger = contextProvider.lookupFirst(null, BpelDebugger.class);
45	null, BpelDebugger.class);
46	myHelper = new VariablesUtil(myDebugger);	45	myHelper = new VariablesUtil(myDebugger);
47	}	46	}
48	/*{@inheritDoc}/	47	/*{@inheritDoc}/

Lines 49-56 public class LocalsTableModel implements Link Here

(-)a/bpel.debugger.ui/src/org/netbeans/modules/bpel/debugger/ui/variable/LocalsTableModel.java (-2 / +1 lines)
49	public LocalsTableModel(	49	public LocalsTableModel(
50	final ContextProvider contextProvider) {	50	final ContextProvider contextProvider) {
51		51
52	myDebugger = (BpelDebugger) contextProvider.lookupFirst(	52	myDebugger = contextProvider.lookupFirst(null, BpelDebugger.class);
53	null, BpelDebugger.class);
54	myHelper = new VariablesUtil(myDebugger);	53	myHelper = new VariablesUtil(myDebugger);
55	}	54	}
56		55

Lines 55-62 public class LocalsTreeModel implements Link Here

(-)a/bpel.debugger.ui/src/org/netbeans/modules/bpel/debugger/ui/variable/LocalsTreeModel.java (-2 / +1 lines)
55	*/	55	*/
56	public LocalsTreeModel(	56	public LocalsTreeModel(
57	final ContextProvider contextProvider) {	57	final ContextProvider contextProvider) {
58	myDebugger = (BpelDebugger) contextProvider.lookupFirst(	58	myDebugger = contextProvider.lookupFirst(null, BpelDebugger.class);
59	null, BpelDebugger.class);
60	myHelper = new VariablesUtil(myDebugger);	59	myHelper = new VariablesUtil(myDebugger);
61	}	60	}
62		61

Lines 48-55 public class WatchesNodeModel implements Link Here

(-)a/bpel.debugger.ui/src/org/netbeans/modules/bpel/debugger/ui/watch/WatchesNodeModel.java (-2 / +1 lines)
48	final ContextProvider contextProvider) {	48	final ContextProvider contextProvider) {
49		49
50	myContextProvider = contextProvider;	50	myContextProvider = contextProvider;
51	myDebugger = (BpelDebugger)	51	myDebugger = contextProvider.lookupFirst(null, BpelDebugger.class);
52	contextProvider.lookupFirst(null, BpelDebugger.class);
53	myHelper = new VariablesUtil(myDebugger);	52	myHelper = new VariablesUtil(myDebugger);
54	}	53	}
55		54

Lines 44-51 public class WatchesTableModel implement Link Here

(-)a/bpel.debugger.ui/src/org/netbeans/modules/bpel/debugger/ui/watch/WatchesTableModel.java (-2 / +1 lines)
44	final ContextProvider contextProvider) {	44	final ContextProvider contextProvider) {
45		45
46	myContextProvider = contextProvider;	46	myContextProvider = contextProvider;
47	myDebugger = (BpelDebugger)	47	myDebugger = contextProvider.lookupFirst(null, BpelDebugger.class);
48	contextProvider.lookupFirst(null, BpelDebugger.class);
49	myHelper = new Util(myDebugger);	48	myHelper = new Util(myDebugger);
50	}	49	}
51		50

Lines 63-70 public class WatchesTreeModel implements Link Here

(-)a/bpel.debugger.ui/src/org/netbeans/modules/bpel/debugger/ui/watch/WatchesTreeModel.java (-2 / +1 lines)
63	final ContextProvider contextProvider) {	63	final ContextProvider contextProvider) {
64		64
65	myContextProvider = contextProvider;	65	myContextProvider = contextProvider;
66	myDebugger = (BpelDebugger)	66	myDebugger = contextProvider.lookupFirst(null, BpelDebugger.class);
67	contextProvider.lookupFirst(null, BpelDebugger.class);
68	myHelper = new Util(myDebugger);	67	myHelper = new Util(myDebugger);
69	}	68	}
70		69

Lines 40-50 public class AttachingSessionCookie impl Link Here

(-)a/bpel.debugger/src/org/netbeans/modules/bpel/debugger/AttachingSessionCookie.java (-2 / +2 lines)
40	public String getSessionId() {	40	public String getSessionId() {
41	if (mySessionId == null) {	41	if (mySessionId == null) {
42	AttachingCookie attachingCookie =	42	AttachingCookie attachingCookie =
43	(AttachingCookie) myContextProvider.lookupFirst (null, AttachingCookie.class);	43	myContextProvider.lookupFirst(null, AttachingCookie.class);
44	if (attachingCookie != null) {	44	if (attachingCookie != null) {
45	mySessionId = attachingCookie.getHost() + ":" + attachingCookie.getPort();	45	mySessionId = attachingCookie.getHost() + ":" + attachingCookie.getPort();
46	} else {	46	} else {
47	Session session = (Session)myContextProvider.lookupFirst(null, Session.class);	47	Session session = myContextProvider.lookupFirst(null, Session.class);
48	mySessionId = session.getName();	48	mySessionId = session.getName();
49	}	49	}
50	}	50	}




    
    public AttachingSessionProvider (ContextProvider contextProvider) {
        this.mContextProvider = contextProvider;
        mAttachingCookie = contextProvider.lookupFirst(null, AttachingCookie.class);
            (null, AttachingCookie.class);
    };
    
    
    public String getSessionName () {
        Map arguments = mContextProvider.lookupFirst(null, Map.class);
        if (arguments != null) {
            String processName = (String) arguments.get("name");
            if (processName != null)

Lines 41-47 public class BpelDebuggerEngineProvider Link Here

(-)a/bpel.debugger/src/org/netbeans/modules/bpel/debugger/BpelDebuggerEngineProvider.java (-1 / +1 lines)
41	* @param contextProvider provides context for the BPEL debugger engine	41	* @param contextProvider provides context for the BPEL debugger engine
42	*/	42	*/
43	public BpelDebuggerEngineProvider(ContextProvider contextProvider) {	43	public BpelDebuggerEngineProvider(ContextProvider contextProvider) {
44	mySession = (Session) contextProvider.lookupFirst(null, Session.class);	44	mySession = contextProvider.lookupFirst(null, Session.class);
45	}	45	}
46		46
47	public String[] getLanguages() {	47	public String[] getLanguages() {

Lines 82-88 public class BpelDebuggerImpl extends Bp Link Here

(-)a/bpel.debugger/src/org/netbeans/modules/bpel/debugger/BpelDebuggerImpl.java (-3 / +2 lines)
82	super(lookupProvider);	82	super(lookupProvider);
83		83
84	//TODO:why not just call lookupFirst?	84	//TODO:why not just call lookupFirst?
85	List l = lookupProvider.lookup(null, DebuggerEngineProvider.class);	85	List<? extends DebuggerEngineProvider> l = lookupProvider.lookup(null, DebuggerEngineProvider.class);
86	int i;	86	int i;
87	int k = l.size();	87	int k = l.size();
88		88
Lines 108-115 public class BpelDebuggerImpl extends Bp Link Here
108	public SourcePath getSourcePath() {	108	public SourcePath getSourcePath() {
109		109
110	if (mSourcePath == null) {	110	if (mSourcePath == null) {
111	mSourcePath = (SourcePath)getLookupProvider().	111	mSourcePath = getLookupProvider().lookupFirst(null, SourcePath.class);
112	lookupFirst(null, SourcePath.class);
113	}	112	}
114	return mSourcePath;	113	return mSourcePath;
115	}	114	}

Lines 42-48 public class DebugProjectSessionCookie i Link Here

(-)a/bpel.debugger/src/org/netbeans/modules/bpel/debugger/DebugProjectSessionCookie.java (-2 / +2 lines)
42	if (mySessionId != null) {	42	if (mySessionId != null) {
43	return mySessionId;	43	return mySessionId;
44	} else {	44	} else {
45	Map params = (Map)myContextProvider.lookupFirst(null, Map.class);	45	Map params = myContextProvider.lookupFirst(null, Map.class);
46	if (params != null) {	46	if (params != null) {
47	String projectBaseDir = (String)params.get("projectBaseDir");	47	String projectBaseDir = (String)params.get("projectBaseDir");
48	if (projectBaseDir != null) {	48	if (projectBaseDir != null) {
Lines 52-58 public class DebugProjectSessionCookie i Link Here
52	}	52	}
53		53
54	//some deffensive logic	54	//some deffensive logic
55	Session session = (Session)myContextProvider.lookupFirst(null, Session.class);	55	Session session = myContextProvider.lookupFirst(null, Session.class);
56	mySessionId = session.getName();	56	mySessionId = session.getName();
57	return mySessionId;	57	return mySessionId;
58	}	58	}

Lines 47-53 public class DebugProjectSourcePathSelec Link Here

(-)a/bpel.debugger/src/org/netbeans/modules/bpel/debugger/DebugProjectSourcePathSelectionProvider.java (-1 / +1 lines)
47		47
48	public boolean isSelected(String path) {	48	public boolean isSelected(String path) {
49	if (mySubprojectsBaseDirs == null) {	49	if (mySubprojectsBaseDirs == null) {
50	Map params = (Map)myContextProvider.lookupFirst(null, Map.class);	50	Map params = myContextProvider.lookupFirst(null, Map.class);
51	if (params != null) {	51	if (params != null) {
52	String projectBaseDir = (String)params.get("projectBaseDir");	52	String projectBaseDir = (String)params.get("projectBaseDir");
53	if (projectBaseDir != null) {	53	if (projectBaseDir != null) {




import java.util.Collections;
import java.util.Set;
import org.netbeans.api.debugger.ActionsManager;
import org.netbeans.api.debugger.Session;
import org.netbeans.modules.bpel.debugger.api.BpelDebugger;
import org.netbeans.modules.bpel.debugger.api.AttachingCookie;
import org.netbeans.modules.bpel.debugger.api.DebugException;
import org.netbeans.modules.bpel.debugger.BpelDebuggerImpl;
import org.netbeans.spi.debugger.ActionsProviderSupport;
import org.netbeans.spi.debugger.ContextProvider;
import org.openide.ErrorManager;
import org.openide.util.RequestProcessor;



    
    public void postAction(Object action, Runnable actionPerformedNotifier) {
        AttachingCookie cookie = 
            mLookupProvider.lookupFirst(null, AttachingCookie.class);
        final String host = cookie.getHost();
        final int port = cookie.getPort();
        

Lines 58-64 public class DebugProjectActionProvider Link Here

(-)a/bpel.debugger/src/org/netbeans/modules/bpel/debugger/action/DebugProjectActionProvider.java (-1 / +1 lines)
58		58
59	@Override	59	@Override
60	public void postAction(Object action, Runnable actionPerformedNotifier) {	60	public void postAction(Object action, Runnable actionPerformedNotifier) {
61	final Map params = (Map)mLookupProvider.lookupFirst(null, Map.class);	61	final Map params = mLookupProvider.lookupFirst(null, Map.class);
62		62
63	RequestProcessor.getDefault().post(new Runnable() {	63	RequestProcessor.getDefault().post(new Runnable() {
64	public void run() {	64	public void run() {

Lines 119-125 public class CurrentThreadAnnotationList Link Here

(-)a/cnd.debugger.gdb/src/org/netbeans/modules/cnd/debugger/gdb/CurrentThreadAnnotationListener.java (-1 / +1 lines)
119	if (currentEngine == null) {	119	if (currentEngine == null) {
120	return null;	120	return null;
121	}	121	}
122	return (GdbDebugger) currentEngine.lookupFirst(null, GdbDebugger.class);	122	return currentEngine.lookupFirst(null, GdbDebugger.class);
123	}	123	}
124		124
125	/**	125	/**

Lines 76-82 public class DebuggerOutput extends Lazy Link Here

(-)a/cnd.debugger.gdb/src/org/netbeans/modules/cnd/debugger/gdb/DebuggerOutput.java (-1 / +1 lines)
76		76
77	public DebuggerOutput(ContextProvider contextProvider) {	77	public DebuggerOutput(ContextProvider contextProvider) {
78	this.contextProvider = contextProvider;	78	this.contextProvider = contextProvider;
79	this.debugger = (GdbDebugger) contextProvider.lookupFirst(null, GdbDebugger.class);	79	this.debugger = contextProvider.lookupFirst(null, GdbDebugger.class);
80		80
81	// close old tabs	81	// close old tabs
82	if (DebuggerManager.getDebuggerManager().getSessions().length == 1) {	82	if (DebuggerManager.getDebuggerManager().getSessions().length == 1) {




        
        setStarting();
        try {
            pae = lookupProvider.lookupFirst(null, ProjectActionEvent.class);
            iotab = lookupProvider.lookupFirst(null, InputOutput.class);
            if (iotab != null) {
                iotab.setErrSeparated(false);
            }

            gdb.gdb_set("print repeat",  // NOI18N
                    Integer.toString(CppSettings.getDefault().getArrayRepeatThreshold()));
            if (pae.getID() == DEBUG_ATTACH) {
                programPID = lookupProvider.lookupFirst(null, Long.class);
                CommandBuffer cb = new CommandBuffer();
                gdb.target_attach(cb, Long.toString(programPID));
                cb.waitForCompletion();

                    gdb.exec_run(pae.getProfile().getArgsFlat());
                } catch (Exception ex) {
                    ErrorManager.getDefault().notify(ex);
                    lookupProvider.lookupFirst(null, Session.class).kill();
                }
                if (Utilities.isWindows()) {
                    gdb.info_threads(); // we get the PID from this...

            }
            if (gdb != null) {
                if (state.equals(STATE_RUNNING)) {
                    ProjectActionEvent pae = lookupProvider.lookupFirst(null, ProjectActionEvent.class);
                            null, ProjectActionEvent.class);
                    gdb.exec_interrupt();
                    if (pae.getID() == DEBUG_ATTACH) {
                        gdb.target_detach();

                DialogDisplayer.getDefault().notify(
                       new NotifyDescriptor.Message(NbBundle.getMessage(GdbDebugger.class,
                       "ERR_CantAttach"))); // NOI18N
                (lookupProvider.lookupFirst(null, Session.class)).kill();
            } else if (msg.startsWith("\"No symbol ") && msg.endsWith(" in current context.\"")) { // NOI18N
                String type = msg.substring(13, msg.length() - 23);
                log.warning("Failed type lookup for " + type);

                DialogDisplayer.getDefault().notify(
                       new NotifyDescriptor.Message(NbBundle.getMessage(GdbDebugger.class,
                       "ERR_CorruptedStack"))); // NOI18N
                (lookupProvider.lookupFirst(null, Session.class)).kill();
            } else if (msg.contains("error reading line numbers")) { // NOI18N
                DialogDisplayer.getDefault().notify(
                       new NotifyDescriptor.Message(NbBundle.getMessage(GdbDebugger.class,

                DialogDisplayer.getDefault().notify(
                       new NotifyDescriptor.Message(NbBundle.getMessage(GdbDebugger.class,
                       "ERR_NoSymbolTable"))); // NOI18N
                (lookupProvider.lookupFirst(null, Session.class)).kill();
            } else if (msg.contains("Cannot access memory at address")) { // NOI18N
                // ignore - probably dereferencing an uninitialized pointer
            } else if (msg.contains("mi_cmd_break_insert: Garbage following <location>")) { // NOI18N

Lines 53-59 public class GdbEngineProvider extends D Link Here

(-)a/cnd.debugger.gdb/src/org/netbeans/modules/cnd/debugger/gdb/GdbEngineProvider.java (-1 / +1 lines)
53	private Session session;	53	private Session session;
54		54
55	public GdbEngineProvider(ContextProvider contextProvider) {	55	public GdbEngineProvider(ContextProvider contextProvider) {
56	session = (Session) contextProvider.lookupFirst(null, Session.class);	56	session = contextProvider.lookupFirst(null, Session.class);
57	}	57	}
58		58
59	public String[] getLanguages() {	59	public String[] getLanguages() {

Lines 56-62 public class GdbSessionProvider extends Link Here

(-)a/cnd.debugger.gdb/src/org/netbeans/modules/cnd/debugger/gdb/GdbSessionProvider.java (-1 / +1 lines)
56		56
57	public GdbSessionProvider(ContextProvider contextProvider) {	57	public GdbSessionProvider(ContextProvider contextProvider) {
58	this.contextProvider = contextProvider;	58	this.contextProvider = contextProvider;
59	projectActionEvent = (ProjectActionEvent) contextProvider.lookupFirst(null, ProjectActionEvent.class);	59	projectActionEvent = contextProvider.lookupFirst(null, ProjectActionEvent.class);
60	};	60	};
61		61
62	public String getSessionName () {	62	public String getSessionName () {

Lines 94-100 public class LocalVariableImpl implement Link Here

(-)a/cnd.debugger.gdb/src/org/netbeans/modules/cnd/debugger/gdb/LocalVariableImpl.java (-1 / +1 lines)
94	if (debugger == null) {	94	if (debugger == null) {
95	// Don't set it unless its needed...	95	// Don't set it unless its needed...
96	DebuggerEngine currentEngine = DebuggerManager.getDebuggerManager().getCurrentEngine();	96	DebuggerEngine currentEngine = DebuggerManager.getDebuggerManager().getCurrentEngine();
97	debugger = (GdbDebugger) currentEngine.lookupFirst(null, GdbDebugger.class);	97	debugger = currentEngine.lookupFirst(null, GdbDebugger.class);
98	}	98	}
99		99
100	debugger.getGdbProxy().data_evaluate_expression(name + "=" + expression); // NOI18N	100	debugger.getGdbProxy().data_evaluate_expression(name + "=" + expression); // NOI18N

Lines 74-80 public class ToolTipAnnotation extends A Link Here

(-)a/cnd.debugger.gdb/src/org/netbeans/modules/cnd/debugger/gdb/ToolTipAnnotation.java (-2 / +2 lines)
74	if (currentEngine == null) {	74	if (currentEngine == null) {
75	return null;	75	return null;
76	}	76	}
77	GdbDebugger debugger = (GdbDebugger) currentEngine.lookupFirst(null, GdbDebugger.class);	77	GdbDebugger debugger = currentEngine.lookupFirst(null, GdbDebugger.class);
78	if (debugger == null) {	78	if (debugger == null) {
79	return null;	79	return null;
80	}	80	}
Lines 87-93 public class ToolTipAnnotation extends A Link Here
87	if (dob == null) {	87	if (dob == null) {
88	return null;	88	return null;
89	}	89	}
90	EditorCookie ec = (EditorCookie) dob.getCookie(EditorCookie.class);	90	EditorCookie ec = dob.getCookie(EditorCookie.class);
91	if (ec == null) {	91	if (ec == null) {
92	return null;	92	return null;
93	}	93	}

Lines 60-66 public abstract class GdbDebuggerActionP Link Here

(-)a/cnd.debugger.gdb/src/org/netbeans/modules/cnd/debugger/gdb/actions/GdbDebuggerActionProvider.java (-1 / +1 lines)
60	private volatile boolean disabled;	60	private volatile boolean disabled;
61		61
62	GdbDebuggerActionProvider(ContextProvider lookupProvider) {	62	GdbDebuggerActionProvider(ContextProvider lookupProvider) {
63	debugger = (GdbDebugger) lookupProvider.lookupFirst(null, GdbDebugger.class);	63	debugger = lookupProvider.lookupFirst(null, GdbDebugger.class);
64	debugger.addPropertyChangeListener(this);	64	debugger.addPropertyChangeListener(this);
65	}	65	}
66		66

Lines 74-81 public class KillActionProvider extends Link Here

(-)a/cnd.debugger.gdb/src/org/netbeans/modules/cnd/debugger/gdb/actions/KillActionProvider.java (-2 / +1 lines)
74	private GdbDebugger debuggerImpl;	74	private GdbDebugger debuggerImpl;
75		75
76	public KillActionProvider(ContextProvider lookupProvider) {	76	public KillActionProvider(ContextProvider lookupProvider) {
77	debuggerImpl = (GdbDebugger) lookupProvider.lookupFirst	77	debuggerImpl = lookupProvider.lookupFirst(null, GdbDebugger.class);
78	(null, GdbDebugger.class);
79	//super (debuggerImpl);	78	//super (debuggerImpl);
80	this.lookupProvider = lookupProvider;	79	this.lookupProvider = lookupProvider;
81	}	80	}

Lines 63-69 public class MakeCalleeCurrentActionProv Link Here

(-)a/cnd.debugger.gdb/src/org/netbeans/modules/cnd/debugger/gdb/actions/MakeCalleeCurrentActionProvider.java (-1 / +1 lines)
63		63
64		64
65	public MakeCalleeCurrentActionProvider(ContextProvider lookupProvider) {	65	public MakeCalleeCurrentActionProvider(ContextProvider lookupProvider) {
66	debugger = (GdbDebugger) lookupProvider.lookupFirst(null, GdbDebugger.class);	66	debugger = lookupProvider.lookupFirst(null, GdbDebugger.class);
67	this.lookupProvider = lookupProvider;	67	this.lookupProvider = lookupProvider;
68	debugger.addPropertyChangeListener(GdbDebugger.PROP_CURRENT_CALL_STACK_FRAME, this);	68	debugger.addPropertyChangeListener(GdbDebugger.PROP_CURRENT_CALL_STACK_FRAME, this);
69	}	69	}

Lines 64-70 public class MakeCallerCurrentActionProv Link Here

(-)a/cnd.debugger.gdb/src/org/netbeans/modules/cnd/debugger/gdb/actions/MakeCallerCurrentActionProvider.java (-1 / +1 lines)
64	private GdbDebugger debugger;	64	private GdbDebugger debugger;
65		65
66	public MakeCallerCurrentActionProvider(ContextProvider lookupProvider) {	66	public MakeCallerCurrentActionProvider(ContextProvider lookupProvider) {
67	debugger = (GdbDebugger) lookupProvider.lookupFirst(null, GdbDebugger.class);	67	debugger = lookupProvider.lookupFirst(null, GdbDebugger.class);
68	this.lookupProvider = lookupProvider;	68	this.lookupProvider = lookupProvider;
69	debugger.addPropertyChangeListener(GdbDebugger.PROP_CURRENT_CALL_STACK_FRAME, this);	69	debugger.addPropertyChangeListener(GdbDebugger.PROP_CURRENT_CALL_STACK_FRAME, this);
70	}	70	}

Lines 71-77 public class StartActionProvider extends Link Here

(-)a/cnd.debugger.gdb/src/org/netbeans/modules/cnd/debugger/gdb/actions/StartActionProvider.java (-1 / +1 lines)
71	*/	71	*/
72	public StartActionProvider(ContextProvider lookupProvider) {	72	public StartActionProvider(ContextProvider lookupProvider) {
73	this.lookupProvider = lookupProvider;	73	this.lookupProvider = lookupProvider;
74	debuggerImpl = (GdbDebugger) lookupProvider.lookupFirst(null, GdbDebugger.class);	74	debuggerImpl = lookupProvider.lookupFirst(null, GdbDebugger.class);
75		75
76	}	76	}
77		77

Lines 115-122 public class ToggleBreakpointActionProvi Link Here

(-)a/cnd.debugger.gdb/src/org/netbeans/modules/cnd/debugger/gdb/actions/ToggleBreakpointActionProvider.java (-2 / +1 lines)
115		115
116	private BreakpointAnnotationListener getBreakpointAnnotationListener() {	116	private BreakpointAnnotationListener getBreakpointAnnotationListener() {
117	if (breakpointAnnotationListener == null) {	117	if (breakpointAnnotationListener == null) {
118	breakpointAnnotationListener = (BreakpointAnnotationListener)	118	breakpointAnnotationListener = DebuggerManager.getDebuggerManager().lookupFirst(null, BreakpointAnnotationListener.class);
119	DebuggerManager.getDebuggerManager().lookupFirst(null, BreakpointAnnotationListener.class);
120	}	119	}
121	return breakpointAnnotationListener;	120	return breakpointAnnotationListener;
122	}	121	}

Lines 86-92 public class BreakpointOutput extends La Link Here

(-)a/cnd.debugger.gdb/src/org/netbeans/modules/cnd/debugger/gdb/breakpoints/BreakpointOutput.java (-1 / +1 lines)
86		86
87	public BreakpointOutput(ContextProvider contextProvider) {	87	public BreakpointOutput(ContextProvider contextProvider) {
88	this.contextProvider = contextProvider;	88	this.contextProvider = contextProvider;
89	this.debugger = (GdbDebugger) contextProvider.lookupFirst(null, GdbDebugger.class);	89	this.debugger = contextProvider.lookupFirst(null, GdbDebugger.class);
90	debugger.addPropertyChangeListener(GdbDebugger.PROP_STATE, this);	90	debugger.addPropertyChangeListener(GdbDebugger.PROP_STATE, this);
91	hookBreakpoints();	91	hookBreakpoints();
92	DebuggerManager.getDebuggerManager().addDebuggerListener(DebuggerManager.PROP_BREAKPOINTS, this);	92	DebuggerManager.getDebuggerManager().addDebuggerListener(DebuggerManager.PROP_BREAKPOINTS, this);

Lines 70-77 public class BreakpointsEngineListener e Link Here

(-)a/cnd.debugger.gdb/src/org/netbeans/modules/cnd/debugger/gdb/breakpoints/BreakpointsEngineListener.java (-2 / +2 lines)
70	private HashMap<Breakpoint, BreakpointImpl> breakpointToImpl = new HashMap<Breakpoint, BreakpointImpl>();	70	private HashMap<Breakpoint, BreakpointImpl> breakpointToImpl = new HashMap<Breakpoint, BreakpointImpl>();
71		71
72	public BreakpointsEngineListener(ContextProvider lookupProvider) {	72	public BreakpointsEngineListener(ContextProvider lookupProvider) {
73	debugger = (GdbDebugger) lookupProvider.lookupFirst(null, GdbDebugger.class);	73	debugger = lookupProvider.lookupFirst(null, GdbDebugger.class);
74	session = (Session) lookupProvider.lookupFirst(null, Session.class);	74	session = lookupProvider.lookupFirst(null, Session.class);
75	debugger.addPropertyChangeListener(this);	75	debugger.addPropertyChangeListener(this);
76	breakpointsReader = PersistenceManager.findBreakpointsReader();	76	breakpointsReader = PersistenceManager.findBreakpointsReader();
77	}	77	}

Lines 59-68 public class BreakpointsUpdater extends Link Here

(-)a/cnd.debugger.gdb/src/org/netbeans/modules/cnd/debugger/gdb/breakpoints/BreakpointsUpdater.java (-3 / +2 lines)
59	private GdbDebugger debugger;	59	private GdbDebugger debugger;
60		60
61	public BreakpointsUpdater(ContextProvider lookupProvider) {	61	public BreakpointsUpdater(ContextProvider lookupProvider) {
62	debugger = (GdbDebugger) lookupProvider.lookupFirst(null, GdbDebugger.class);	62	debugger = lookupProvider.lookupFirst(null, GdbDebugger.class);
63	EditorContextBridge.createTimeStamp(debugger);	63	EditorContextBridge.createTimeStamp(debugger);
64	BreakpointAnnotationListener bal = (BreakpointAnnotationListener)	64	BreakpointAnnotationListener bal = DebuggerManager.getDebuggerManager().lookupFirst(null, BreakpointAnnotationListener.class);
65	DebuggerManager.getDebuggerManager().lookupFirst(null, BreakpointAnnotationListener.class);
66	bal.updateBreakpoints();	65	bal.updateBreakpoints();
67	}	66	}
68		67

Lines 218-224 public class Disassembly implements Prop Link Here

(-)a/cnd.debugger.gdb/src/org/netbeans/modules/cnd/debugger/gdb/disassembly/Disassembly.java (-1 / +1 lines)
218	if (currentEngine == null) {	218	if (currentEngine == null) {
219	return null;	219	return null;
220	}	220	}
221	GdbDebugger debugger = (GdbDebugger) currentEngine.lookupFirst(null, GdbDebugger.class);	221	GdbDebugger debugger = currentEngine.lookupFirst(null, GdbDebugger.class);
222	if (debugger == null) {	222	if (debugger == null) {
223	return null;	223	return null;
224	}	224	}

Lines 522-528 public class AbstractVariable implements Link Here

(-)a/cnd.debugger.gdb/src/org/netbeans/modules/cnd/debugger/gdb/models/AbstractVariable.java (-1 / +1 lines)
522	if (currentEngine == null) {	522	if (currentEngine == null) {
523	return null;	523	return null;
524	}	524	}
525	debugger = (GdbDebugger) currentEngine.lookupFirst(null, GdbDebugger.class);	525	debugger = currentEngine.lookupFirst(null, GdbDebugger.class);
526	}	526	}
527	return debugger;	527	return debugger;
528	}	528	}

Lines 95-101 public class CallStackActionsProvider im Link Here

(-)a/cnd.debugger.gdb/src/org/netbeans/modules/cnd/debugger/gdb/models/CallStackActionsProvider.java (-1 / +1 lines)
95		95
96	public CallStackActionsProvider(ContextProvider lookupProvider) {	96	public CallStackActionsProvider(ContextProvider lookupProvider) {
97	this.lookupProvider = lookupProvider;	97	this.lookupProvider = lookupProvider;
98	debugger = (GdbDebugger) lookupProvider.lookupFirst(null, GdbDebugger.class);	98	debugger = lookupProvider.lookupFirst(null, GdbDebugger.class);
99	}	99	}
100		100
101	public Action[] getActions(Object node) throws UnknownTypeException {	101	public Action[] getActions(Object node) throws UnknownTypeException {

Lines 73-80 public class CallStackNodeModel implemen Link Here

(-)a/cnd.debugger.gdb/src/org/netbeans/modules/cnd/debugger/gdb/models/CallStackNodeModel.java (-2 / +2 lines)
73		73
74		74
75	public CallStackNodeModel(ContextProvider lookupProvider) {	75	public CallStackNodeModel(ContextProvider lookupProvider) {
76	debugger = (GdbDebugger) lookupProvider.lookupFirst(null, GdbDebugger.class);	76	debugger = lookupProvider.lookupFirst(null, GdbDebugger.class);
77	session = (Session) lookupProvider.lookupFirst(null, Session.class);	77	session = lookupProvider.lookupFirst(null, Session.class);
78	new Listener(this, debugger);	78	new Listener(this, debugger);
79	}	79	}
80		80

Lines 69-75 public class CallStackTreeModel implemen Link Here

(-)a/cnd.debugger.gdb/src/org/netbeans/modules/cnd/debugger/gdb/models/CallStackTreeModel.java (-1 / +1 lines)
69		69
70		70
71	public CallStackTreeModel(ContextProvider lookupProvider) {	71	public CallStackTreeModel(ContextProvider lookupProvider) {
72	debugger = (GdbDebugger) lookupProvider.lookupFirst(null, GdbDebugger.class);	72	debugger = lookupProvider.lookupFirst(null, GdbDebugger.class);
73	}	73	}
74		74
75	/**	75	/**

Lines 77-83 public class LocalsTreeModel implements Link Here

(-)a/cnd.debugger.gdb/src/org/netbeans/modules/cnd/debugger/gdb/models/LocalsTreeModel.java (-1 / +1 lines)
77	private static Logger log = Logger.getLogger("gdb.logger"); // NOI18N	77	private static Logger log = Logger.getLogger("gdb.logger"); // NOI18N
78		78
79	public LocalsTreeModel(ContextProvider lookupProvider) {	79	public LocalsTreeModel(ContextProvider lookupProvider) {
80	debugger = (GdbDebugger) lookupProvider.lookupFirst(null, GdbDebugger.class);	80	debugger = lookupProvider.lookupFirst(null, GdbDebugger.class);
81	}	81	}
82		82
83	public Object getRoot() {	83	public Object getRoot() {

Lines 80-86 public class ThreadsActionsProvider impl Link Here

(-)a/cnd.debugger.gdb/src/org/netbeans/modules/cnd/debugger/gdb/models/ThreadsActionsProvider.java (-1 / +1 lines)
80		80
81	private GdbDebugger getDebugger() {	81	private GdbDebugger getDebugger() {
82	if (debugger == null) {	82	if (debugger == null) {
83	debugger = (GdbDebugger) lookupProvider.lookupFirst(null, GdbDebugger.class);	83	debugger = lookupProvider.lookupFirst(null, GdbDebugger.class);
84	}	84	}
85	return debugger;	85	return debugger;
86	}	86	}

Lines 69-75 public class ThreadsNodeModel implements Link Here

(-)a/cnd.debugger.gdb/src/org/netbeans/modules/cnd/debugger/gdb/models/ThreadsNodeModel.java (-1 / +1 lines)
69	private Vector listeners = new Vector();	69	private Vector listeners = new Vector();
70		70
71	public ThreadsNodeModel(ContextProvider lookupProvider) {	71	public ThreadsNodeModel(ContextProvider lookupProvider) {
72	debugger = (GdbDebugger) lookupProvider.lookupFirst(null, GdbDebugger.class);	72	debugger = lookupProvider.lookupFirst(null, GdbDebugger.class);
73	new Listener(this, debugger);	73	new Listener(this, debugger);
74	}	74	}
75		75

Lines 66-72 public class ThreadsTreeModel implements Link Here

(-)a/cnd.debugger.gdb/src/org/netbeans/modules/cnd/debugger/gdb/models/ThreadsTreeModel.java (-1 / +1 lines)
66	private Listener listener;	66	private Listener listener;
67		67
68	public ThreadsTreeModel(ContextProvider lookupProvider) {	68	public ThreadsTreeModel(ContextProvider lookupProvider) {
69	debugger = (GdbDebugger) lookupProvider.lookupFirst(null, GdbDebugger.class);	69	debugger = lookupProvider.lookupFirst(null, GdbDebugger.class);
70	}	70	}
71		71
72	/**	72	/**

Lines 81-87 public class VariablesActionsProvider im Link Here

(-)a/cnd.debugger.gdb/src/org/netbeans/modules/cnd/debugger/gdb/models/VariablesActionsProvider.java (-1 / +1 lines)
81		81
82	public VariablesActionsProvider(ContextProvider lookupProvider) {	82	public VariablesActionsProvider(ContextProvider lookupProvider) {
83	this.lookupProvider = lookupProvider;	83	this.lookupProvider = lookupProvider;
84	debugger = (GdbDebugger) lookupProvider.lookupFirst(null, GdbDebugger.class);	84	debugger = lookupProvider.lookupFirst(null, GdbDebugger.class);
85	}	85	}
86		86
87	public Action[] getActions(Object node) throws UnknownTypeException {	87	public Action[] getActions(Object node) throws UnknownTypeException {

Lines 74-80 public class VariablesTableModel impleme Link Here

(-)a/cnd.debugger.gdb/src/org/netbeans/modules/cnd/debugger/gdb/models/VariablesTableModel.java (-1 / +1 lines)
74		74
75	public VariablesTableModel(ContextProvider lookupProvider) {	75	public VariablesTableModel(ContextProvider lookupProvider) {
76	this.lookupProvider = lookupProvider;	76	this.lookupProvider = lookupProvider;
77	debugger = (GdbDebugger) lookupProvider.lookupFirst(null, GdbDebugger.class);	77	debugger = lookupProvider.lookupFirst(null, GdbDebugger.class);
78	}	78	}
79		79
80	public Object getValueAt(Object row, String columnID) throws UnknownTypeException {	80	public Object getValueAt(Object row, String columnID) throws UnknownTypeException {

Lines 85-91 public class WatchesTreeModel implements Link Here

(-)a/cnd.debugger.gdb/src/org/netbeans/modules/cnd/debugger/gdb/models/WatchesTreeModel.java (-1 / +1 lines)
85		85
86	public WatchesTreeModel(ContextProvider lookupProvider) {	86	public WatchesTreeModel(ContextProvider lookupProvider) {
87	this.lookupProvider = lookupProvider;	87	this.lookupProvider = lookupProvider;
88	debugger = (GdbDebugger) lookupProvider.lookupFirst(null, GdbDebugger.class);	88	debugger = lookupProvider.lookupFirst(null, GdbDebugger.class);
89	debugger.addPropertyChangeListener(this);	89	debugger.addPropertyChangeListener(this);
90	watchesTreeModel = this;	90	watchesTreeModel = this;
91	}	91	}

Lines 88-95 public class GdbConsoleWindow extends To Link Here

(-)a/cnd.debugger.gdb/src/org/netbeans/modules/cnd/debugger/gdb/proxy/GdbConsoleWindow.java (-2 / +1 lines)
88	this.debugger = debugger;	88	this.debugger = debugger;
89	this.gdbProxy = gdbProxy;	89	this.gdbProxy = gdbProxy;
90	debugger.addPropertyChangeListener(this);	90	debugger.addPropertyChangeListener(this);
91	ProjectActionEvent pae = (ProjectActionEvent)	91	ProjectActionEvent pae = debugger.getLookup().lookupFirst(null, ProjectActionEvent.class);
92	debugger.getLookup().lookupFirst(null, ProjectActionEvent.class);
93	programName.setText(pae.getExecutable());	92	programName.setText(pae.getExecutable());
94	}	93	}
95		94

Lines 75-82 public class JPDAAppReloaded extends Tas Link Here

(-)a/debugger.jpda.ant/antsrc/org/netbeans/modules/debugger/jpda/ant/JPDAAppReloaded.java (-2 / +1 lines)
75	logger.fine("No debugging sessions was found.");	75	logger.fine("No debugging sessions was found.");
76	return ;	76	return ;
77	}	77	}
78	JPDADebugger debugger = (JPDADebugger) debuggerEngine.lookupFirst	78	JPDADebugger debugger = debuggerEngine.lookupFirst(null, JPDADebugger.class);
79	(null, JPDADebugger.class);
80	if (debugger == null) {	79	if (debugger == null) {
81	logger.fine("Current debugger is not JPDA one.");	80	logger.fine("Current debugger is not JPDA one.");
82	return ;	81	return ;




        if (debuggerEngine == null) {
            throw new BuildException ("No debugging sessions was found.");
        }
        JPDADebugger debugger = debuggerEngine.lookupFirst(null, JPDADebugger.class);
            (null, JPDADebugger.class);
        if (debugger == null) {
            throw new BuildException("Current debugger is not JPDA one.");
        }

        
        FileUtils fileUtils = FileUtils.newFileUtils ();
        Map map = new HashMap ();
        EditorContext editorContext = DebuggerManager.getDebuggerManager().lookupFirst(null, EditorContext.class);
            getDebuggerManager ().lookupFirst (null, EditorContext.class);

        Iterator it = filesets.iterator ();
        while (it.hasNext ()) {




        }
        
        public void engineAdded (DebuggerEngine engine) {
            JPDADebugger debugger = engine.lookupFirst(null, JPDADebugger.class);
                (null, JPDADebugger.class);
            if (debugger == null) return;
            debugger.addPropertyChangeListener (
                JPDADebugger.PROP_STATE,

        }
        
        public void engineRemoved (DebuggerEngine engine) {
            JPDADebugger debugger = engine.lookupFirst(null, JPDADebugger.class);
                (null, JPDADebugger.class);
            if (debugger == null) return;
            debugger.removePropertyChangeListener (
                JPDADebugger.PROP_STATE,

Lines 46-52 made subject to such option by the copyr Link Here

(-)a/debugger.jpda.ant/build.xml (-1 / +1 lines)
46		46
47	<target name="nblib" depends="init">	47	<target name="nblib" depends="init">
48	<mkdir dir="build/antclasses"/>	48	<mkdir dir="build/antclasses"/>
49	<javac srcdir="antsrc" destdir="build/antclasses" source="1.4" debug="true" deprecation="true">	49	<javac srcdir="antsrc" destdir="build/antclasses" source="1.5" debug="true" deprecation="true">
50	<classpath>	50	<classpath>
51	<path refid="cp"/>	51	<path refid="cp"/>
52	<pathelement location="${ant.jar}"/>	52	<pathelement location="${ant.jar}"/>

Lines 79-86 public class HeapActionsFilter implement Link Here

(-)a/debugger.jpda.heapwalk/src/org/netbeans/modules/debugger/jpda/heapwalk/models/HeapActionsFilter.java (-2 / +1 lines)
79		79
80	/** Creates a new instance of HeapActionsFilter */	80	/** Creates a new instance of HeapActionsFilter */
81	public HeapActionsFilter(ContextProvider contextProvider) {	81	public HeapActionsFilter(ContextProvider contextProvider) {
82	debugger = (JPDADebugger) contextProvider.	82	debugger = contextProvider.lookupFirst(null, JPDADebugger.class);
83	lookupFirst (null, JPDADebugger.class);
84		83
85	}	84	}
86		85

Lines 154-160 public class ClassesCountsView extends T Link Here

(-)a/debugger.jpda.heapwalk/src/org/netbeans/modules/debugger/jpda/heapwalk/views/ClassesCountsView.java (-2 / +2 lines)
154	JPDADebugger debugger = null;	154	JPDADebugger debugger = null;
155	DebuggerEngine engine = DebuggerManager.getDebuggerManager().getCurrentEngine();	155	DebuggerEngine engine = DebuggerManager.getDebuggerManager().getCurrentEngine();
156	if (engine != null) {	156	if (engine != null) {
157	debugger = (JPDADebugger) engine.lookupFirst(null, JPDADebugger.class);	157	debugger = engine.lookupFirst(null, JPDADebugger.class);
158	}	158	}
159	if (content != null) {	159	if (content != null) {
160	remove(content);	160	remove(content);
Lines 293-299 public class ClassesCountsView extends T Link Here
293	private synchronized void attachToStateChange(DebuggerEngine engine) {	293	private synchronized void attachToStateChange(DebuggerEngine engine) {
294	detachFromStateChange();	294	detachFromStateChange();
295	if (engine == null) return ;	295	if (engine == null) return ;
296	JPDADebugger debugger = (JPDADebugger) engine.lookupFirst(null, JPDADebugger.class);	296	JPDADebugger debugger = engine.lookupFirst(null, JPDADebugger.class);
297	if (debugger == null) return ;	297	if (debugger == null) return ;
298	debugger.addPropertyChangeListener(JPDADebugger.PROP_STATE, this);	298	debugger.addPropertyChangeListener(JPDADebugger.PROP_STATE, this);
299	lastDebugger = new WeakReference<JPDADebugger>(debugger);	299	lastDebugger = new WeakReference<JPDADebugger>(debugger);

Lines 220-226 public class InstancesView extends TopCo Link Here

(-)a/debugger.jpda.heapwalk/src/org/netbeans/modules/debugger/jpda/heapwalk/views/InstancesView.java (-1 / +1 lines)
220	int state = JPDADebugger.STATE_DISCONNECTED;	220	int state = JPDADebugger.STATE_DISCONNECTED;
221	DebuggerEngine de = DebuggerManager.getDebuggerManager().getCurrentEngine();	221	DebuggerEngine de = DebuggerManager.getDebuggerManager().getCurrentEngine();
222	if (de != null) {	222	if (de != null) {
223	JPDADebugger d = (JPDADebugger) de.lookupFirst(null, JPDADebugger.class);	223	JPDADebugger d = de.lookupFirst(null, JPDADebugger.class);
224	if (d != null) {	224	if (d != null) {
225	state = getThreadsState(d);	225	state = getThreadsState(d);
226	synchronized (this) {	226	synchronized (this) {




    public void propertyChange (PropertyChangeEvent e) {
        updateModel ();
    }

    // XXX copy-paste programming!
    private <T> List<? extends T> joinLookups(DebuggerEngine e, DebuggerManager dm, Class<T> service) {
        List<? extends T> es = e.lookup (viewType, service);
        List<? extends T> ms = dm.lookup(viewType, service);
        List<T> joined = new ArrayList<T>(es);
        for (T t : ms) {
            if (!es.contains(t)) {
                joined.add(t);
            }
        }
        return joined;
    }
    
    private synchronized void updateModel () {

Lines 79-86 public class FixActionProvider extends A Link Here

(-)a/debugger.jpda.projects/src/org/netbeans/modules/debugger/jpda/projects/FixActionProvider.java (-2 / +1 lines)
79		79
80		80
81	public FixActionProvider (ContextProvider lookupProvider) {	81	public FixActionProvider (ContextProvider lookupProvider) {
82	debugger = (JPDADebugger) lookupProvider.lookupFirst	82	debugger = lookupProvider.lookupFirst(null, JPDADebugger.class);
83	(null, JPDADebugger.class);
84		83
85	listener = new Listener ();	84	listener = new Listener ();
86	MainProjectManager.getDefault ().addPropertyChangeListener (listener);	85	MainProjectManager.getDefault ().addPropertyChangeListener (listener);




    private LineBreakpoint      breakpoint;
    
    {
        editor = DebuggerManager.getDebuggerManager().lookupFirst(null, EditorContext.class);
            getDebuggerManager ().lookupFirst (null, EditorContext.class);
        
        Listener listener = new Listener ();
        MainProjectManager.getDefault ().addPropertyChangeListener (listener);

        }
        
        public void engineAdded (DebuggerEngine engine) {
            JPDADebugger debugger = engine.lookupFirst(null, JPDADebugger.class);
                (null, JPDADebugger.class);
            if (debugger == null) return;
            debugger.addPropertyChangeListener (
                JPDADebugger.PROP_STATE,

        }
        
        public void engineRemoved (DebuggerEngine engine) {
            JPDADebugger debugger = engine.lookupFirst(null, JPDADebugger.class);
                (null, JPDADebugger.class);
            if (debugger == null) return;
            debugger.removePropertyChangeListener (
                JPDADebugger.PROP_STATE,

Lines 116-123 public class SourcePathProviderImpl exte Link Here

(-)a/debugger.jpda.projects/src/org/netbeans/modules/debugger/jpda/projects/SourcePathProviderImpl.java (-2 / +1 lines)
116	pcs = new PropertyChangeSupport (this);	116	pcs = new PropertyChangeSupport (this);
117	//this.session = (Session) contextProvider.lookupFirst	117	//this.session = (Session) contextProvider.lookupFirst
118	// (null, Session.class);	118	// (null, Session.class);
119	Map properties = (Map) contextProvider.lookupFirst	119	Map properties = contextProvider.lookupFirst(null, Map.class);
120	(null, Map.class);
121		120
122	// 2) get default allSourceRoots of source roots used for stepping	121	// 2) get default allSourceRoots of source roots used for stepping
123	if (properties != null) {	122	if (properties != null) {




        DebuggerEngine currentEngine = DebuggerManager.getDebuggerManager ().
            getCurrentEngine ();
        if (currentEngine == null) return null;
        JPDADebugger d = currentEngine.lookupFirst(null, JPDADebugger.class);
            (null, JPDADebugger.class);
        if (d == null) return null;

        Part lp = (Part) getAttachedAnnotatable();

        Line line = lp.getLine ();
        DataObject dob = DataEditorSupport.findDataObject (line);
        if (dob == null) return null;
        EditorCookie ec = dob.getCookie(EditorCookie.class);
        if (ec == null) 
            return null;
            // Only for editable dataobjects

        DebuggerEngine currentEngine = DebuggerManager.getDebuggerManager ().
            getCurrentEngine ();
        if (currentEngine == null) return;
        JPDADebugger d = currentEngine.lookupFirst(null, JPDADebugger.class);
            (null, JPDADebugger.class);
        if (d == null) return;
        JPDAThread t = d.getCurrentThread();
        if (t == null || !t.isSuspended()) return ;

Lines 91-100 PropertyChangeListener { Link Here

(-)a/debugger.jpda.ui/src/org/netbeans/modules/debugger/jpda/ui/BreakpointOutput.java (-3 / +2 lines)
91		91
92	public BreakpointOutput (ContextProvider contextProvider) {	92	public BreakpointOutput (ContextProvider contextProvider) {
93	this.contextProvider = contextProvider;	93	this.contextProvider = contextProvider;
94	this.debugger = (JPDADebugger) contextProvider.lookupFirst	94	this.debugger = contextProvider.lookupFirst(null, JPDADebugger.class);
95	(null, JPDADebugger.class);
96	debugger.addPropertyChangeListener (	95	debugger.addPropertyChangeListener (
97	debugger.PROP_STATE,	96	JPDADebugger.PROP_STATE,
98	this	97	this
99	);	98	);
100	hookBreakpoints ();	99	hookBreakpoints ();

Lines 360-367 Controller, ActionListener { Link Here

(-)a/debugger.jpda.ui/src/org/netbeans/modules/debugger/jpda/ui/ConnectPanel.java (-2 / +1 lines)
360	);	360	);
361	if (es != null) {	361	if (es != null) {
362	for (int i = 0; i < es.length; i++) {	362	for (int i = 0; i < es.length; i++) {
363	JPDADebugger d = (JPDADebugger) es [i].lookupFirst	363	JPDADebugger d = es[i].lookupFirst(null, JPDADebugger.class);
364	(null, JPDADebugger.class);
365	if (d == null) continue;	364	if (d == null) continue;
366	try {	365	try {
367	// workaround for #64227	366	// workaround for #64227

Lines 119-126 public class CurrentThreadAnnotationList Link Here

(-)a/debugger.jpda.ui/src/org/netbeans/modules/debugger/jpda/ui/CurrentThreadAnnotationListener.java (-3 / +2 lines)
119	DebuggerEngine currentEngine = DebuggerManager.	119	DebuggerEngine currentEngine = DebuggerManager.
120	getDebuggerManager ().getCurrentEngine ();	120	getDebuggerManager ().getCurrentEngine ();
121	if (currentEngine == null) return null;	121	if (currentEngine == null) return null;
122	return (JPDADebugger) currentEngine.lookupFirst	122	return currentEngine.lookupFirst(null, JPDADebugger.class);
123	(null, JPDADebugger.class);
124	}	123	}
125		124
126	private void updateCurrentThread () {	125	private void updateCurrentThread () {
Lines 171-177 public class CurrentThreadAnnotationList Link Here
171	DebuggerEngine currentEngine = (currentSession == null) ?	170	DebuggerEngine currentEngine = (currentSession == null) ?
172	null : currentSession.getCurrentEngine();	171	null : currentSession.getCurrentEngine();
173	final SourcePath sourcePath = (currentEngine == null) ?	172	final SourcePath sourcePath = (currentEngine == null) ?
174	null : (SourcePath) currentEngine.lookupFirst(null, SourcePath.class);	173	null : currentEngine.lookupFirst(null, SourcePath.class);
175		174
176	// 3) annotate current line & stack	175	// 3) annotate current line & stack
177	synchronized (currentPCLock) {	176	synchronized (currentPCLock) {





    public DebuggerOutput (ContextProvider contextProvider) {
        this.contextProvider = contextProvider;
        this.debugger = contextProvider.lookupFirst(null, JPDADebugger.class);
            (null, JPDADebugger.class);
        //this.engine = (DebuggerEngine) contextProvider.lookupFirst 
        //    (null, DebuggerEngine.class);
        engineContext = contextProvider.lookupFirst(null, SourcePath.class);
            (null, SourcePath.class);
        
        // close old tabs
        if (DebuggerManager.getDebuggerManager ().getSessions ().length == 1) {

        }
        
        // open new tab
        String title = contextProvider.lookupFirst(null, String.class);
        if (title == null)
            title = NbBundle.getBundle (IOManager.class).getString 
                ("CTL_DebuggerConsole_Title");

            ioManager = this.ioManager;
        }
        if (debuggerState == JPDADebugger.STATE_STARTING) {
            AbstractDICookie cookie = contextProvider.lookupFirst(null, AbstractDICookie.class);
                lookupFirst (null, AbstractDICookie.class);
            if (cookie instanceof AttachingDICookie) {
                AttachingDICookie c = (AttachingDICookie) cookie;
                if (c.getHostName () != null) {




                if (autoClosed) {
                    DebuggerEngine de = DebuggerManager.getDebuggerManager().getCurrentEngine();
                    if (de == null) return ;
                    JPDADebugger debugger = de.lookupFirst(null, JPDADebugger.class);
                    if (debugger == null) return ;
                    open(debugger);
                    autoClosed = false;

                eval.csfListener = null;
                DebuggerEngine de = DebuggerManager.getDebuggerManager().getCurrentEngine();
                if (de == null) return ;
                JPDADebugger debugger = de.lookupFirst(null, JPDADebugger.class);
                eval.setDebugger(debugger);
            }
            updateModel ();
        }
    
        // XXX copy-paste programming!
        private <T> List<? extends T> joinLookups(DebuggerEngine e, DebuggerManager dm, Class<T> service) {
            List<? extends T> es = e.lookup (viewType, service);
            List<? extends T> ms = dm.lookup(viewType, service);
            List<T> joined = new ArrayList<T>(es);
            for (T t : ms) {
                if (!es.contains(t)) {
                    joined.add(t);
                }
            }
            return joined;
        }
    
        public synchronized void updateModel () {

Lines 125-132 PropertyChangeListener { Link Here

(-)a/debugger.jpda.ui/src/org/netbeans/modules/debugger/jpda/ui/SmartSteppingImpl.java (-2 / +1 lines)
125		125
126	private SourcePath getEngineContext (ContextProvider lookupProvider) {	126	private SourcePath getEngineContext (ContextProvider lookupProvider) {
127	if (engineContext == null) {	127	if (engineContext == null) {
128	engineContext = (SourcePath) lookupProvider.lookupFirst	128	engineContext = lookupProvider.lookupFirst(null, SourcePath.class);
129	(null, SourcePath.class);
130	engineContext.addPropertyChangeListener (this);	129	engineContext.addPropertyChangeListener (this);
131	}	130	}
132	return engineContext;	131	return engineContext;

Lines 87-94 public class SourcePath { Link Here

(-)a/debugger.jpda.ui/src/org/netbeans/modules/debugger/jpda/ui/SourcePath.java (-2 / +1 lines)
87		87
88	public SourcePath (ContextProvider contextProvider) {	88	public SourcePath (ContextProvider contextProvider) {
89	this.contextProvider = contextProvider;	89	this.contextProvider = contextProvider;
90	debugger = (JPDADebugger) contextProvider.lookupFirst	90	debugger = contextProvider.lookupFirst(null, JPDADebugger.class);
91	(null, JPDADebugger.class);
92	getContext();// To initialize the source path provider	91	getContext();// To initialize the source path provider
93	}	92	}
94		93

Lines 101-111 public class WatchPanel { Link Here

(-)a/debugger.jpda.ui/src/org/netbeans/modules/debugger/jpda/ui/WatchPanel.java (-2 / +2 lines)
101	EditorKit kit = CloneableEditorSupport.getEditorKit("text/x-java");	101	EditorKit kit = CloneableEditorSupport.getEditorKit("text/x-java");
102	editorPane.setEditorKit(kit);	102	editorPane.setEditorKit(kit);
103	DebuggerEngine en = DebuggerManager.getDebuggerManager ().getCurrentEngine();	103	DebuggerEngine en = DebuggerManager.getDebuggerManager ().getCurrentEngine();
104	JPDADebugger d = (JPDADebugger) en.lookupFirst(null, JPDADebugger.class);	104	JPDADebugger d = en.lookupFirst(null, JPDADebugger.class);
105	CallStackFrame csf = d.getCurrentCallStackFrame();	105	CallStackFrame csf = d.getCurrentCallStackFrame();
106	if (csf != null) {	106	if (csf != null) {
107	String language = DebuggerManager.getDebuggerManager ().getCurrentSession().getCurrentLanguage();	107	String language = DebuggerManager.getDebuggerManager ().getCurrentSession().getCurrentLanguage();
108	SourcePath sp = (SourcePath) en.lookupFirst(null, SourcePath.class);	108	SourcePath sp = en.lookupFirst(null, SourcePath.class);
109	String url = sp.getURL(csf, language);	109	String url = sp.getURL(csf, language);
110	int line = csf.getLineNumber(language);	110	int line = csf.getLineNumber(language);
111	setupContext(editorPane, url, line);	111	setupContext(editorPane, url, line);

Lines 64-71 public class MakeCalleeCurrentActionProv Link Here

(-)a/debugger.jpda.ui/src/org/netbeans/modules/debugger/jpda/ui/actions/MakeCalleeCurrentActionProvider.java (-2 / +1 lines)
64		64
65	public MakeCalleeCurrentActionProvider (ContextProvider lookupProvider) {	65	public MakeCalleeCurrentActionProvider (ContextProvider lookupProvider) {
66	super (	66	super (
67	(JPDADebugger) lookupProvider.lookupFirst	67	lookupProvider.lookupFirst(null, JPDADebugger.class)
68	(null, JPDADebugger.class)
69	);	68	);
70	this.lookupProvider = lookupProvider;	69	this.lookupProvider = lookupProvider;
71	getDebuggerImpl ().addPropertyChangeListener	70	getDebuggerImpl ().addPropertyChangeListener

Lines 71-78 public class MakeCallerCurrentActionProv Link Here

(-)a/debugger.jpda.ui/src/org/netbeans/modules/debugger/jpda/ui/actions/MakeCallerCurrentActionProvider.java (-2 / +1 lines)
71		71
72	public MakeCallerCurrentActionProvider (ContextProvider lookupProvider) {	72	public MakeCallerCurrentActionProvider (ContextProvider lookupProvider) {
73	super (	73	super (
74	(JPDADebugger) lookupProvider.lookupFirst	74	lookupProvider.lookupFirst(null, JPDADebugger.class)
75	(null, JPDADebugger.class)
76	);	75	);
77	this.lookupProvider = lookupProvider;	76	this.lookupProvider = lookupProvider;
78	getDebuggerImpl ().addPropertyChangeListener	77	getDebuggerImpl ().addPropertyChangeListener




    
    
    public RunToCursorActionProvider (ContextProvider lookupProvider) {
        debugger = lookupProvider.lookupFirst(null, JPDADebugger.class);
        session = lookupProvider.lookupFirst(null, Session.class);
        debugger.addPropertyChangeListener (JPDADebugger.PROP_STATE, this);
                (null, Session.class);
        debugger.addPropertyChangeListener (debugger.PROP_STATE, this);
        EditorContextBridge.getContext().addPropertyChangeListener (this);
    }
    
    private void destroy () {
        debugger.removePropertyChangeListener (JPDADebugger.PROP_STATE, this);
        EditorContextBridge.getContext().removePropertyChangeListener (this);
    }
    

Lines 78-85 implements PropertyChangeListener { Link Here

(-)a/debugger.jpda.ui/src/org/netbeans/modules/debugger/jpda/ui/actions/ToggleBreakpointActionProvider.java (-2 / +1 lines)
78	}	78	}
79		79
80	public ToggleBreakpointActionProvider (ContextProvider lookupProvider) {	80	public ToggleBreakpointActionProvider (ContextProvider lookupProvider) {
81	debugger = (JPDADebugger) lookupProvider.lookupFirst	81	debugger = lookupProvider.lookupFirst(null, JPDADebugger.class);
82	(null, JPDADebugger.class);
83	debugger.addPropertyChangeListener (JPDADebugger.PROP_STATE, this);	82	debugger.addPropertyChangeListener (JPDADebugger.PROP_STATE, this);
84	EditorContextBridge.getContext().addPropertyChangeListener (this);	83	EditorContextBridge.getContext().addPropertyChangeListener (this);
85	}	84	}





    public CallStackActionsProvider (ContextProvider lookupProvider) {
        this.lookupProvider = lookupProvider;
        debugger = lookupProvider.lookupFirst(null, JPDADebugger.class);
            lookupFirst (null, JPDADebugger.class);
    }
    
    public Action[] getActions (Object node) throws UnknownTypeException {

    }
    
    private static Clipboard getClipboard() {
        Clipboard clipboard = org.openide.util.Lookup.getDefault().lookup(Clipboard.class);
        if (clipboard == null) {
            clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
        }

                public void run () {
                    String language = DebuggerManager.getDebuggerManager ().
                        getCurrentSession ().getCurrentLanguage ();
                    SourcePath sp = DebuggerManager.getDebuggerManager().getCurrentEngine().lookupFirst(null, SourcePath.class);
                        getDebuggerManager ().getCurrentEngine ().lookupFirst 
                        (null, SourcePath.class);
                    sp.showSource (frame, language);
                }
            });

Lines 77-86 public class CallStackNodeModel implemen Link Here

(-)a/debugger.jpda.ui/src/org/netbeans/modules/debugger/jpda/ui/models/CallStackNodeModel.java (-4 / +2 lines)
77		77
78		78
79	public CallStackNodeModel (ContextProvider lookupProvider) {	79	public CallStackNodeModel (ContextProvider lookupProvider) {
80	debugger = (JPDADebugger) lookupProvider.	80	debugger = lookupProvider.lookupFirst(null, JPDADebugger.class);
81	lookupFirst (null, JPDADebugger.class);	81	session = lookupProvider.lookupFirst(null, Session.class);
82	session = (Session) lookupProvider.
83	lookupFirst (null, Session.class);
84	new Listener (this, debugger);	82	new Listener (this, debugger);
85	}	83	}
86		84

Lines 79-85 public class ClassesActionsProvider impl Link Here

(-)a/debugger.jpda.ui/src/org/netbeans/modules/debugger/jpda/ui/models/ClassesActionsProvider.java (-1 / +1 lines)
79		79
80	public ClassesActionsProvider (ContextProvider lookupProvider) {	80	public ClassesActionsProvider (ContextProvider lookupProvider) {
81	//debugger = (JPDADebugger) lookupProvider.lookupFirst(null, JPDADebugger.class);	81	//debugger = (JPDADebugger) lookupProvider.lookupFirst(null, JPDADebugger.class);
82	tree = (TreeModel) lookupProvider.lookupFirst ("ClassesView", TreeModel.class);	82	tree = lookupProvider.lookupFirst("ClassesView", TreeModel.class);
83	}	83	}
84		84
85	public Action[] getActions (Object node) throws UnknownTypeException {	85	public Action[] getActions (Object node) throws UnknownTypeException {

Lines 89-95 public class JPDASessionActionsProvider Link Here

(-)a/debugger.jpda.ui/src/org/netbeans/modules/debugger/jpda/ui/models/JPDASessionActionsProvider.java (-1 / +1 lines)
89	List myActions = new ArrayList();	89	List myActions = new ArrayList();
90	DebuggerEngine e = session.getCurrentEngine ();	90	DebuggerEngine e = session.getCurrentEngine ();
91	if (e != null) {	91	if (e != null) {
92	JPDADebugger d = (JPDADebugger) e.lookupFirst(null, JPDADebugger.class);	92	JPDADebugger d = e.lookupFirst(null, JPDADebugger.class);
93	myActions.add(new CustomizeSession(d));	93	myActions.add(new CustomizeSession(d));
94	}	94	}
95	myActions.add(new LanguageSelection(session));	95	myActions.add(new LanguageSelection(session));

Lines 121-127 PropertyChangeListener { Link Here

(-)a/debugger.jpda.ui/src/org/netbeans/modules/debugger/jpda/ui/models/SessionsTableModelFilter.java (-2 / +2 lines)
121	if (e == null) {	121	if (e == null) {
122	return false;	122	return false;
123	}	123	}
124	JPDADebugger d = (JPDADebugger) e.lookupFirst(null, JPDADebugger.class);	124	JPDADebugger d = e.lookupFirst(null, JPDADebugger.class);
125	return d != null;	125	return d != null;
126	}	126	}
127		127
Lines 129-135 PropertyChangeListener { Link Here
129	DebuggerEngine e = s.getCurrentEngine ();	129	DebuggerEngine e = s.getCurrentEngine ();
130	if (e == null)	130	if (e == null)
131	return loc ("MSG_Session_State_Starting");	131	return loc ("MSG_Session_State_Starting");
132	JPDADebugger d = (JPDADebugger) e.lookupFirst (null, JPDADebugger.class);	132	JPDADebugger d = e.lookupFirst(null, JPDADebugger.class);
133	synchronized (this) {	133	synchronized (this) {
134	if (!addedAsListener) {	134	if (!addedAsListener) {
135	d.addPropertyChangeListener (JPDADebugger.PROP_STATE, this);	135	d.addPropertyChangeListener (JPDADebugger.PROP_STATE, this);

Lines 96-105 NodeActionsProvider { Link Here

(-)a/debugger.jpda.ui/src/org/netbeans/modules/debugger/jpda/ui/models/SourcesModel.java (-4 / +2 lines)
96		96
97		97
98	public SourcesModel (ContextProvider lookupProvider) {	98	public SourcesModel (ContextProvider lookupProvider) {
99	sourcePath = (SourcePath) lookupProvider.	99	sourcePath = lookupProvider.lookupFirst(null, SourcePath.class);
100	lookupFirst (null, SourcePath.class);	100	debugger = lookupProvider.lookupFirst(null, JPDADebugger.class);
101	debugger = (JPDADebugger) lookupProvider.
102	lookupFirst (null, JPDADebugger.class);
103	loadFilters ();	101	loadFilters ();
104	}	102	}
105		103




                if (nodes[0] instanceof MonitorModel.ThreadWithBordel) nodes[0] = ((MonitorModel.ThreadWithBordel) nodes[0]).originalThread;
                String language = DebuggerManager.getDebuggerManager ().
                    getCurrentSession ().getCurrentLanguage ();
                SourcePath sp = DebuggerManager.getDebuggerManager().getCurrentEngine().lookupFirst(null, SourcePath.class);
                    getDebuggerManager ().getCurrentEngine ().lookupFirst 
                    (null, SourcePath.class);
                sp.showSource ((JPDAThread) nodes [0], language);
            }
        },

    
    
    public ThreadsActionsProvider (ContextProvider lookupProvider) {
        debugger = lookupProvider.lookupFirst(null, JPDADebugger.class);
            lookupFirst (null, JPDADebugger.class);
    }
    
    public Action[] getActions (Object node) throws UnknownTypeException {

            getCurrentSession ().getCurrentLanguage ();
        if (!t.isSuspended ())
            return false;
        SourcePath sp = DebuggerManager.getDebuggerManager().getCurrentEngine().lookupFirst(null, SourcePath.class);
        SourcePath sp = (SourcePath) DebuggerManager.
            getDebuggerManager ().getCurrentEngine ().lookupFirst 
            (null, SourcePath.class);
        return sp.sourceAvailable (t, language, true);
    }
}

Lines 86-95 public class ThreadsNodeModel implements Link Here

(-)a/debugger.jpda.ui/src/org/netbeans/modules/debugger/jpda/ui/models/ThreadsNodeModel.java (-4 / +2 lines)
86		86
87		87
88	public ThreadsNodeModel (ContextProvider lookupProvider) {	88	public ThreadsNodeModel (ContextProvider lookupProvider) {
89	debugger = (JPDADebugger) lookupProvider.	89	debugger = lookupProvider.lookupFirst(null, JPDADebugger.class);
90	lookupFirst (null, JPDADebugger.class);	90	session = lookupProvider.lookupFirst(null, Session.class);
91	session = (Session) lookupProvider.
92	lookupFirst (null, Session.class);
93	new Listener (this, debugger);	91	new Listener (this, debugger);
94	}	92	}
95		93




    }
    
    public void goToSource (Field variable) {
        SourcePath ectx = lookupProvider.lookupFirst(null, SourcePath.class);
            (null, SourcePath.class);
        ectx.showSource (variable);
    }

    private boolean isSourceAvailable (Field v) {
        SourcePath ectx = lookupProvider.lookupFirst(null, SourcePath.class);
            (null, SourcePath.class);
        return ectx.sourceAvailable (v);
    }
}

Lines 102-109 public class VariablesNodeModel implemen Link Here

(-)a/debugger.jpda.ui/src/org/netbeans/modules/debugger/jpda/ui/models/VariablesNodeModel.java (-2 / +1 lines)
102		102
103		103
104	public VariablesNodeModel (ContextProvider lookupProvider) {	104	public VariablesNodeModel (ContextProvider lookupProvider) {
105	debugger = (JPDADebugger) lookupProvider.	105	debugger = lookupProvider.lookupFirst(null, JPDADebugger.class);
106	lookupFirst (null, JPDADebugger.class);
107	}	106	}
108		107
109		108

Lines 73-79 public class VariablesTableModel impleme Link Here

(-)a/debugger.jpda.ui/src/org/netbeans/modules/debugger/jpda/ui/models/VariablesTableModel.java (-1 / +1 lines)
73	private JPDADebugger debugger;	73	private JPDADebugger debugger;
74		74
75	public VariablesTableModel(ContextProvider contextProvider) {	75	public VariablesTableModel(ContextProvider contextProvider) {
76	debugger = (JPDADebugger) contextProvider.lookupFirst(null, JPDADebugger.class);	76	debugger = contextProvider.lookupFirst(null, JPDADebugger.class);
77	}	77	}
78		78
79	public Object getValueAt (Object row, String columnID) throws	79	public Object getValueAt (Object row, String columnID) throws




        updateModel ();
    }
    
    // XXX copy-paste programming!
    private <T> List<? extends T> joinLookups(DebuggerEngine e, DebuggerManager dm, Class<T> service) {
        List<? extends T> es = e.lookup (viewType, service);
        List<? extends T> ms = dm.lookup(viewType, service);
        List<T> joined = new ArrayList<T>(es);
        for (T t : ms) {
            if (!es.contains(t)) {
                joined.add(t);
            }
        }
        return joined;
    }
    
    private synchronized void updateModel () {





    public AttachingSessionProvider (ContextProvider contextProvider) {
        this.contextProvider = contextProvider;
        sadic = contextProvider.lookupFirst(null, AttachingDICookie.class);
            (null, AttachingDICookie.class);
    };
    
    public String getSessionName () {
        Map arguments = contextProvider.lookupFirst(null, Map.class);
            (null, Map.class);
        if (arguments != null) {
            String processName = (String) arguments.get ("name");
            if (processName != null)




    }
    
    public Session getSession() {
        return lookupProvider.lookupFirst(null, Session.class);
    }
    
    private Boolean canBeModified;

     */
    public SmartSteppingFilter getSmartSteppingFilter () {
        if (smartSteppingFilter == null) {
            smartSteppingFilter = lookupProvider.lookupFirst(null, SmartSteppingFilter.class);
                lookupFirst (null, SmartSteppingFilter.class);
            smartSteppingFilter.addExclusionPatterns (
                (Set) Properties.getDefault ().getProperties ("debugger").
                    getProperties ("sources").getProperties ("class_filters").

    
    private CompoundSmartSteppingListener getCompoundSmartSteppingListener () {
        if (compoundSmartSteppingListener == null)
            compoundSmartSteppingListener = lookupProvider.lookupFirst(null, CompoundSmartSteppingListener.class);
                lookupFirst (null, CompoundSmartSteppingListener.class);
        return compoundSmartSteppingListener;
    }
    

                finishing = true;
            }
            logger.fine("StartActionProvider.finish ()");
            AbstractDICookie di = lookupProvider.lookupFirst(null, AbstractDICookie.class);
                (null, AbstractDICookie.class);
            if (getState () == STATE_DISCONNECTED) return;
            Operator o = getOperator();
            if (o != null) o.stop();

    private SourcePath engineContext;
    public synchronized SourcePath getEngineContext () {
        if (engineContext == null)
            engineContext = lookupProvider.lookupFirst(null, SourcePath.class);
                lookupFirst (null, SourcePath.class);
        return engineContext;
    }


    }
    
    public JPDAStep createJPDAStep(int size, int depth) {
        Session session = lookupProvider.lookupFirst(null, Session.class);
        return new JPDAStepImpl(this, session, size, depth);
    }
    





package org.netbeans.modules.debugger.jpda;

import com.sun.jdi.AbsentInformationException;
import com.sun.jdi.IncompatibleThreadStateException;
import com.sun.jdi.event.LocatableEvent;
import java.beans.PropertyChangeListener;
import java.lang.reflect.InvocationTargetException;
import java.net.MalformedURLException;
import java.net.URL;
import java.awt.Color;
import java.awt.Dialog;
import java.awt.GridBagLayout;


import org.netbeans.api.debugger.DebuggerManager;
import org.netbeans.api.debugger.Session;
import org.netbeans.api.debugger.jpda.CallStackFrame;
import org.netbeans.api.debugger.jpda.JPDABreakpoint;
import org.netbeans.api.debugger.jpda.JPDAStep;
import org.netbeans.api.debugger.jpda.JPDAThread;
import org.netbeans.api.debugger.jpda.JPDADebugger;
import com.sun.jdi.event.Event;
import com.sun.jdi.request.BreakpointRequest;
import com.sun.jdi.ThreadReference;
import com.sun.jdi.request.StepRequest;
import com.sun.jdi.request.EventRequest;
import com.sun.jdi.request.EventRequestManager;

import com.sun.jdi.VirtualMachine;
import org.netbeans.api.debugger.jpda.JPDAThreadGroup;
import org.netbeans.api.debugger.jpda.MethodBreakpoint;
import org.netbeans.api.debugger.jpda.SmartSteppingFilter;
import org.netbeans.api.debugger.jpda.Variable;
import org.netbeans.api.debugger.jpda.event.JPDABreakpointEvent;
import org.netbeans.api.debugger.jpda.event.JPDABreakpointListener;
import org.netbeans.modules.debugger.jpda.JPDAStepImpl.SingleThreadedStepWatch;
import org.netbeans.modules.debugger.jpda.actions.SmartSteppingFilterImpl;
import org.netbeans.modules.debugger.jpda.breakpoints.MethodBreakpointImpl;
import org.netbeans.modules.debugger.jpda.util.Executor;
import org.netbeans.modules.debugger.jpda.JPDADebuggerImpl;
import org.netbeans.modules.debugger.jpda.actions.StepIntoActionProvider;
import org.netbeans.modules.debugger.jpda.models.JPDAThreadImpl;
import org.netbeans.spi.debugger.jpda.EditorContext.Operation;
import org.openide.DialogDescriptor;
import org.openide.DialogDescriptor;
import org.openide.ErrorManager;
import org.openide.NotifyDescriptor;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.URLMapper;
import org.openide.util.NbBundle;
import org.openide.util.RequestProcessor;


                return false; // The session has finished
            }
            int depth;
            Map properties = session.lookupFirst(null, Map.class);
            if (properties != null && properties.containsKey (StepIntoActionProvider.SS_STEP_OUT)) {
                depth = StepRequest.STEP_OUT;
            } else {

Lines 61-67 public class JavaEngineProvider extends Link Here

(-)a/debugger.jpda/src/org/netbeans/modules/debugger/jpda/JavaEngineProvider.java (-1 / +1 lines)
61	private Session session;	61	private Session session;
62		62
63	public JavaEngineProvider (ContextProvider contextProvider) {	63	public JavaEngineProvider (ContextProvider contextProvider) {
64	session = (Session) contextProvider.lookupFirst (null, Session.class);	64	session = contextProvider.lookupFirst(null, Session.class);
65	}	65	}
66		66
67	public String[] getLanguages () {	67	public String[] getLanguages () {




    
    public LaunchingSessionProvider (ContextProvider contextProvider) {
        this.contextProvider = contextProvider;
        launchingCookie = contextProvider.lookupFirst(null, LaunchingDICookie.class);
            (null, LaunchingDICookie.class);
    };
    
    public String getSessionName () {
        Map arguments = contextProvider.lookupFirst(null, Map.class);
            (null, Map.class);
        if (arguments != null) {
            String processName = (String) arguments.get ("name");
            if (processName != null)





    public ListeningSessionProvider (ContextProvider contextProvider) {
        this.contextProvider = contextProvider;
        smadic = contextProvider.lookupFirst(null, ListeningDICookie.class);
            (null, ListeningDICookie.class);
    };
    
    public String getSessionName () {
        Map arguments = contextProvider.lookupFirst(null, Map.class);
            (null, Map.class);
        if (arguments != null) {
            String processName = (String) arguments.get ("name");
            if (processName != null)

Lines 75-82 public class SourcePath { Link Here

(-)a/debugger.jpda/src/org/netbeans/modules/debugger/jpda/SourcePath.java (-2 / +1 lines)
75		75
76	public SourcePath (ContextProvider lookupProvider) {	76	public SourcePath (ContextProvider lookupProvider) {
77	this.lookupProvider = lookupProvider;	77	this.lookupProvider = lookupProvider;
78	debugger = (JPDADebugger) lookupProvider.lookupFirst	78	debugger = lookupProvider.lookupFirst(null, JPDADebugger.class);
79	(null, JPDADebugger.class);
80	}	79	}
81		80
82	public SourcePathProvider getContext () {	81	public SourcePathProvider getContext () {

Lines 66-73 public class CompoundSmartSteppingListen Link Here

(-)a/debugger.jpda/src/org/netbeans/modules/debugger/jpda/actions/CompoundSmartSteppingListener.java (-2 / +1 lines)
66		66
67	public CompoundSmartSteppingListener (ContextProvider lookupProvider) {	67	public CompoundSmartSteppingListener (ContextProvider lookupProvider) {
68	this.lookupProvider = lookupProvider;	68	this.lookupProvider = lookupProvider;
69	SmartSteppingFilter smartSteppingFilter = (SmartSteppingFilter) lookupProvider.	69	SmartSteppingFilter smartSteppingFilter = lookupProvider.lookupFirst(null, SmartSteppingFilter.class);
70	lookupFirst (null, SmartSteppingFilter.class);
71	initFilter (smartSteppingFilter);	70	initFilter (smartSteppingFilter);
72	}	71	}
73		72




    public RunIntoMethodActionProvider(ContextProvider lookupProvider) {
        debugger = (JPDADebuggerImpl) lookupProvider.lookupFirst 
                (null, JPDADebugger.class);
        session = lookupProvider.lookupFirst(null, Session.class);
        sourcePath = lookupProvider.lookupFirst(null, SourcePath.class);
        debugger.addPropertyChangeListener (JPDADebuggerImpl.PROP_STATE, this);
                (null, SourcePath.class);
        debugger.addPropertyChangeListener (debugger.PROP_STATE, this);
        EditorContextBridge.getContext().addPropertyChangeListener (this);
    }
    
    private void destroy () {
        debugger.removePropertyChangeListener (JPDADebuggerImpl.PROP_STATE, this);
        EditorContextBridge.getContext().removePropertyChangeListener (this);
    }
    




        
        
        debuggerImpl.setStarting ();
        final AbstractDICookie cookie = lookupProvider.lookupFirst(null, AbstractDICookie.class);
            lookupFirst (null, AbstractDICookie.class);
        doStartDebugger(cookie);
        if (startVerbose)
            System.out.println ("\nS StartActionProvider." +

        }
        
        
        final AbstractDICookie cookie = lookupProvider.lookupFirst(null, AbstractDICookie.class);
            lookupFirst (null, AbstractDICookie.class);
        
        if (startVerbose)
            System.out.println ("\nS StartActionProvider." +

                );
            debuggerImpl.setException (exception);
            // kill the session that did not start properly
            final Session session = lookupProvider.lookupFirst(null, Session.class);
            RequestProcessor.getDefault().post(new Runnable() {
                public void run() {
                    // Kill it in a separate thread so that the startup sequence can be finished.




        );
        this.lookupProvider = lookupProvider;
        setProviderToDisableOnLazyAction(this);
        Map properties = lookupProvider.lookupFirst(null, Map.class);
        if (properties != null) {
            smartSteppingStepOut = properties.containsKey (StepIntoActionProvider.SS_STEP_OUT);
        }

                     (lookupProvider, t, getSmartSteppingFilterImpl ())
                ) {
                    // YES!
                    Session session = lookupProvider.lookupFirst(null, Session.class);
                    if (session != null) {
                        DebuggerManager.getDebuggerManager().setCurrentSession(session);
                    }

    
    private CompoundSmartSteppingListener getCompoundSmartSteppingListener () {
        if (compoundSmartSteppingListener == null)
            compoundSmartSteppingListener = lookupProvider.lookupFirst(null, CompoundSmartSteppingListener.class);
                lookupFirst (null, CompoundSmartSteppingListener.class);
        return compoundSmartSteppingListener;
    }
}




        );
        this.contextProvider = contextProvider;
        getSmartSteppingFilterImpl ().addPropertyChangeListener (this);
        SourcePath ec = contextProvider.lookupFirst(null, SourcePath.class);
            lookupFirst (null, SourcePath.class);
        ec.addPropertyChangeListener (this);
        Map properties = contextProvider.lookupFirst(null, Map.class);
        if (properties != null)
            smartSteppingStepOut = properties.containsKey (SS_STEP_OUT);
        setProviderToDisableOnLazyAction(this);

            }
            if (stop) {
                removeStepRequests (le.thread ());
                Session session = contextProvider.lookupFirst(null, Session.class);
                if (session != null) {
                    DebuggerManager.getDebuggerManager().setCurrentSession(session);
                }

    
    private SmartSteppingFilter getSmartSteppingFilterImpl () {
        if (smartSteppingFilter == null)
            smartSteppingFilter = contextProvider.lookupFirst(null, SmartSteppingFilter.class);
                lookupFirst (null, SmartSteppingFilter.class);
        return smartSteppingFilter;
    }


    
    private CompoundSmartSteppingListener getCompoundSmartSteppingListener () {
        if (compoundSmartSteppingListener == null)
            compoundSmartSteppingListener = contextProvider.lookupFirst(null, CompoundSmartSteppingListener.class);
                contextProvider.lookupFirst (null, CompoundSmartSteppingListener.class);
        return compoundSmartSteppingListener;
    }





import org.netbeans.spi.debugger.ContextProvider;
import org.netbeans.api.debugger.Session;
import org.netbeans.api.debugger.jpda.JPDADebugger;
import org.netbeans.api.debugger.jpda.LineBreakpoint;
import org.netbeans.modules.debugger.jpda.JPDADebuggerImpl;
import org.netbeans.spi.debugger.ActionsProviderSupport;


    
    
    public StepOperationActionProvider (ContextProvider lookupProvider) {
        debugger = lookupProvider.lookupFirst(null, JPDADebugger.class);
        session = lookupProvider.lookupFirst(null, Session.class);
        debugger.addPropertyChangeListener (JPDADebugger.PROP_STATE, this);
                (null, Session.class);
        debugger.addPropertyChangeListener (debugger.PROP_STATE, this);
    }
    
    private void destroy () {
        debugger.removePropertyChangeListener (JPDADebugger.PROP_STATE, this);
    }
    
    static ActionsManager getCurrentActionsManager () {

        setEnabled (
            ActionsManager.ACTION_STEP_OPERATION,
            getActionsManager().isEnabled(ActionsManager.ACTION_CONTINUE) &&
            (debugger.getState () == JPDADebugger.STATE_STOPPED)  &&
            (debugger.getCurrentThread () != null)
        );
        if (debugger.getState () == JPDADebugger.STATE_DISCONNECTED) 
            destroy ();
    }
    

            setEnabled (
                ActionsManager.ACTION_STEP_OPERATION,
                enabled &&
                (debugger.getState () == JPDADebugger.STATE_STOPPED)  &&
                (debugger.getCurrentThread () != null)
            );
        }

Lines 91-99 implements PropertyChangeListener, Debug Link Here

(-)a/debugger.jpda/src/org/netbeans/modules/debugger/jpda/breakpoints/BreakpointsEngineListener.java (-3 / +2 lines)
91	public BreakpointsEngineListener (ContextProvider lookupProvider) {	91	public BreakpointsEngineListener (ContextProvider lookupProvider) {
92	debugger = (JPDADebuggerImpl) lookupProvider.lookupFirst	92	debugger = (JPDADebuggerImpl) lookupProvider.lookupFirst
93	(null, JPDADebugger.class);	93	(null, JPDADebugger.class);
94	engineContext = (SourcePath) lookupProvider.	94	engineContext = lookupProvider.lookupFirst(null, SourcePath.class);
95	lookupFirst (null, SourcePath.class);	95	session = lookupProvider.lookupFirst(null, Session.class);
96	session = (Session) lookupProvider.lookupFirst(null, Session.class);
97	debugger.addPropertyChangeListener (	96	debugger.addPropertyChangeListener (
98	JPDADebugger.PROP_STATE,	97	JPDADebugger.PROP_STATE,
99	this	98	this

Lines 273-278 public class ExpressionStepTest extends Link Here

(-)a/debugger.jpda/test/unit/src/org/netbeans/api/debugger/jpda/ExpressionStepTest.java (+1 lines)
273	}	273	}
274		274
275	private static EditorContext getContext () {	275	private static EditorContext getContext () {
		276	// XXX lookupFirst?
276	List l = DebuggerManager.getDebuggerManager ().lookup	277	List l = DebuggerManager.getDebuggerManager ().lookup
277	(null, EditorContext.class);	278	(null, EditorContext.class);
278	EditorContext context = (EditorContext) l.get (0);	279	EditorContext context = (EditorContext) l.get (0);




        this.contextProvider = contextProvider;
    }
    
    private static <T> List<? extends T> debugLookup(String folder, Class<T> clazz) {
        return DebuggerManager.getDebuggerManager().lookup(folder, clazz);
        return (List<T>) DebuggerManager.getDebuggerManager().lookup(folder, clazz);
    }
    
    @SuppressWarnings("unchecked")
    static <T> T lookupFirst(final ContextProvider cp, Class<T> clazz) {
        return cp.lookupFirst(null, clazz);
    }
    
    public void fireModelChanges() {


    public static SessionsTableModelFilter getSessionsModel() {
        if (sessionsModel == null) {
            List<? extends TableModelFilter> tableModels = ContextProviderWrapper.debugLookup("SessionsView", TableModelFilter.class);
            for (TableModelFilter model : tableModels) {
                if (model instanceof SessionsTableModelFilter) {
                    sessionsModel = (SessionsTableModelFilter) model;

    
    public static BreakpointModel getBreakpointModel() {
        if (breakpointModel == null) {
            List<? extends TableModel> tableModels = ContextProviderWrapper.debugLookup("BreakpointsView", TableModel.class);
            for (TableModel model : tableModels) {
                if (model instanceof BreakpointModel) {
                    breakpointModel = (BreakpointModel) model;

Lines 226-232 public final class RubyDebugger implemen Link Here

(-)a/ruby.debugger/src/org/netbeans/modules/ruby/debugger/RubyDebugger.java (-1 / +1 lines)
226	DebuggerEngine[] es = dm.startDebugging(di);	226	DebuggerEngine[] es = dm.startDebugging(di);
227		227
228	RubyDebuggerActionProvider provider =	228	RubyDebuggerActionProvider provider =
229	(RubyDebuggerActionProvider) es[0].lookupFirst(null, RubyDebuggerActionProvider.class);	229	es[0].lookupFirst(null, RubyDebuggerActionProvider.class);
230	assert provider != null;	230	assert provider != null;
231	proxy.addRubyDebugEventListener(provider);	231	proxy.addRubyDebugEventListener(provider);
232	}	232	}

Lines 128-134 public final class Util { Link Here

(-)a/ruby.debugger/src/org/netbeans/modules/ruby/debugger/Util.java (-1 / +1 lines)
128	public static RubySession getCurrentSession() {	128	public static RubySession getCurrentSession() {
129	DebuggerEngine currentEngine = DebuggerManager.getDebuggerManager().getCurrentEngine();	129	DebuggerEngine currentEngine = DebuggerManager.getDebuggerManager().getCurrentEngine();
130	return (currentEngine == null) ? null :	130	return (currentEngine == null) ? null :
131	(RubySession) currentEngine.lookupFirst(null, RubySession.class);	131	currentEngine.lookupFirst(null, RubySession.class);
132	}	132	}
133		133
134	static boolean offerToInstallFastDebugger(final RubyPlatform platform) {	134	static boolean offerToInstallFastDebugger(final RubyPlatform platform) {

Lines 100-106 public final class SessionsTableModelFil Link Here

(-)a/ruby.debugger/src/org/netbeans/modules/ruby/debugger/model/SessionsTableModelFilter.java (-1 / +1 lines)
100	if (e == null) {	100	if (e == null) {
101	return getMessage("MSG_Session.State.Starting");	101	return getMessage("MSG_Session.State.Starting");
102	}	102	}
103	RubySession session = (RubySession) e.lookupFirst (null, RubySession.class);	103	RubySession session = e.lookupFirst(null, RubySession.class);
104	String state;	104	String state;
105	switch (session.getState()) {	105	switch (session.getState()) {
106	case RUNNING:	106	case RUNNING:

Lines 38-41 Link Here

(-)a/spi.debugger.ui/nbproject/project.properties (+2 lines)
38	# made subject to such option by the copyright holder.	38	# made subject to such option by the copyright holder.
39		39
40	is.autoload=true	40	is.autoload=true
		41	javac.compilerargs=-Xlint -Xlint:-serial
		42	javac.source=1.5
41	javadoc.arch=${basedir}/arch.xml	43	javadoc.arch=${basedir}/arch.xml




    private javax.swing.JPanel      pEvent;
    /** <CODE>HelpCtx</CODE> of the selected breakpoint type's customizer */
    private HelpCtx                 helpCtx;
    private List<? extends BreakpointType> breakpointTypes;


    // init ....................................................................

    public AddBreakpointPanel () {
        breakpointTypes = DebuggerManager.getDebuggerManager ().lookup 
            (null, BreakpointType.class);
        int i, k = breakpointTypes.size ();
        String def = null;
        for (BreakpointType bt : breakpointTypes) {
            BreakpointType bt = (BreakpointType) breakpointTypes.get (i);
            String dn = bt.getCategoryDisplayName ();
            if (!cathegories.contains (dn)) {
                cathegories.add (dn);

        doNotRefresh = true;
        cbEvents.removeAllItems ();
        types = new ArrayList ();
        int defIndex = 0;
        for (BreakpointType bt : breakpointTypes) {
            BreakpointType bt = (BreakpointType) breakpointTypes.get (i);
            if (!bt.getCategoryDisplayName ().equals (c))
                continue;
            cbEvents.addItem (bt.getTypeDisplayName ());




        updateModel ();
    }
    
    // XXX copy-paste programming!
    private <T> List<? extends T> joinLookups(DebuggerEngine e, DebuggerManager dm, Class<T> service) {
        List<? extends T> es = e.lookup (viewType, service);
        List<? extends T> ms = dm.lookup(viewType, service);
        List<T> joined = new ArrayList<T>(es);
        for (T t : ms) {
            if (!es.contains(t)) {
                joined.add(t);
            }
        }
        return joined;
    }
    
    private synchronized void updateModel () {

Lines 65-72 public class LaunchDebuggerTest extends Link Here

(-)a/spi.debugger.ui/test/unit/src/org/netbeans/api/debugger/LaunchDebuggerTest.java (-3 / +8 lines)
65	TestDebuggerManagerListener dml = new TestDebuggerManagerListener();	65	TestDebuggerManagerListener dml = new TestDebuggerManagerListener();
66	dm.addDebuggerListener(dml);	66	dm.addDebuggerListener(dml);
67		67
68	TestLazyDebuggerManagerListener ldml = (TestLazyDebuggerManagerListener)	68	TestLazyDebuggerManagerListener ldml = null;
69	dm.lookupFirst (null, LazyDebuggerManagerListener.class);	69	for (LazyDebuggerManagerListener _ldml : dm.lookup(null, LazyDebuggerManagerListener.class)) {
		70	if (_ldml instanceof TestLazyDebuggerManagerListener) {
		71	ldml = (TestLazyDebuggerManagerListener) _ldml;
		72	break;
		73	}
		74	}
70	assertNotNull("Lazy debugger manager listener not loaded", ldml);	75	assertNotNull("Lazy debugger manager listener not loaded", ldml);
71		76
72	Map args = new HashMap();	77	Map args = new HashMap();
Lines 82-88 public class LaunchDebuggerTest extends Link Here
82	testStartEvents(ldml, engines);	87	testStartEvents(ldml, engines);
83		88
84	DebuggerEngine debugger = engines[0];	89	DebuggerEngine debugger = engines[0];
85	DebuggerInfo dic = (DebuggerInfo) debugger.lookupFirst(null, DebuggerInfo.class);	90	DebuggerInfo dic = debugger.lookupFirst(null, DebuggerInfo.class);
86	assertSame("Wrong debugger info in engine lookup", dic, di);	91	assertSame("Wrong debugger info in engine lookup", dic, di);
87	assertTrue("Engine did not start", tdi.hasInfo(ActionsManager.ACTION_START));	92	assertTrue("Engine did not start", tdi.hasInfo(ActionsManager.ACTION_START));
88		93

Lines 58-64 public class TestEngineProvider extends Link Here

(-)a/spi.debugger.ui/test/unit/src/org/netbeans/api/debugger/test/TestEngineProvider.java (-1 / +1 lines)
58	private Session session;	58	private Session session;
59		59
60	public TestEngineProvider (ContextProvider s) {	60	public TestEngineProvider (ContextProvider s) {
61	session = (Session) s.lookupFirst(null, Session.class);	61	session = s.lookupFirst(null, Session.class);
62	}	62	}
63		63
64	public String [] getLanguages () {	64	public String [] getLanguages () {

Lines 56-63 public class TestSessionProvider extends Link Here

(-)a/spi.debugger.ui/test/unit/src/org/netbeans/api/debugger/test/TestSessionProvider.java (-2 / +2 lines)
56	private TestDICookie cookie;	56	private TestDICookie cookie;
57		57
58	public TestSessionProvider (ContextProvider info) {	58	public TestSessionProvider (ContextProvider info) {
59	this.info = (DebuggerInfo) info.lookupFirst(null, DebuggerInfo.class);	59	this.info = info.lookupFirst(null, DebuggerInfo.class);
60	cookie = (TestDICookie) info.lookupFirst(null, TestDICookie.class);	60	cookie = info.lookupFirst(null, TestDICookie.class);
61	};	61	};
62		62
63	public String getSessionName () {	63	public String getSessionName () {





    public KillActionProvider (ContextProvider lookupProvider) {
        this.lookupProvider = lookupProvider;
        debugger = lookupProvider.lookupFirst(null, TestDebugger.class);
            (null, TestDebugger.class);
    }

    public boolean isEnabled(Object action) {

        
    public void doAction (Object action) {
        debugger.finish();
        DebuggerInfo di = lookupProvider.lookupFirst(null, DebuggerInfo.class);
        TestDICookie tic = di.lookupFirst(null, TestDICookie.class);
        TestDICookie tic = (TestDICookie) di.lookupFirst(null, TestDICookie.class);
        tic.addInfo(ActionsManager.ACTION_KILL);
    }
}




    
    
    public StartActionProvider (ContextProvider lookupProvider) {
        debuggerImpl = lookupProvider.lookupFirst(null, TestDebugger.class);
            (null, TestDebugger.class);
        this.lookupProvider = lookupProvider;
    }
    

    
    public void doAction (Object action) {
        if (debuggerImpl == null) return;
        final TestDICookie cookie = lookupProvider.lookupFirst(null, TestDICookie.class);
            (null, TestDICookie.class);
        cookie.addInfo(ActionsManager.ACTION_START);
    }


Lines 62-68 public class TestDebuggerActionsProvider Link Here

(-)a/spi.debugger.ui/test/unit/src/org/netbeans/api/debugger/test/actions/TestDebuggerActionsProvider.java (-2 / +2 lines)
62	private Set supportedActions;	62	private Set supportedActions;
63		63
64	public TestDebuggerActionsProvider(ContextProvider lookupProvider) {	64	public TestDebuggerActionsProvider(ContextProvider lookupProvider) {
65	debuggerImpl = (TestDebugger) lookupProvider.lookupFirst(null, TestDebugger.class);	65	debuggerImpl = lookupProvider.lookupFirst(null, TestDebugger.class);
66	this.lookupProvider = lookupProvider;	66	this.lookupProvider = lookupProvider;
67	supportedActions = new HashSet();	67	supportedActions = new HashSet();
68	supportedActions.add(ActionsManager.ACTION_CONTINUE);	68	supportedActions.add(ActionsManager.ACTION_CONTINUE);
Lines 86-92 public class TestDebuggerActionsProvider Link Here
86		86
87	public void doAction (Object action) {	87	public void doAction (Object action) {
88	if (debuggerImpl == null) return;	88	if (debuggerImpl == null) return;
89	final TestDICookie cookie = (TestDICookie) lookupProvider.lookupFirst(null, TestDICookie.class);	89	final TestDICookie cookie = lookupProvider.lookupFirst(null, TestDICookie.class);
90	cookie.addInfo(action);	90	cookie.addInfo(action);
91	}	91	}
92		92

Return to bug 128229

Lines 176-183 public abstract class JPDADebugger { Link Here

(-)a/api.debugger.jpda/src/org/netbeans/api/debugger/jpda/JPDADebugger.java (-6 / +3 lines)
176	);	176	);
177	int i, k = es.length;	177	int i, k = es.length;
178	for (i = 0; i < k; i++) {	178	for (i = 0; i < k; i++) {
179	JPDADebugger d = (JPDADebugger) es [i].lookupFirst	179	JPDADebugger d = es[i].lookupFirst(null, JPDADebugger.class);
180	(null, JPDADebugger.class);
181	if (d == null) continue;	180	if (d == null) continue;
182	d.waitRunning ();	181	d.waitRunning ();
183	return d;	182	return d;
Lines 247-254 public abstract class JPDADebugger { Link Here
247	);	246	);
248	int i, k = es.length;	247	int i, k = es.length;
249	for (i = 0; i < k; i++) {	248	for (i = 0; i < k; i++) {
250	JPDADebugger d = (JPDADebugger) es [i].lookupFirst	249	JPDADebugger d = es[i].lookupFirst(null, JPDADebugger.class);
251	(null, JPDADebugger.class);
252	if (d == null) continue;	250	if (d == null) continue;
253	d.waitRunning ();	251	d.waitRunning ();
254	return d;	252	return d;
Lines 282-289 public abstract class JPDADebugger { Link Here
282	);	280	);
283	int i, k = es.length;	281	int i, k = es.length;
284	for (i = 0; i < k; i++) {	282	for (i = 0; i < k; i++) {
285	JPDADebugger d = (JPDADebugger) es [i].lookupFirst	283	JPDADebugger d = es[i].lookupFirst(null, JPDADebugger.class);
286	(null, JPDADebugger.class);
287	d.waitRunning ();	284	d.waitRunning ();
288	if (d == null) continue;	285	if (d == null) continue;
289	return d;	286	return d;

Lines 72-77 made subject to such option by the copyr Link Here

(-)a/api.debugger/apichanges.xml (+33 lines)
72	<!-- ACTUAL CHANGES BEGIN HERE: -->	72	<!-- ACTUAL CHANGES BEGIN HERE: -->
73		73
74	<changes>	74	<changes>
		75	<change id="generification">
		76	<api name="DebuggerCoreAPI"/>
		77	<summary>Use of some generic types in API; <code>ContextProvider</code> implemented more broadly</summary>
		78	<version major="1" minor="13"/>
		79	<date day="1" month="3" year="2008"/>
		80	<author login="jglick"/>
		81	<compatibility binary="compatible" source="incompatible" modification="yes" semantic="compatible">
		82	<p>
		83	As with any generification, it is possible for old code to no longer compile. E.g.
		84	</p>
		85	<pre>List<X> = lookup.lookup(folder, X.class);</pre>
		86	<p>
		87	must be changed to:
		88	</p>
		89	<pre>List<? extends X> = lookup.lookup(folder, X.class);</pre>
		90	</compatibility>
		91	<description>
		92	<p>
		93	<code>ContextProvider</code> is now properly generified, and implemented also by:
		94	</p>
		95	<ul>
		96	<li><code>DebuggerEngine</code></li>
		97	<li><code>DebuggerInfo</code></li>
		98	<li><code>DebuggerManager</code></li>
		99	<li><code>Session</code></li>
		100	</ul>
		101	</description>
		102	<class package="org.netbeans.api.debugger" name="DebuggerEngine"/>
		103	<class package="org.netbeans.api.debugger" name="DebuggerInfo"/>
		104	<class package="org.netbeans.api.debugger" name="DebuggerManager"/>
		105	<class package="org.netbeans.api.debugger" name="Session"/>
		106	<issue number="128229"/>
		107	</change>
75	<change id="debugger-dual-actions">	108	<change id="debugger-dual-actions">
76	<api name="DebuggerCoreAPI"/>	109	<api name="DebuggerCoreAPI"/>
77	<summary>Support for "dual" actions added.</summary>	110	<summary>Support for "dual" actions added.</summary>

Lines 41-49 Link Here

(-)a/api.debugger/src/org/netbeans/api/debugger/DebuggerEngine.java (-6 / +5 lines)
41		41
42	package org.netbeans.api.debugger;	42	package org.netbeans.api.debugger;
43		43
44	import java.beans.*;	44	import java.util.List;
45	import java.io.*;	45	import org.netbeans.spi.debugger.ContextProvider;
46	import java.util.*;
47		46
48	/**	47	/**
49	* Debugger Engine represents implementation of one debugger (Java Debugger,	48	* Debugger Engine represents implementation of one debugger (Java Debugger,
Lines 122-128 import java.util.*; Link Here
122	*	121	*
123	* @author Jan Jancura	122	* @author Jan Jancura
124	*/	123	*/
125	public final class DebuggerEngine {	124	public final class DebuggerEngine implements ContextProvider {
126		125
127		126
128	// variables ...............................................................	127	// variables ...............................................................
Lines 176-182 public final class DebuggerEngine { Link Here
176	* @param service a type of service to look for	175	* @param service a type of service to look for
177	* @return list of services of given type	176	* @return list of services of given type
178	*/	177	*/
179	public List lookup (String folder, Class service) {	178	public <T> List<? extends T> lookup(String folder, Class<T> service) {
180	return lookup.lookup (folder, service);	179	return lookup.lookup (folder, service);
181	}	180	}
182		181
Lines 186-192 public final class DebuggerEngine { Link Here
186	* @param service a type of service to look for	185	* @param service a type of service to look for
187	* @return ne service of given type	186	* @return ne service of given type
188	*/	187	*/
189	public Object lookupFirst (String folder, Class service) {	188	public <T> T lookupFirst(String folder, Class<T> service) {
190	return lookup.lookupFirst (folder, service);	189	return lookup.lookupFirst (folder, service);
191	}	190	}
192		191

Lines 48-60 import org.openide.util.Cancellable; Link Here

(-)a/api.debugger/src/org/netbeans/api/debugger/DebuggerManager.java (-9 / +7 lines)
48	import org.openide.util.Cancellable;	48	import org.openide.util.Cancellable;
49	import org.openide.util.Task;	49	import org.openide.util.Task;
50		50
		51	import org.netbeans.spi.debugger.ContextProvider;
51	import org.netbeans.spi.debugger.DelegatingDebuggerEngineProvider;	52	import org.netbeans.spi.debugger.DelegatingDebuggerEngineProvider;
52	import org.netbeans.spi.debugger.DelegatingSessionProvider;	53	import org.netbeans.spi.debugger.DelegatingSessionProvider;
53	import org.netbeans.spi.debugger.DebuggerEngineProvider;	54	import org.netbeans.spi.debugger.DebuggerEngineProvider;
54	import org.netbeans.spi.debugger.SessionProvider;	55	import org.netbeans.spi.debugger.SessionProvider;
55	import org.openide.modules.ModuleInfo;
56	import org.openide.util.WeakListeners;
57	import org.openide.util.WeakSet;
58		56
59		57
60	/**	58	/**
Lines 138-144 import org.openide.util.WeakSet; Link Here
138	*	136	*
139	* @author Jan Jancura	137	* @author Jan Jancura
140	*/	138	*/
141	public final class DebuggerManager {	139	public final class DebuggerManager implements ContextProvider {
142		140
143	// TODO: deprecate all these properties. They are useless, since there are	141	// TODO: deprecate all these properties. They are useless, since there are
144	// dedicated methods in DebuggerManagerListener	142	// dedicated methods in DebuggerManagerListener
Lines 225-231 public final class DebuggerManager { Link Here
225	* @param service a type of service to look for	223	* @param service a type of service to look for
226	* @return list of services of given type	224	* @return list of services of given type
227	*/	225	*/
228	public List lookup (String folder, Class service) {	226	public <T> List<? extends T> lookup(String folder, Class<T> service) {
229	return lookup.lookup (folder, service);	227	return lookup.lookup (folder, service);
230	}	228	}
231		229
Lines 235-241 public final class DebuggerManager { Link Here
235	* @param service a type of service to look for	233	* @param service a type of service to look for
236	* @return ne service of given type	234	* @return ne service of given type
237	*/	235	*/
238	public Object lookupFirst (String folder, Class service) {	236	public <T> T lookupFirst(String folder, Class<T> service) {
239	return lookup.lookupFirst (folder, service);	237	return lookup.lookupFirst (folder, service);
240	}	238	}
241		239
Lines 1266-1272 public final class DebuggerManager { Link Here
1266	// helper methods ....................................................	1264	// helper methods ....................................................
1267		1265
1268	private Set<LazyDebuggerManagerListener> loadedListeners;	1266	private Set<LazyDebuggerManagerListener> loadedListeners;
1269	private List<LazyDebuggerManagerListener> listenersLookupList;	1267	private List<? extends LazyDebuggerManagerListener> listenersLookupList;
1270		1268
1271	private void initDebuggerManagerListeners () {	1269	private void initDebuggerManagerListeners () {
1272	synchronized (listenersMap) {	1270	synchronized (listenersMap) {
Lines 1277-1283 public final class DebuggerManager { Link Here
1277	((Customizer) listenersLookupList).addPropertyChangeListener(new PropertyChangeListener() {	1275	((Customizer) listenersLookupList).addPropertyChangeListener(new PropertyChangeListener() {
1278		1276
1279	public void propertyChange(PropertyChangeEvent evt) {	1277	public void propertyChange(PropertyChangeEvent evt) {
1280	refreshDebuggerManagerListeners((List<LazyDebuggerManagerListener>) evt.getSource());	1278	refreshDebuggerManagerListeners((List<? extends LazyDebuggerManagerListener>) evt.getSource());
1281	}	1279	}
1282	});	1280	});
1283	}	1281	}
Lines 1285-1291 public final class DebuggerManager { Link Here
1285	}	1283	}
1286	}	1284	}
1287		1285
1288	private void refreshDebuggerManagerListeners (List<LazyDebuggerManagerListener> listenersLookupList) {	1286	private void refreshDebuggerManagerListeners(List<? extends LazyDebuggerManagerListener> listenersLookupList) {
1289	//System.err.println("\n refreshDebuggerManagerListeners()");	1287	//System.err.println("\n refreshDebuggerManagerListeners()");
1290	//It's neccessary to pay attention on the order in which the listeners and breakpoints are registered!	1288	//It's neccessary to pay attention on the order in which the listeners and breakpoints are registered!
1291	//Annotation listeners must be unregistered AFTER breakpoints are removed	1289	//Annotation listeners must be unregistered AFTER breakpoints are removed

Lines 48-53 import java.util.HashSet; Link Here

(-)a/api.debugger/src/org/netbeans/api/debugger/Session.java (-3 / +4 lines)
48	import java.util.HashSet;	48	import java.util.HashSet;
49	import java.util.Iterator;	49	import java.util.Iterator;
50	import java.util.List;	50	import java.util.List;
		51	import org.netbeans.spi.debugger.ContextProvider;
51		52
52		53
53	/** Session visually represents one process or application. It should	54	/** Session visually represents one process or application. It should
Lines 134-140 import java.util.List; Link Here
134	*	135	*
135	* @author Jan Jancura	136	* @author Jan Jancura
136	*/	137	*/
137	public final class Session {	138	public final class Session implements ContextProvider {
138		139
139	/** Name of property for current language. */	140	/** Name of property for current language. */
140	public static final String PROP_CURRENT_LANGUAGE = "currentLanguage";	141	public static final String PROP_CURRENT_LANGUAGE = "currentLanguage";
Lines 252-258 public final class Session { Link Here
252	* @param service a type of service to look for	253	* @param service a type of service to look for
253	* @return list of services of given type	254	* @return list of services of given type
254	*/	255	*/
255	public List lookup (String folder, Class service) {	256	public <T> List<? extends T> lookup(String folder, Class<T> service) {
256	return lookup.lookup (folder, service);	257	return lookup.lookup (folder, service);
257	}	258	}
258		259
Lines 262-268 public final class Session { Link Here
262	* @param service a type of service to look for	263	* @param service a type of service to look for
263	* @return ne service of given type	264	* @return ne service of given type
264	*/	265	*/
265	public Object lookupFirst (String folder, Class service) {	266	public <T> T lookupFirst(String folder, Class<T> service) {
266	return lookup.lookupFirst (folder, service);	267	return lookup.lookupFirst (folder, service);
267	}	268	}
268		269

Lines 39-45 public final class TracerAccess { Link Here

(-)a/bpel.debugger.api/src/org/netbeans/modules/bpel/debugger/api/TracerAccess.java (-4 / +2 lines)
39	if (provider == null) {	39	if (provider == null) {
40	throw new IllegalArgumentException("Can't return tracer for null");// NOI18N	40	throw new IllegalArgumentException("Can't return tracer for null");// NOI18N
41	}	41	}
42	return getTracer ((Session) provider.lookupFirst(null, Session.class));	42	return getTracer (provider.lookupFirst(null, Session.class));
43	}	43	}
44		44
45	/**	45	/**
Lines 54-62 public final class TracerAccess { Link Here
54	private static TracerFactory getTracerFactory() {	54	private static TracerFactory getTracerFactory() {
55	if (ourTracerFactory == null) {	55	if (ourTracerFactory == null) {
56	ourTracerFactory =	56	ourTracerFactory =
57	(TracerFactory) DebuggerManager.getDebuggerManager().lookupFirst(	57	DebuggerManager.getDebuggerManager().lookupFirst(null, TracerFactory.class);
58	null, TracerFactory.class
59	);
60	assert ourTracerFactory != null : "Can't find Tracer Factory"; // NOI18N	58	assert ourTracerFactory != null : "Can't find Tracer Factory"; // NOI18N
61	}	59	}
62	return ourTracerFactory;	60	return ourTracerFactory;

Lines 131-143 public class ProcessExecutionViewListene Link Here

(-)a/bpel.debugger.ui/src/org/netbeans/modules/bpel/debugger/ui/execution/ProcessExecutionViewListener.java (-11 / +10 lines)
131	Models.setModelsToView(myView, Models.createCompoundModel(models));	131	Models.setModelsToView(myView, Models.createCompoundModel(models));
132	}	132	}
133		133
134	private List lookup(	134	// XXX copy-paste programming!
		135	private <T> List<? extends T> lookup(
135	final DebuggerEngine engine,	136	final DebuggerEngine engine,
136	final DebuggerManager manager,	137	final DebuggerManager manager,
137	final Class service) {	138	final Class<T> service) {
138	final List engineService = engine.lookup(myViewType, service);	139	final List<? extends T> engineService = engine.lookup(myViewType, service);
139	final List managerService = manager.lookup(myViewType, service);	140	final List<? extends T> managerService = manager.lookup(myViewType, service);
140	final List<Object> joined = new ArrayList<Object>();	141	final List<T> joined = new ArrayList<T>();
141		142
142	add(joined, engineService);	143	add(joined, engineService);
143	add(joined, managerService);	144	add(joined, managerService);
Lines 145-156 public class ProcessExecutionViewListene Link Here
145	return joined;	146	return joined;
146	}	147	}
147		148
148	private void add(	149	private <T> void add(
149	final List<Object> source,	150	final List<T> source,
150	final List collection) {	151	final List<? extends T> collection) {
151	final Object[] elements = collection.toArray();	152	for (T element : collection) {
152
153	for (Object element : elements) {
154	if (!source.contains(element)) {	153	if (!source.contains(element)) {
155	source.add(element);	154	source.add(element);
156	}	155	}

Lines 102-130 class ProcessesViewListener extends Debu Link Here

(-)a/bpel.debugger.ui/src/org/netbeans/modules/bpel/debugger/ui/process/ProcessesViewListener.java (-19 / +19 lines)
102	Models.setModelsToView (myView, Models.createCompoundModel (models));	102	Models.setModelsToView (myView, Models.createCompoundModel (models));
103	}	103	}
104		104
105	private List lookup(	105	// XXX copy-paste programming!
106	DebuggerEngine engine,	106	private <T> List<? extends T> lookup(
107	DebuggerManager manager,	107	final DebuggerEngine engine,
108	Class service)	108	final DebuggerManager manager,
109	{	109	final Class<T> service) {
110	List engineService = engine.lookup(myViewType, service);	110	final List<? extends T> engineService = engine.lookup(myViewType, service);
111	List managerService = manager.lookup(myViewType, service);	111	final List<? extends T> managerService = manager.lookup(myViewType, service);
112	List<Object> joined = new ArrayList<Object>();	112	final List<T> joined = new ArrayList<T>();
113		113
114	add (joined, engineService);	114	add(joined, engineService);
115	add (joined, managerService);	115	add(joined, managerService);
116		116
117	return joined;	117	return joined;
118	}	118	}
119		119
120	private void add(List<Object> source, List collection) {	120	private <T> void add(
121	Object[] elements = collection.toArray();	121	final List<T> source,
122		122	final List<? extends T> collection) {
123	for (Object element : elements) {	123	for (T element : collection) {
124	if ( !source.contains(element)) {	124	if (!source.contains(element)) {
125	source.add(element);	125	source.add(element);
126	}	126	}
127	}	127	}
128	}	128	}
129		129
130	private String myViewType;	130	private String myViewType;

Lines 98-107 public class SourcePathImpl implements S Link Here

(-)a/bpel.debugger.ui/src/org/netbeans/modules/bpel/debugger/ui/source/SourcePathImpl.java (-8 / +4 lines)
98	*/	98	*/
99	public SourcePathImpl(ContextProvider lookupProvider) {	99	public SourcePathImpl(ContextProvider lookupProvider) {
100	myLookupProvider = lookupProvider;	100	myLookupProvider = lookupProvider;
101	myDebugger = (BpelDebugger) lookupProvider.lookupFirst	101	myDebugger = lookupProvider.lookupFirst(null, BpelDebugger.class);
102	(null, BpelDebugger.class);	102	mySourcesRegistry = Lookup.getDefault().lookup(BpelSourcesRegistry.class);
103	mySourcesRegistry = (BpelSourcesRegistry)Lookup.
104	getDefault().lookup(BpelSourcesRegistry.class);
105	updateAvailableSources();	103	updateAvailableSources();
106	}	104	}
107		105
Lines 252-267 public class SourcePathImpl implements S Link Here
252		250
253	private synchronized SessionCookie getSessionCookie() {	251	private synchronized SessionCookie getSessionCookie() {
254	if (mySessionCookie == null) {	252	if (mySessionCookie == null) {
255	mySessionCookie = (SessionCookie) myLookupProvider.lookupFirst(	253	mySessionCookie = myLookupProvider.lookupFirst(null, SessionCookie.class);
256	null, SessionCookie.class);
257	}	254	}
258	return mySessionCookie;	255	return mySessionCookie;
259	}	256	}
260		257
261	private synchronized SourcePathSelectionProvider getSelectionProvider() {	258	private synchronized SourcePathSelectionProvider getSelectionProvider() {
262	if (mySelectionProvider == null) {	259	if (mySelectionProvider == null) {
263	mySelectionProvider = (SourcePathSelectionProvider) myLookupProvider.lookupFirst(	260	mySelectionProvider = myLookupProvider.lookupFirst(null, SourcePathSelectionProvider.class);
264	null, SourcePathSelectionProvider.class);
265	}	261	}
266	return mySelectionProvider;	262	return mySelectionProvider;
267	}	263	}

Lines 51-63 public class AttachingSessionProvider ex Link Here

(-)a/bpel.debugger/src/org/netbeans/modules/bpel/debugger/AttachingSessionProvider.java (-3 / +2 lines)
51		51
52	public AttachingSessionProvider (ContextProvider contextProvider) {	52	public AttachingSessionProvider (ContextProvider contextProvider) {
53	this.mContextProvider = contextProvider;	53	this.mContextProvider = contextProvider;
54	mAttachingCookie = (AttachingCookie) contextProvider.lookupFirst	54	mAttachingCookie = contextProvider.lookupFirst(null, AttachingCookie.class);
55	(null, AttachingCookie.class);
56	};	55	};
57		56
58		57
59	public String getSessionName () {	58	public String getSessionName () {
60	Map arguments = (Map) mContextProvider.lookupFirst(null, Map.class);	59	Map arguments = mContextProvider.lookupFirst(null, Map.class);
61	if (arguments != null) {	60	if (arguments != null) {
62	String processName = (String) arguments.get("name");	61	String processName = (String) arguments.get("name");
63	if (processName != null)	62	if (processName != null)

Lines 23-36 import java.util.Collections; Link Here

(-)a/bpel.debugger/src/org/netbeans/modules/bpel/debugger/action/AttachActionProvider.java (-3 / +1 lines)
23	import java.util.Collections;	23	import java.util.Collections;
24	import java.util.Set;	24	import java.util.Set;
25	import org.netbeans.api.debugger.ActionsManager;	25	import org.netbeans.api.debugger.ActionsManager;
26	import org.netbeans.api.debugger.Session;
27	import org.netbeans.modules.bpel.debugger.api.BpelDebugger;	26	import org.netbeans.modules.bpel.debugger.api.BpelDebugger;
28	import org.netbeans.modules.bpel.debugger.api.AttachingCookie;	27	import org.netbeans.modules.bpel.debugger.api.AttachingCookie;
29	import org.netbeans.modules.bpel.debugger.api.DebugException;	28	import org.netbeans.modules.bpel.debugger.api.DebugException;
30	import org.netbeans.modules.bpel.debugger.BpelDebuggerImpl;	29	import org.netbeans.modules.bpel.debugger.BpelDebuggerImpl;
31	import org.netbeans.spi.debugger.ActionsProviderSupport;	30	import org.netbeans.spi.debugger.ActionsProviderSupport;
32	import org.netbeans.spi.debugger.ContextProvider;	31	import org.netbeans.spi.debugger.ContextProvider;
33	import org.openide.ErrorManager;
34	import org.openide.util.RequestProcessor;	32	import org.openide.util.RequestProcessor;
35		33
36		34
Lines 60-66 public class AttachActionProvider extend Link Here
60		58
61	public void postAction(Object action, Runnable actionPerformedNotifier) {	59	public void postAction(Object action, Runnable actionPerformedNotifier) {
62	AttachingCookie cookie =	60	AttachingCookie cookie =
63	(AttachingCookie) mLookupProvider.lookupFirst (null, AttachingCookie.class);	61	mLookupProvider.lookupFirst(null, AttachingCookie.class);
64	final String host = cookie.getHost();	62	final String host = cookie.getHost();
65	final int port = cookie.getPort();	63	final int port = cookie.getPort();
66		64

Lines 207-214 public class GdbDebugger implements Prop Link Here

(-)a/cnd.debugger.gdb/src/org/netbeans/modules/cnd/debugger/gdb/GdbDebugger.java (-9 / +8 lines)
207		207
208	setStarting();	208	setStarting();
209	try {	209	try {
210	pae = (ProjectActionEvent) lookupProvider.lookupFirst(null, ProjectActionEvent.class);	210	pae = lookupProvider.lookupFirst(null, ProjectActionEvent.class);
211	iotab = (InputOutput) lookupProvider.lookupFirst(null, InputOutput.class);	211	iotab = lookupProvider.lookupFirst(null, InputOutput.class);
212	if (iotab != null) {	212	if (iotab != null) {
213	iotab.setErrSeparated(false);	213	iotab.setErrSeparated(false);
214	}	214	}
Lines 242-248 public class GdbDebugger implements Prop Link Here
242	gdb.gdb_set("print repeat", // NOI18N	242	gdb.gdb_set("print repeat", // NOI18N
243	Integer.toString(CppSettings.getDefault().getArrayRepeatThreshold()));	243	Integer.toString(CppSettings.getDefault().getArrayRepeatThreshold()));
244	if (pae.getID() == DEBUG_ATTACH) {	244	if (pae.getID() == DEBUG_ATTACH) {
245	programPID = (Long) lookupProvider.lookupFirst(null, Long.class);	245	programPID = lookupProvider.lookupFirst(null, Long.class);
246	CommandBuffer cb = new CommandBuffer();	246	CommandBuffer cb = new CommandBuffer();
247	gdb.target_attach(cb, Long.toString(programPID));	247	gdb.target_attach(cb, Long.toString(programPID));
248	cb.waitForCompletion();	248	cb.waitForCompletion();
Lines 318-324 public class GdbDebugger implements Prop Link Here
318	gdb.exec_run(pae.getProfile().getArgsFlat());	318	gdb.exec_run(pae.getProfile().getArgsFlat());
319	} catch (Exception ex) {	319	} catch (Exception ex) {
320	ErrorManager.getDefault().notify(ex);	320	ErrorManager.getDefault().notify(ex);
321	((Session) lookupProvider.lookupFirst(null, Session.class)).kill();	321	lookupProvider.lookupFirst(null, Session.class).kill();
322	}	322	}
323	if (Utilities.isWindows()) {	323	if (Utilities.isWindows()) {
324	gdb.info_threads(); // we get the PID from this...	324	gdb.info_threads(); // we get the PID from this...
Lines 584-591 public class GdbDebugger implements Prop Link Here
584	}	584	}
585	if (gdb != null) {	585	if (gdb != null) {
586	if (state.equals(STATE_RUNNING)) {	586	if (state.equals(STATE_RUNNING)) {
587	ProjectActionEvent pae = (ProjectActionEvent) lookupProvider.lookupFirst(	587	ProjectActionEvent pae = lookupProvider.lookupFirst(null, ProjectActionEvent.class);
588	null, ProjectActionEvent.class);
589	gdb.exec_interrupt();	588	gdb.exec_interrupt();
590	if (pae.getID() == DEBUG_ATTACH) {	589	if (pae.getID() == DEBUG_ATTACH) {
591	gdb.target_detach();	590	gdb.target_detach();
Lines 733-739 public class GdbDebugger implements Prop Link Here
733	DialogDisplayer.getDefault().notify(	732	DialogDisplayer.getDefault().notify(
734	new NotifyDescriptor.Message(NbBundle.getMessage(GdbDebugger.class,	733	new NotifyDescriptor.Message(NbBundle.getMessage(GdbDebugger.class,
735	"ERR_CantAttach"))); // NOI18N	734	"ERR_CantAttach"))); // NOI18N
736	((Session) lookupProvider.lookupFirst(null, Session.class)).kill();	735	(lookupProvider.lookupFirst(null, Session.class)).kill();
737	} else if (msg.startsWith("\"No symbol ") && msg.endsWith(" in current context.\"")) { // NOI18N	736	} else if (msg.startsWith("\"No symbol ") && msg.endsWith(" in current context.\"")) { // NOI18N
738	String type = msg.substring(13, msg.length() - 23);	737	String type = msg.substring(13, msg.length() - 23);
739	log.warning("Failed type lookup for " + type);	738	log.warning("Failed type lookup for " + type);
Lines 743-749 public class GdbDebugger implements Prop Link Here
743	DialogDisplayer.getDefault().notify(	742	DialogDisplayer.getDefault().notify(
744	new NotifyDescriptor.Message(NbBundle.getMessage(GdbDebugger.class,	743	new NotifyDescriptor.Message(NbBundle.getMessage(GdbDebugger.class,
745	"ERR_CorruptedStack"))); // NOI18N	744	"ERR_CorruptedStack"))); // NOI18N
746	((Session) lookupProvider.lookupFirst(null, Session.class)).kill();	745	(lookupProvider.lookupFirst(null, Session.class)).kill();
747	} else if (msg.contains("error reading line numbers")) { // NOI18N	746	} else if (msg.contains("error reading line numbers")) { // NOI18N
748	DialogDisplayer.getDefault().notify(	747	DialogDisplayer.getDefault().notify(
749	new NotifyDescriptor.Message(NbBundle.getMessage(GdbDebugger.class,	748	new NotifyDescriptor.Message(NbBundle.getMessage(GdbDebugger.class,
Lines 752-758 public class GdbDebugger implements Prop Link Here
752	DialogDisplayer.getDefault().notify(	751	DialogDisplayer.getDefault().notify(
753	new NotifyDescriptor.Message(NbBundle.getMessage(GdbDebugger.class,	752	new NotifyDescriptor.Message(NbBundle.getMessage(GdbDebugger.class,
754	"ERR_NoSymbolTable"))); // NOI18N	753	"ERR_NoSymbolTable"))); // NOI18N
755	((Session) lookupProvider.lookupFirst(null, Session.class)).kill();	754	(lookupProvider.lookupFirst(null, Session.class)).kill();
756	} else if (msg.contains("Cannot access memory at address")) { // NOI18N	755	} else if (msg.contains("Cannot access memory at address")) { // NOI18N
757	// ignore - probably dereferencing an uninitialized pointer	756	// ignore - probably dereferencing an uninitialized pointer
758	} else if (msg.contains("mi_cmd_break_insert: Garbage following <location>")) { // NOI18N	757	} else if (msg.contains("mi_cmd_break_insert: Garbage following <location>")) { // NOI18N

Lines 106-113 public class JPDAReload extends Task { Link Here

(-)a/debugger.jpda.ant/antsrc/org/netbeans/modules/debugger/jpda/ant/JPDAReload.java (-4 / +2 lines)
106	if (debuggerEngine == null) {	106	if (debuggerEngine == null) {
107	throw new BuildException ("No debugging sessions was found.");	107	throw new BuildException ("No debugging sessions was found.");
108	}	108	}
109	JPDADebugger debugger = (JPDADebugger) debuggerEngine.lookupFirst	109	JPDADebugger debugger = debuggerEngine.lookupFirst(null, JPDADebugger.class);
110	(null, JPDADebugger.class);
111	if (debugger == null) {	110	if (debugger == null) {
112	throw new BuildException("Current debugger is not JPDA one.");	111	throw new BuildException("Current debugger is not JPDA one.");
113	}	112	}
Lines 122-129 public class JPDAReload extends Task { Link Here
122		121
123	FileUtils fileUtils = FileUtils.newFileUtils ();	122	FileUtils fileUtils = FileUtils.newFileUtils ();
124	Map map = new HashMap ();	123	Map map = new HashMap ();
125	EditorContext editorContext = (EditorContext) DebuggerManager.	124	EditorContext editorContext = DebuggerManager.getDebuggerManager().lookupFirst(null, EditorContext.class);
126	getDebuggerManager ().lookupFirst (null, EditorContext.class);
127		125
128	Iterator it = filesets.iterator ();	126	Iterator it = filesets.iterator ();
129	while (it.hasNext ()) {	127	while (it.hasNext ()) {

Lines 569-576 public class JPDAStart extends Task impl Link Here

(-)a/debugger.jpda.ant/antsrc/org/netbeans/modules/debugger/jpda/ant/JPDAStart.java (-4 / +2 lines)
569	}	569	}
570		570
571	public void engineAdded (DebuggerEngine engine) {	571	public void engineAdded (DebuggerEngine engine) {
572	JPDADebugger debugger = (JPDADebugger) engine.lookupFirst	572	JPDADebugger debugger = engine.lookupFirst(null, JPDADebugger.class);
573	(null, JPDADebugger.class);
574	if (debugger == null) return;	573	if (debugger == null) return;
575	debugger.addPropertyChangeListener (	574	debugger.addPropertyChangeListener (
576	JPDADebugger.PROP_STATE,	575	JPDADebugger.PROP_STATE,
Lines 580-587 public class JPDAStart extends Task impl Link Here
580	}	579	}
581		580
582	public void engineRemoved (DebuggerEngine engine) {	581	public void engineRemoved (DebuggerEngine engine) {
583	JPDADebugger debugger = (JPDADebugger) engine.lookupFirst	582	JPDADebugger debugger = engine.lookupFirst(null, JPDADebugger.class);
584	(null, JPDADebugger.class);
585	if (debugger == null) return;	583	if (debugger == null) return;
586	debugger.removePropertyChangeListener (	584	debugger.removePropertyChangeListener (
587	JPDADebugger.PROP_STATE,	585	JPDADebugger.PROP_STATE,

Lines 120-132 class ViewModelListener extends Debugger Link Here

(-)a/debugger.jpda.heapwalk/src/org/netbeans/modules/debugger/jpda/heapwalk/views/ViewModelListener.java (-7 / +12 lines)
120	public void propertyChange (PropertyChangeEvent e) {	120	public void propertyChange (PropertyChangeEvent e) {
121	updateModel ();	121	updateModel ();
122	}	122	}
123		123
124	private List joinLookups(DebuggerEngine e, DebuggerManager dm, Class service) {	124	// XXX copy-paste programming!
125	List es = e.lookup (viewType, service);	125	private <T> List<? extends T> joinLookups(DebuggerEngine e, DebuggerManager dm, Class<T> service) {
126	List ms = dm.lookup(viewType, service);	126	List<? extends T> es = e.lookup (viewType, service);
127	ms.removeAll(es);	127	List<? extends T> ms = dm.lookup(viewType, service);
128	es.addAll(ms);	128	List<T> joined = new ArrayList<T>(es);
129	return es;	129	for (T t : ms) {
		130	if (!es.contains(t)) {
		131	joined.add(t);
		132	}
		133	}
		134	return joined;
130	}	135	}
131		136
132	private synchronized void updateModel () {	137	private synchronized void updateModel () {

Lines 89-96 public class RunToCursorActionProvider e Link Here

(-)a/debugger.jpda.projects/src/org/netbeans/modules/debugger/jpda/projects/RunToCursorActionProvider.java (-6 / +3 lines)
89	private LineBreakpoint breakpoint;	89	private LineBreakpoint breakpoint;
90		90
91	{	91	{
92	editor = (EditorContext) DebuggerManager.	92	editor = DebuggerManager.getDebuggerManager().lookupFirst(null, EditorContext.class);
93	getDebuggerManager ().lookupFirst (null, EditorContext.class);
94		93
95	Listener listener = new Listener ();	94	Listener listener = new Listener ();
96	MainProjectManager.getDefault ().addPropertyChangeListener (listener);	95	MainProjectManager.getDefault ().addPropertyChangeListener (listener);
Lines 222-229 public class RunToCursorActionProvider e Link Here
222	}	221	}
223		222
224	public void engineAdded (DebuggerEngine engine) {	223	public void engineAdded (DebuggerEngine engine) {
225	JPDADebugger debugger = (JPDADebugger) engine.lookupFirst	224	JPDADebugger debugger = engine.lookupFirst(null, JPDADebugger.class);
226	(null, JPDADebugger.class);
227	if (debugger == null) return;	225	if (debugger == null) return;
228	debugger.addPropertyChangeListener (	226	debugger.addPropertyChangeListener (
229	JPDADebugger.PROP_STATE,	227	JPDADebugger.PROP_STATE,
Lines 232-239 public class RunToCursorActionProvider e Link Here
232	}	230	}
233		231
234	public void engineRemoved (DebuggerEngine engine) {	232	public void engineRemoved (DebuggerEngine engine) {
235	JPDADebugger debugger = (JPDADebugger) engine.lookupFirst	233	JPDADebugger debugger = engine.lookupFirst(null, JPDADebugger.class);
236	(null, JPDADebugger.class);
237	if (debugger == null) return;	234	if (debugger == null) return;
238	debugger.removePropertyChangeListener (	235	debugger.removePropertyChangeListener (
239	JPDADebugger.PROP_STATE,	236	JPDADebugger.PROP_STATE,

Lines 97-108 PropertyChangeListener { Link Here

(-)a/debugger.jpda.ui/src/org/netbeans/modules/debugger/jpda/ui/DebuggerOutput.java (-7 / +4 lines)
97		97
98	public DebuggerOutput (ContextProvider contextProvider) {	98	public DebuggerOutput (ContextProvider contextProvider) {
99	this.contextProvider = contextProvider;	99	this.contextProvider = contextProvider;
100	this.debugger = (JPDADebugger) contextProvider.lookupFirst	100	this.debugger = contextProvider.lookupFirst(null, JPDADebugger.class);
101	(null, JPDADebugger.class);
102	//this.engine = (DebuggerEngine) contextProvider.lookupFirst	101	//this.engine = (DebuggerEngine) contextProvider.lookupFirst
103	// (null, DebuggerEngine.class);	102	// (null, DebuggerEngine.class);
104	engineContext = (SourcePath) contextProvider.lookupFirst	103	engineContext = contextProvider.lookupFirst(null, SourcePath.class);
105	(null, SourcePath.class);
106		104
107	// close old tabs	105	// close old tabs
108	if (DebuggerManager.getDebuggerManager ().getSessions ().length == 1) {	106	if (DebuggerManager.getDebuggerManager ().getSessions ().length == 1) {
Lines 113-119 PropertyChangeListener { Link Here
113	}	111	}
114		112
115	// open new tab	113	// open new tab
116	String title = (String) contextProvider.lookupFirst (null, String.class);	114	String title = contextProvider.lookupFirst(null, String.class);
117	if (title == null)	115	if (title == null)
118	title = NbBundle.getBundle (IOManager.class).getString	116	title = NbBundle.getBundle (IOManager.class).getString
119	("CTL_DebuggerConsole_Title");	117	("CTL_DebuggerConsole_Title");
Lines 152-159 PropertyChangeListener { Link Here
152	ioManager = this.ioManager;	150	ioManager = this.ioManager;
153	}	151	}
154	if (debuggerState == JPDADebugger.STATE_STARTING) {	152	if (debuggerState == JPDADebugger.STATE_STARTING) {
155	AbstractDICookie cookie = (AbstractDICookie) contextProvider.	153	AbstractDICookie cookie = contextProvider.lookupFirst(null, AbstractDICookie.class);
156	lookupFirst (null, AbstractDICookie.class);
157	if (cookie instanceof AttachingDICookie) {	154	if (cookie instanceof AttachingDICookie) {
158	AttachingDICookie c = (AttachingDICookie) cookie;	155	AttachingDICookie c = (AttachingDICookie) cookie;
159	if (c.getHostName () != null) {	156	if (c.getHostName () != null) {

Lines 418-424 public class Evaluator extends javax.swi Link Here

(-)a/debugger.jpda.ui/src/org/netbeans/modules/debugger/jpda/ui/Evaluator.java (-8 / +13 lines)
418	if (autoClosed) {	418	if (autoClosed) {
419	DebuggerEngine de = DebuggerManager.getDebuggerManager().getCurrentEngine();	419	DebuggerEngine de = DebuggerManager.getDebuggerManager().getCurrentEngine();
420	if (de == null) return ;	420	if (de == null) return ;
421	JPDADebugger debugger = (JPDADebugger) de.lookupFirst(null, JPDADebugger.class);	421	JPDADebugger debugger = de.lookupFirst(null, JPDADebugger.class);
422	if (debugger == null) return ;	422	if (debugger == null) return ;
423	open(debugger);	423	open(debugger);
424	autoClosed = false;	424	autoClosed = false;
Lines 568-585 public class Evaluator extends javax.swi Link Here
568	eval.csfListener = null;	568	eval.csfListener = null;
569	DebuggerEngine de = DebuggerManager.getDebuggerManager().getCurrentEngine();	569	DebuggerEngine de = DebuggerManager.getDebuggerManager().getCurrentEngine();
570	if (de == null) return ;	570	if (de == null) return ;
571	JPDADebugger debugger = (JPDADebugger) de.lookupFirst(null, JPDADebugger.class);	571	JPDADebugger debugger = de.lookupFirst(null, JPDADebugger.class);
572	eval.setDebugger(debugger);	572	eval.setDebugger(debugger);
573	}	573	}
574	updateModel ();	574	updateModel ();
575	}	575	}
576		576
577	private List joinLookups(DebuggerEngine e, DebuggerManager dm, Class service) {	577	// XXX copy-paste programming!
578	List es = e.lookup (viewType, service);	578	private <T> List<? extends T> joinLookups(DebuggerEngine e, DebuggerManager dm, Class<T> service) {
579	List ms = dm.lookup(viewType, service);	579	List<? extends T> es = e.lookup (viewType, service);
580	ms.removeAll(es);	580	List<? extends T> ms = dm.lookup(viewType, service);
581	es.addAll(ms);	581	List<T> joined = new ArrayList<T>(es);
582	return es;	582	for (T t : ms) {
		583	if (!es.contains(t)) {
		584	joined.add(t);
		585	}
		586	}
		587	return joined;
583	}	588	}
584		589
585	public synchronized void updateModel () {	590	public synchronized void updateModel () {

Lines 84-90 public class EvaluateAction extends Abst Link Here

(-)a/debugger.jpda.ui/src/org/netbeans/modules/debugger/jpda/ui/actions/EvaluateAction.java (-2 / +2 lines)
84	private synchronized boolean canBeEnabled() {	84	private synchronized boolean canBeEnabled() {
85	DebuggerEngine de = DebuggerManager.getDebuggerManager().getCurrentEngine();	85	DebuggerEngine de = DebuggerManager.getDebuggerManager().getCurrentEngine();
86	if (de == null) return false;	86	if (de == null) return false;
87	JPDADebugger debugger = (JPDADebugger) de.lookupFirst(null, JPDADebugger.class);	87	JPDADebugger debugger = de.lookupFirst(null, JPDADebugger.class);
88	JPDADebugger lastDebugger = (JPDADebugger) lastDebuggerRef.get();	88	JPDADebugger lastDebugger = (JPDADebugger) lastDebuggerRef.get();
89	if (lastDebugger != null && debugger != lastDebugger) {	89	if (lastDebugger != null && debugger != lastDebugger) {
90	lastDebugger.removePropertyChangeListener(	90	lastDebugger.removePropertyChangeListener(
Lines 114-120 public class EvaluateAction extends Abst Link Here
114	public void actionPerformed (ActionEvent evt) {	114	public void actionPerformed (ActionEvent evt) {
115	DebuggerEngine de = DebuggerManager.getDebuggerManager().getCurrentEngine();	115	DebuggerEngine de = DebuggerManager.getDebuggerManager().getCurrentEngine();
116	if (de == null) return ;	116	if (de == null) return ;
117	JPDADebugger debugger = (JPDADebugger) de.lookupFirst(null, JPDADebugger.class);	117	JPDADebugger debugger = de.lookupFirst(null, JPDADebugger.class);
118	if (debugger == null) return ;	118	if (debugger == null) return ;
119	Evaluator.open(debugger);	119	Evaluator.open(debugger);
120	}	120	}

Lines 75-90 public class RunToCursorActionProvider e Link Here

(-)a/debugger.jpda.ui/src/org/netbeans/modules/debugger/jpda/ui/actions/RunToCursorActionProvider.java (-6 / +4 lines)
75		75
76		76
77	public RunToCursorActionProvider (ContextProvider lookupProvider) {	77	public RunToCursorActionProvider (ContextProvider lookupProvider) {
78	debugger = (JPDADebugger) lookupProvider.lookupFirst	78	debugger = lookupProvider.lookupFirst(null, JPDADebugger.class);
79	(null, JPDADebugger.class);	79	session = lookupProvider.lookupFirst(null, Session.class);
80	session = (Session) lookupProvider.lookupFirst	80	debugger.addPropertyChangeListener (JPDADebugger.PROP_STATE, this);
81	(null, Session.class);
82	debugger.addPropertyChangeListener (debugger.PROP_STATE, this);
83	EditorContextBridge.getContext().addPropertyChangeListener (this);	81	EditorContextBridge.getContext().addPropertyChangeListener (this);
84	}	82	}
85		83
86	private void destroy () {	84	private void destroy () {
87	debugger.removePropertyChangeListener (debugger.PROP_STATE, this);	85	debugger.removePropertyChangeListener (JPDADebugger.PROP_STATE, this);
88	EditorContextBridge.getContext().removePropertyChangeListener (this);	86	EditorContextBridge.getContext().removePropertyChangeListener (this);
89	}	87	}
90		88

Lines 139-146 public class CallStackActionsProvider im Link Here

(-)a/debugger.jpda.ui/src/org/netbeans/modules/debugger/jpda/ui/models/CallStackActionsProvider.java (-6 / +3 lines)
139		139
140	public CallStackActionsProvider (ContextProvider lookupProvider) {	140	public CallStackActionsProvider (ContextProvider lookupProvider) {
141	this.lookupProvider = lookupProvider;	141	this.lookupProvider = lookupProvider;
142	debugger = (JPDADebugger) lookupProvider.	142	debugger = lookupProvider.lookupFirst(null, JPDADebugger.class);
143	lookupFirst (null, JPDADebugger.class);
144	}	143	}
145		144
146	public Action[] getActions (Object node) throws UnknownTypeException {	145	public Action[] getActions (Object node) throws UnknownTypeException {
Lines 234-240 public class CallStackActionsProvider im Link Here
234	}	233	}
235		234
236	private static Clipboard getClipboard() {	235	private static Clipboard getClipboard() {
237	Clipboard clipboard = (Clipboard) org.openide.util.Lookup.getDefault().lookup(Clipboard.class);	236	Clipboard clipboard = org.openide.util.Lookup.getDefault().lookup(Clipboard.class);
238	if (clipboard == null) {	237	if (clipboard == null) {
239	clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();	238	clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
240	}	239	}
Lines 249-257 public class CallStackActionsProvider im Link Here
249	public void run () {	248	public void run () {
250	String language = DebuggerManager.getDebuggerManager ().	249	String language = DebuggerManager.getDebuggerManager ().
251	getCurrentSession ().getCurrentLanguage ();	250	getCurrentSession ().getCurrentLanguage ();
252	SourcePath sp = (SourcePath) DebuggerManager.	251	SourcePath sp = DebuggerManager.getDebuggerManager().getCurrentEngine().lookupFirst(null, SourcePath.class);
253	getDebuggerManager ().getCurrentEngine ().lookupFirst
254	(null, SourcePath.class);
255	sp.showSource (frame, language);	252	sp.showSource (frame, language);
256	}	253	}
257	});	254	});

Lines 94-102 public class ThreadsActionsProvider impl Link Here

(-)a/debugger.jpda.ui/src/org/netbeans/modules/debugger/jpda/ui/models/ThreadsActionsProvider.java (-9 / +3 lines)
94	if (nodes[0] instanceof MonitorModel.ThreadWithBordel) nodes[0] = ((MonitorModel.ThreadWithBordel) nodes[0]).originalThread;	94	if (nodes[0] instanceof MonitorModel.ThreadWithBordel) nodes[0] = ((MonitorModel.ThreadWithBordel) nodes[0]).originalThread;
95	String language = DebuggerManager.getDebuggerManager ().	95	String language = DebuggerManager.getDebuggerManager ().
96	getCurrentSession ().getCurrentLanguage ();	96	getCurrentSession ().getCurrentLanguage ();
97	SourcePath sp = (SourcePath) DebuggerManager.	97	SourcePath sp = DebuggerManager.getDebuggerManager().getCurrentEngine().lookupFirst(null, SourcePath.class);
98	getDebuggerManager ().getCurrentEngine ().lookupFirst
99	(null, SourcePath.class);
100	sp.showSource ((JPDAThread) nodes [0], language);	98	sp.showSource ((JPDAThread) nodes [0], language);
101	}	99	}
102	},	100	},
Lines 184-191 public class ThreadsActionsProvider impl Link Here
184		182
185		183
186	public ThreadsActionsProvider (ContextProvider lookupProvider) {	184	public ThreadsActionsProvider (ContextProvider lookupProvider) {
187	debugger = (JPDADebugger) lookupProvider.	185	debugger = lookupProvider.lookupFirst(null, JPDADebugger.class);
188	lookupFirst (null, JPDADebugger.class);
189	}	186	}
190		187
191	public Action[] getActions (Object node) throws UnknownTypeException {	188	public Action[] getActions (Object node) throws UnknownTypeException {
Lines 246-255 public class ThreadsActionsProvider impl Link Here
246	getCurrentSession ().getCurrentLanguage ();	243	getCurrentSession ().getCurrentLanguage ();
247	if (!t.isSuspended ())	244	if (!t.isSuspended ())
248	return false;	245	return false;
249	String className = t.getClassName ();	246	SourcePath sp = DebuggerManager.getDebuggerManager().getCurrentEngine().lookupFirst(null, SourcePath.class);
250	SourcePath sp = (SourcePath) DebuggerManager.
251	getDebuggerManager ().getCurrentEngine ().lookupFirst
252	(null, SourcePath.class);
253	return sp.sourceAvailable (t, language, true);	247	return sp.sourceAvailable (t, language, true);
254	}	248	}
255	}	249	}

Lines 131-144 public class VariablesActionsProvider im Link Here

(-)a/debugger.jpda.ui/src/org/netbeans/modules/debugger/jpda/ui/models/VariablesActionsProvider.java (-4 / +2 lines)
131	}	131	}
132		132
133	public void goToSource (Field variable) {	133	public void goToSource (Field variable) {
134	SourcePath ectx = (SourcePath) lookupProvider.lookupFirst	134	SourcePath ectx = lookupProvider.lookupFirst(null, SourcePath.class);
135	(null, SourcePath.class);
136	ectx.showSource (variable);	135	ectx.showSource (variable);
137	}	136	}
138		137
139	private boolean isSourceAvailable (Field v) {	138	private boolean isSourceAvailable (Field v) {
140	SourcePath ectx = (SourcePath) lookupProvider.lookupFirst	139	SourcePath ectx = lookupProvider.lookupFirst(null, SourcePath.class);
141	(null, SourcePath.class);
142	return ectx.sourceAvailable (v);	140	return ectx.sourceAvailable (v);
143	}	141	}
144	}	142	}

Lines 399-405 public class JPDADebuggerImpl extends JP Link Here

(-)a/debugger.jpda/src/org/netbeans/modules/debugger/jpda/JPDADebuggerImpl.java (-10 / +6 lines)
399	}	399	}
400		400
401	public Session getSession() {	401	public Session getSession() {
402	return (Session) lookupProvider.lookupFirst (null, Session.class);	402	return lookupProvider.lookupFirst(null, Session.class);
403	}	403	}
404		404
405	private Boolean canBeModified;	405	private Boolean canBeModified;
Lines 438-445 public class JPDADebuggerImpl extends JP Link Here
438	*/	438	*/
439	public SmartSteppingFilter getSmartSteppingFilter () {	439	public SmartSteppingFilter getSmartSteppingFilter () {
440	if (smartSteppingFilter == null) {	440	if (smartSteppingFilter == null) {
441	smartSteppingFilter = (SmartSteppingFilter) lookupProvider.	441	smartSteppingFilter = lookupProvider.lookupFirst(null, SmartSteppingFilter.class);
442	lookupFirst (null, SmartSteppingFilter.class);
443	smartSteppingFilter.addExclusionPatterns (	442	smartSteppingFilter.addExclusionPatterns (
444	(Set) Properties.getDefault ().getProperties ("debugger").	443	(Set) Properties.getDefault ().getProperties ("debugger").
445	getProperties ("sources").getProperties ("class_filters").	444	getProperties ("sources").getProperties ("class_filters").
Lines 456-463 public class JPDADebuggerImpl extends JP Link Here
456		455
457	private CompoundSmartSteppingListener getCompoundSmartSteppingListener () {	456	private CompoundSmartSteppingListener getCompoundSmartSteppingListener () {
458	if (compoundSmartSteppingListener == null)	457	if (compoundSmartSteppingListener == null)
459	compoundSmartSteppingListener = (CompoundSmartSteppingListener) lookupProvider.	458	compoundSmartSteppingListener = lookupProvider.lookupFirst(null, CompoundSmartSteppingListener.class);
460	lookupFirst (null, CompoundSmartSteppingListener.class);
461	return compoundSmartSteppingListener;	459	return compoundSmartSteppingListener;
462	}	460	}
463		461
Lines 1069-1076 public class JPDADebuggerImpl extends JP Link Here
1069	finishing = true;	1067	finishing = true;
1070	}	1068	}
1071	logger.fine("StartActionProvider.finish ()");	1069	logger.fine("StartActionProvider.finish ()");
1072	AbstractDICookie di = (AbstractDICookie) lookupProvider.lookupFirst	1070	AbstractDICookie di = lookupProvider.lookupFirst(null, AbstractDICookie.class);
1073	(null, AbstractDICookie.class);
1074	if (getState () == STATE_DISCONNECTED) return;	1071	if (getState () == STATE_DISCONNECTED) return;
1075	Operator o = getOperator();	1072	Operator o = getOperator();
1076	if (o != null) o.stop();	1073	if (o != null) o.stop();
Lines 1396-1403 public class JPDADebuggerImpl extends JP Link Here
1396	private SourcePath engineContext;	1393	private SourcePath engineContext;
1397	public synchronized SourcePath getEngineContext () {	1394	public synchronized SourcePath getEngineContext () {
1398	if (engineContext == null)	1395	if (engineContext == null)
1399	engineContext = (SourcePath) lookupProvider.	1396	engineContext = lookupProvider.lookupFirst(null, SourcePath.class);
1400	lookupFirst (null, SourcePath.class);
1401	return engineContext;	1397	return engineContext;
1402	}	1398	}
1403		1399
Lines 1559-1565 public class JPDADebuggerImpl extends JP Link Here
1559	}	1555	}
1560		1556
1561	public JPDAStep createJPDAStep(int size, int depth) {	1557	public JPDAStep createJPDAStep(int size, int depth) {
1562	Session session = (Session) lookupProvider.lookupFirst (null, Session.class);	1558	Session session = lookupProvider.lookupFirst(null, Session.class);
1563	return new JPDAStepImpl(this, session, size, depth);	1559	return new JPDAStepImpl(this, session, size, depth);
1564	}	1560	}
1565		1561

Lines 41-53 Link Here

(-)a/debugger.jpda/src/org/netbeans/modules/debugger/jpda/JPDAStepImpl.java (-14 / +1 lines)
41		41
42	package org.netbeans.modules.debugger.jpda;	42	package org.netbeans.modules.debugger.jpda;
43		43
44	import com.sun.jdi.AbsentInformationException;
45	import com.sun.jdi.IncompatibleThreadStateException;	44	import com.sun.jdi.IncompatibleThreadStateException;
46	import com.sun.jdi.event.LocatableEvent;	45	import com.sun.jdi.event.LocatableEvent;
47	import java.beans.PropertyChangeListener;
48	import java.lang.reflect.InvocationTargetException;
49	import java.net.MalformedURLException;
50	import java.net.URL;
51	import java.awt.Color;	46	import java.awt.Color;
52	import java.awt.Dialog;	47	import java.awt.Dialog;
53	import java.awt.GridBagLayout;	48	import java.awt.GridBagLayout;
Lines 71-84 import javax.swing.UIManager; Link Here
71		66
72	import org.netbeans.api.debugger.DebuggerManager;	67	import org.netbeans.api.debugger.DebuggerManager;
73	import org.netbeans.api.debugger.Session;	68	import org.netbeans.api.debugger.Session;
74	import org.netbeans.api.debugger.jpda.CallStackFrame;
75	import org.netbeans.api.debugger.jpda.JPDABreakpoint;	69	import org.netbeans.api.debugger.jpda.JPDABreakpoint;
76	import org.netbeans.api.debugger.jpda.JPDAStep;	70	import org.netbeans.api.debugger.jpda.JPDAStep;
77	import org.netbeans.api.debugger.jpda.JPDAThread;	71	import org.netbeans.api.debugger.jpda.JPDAThread;
78	import org.netbeans.api.debugger.jpda.JPDADebugger;	72	import org.netbeans.api.debugger.jpda.JPDADebugger;
79	import com.sun.jdi.event.Event;	73	import com.sun.jdi.event.Event;
80	import com.sun.jdi.request.BreakpointRequest;	74	import com.sun.jdi.request.BreakpointRequest;
81	import com.sun.jdi.ThreadReference;
82	import com.sun.jdi.request.StepRequest;	75	import com.sun.jdi.request.StepRequest;
83	import com.sun.jdi.request.EventRequest;	76	import com.sun.jdi.request.EventRequest;
84	import com.sun.jdi.request.EventRequestManager;	77	import com.sun.jdi.request.EventRequestManager;
Lines 91-114 import com.sun.jdi.VirtualMachine; Link Here
91	import com.sun.jdi.VirtualMachine;	84	import com.sun.jdi.VirtualMachine;
92	import org.netbeans.api.debugger.jpda.JPDAThreadGroup;	85	import org.netbeans.api.debugger.jpda.JPDAThreadGroup;
93	import org.netbeans.api.debugger.jpda.MethodBreakpoint;	86	import org.netbeans.api.debugger.jpda.MethodBreakpoint;
94	import org.netbeans.api.debugger.jpda.SmartSteppingFilter;
95	import org.netbeans.api.debugger.jpda.Variable;	87	import org.netbeans.api.debugger.jpda.Variable;
96	import org.netbeans.api.debugger.jpda.event.JPDABreakpointEvent;	88	import org.netbeans.api.debugger.jpda.event.JPDABreakpointEvent;
97	import org.netbeans.api.debugger.jpda.event.JPDABreakpointListener;	89	import org.netbeans.api.debugger.jpda.event.JPDABreakpointListener;
98	import org.netbeans.modules.debugger.jpda.JPDAStepImpl.SingleThreadedStepWatch;	90	import org.netbeans.modules.debugger.jpda.JPDAStepImpl.SingleThreadedStepWatch;
99	import org.netbeans.modules.debugger.jpda.actions.SmartSteppingFilterImpl;
100	import org.netbeans.modules.debugger.jpda.breakpoints.MethodBreakpointImpl;	91	import org.netbeans.modules.debugger.jpda.breakpoints.MethodBreakpointImpl;
101	import org.netbeans.modules.debugger.jpda.util.Executor;	92	import org.netbeans.modules.debugger.jpda.util.Executor;
102	import org.netbeans.modules.debugger.jpda.JPDADebuggerImpl;
103	import org.netbeans.modules.debugger.jpda.actions.StepIntoActionProvider;	93	import org.netbeans.modules.debugger.jpda.actions.StepIntoActionProvider;
104	import org.netbeans.modules.debugger.jpda.models.JPDAThreadImpl;	94	import org.netbeans.modules.debugger.jpda.models.JPDAThreadImpl;
105	import org.netbeans.spi.debugger.jpda.EditorContext.Operation;	95	import org.netbeans.spi.debugger.jpda.EditorContext.Operation;
106	import org.openide.DialogDescriptor;	96	import org.openide.DialogDescriptor;
107	import org.openide.DialogDescriptor;
108	import org.openide.ErrorManager;	97	import org.openide.ErrorManager;
109	import org.openide.NotifyDescriptor;	98	import org.openide.NotifyDescriptor;
110	import org.openide.filesystems.FileObject;
111	import org.openide.filesystems.URLMapper;
112	import org.openide.util.NbBundle;	99	import org.openide.util.NbBundle;
113	import org.openide.util.RequestProcessor;	100	import org.openide.util.RequestProcessor;
114		101
Lines 554-560 public class JPDAStepImpl extends JPDASt Link Here
554	return false; // The session has finished	541	return false; // The session has finished
555	}	542	}
556	int depth;	543	int depth;
557	Map properties = (Map) session.lookupFirst (null, Map.class);	544	Map properties = session.lookupFirst(null, Map.class);
558	if (properties != null && properties.containsKey (StepIntoActionProvider.SS_STEP_OUT)) {	545	if (properties != null && properties.containsKey (StepIntoActionProvider.SS_STEP_OUT)) {
559	depth = StepRequest.STEP_OUT;	546	depth = StepRequest.STEP_OUT;
560	} else {	547	} else {

Lines 63-75 public class LaunchingSessionProvider ex Link Here

(-)a/debugger.jpda/src/org/netbeans/modules/debugger/jpda/LaunchingSessionProvider.java (-4 / +2 lines)
63		63
64	public LaunchingSessionProvider (ContextProvider contextProvider) {	64	public LaunchingSessionProvider (ContextProvider contextProvider) {
65	this.contextProvider = contextProvider;	65	this.contextProvider = contextProvider;
66	launchingCookie = (LaunchingDICookie) contextProvider.lookupFirst	66	launchingCookie = contextProvider.lookupFirst(null, LaunchingDICookie.class);
67	(null, LaunchingDICookie.class);
68	};	67	};
69		68
70	public String getSessionName () {	69	public String getSessionName () {
71	Map arguments = (Map) contextProvider.lookupFirst	70	Map arguments = contextProvider.lookupFirst(null, Map.class);
72	(null, Map.class);
73	if (arguments != null) {	71	if (arguments != null) {
74	String processName = (String) arguments.get ("name");	72	String processName = (String) arguments.get ("name");
75	if (processName != null)	73	if (processName != null)

Lines 60-72 public class ListeningSessionProvider ex Link Here

(-)a/debugger.jpda/src/org/netbeans/modules/debugger/jpda/ListeningSessionProvider.java (-4 / +2 lines)
60		60
61	public ListeningSessionProvider (ContextProvider contextProvider) {	61	public ListeningSessionProvider (ContextProvider contextProvider) {
62	this.contextProvider = contextProvider;	62	this.contextProvider = contextProvider;
63	smadic = (ListeningDICookie) contextProvider.lookupFirst	63	smadic = contextProvider.lookupFirst(null, ListeningDICookie.class);
64	(null, ListeningDICookie.class);
65	};	64	};
66		65
67	public String getSessionName () {	66	public String getSessionName () {
68	Map arguments = (Map) contextProvider.lookupFirst	67	Map arguments = contextProvider.lookupFirst(null, Map.class);
69	(null, Map.class);
70	if (arguments != null) {	68	if (arguments != null) {
71	String processName = (String) arguments.get ("name");	69	String processName = (String) arguments.get ("name");
72	if (processName != null)	70	if (processName != null)

Lines 100-115 public class RunIntoMethodActionProvider Link Here

(-)a/debugger.jpda/src/org/netbeans/modules/debugger/jpda/actions/RunIntoMethodActionProvider.java (-6 / +4 lines)
100	public RunIntoMethodActionProvider(ContextProvider lookupProvider) {	100	public RunIntoMethodActionProvider(ContextProvider lookupProvider) {
101	debugger = (JPDADebuggerImpl) lookupProvider.lookupFirst	101	debugger = (JPDADebuggerImpl) lookupProvider.lookupFirst
102	(null, JPDADebugger.class);	102	(null, JPDADebugger.class);
103	session = (Session) lookupProvider.lookupFirst	103	session = lookupProvider.lookupFirst(null, Session.class);
104	(null, Session.class);	104	sourcePath = lookupProvider.lookupFirst(null, SourcePath.class);
105	sourcePath = (SourcePath) lookupProvider.lookupFirst	105	debugger.addPropertyChangeListener (JPDADebuggerImpl.PROP_STATE, this);
106	(null, SourcePath.class);
107	debugger.addPropertyChangeListener (debugger.PROP_STATE, this);
108	EditorContextBridge.getContext().addPropertyChangeListener (this);	106	EditorContextBridge.getContext().addPropertyChangeListener (this);
109	}	107	}
110		108
111	private void destroy () {	109	private void destroy () {
112	debugger.removePropertyChangeListener (debugger.PROP_STATE, this);	110	debugger.removePropertyChangeListener (JPDADebuggerImpl.PROP_STATE, this);
113	EditorContextBridge.getContext().removePropertyChangeListener (this);	111	EditorContextBridge.getContext().removePropertyChangeListener (this);
114	}	112	}
115		113

Lines 118-125 public class StartActionProvider extends Link Here

(-)a/debugger.jpda/src/org/netbeans/modules/debugger/jpda/actions/StartActionProvider.java (-5 / +3 lines)
118		118
119		119
120	debuggerImpl.setStarting ();	120	debuggerImpl.setStarting ();
121	final AbstractDICookie cookie = (AbstractDICookie) lookupProvider.	121	final AbstractDICookie cookie = lookupProvider.lookupFirst(null, AbstractDICookie.class);
122	lookupFirst (null, AbstractDICookie.class);
123	doStartDebugger(cookie);	122	doStartDebugger(cookie);
124	if (startVerbose)	123	if (startVerbose)
125	System.out.println ("\nS StartActionProvider." +	124	System.out.println ("\nS StartActionProvider." +
Lines 144-151 public class StartActionProvider extends Link Here
144	}	143	}
145		144
146		145
147	final AbstractDICookie cookie = (AbstractDICookie) lookupProvider.	146	final AbstractDICookie cookie = lookupProvider.lookupFirst(null, AbstractDICookie.class);
148	lookupFirst (null, AbstractDICookie.class);
149		147
150	if (startVerbose)	148	if (startVerbose)
151	System.out.println ("\nS StartActionProvider." +	149	System.out.println ("\nS StartActionProvider." +
Lines 238-244 public class StartActionProvider extends Link Here
238	);	236	);
239	debuggerImpl.setException (exception);	237	debuggerImpl.setException (exception);
240	// kill the session that did not start properly	238	// kill the session that did not start properly
241	final Session session = (Session) lookupProvider.lookupFirst(null, Session.class);	239	final Session session = lookupProvider.lookupFirst(null, Session.class);
242	RequestProcessor.getDefault().post(new Runnable() {	240	RequestProcessor.getDefault().post(new Runnable() {
243	public void run() {	241	public void run() {
244	// Kill it in a separate thread so that the startup sequence can be finished.	242	// Kill it in a separate thread so that the startup sequence can be finished.

Lines 93-99 public class AddBreakpointPanel extends Link Here

(-)a/spi.debugger.ui/src/org/netbeans/modules/debugger/ui/actions/AddBreakpointPanel.java (-7 / +4 lines)
93	private javax.swing.JPanel pEvent;	93	private javax.swing.JPanel pEvent;
94	/** <CODE>HelpCtx</CODE> of the selected breakpoint type's customizer */	94	/** <CODE>HelpCtx</CODE> of the selected breakpoint type's customizer */
95	private HelpCtx helpCtx;	95	private HelpCtx helpCtx;
96	private List breakpointTypes;	96	private List<? extends BreakpointType> breakpointTypes;
97		97
98		98
99	// init ....................................................................	99	// init ....................................................................
Lines 102-111 public class AddBreakpointPanel extends Link Here
102	public AddBreakpointPanel () {	102	public AddBreakpointPanel () {
103	breakpointTypes = DebuggerManager.getDebuggerManager ().lookup	103	breakpointTypes = DebuggerManager.getDebuggerManager ().lookup
104	(null, BreakpointType.class);	104	(null, BreakpointType.class);
105	int i, k = breakpointTypes.size ();
106	String def = null;	105	String def = null;
107	for (i = 0; i < k; i++) {	106	for (BreakpointType bt : breakpointTypes) {
108	BreakpointType bt = (BreakpointType) breakpointTypes.get (i);
109	String dn = bt.getCategoryDisplayName ();	107	String dn = bt.getCategoryDisplayName ();
110	if (!cathegories.contains (dn)) {	108	if (!cathegories.contains (dn)) {
111	cathegories.add (dn);	109	cathegories.add (dn);
Lines 239-247 public class AddBreakpointPanel extends Link Here
239	doNotRefresh = true;	237	doNotRefresh = true;
240	cbEvents.removeAllItems ();	238	cbEvents.removeAllItems ();
241	types = new ArrayList ();	239	types = new ArrayList ();
242	int i, k = breakpointTypes.size (), defIndex = 0;	240	int defIndex = 0;
243	for (i = 0; i < k; i++) {	241	for (BreakpointType bt : breakpointTypes) {
244	BreakpointType bt = (BreakpointType) breakpointTypes.get (i);
245	if (!bt.getCategoryDisplayName ().equals (c))	242	if (!bt.getCategoryDisplayName ().equals (c))
246	continue;	243	continue;
247	cbEvents.addItem (bt.getTypeDisplayName ());	244	cbEvents.addItem (bt.getTypeDisplayName ());