Attachment #40640 for bug #98426

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 98426
Collapse All | Expand All




import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.openide.filesystems.FileStatusListener;
import org.openide.filesystems.FileSystem;
import org.openide.filesystems.FileUtil;
import org.openide.filesystems.Repository;
import org.openide.loaders.DataFolder;
import org.openide.loaders.DataObject;
import org.openide.loaders.DataObjectNotFoundException;
import org.openide.loaders.FolderLookup;
import org.openide.nodes.FilterNode;
import org.openide.nodes.Node;
import org.openide.util.Lookup;
import org.openide.util.RequestProcessor;
import org.openide.util.WeakListeners;
import org.openide.util.lookup.Lookups;


/**A wrapper node for project's root node that adds CVS badges+Project/Actions.

                result.add(actions[cntr]);
            } else {
                // honor 57874 contact:
                Collection<? extends Object> res = Lookups.forPath("Projects/Actions").lookupAll(Object.class); // NOI18N
                if (!res.isEmpty()) {
                    result.add(null);
                    for (Object next : res) {
                        if (next instanceof Action) {
                            result.add((Action) next);
                        } else if (next instanceof JSeparator) {
                        Lookup lookup = actionRegistry.getLookup();
                        Iterator<? extends Object> it = lookup.lookupAll(Object.class).iterator();
                        if (it.hasNext()) {
                            result.add(null);
                        }
                        while (it.hasNext()) {
                            Object next = it.next();
                            if (next instanceof Action) {
                                result.add((Action) next);
                            } else if (next instanceof JSeparator) {
                                result.add(null);
                            }
                        }
                    }
                } catch (DataObjectNotFoundException ex) {
                    // data folder for exitinf fileobject expected
                    ErrorManager.getDefault().notify(ex);
                }
            }
        }




import java.awt.event.ActionEvent;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;

import org.openide.filesystems.FileUtil;
import org.openide.filesystems.Repository;
import org.openide.loaders.DataFolder;
import org.openide.loaders.FolderLookup;
import org.openide.util.Lookup;
import org.openide.util.Mutex;
import org.openide.util.NbBundle;
import org.openide.util.actions.SystemAction;
import org.openide.util.lookup.Lookups;

public final class ModuleActions implements ActionProvider {
    

        actions.add(CommonProjectActions.deleteProjectAction());
        
        // Honor #57874 contract:
        Collection<? extends Object> res = Lookups.forPath("Projects/Actions").lookupAll(Object.class); // NOI18N
        if (!res.isEmpty()) {
            actions.add(null);
            for (Object next : res) {
                if (next instanceof Action) {
                    actions.add((Action) next);
                } else if (next instanceof JSeparator) {




import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import javax.swing.Action;
import javax.swing.JSeparator;

import org.openide.filesystems.FileObject;
import org.openide.filesystems.Repository;
import org.openide.loaders.DataFolder;
import org.openide.loaders.FolderLookup;
import org.openide.util.Lookup;
import org.openide.util.NbBundle;
import org.openide.util.actions.SystemAction;
import org.openide.util.lookup.Lookups;

/**
 * Defines actions available on a suite.

        actions.add(CommonProjectActions.renameProjectAction());
        actions.add(CommonProjectActions.moveProjectAction());
        actions.add(CommonProjectActions.deleteProjectAction());
        Collection<? extends Object> res = Lookups.forPath("Projects/Actions").lookupAll(Object.class); // NOI18N
        if (!res.isEmpty()) {
            actions.add(null);
            for (Object next : res) {
                if (next instanceof Action) {
                    actions.add((Action) next);
                } else if (next instanceof JSeparator) {




import org.netbeans.api.db.explorer.DatabaseConnection;
import org.netbeans.modules.db.api.explorer.MetaDataListener;
import org.netbeans.modules.db.explorer.DbMetaDataListener;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.Repository;
import org.openide.loaders.DataFolder;
import org.openide.loaders.FolderLookup;
import org.openide.util.Lookup;
import org.openide.util.lookup.Lookups;

/**
 *

    }

    private static Lookup.Result getListeners() {
        return Lookups.forPath(REFRESH_LISTENERS_PATH).lookupResult(MetaDataListener.class);
        DataFolder folder = DataFolder.findFolder(fo);
        return new FolderLookup(folder).getLookup().lookup(new Lookup.Template(MetaDataListener.class));
    }
}




import javax.swing.SwingUtilities;
import org.netbeans.modules.db.explorer.actions.AddDriverAction;
import org.netbeans.modules.db.explorer.driver.JDBCDriverConvertor;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.Repository;
import org.openide.loaders.DataFolder;
import org.openide.loaders.FolderLookup;
import org.openide.util.Lookup;
import org.openide.util.LookupEvent;
import org.openide.util.LookupListener;
import org.openide.util.lookup.Lookups;

/**
 * This class manages the list of JDBC drivers registered in the Database Explorer.

    }
    
    private synchronized Lookup.Result getLookupResult() {
        return Lookups.forPath(JDBCDriverConvertor.DRIVERS_PATH).lookupResult(JDBCDriver.class);
            FileObject fo = Repository.getDefault().getDefaultFileSystem().findResource(JDBCDriverConvertor.DRIVERS_PATH);
            DataFolder folder = DataFolder.findFolder(fo);
            result = new FolderLookup(folder).getLookup().lookup(new Lookup.Template(JDBCDriver.class));
        }
        return result;
    }
}




import org.netbeans.api.db.explorer.ConnectionListener;
import org.netbeans.api.db.explorer.DatabaseException;
import org.netbeans.modules.db.explorer.nodes.RootNode;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.Repository;
import org.openide.loaders.DataFolder;
import org.openide.loaders.FolderLookup;
import org.openide.util.Lookup;
import org.openide.util.LookupEvent;
import org.openide.util.LookupListener;
import org.openide.util.lookup.Lookups;


/**

    }
    
    private synchronized Lookup.Result getLookupResult() {
        return Lookups.forPath(DatabaseConnectionConvertor.CONNECTIONS_PATH).lookupResult(DatabaseConnection.class);
            FileObject fo = Repository.getDefault().getDefaultFileSystem().findResource(DatabaseConnectionConvertor.CONNECTIONS_PATH);
            DataFolder folder = DataFolder.findFolder(fo);
            result = new FolderLookup(folder).getLookup().lookup(new Lookup.Template(DatabaseConnection.class));
        }
        return result;
    }
}




import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import javax.swing.SwingUtilities;
import org.netbeans.spi.db.explorer.DatabaseRuntime;
import org.openide.ErrorManager;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.Repository;
import org.openide.loaders.DataFolder;
import org.openide.loaders.FolderLookup;
import org.openide.util.Lookup;
import org.openide.util.lookup.Lookups;


/**

    }
    
    private synchronized Lookup.Result getLookupResult() {
        return Lookups.forPath(RUNTIMES_PATH).lookupResult(DatabaseRuntime.class);
            FileObject fo = Repository.getDefault().getDefaultFileSystem().findResource(RUNTIMES_PATH);
            DataFolder folder = DataFolder.findFolder(fo);
            result = new FolderLookup(folder).getLookup().lookup(new Lookup.Template(DatabaseRuntime.class));
        }
        return result;
    }
}





import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;

import org.netbeans.spi.editor.errorstripe.UpToDateStatusProvider;
import org.netbeans.spi.editor.errorstripe.UpToDateStatusProviderFactory;
import org.openide.ErrorManager;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.Repository;
import org.openide.loaders.DataFolder;
import org.openide.loaders.DataObject;
import org.openide.loaders.FolderLookup;
import org.openide.util.Lookup;
import org.openide.util.Lookup.Result;
import org.openide.util.Lookup.Template;
import org.openide.util.lookup.ProxyLookup;
import org.netbeans.modules.editor.errorstripe.apimodule.SPIAccessor;
import org.openide.util.lookup.Lookups;

/**
 *

    
    private void gatherProviders(JTextComponent pane) {
        long start = System.currentTimeMillis();
        BaseKit kit = Utilities.getKit(pane);

        if (kit == null)
            return ;

        String content = kit.getContentType();
        BaseDocument document = (BaseDocument) pane.getDocument();
        String baseFolder = "Editors/text/base/UpToDateStatusProvider"; // NOI18N
        String contentFolder = "Editors/" + content + "/UpToDateStatusProvider"; // NOI18N

        if (ERR.isLoggable(ErrorManager.INFORMATIONAL)) {
            ERR.log(ErrorManager.INFORMATIONAL, "baseFolder = " + baseFolder );
        }


        Lookup baseLookup = Lookups.forPath(baseFolder);

        if (ERR.isLoggable(ErrorManager.INFORMATIONAL)) {
            ERR.log(ErrorManager.INFORMATIONAL, "contentFolder = " + contentFolder );
        }

        Lookup contentLookup = Lookups.forPath(contentFolder);

        Lookup lookup = new ProxyLookup(new Lookup[] {baseLookup, contentLookup});

        Result creators = lookup.lookup(new Template(MarkProviderCreator.class));

        List markProviders = new ArrayList();

        for (Iterator i = creators.allInstances().iterator(); i.hasNext(); ) {
            MarkProviderCreator creator = (MarkProviderCreator) i.next();

            if (ERR.isLoggable(ErrorManager.INFORMATIONAL)) {
                ERR.log(ErrorManager.INFORMATIONAL, "creator = " + creator );
            }

            MarkProvider provider = creator.createMarkProvider(pane);

            if (provider != null)
                markProviders.add(provider);
        }

        this.providers = markProviders;

        Result updsCreators = lookup.lookup(new Template(UpToDateStatusProviderFactory.class));
        List updsProviders = new ArrayList();

        for (Iterator i = updsCreators.allInstances().iterator(); i.hasNext(); ) {
            UpToDateStatusProviderFactory creator = (UpToDateStatusProviderFactory) i.next();

            if (ERR.isLoggable(ErrorManager.INFORMATIONAL)) {
                ERR.log(ErrorManager.INFORMATIONAL, "creator = " + creator );
            }
            
            DataObject contentDO = contentFolder != null ? DataObject.find(contentFolder) : null;
            Lookup contentLookup = contentFolder != null ? new FolderLookup((DataFolder) contentDO).getLookup() : Lookup.EMPTY;
            
            Lookup lookup = new ProxyLookup(new Lookup[] {baseLookup, contentLookup});
            
            Result creators = lookup.lookup(new Template(MarkProviderCreator.class));
            
            List markProviders = new ArrayList();
            
            for (Iterator i = creators.allInstances().iterator(); i.hasNext(); ) {
                MarkProviderCreator creator = (MarkProviderCreator) i.next();
                
                if (ERR.isLoggable(ErrorManager.INFORMATIONAL)) {
                    ERR.log(ErrorManager.INFORMATIONAL, "creator = " + creator );
                }
                
                MarkProvider provider = creator.createMarkProvider(pane);
                
                if (provider != null)
                    markProviders.add(provider);
            }
            
            this.providers = markProviders;
            
            Result updsCreators = lookup.lookup(new Template(UpToDateStatusProviderFactory.class));
            List updsProviders = new ArrayList();
            
            for (Iterator i = updsCreators.allInstances().iterator(); i.hasNext(); ) {
                UpToDateStatusProviderFactory creator = (UpToDateStatusProviderFactory) i.next();
                
                if (ERR.isLoggable(ErrorManager.INFORMATIONAL)) {
                    ERR.log(ErrorManager.INFORMATIONAL, "creator = " + creator );
                }
                
                UpToDateStatusProvider provider = creator.createUpToDateStatusProvider(pane.getDocument());
                
                if (provider != null)
                    updsProviders.add(provider);
            }

            UpToDateStatusProvider provider = creator.createUpToDateStatusProvider(pane.getDocument());

            if (provider != null)
                updsProviders.add(provider);
        }

        this.upToDateStatusProviders = updsProviders;
        
        long end = System.currentTimeMillis();
        




import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.netbeans.modules.editor.hints.options.ProvidersListAccessor;

import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileUtil;
import org.openide.filesystems.Repository;
import org.openide.util.lookup.Lookups;
import org.openide.loaders.FolderLookup;
import org.openide.util.Lookup.Template;

/**
 *

    private static void init() {
        key2Description = new HashMap<String, ProviderDescription>();
        descriptions = new ArrayList<ProviderDescription>();
        
        Collection<? extends ProviderDescription> looked = Lookups.forPath(PROVIDERS_LIST_FOLDER).lookupAll(ProviderDescription.class);
        Collection<? extends ProviderDescription> looked = flookup.getLookup().lookupAll(ProviderDescription.class);
        
        for (ProviderDescription desc : looked) {
            key2Description.put(desc.getKey(), desc);




import org.openide.filesystems.FileStatusListener;
import org.openide.filesystems.FileSystem;
import org.openide.filesystems.FileUtil;
import org.openide.filesystems.Repository;
import org.openide.loaders.DataFolder;
import org.openide.loaders.FolderLookup;
import org.openide.modules.SpecificationVersion;
import org.openide.nodes.AbstractNode;
import org.openide.nodes.Node;

            actions.add(null);
            
            // honor 57874 contact

            for (Object next : Lookups.forPath("Projects/Actions").lookupAll(Object.class)) {
                if (next instanceof Action) {
                    actions.add((Action) next);
                } else if (next instanceof JSeparator) {
                    actions.add(null);
                    } else if (next instanceof JSeparator) {
                        actions.add(null);
                    }
                }
            }
            




import org.netbeans.spi.project.ActionProvider;
import org.netbeans.spi.project.ui.support.CommonProjectActions;
import org.netbeans.spi.project.ui.support.ProjectSensitiveActions;
import org.openide.ErrorManager;
import org.openide.filesystems.FileChangeListener;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileSystem;
import org.openide.filesystems.Repository;
import org.openide.loaders.DataFolder;
import org.openide.loaders.DataObject;
import org.openide.loaders.DataObjectNotFoundException;
import org.openide.loaders.FolderLookup;
import org.openide.nodes.Children;
import org.openide.nodes.Node;
//import org.openide.util.HelpCtx;

        actions.add(SystemAction.get( org.openide.actions.FindAction.class ));
        
        // honor 57874 contact

        Lookup lookup = Lookups.forPath("Projects/Actions"); // NOI18N
        Lookup.Template query = new Lookup.Template(Object.class);
        Iterator it = lookup.lookup(query).allInstances().iterator();
        if (it.hasNext()) {
            actions.add(null);
        }
        while (it.hasNext()) {
            Object next = it.next();
            if (next instanceof Action) {
                actions.add(next);
            } else if (next instanceof JSeparator) {
                actions.add(null);
                }
                while (it.hasNext()) {
                    Object next = it.next();
                    if (next instanceof Action) {
                        actions.add(next);
                    } else if (next instanceof JSeparator) {
                        actions.add(null);
                    }
                }
            }
        } catch (DataObjectNotFoundException ex) {
            // data folder for exitinf fileobject expected
            ErrorManager.getDefault().notify(ex);
        }
        
//        actions.add(null);




import org.openide.filesystems.FileStatusListener;
import org.openide.filesystems.FileSystem;
import org.openide.filesystems.FileUtil;
import org.openide.filesystems.Repository;
import org.openide.loaders.DataFolder;
import org.openide.loaders.DataObject;
import org.openide.loaders.DataObjectNotFoundException;
import org.openide.loaders.FolderLookup;
import org.openide.modules.SpecificationVersion;
import org.openide.nodes.AbstractNode;
import org.openide.nodes.Children;

            actions.add(SystemAction.get(FindAction.class));
            
            // honor 57874 contact

            Lookup lookup = Lookups.forPath("Projects/Actions"); // NOI18N
            Lookup.Template query = new Lookup.Template(Object.class);
            Iterator it = lookup.lookup(query).allInstances().iterator();
            if (it.hasNext()) {
                actions.add(null);
            }
            while (it.hasNext()) {
                Object next = it.next();
                if (next instanceof Action) {
                    actions.add((Action) next);
                } else if (next instanceof JSeparator) {
                    actions.add(null);
                        Object next = it.next();
                        if (next instanceof Action) {
                            actions.add((Action) next);
                        } else if (next instanceof JSeparator) {
                            actions.add(null);
                        }
                    }
                }
            } catch (DataObjectNotFoundException ex) {
                // data folder for existing fileobject expected
                ErrorManager.getDefault().notify(ex);
            }
            
            actions.add(null);




import org.openide.filesystems.FileStatusListener;
import org.openide.filesystems.FileSystem;
import org.openide.filesystems.FileUtil;
import org.openide.filesystems.Repository;
import org.openide.loaders.DataFolder;
import org.openide.loaders.DataObject;
import org.openide.loaders.DataObjectNotFoundException;
import org.openide.loaders.FolderLookup;
import org.openide.nodes.AbstractNode;
import org.openide.nodes.Node;
import org.openide.nodes.NodeOp;

                null,
            }));
            
            Lookup lookup = Lookups.forPath("Projects/Actions"); // NOI18N
            Lookup.Template query = new Lookup.Template(Object.class);
            Iterator it = lookup.lookup(query).allInstances().iterator();
            if (it.hasNext()) {
                actions.add(null);
            }
            while (it.hasNext()) {
                Object next = it.next();
                if (next instanceof Action) {
                    actions.add((Action) next);
                } else if (next instanceof JSeparator) {
                    actions.add(null);
                    }
                    while (it.hasNext()) {
                        Object next = it.next();
                        if (next instanceof Action) {
                            actions.add((Action) next);
                        } else if (next instanceof JSeparator) {
                            actions.add(null);
                        }
                    }
                }
            } catch (DataObjectNotFoundException ex) {
                // data folder for existing fileobject expected
                ErrorManager.getDefault().notify(ex);
            }
            
            actions.add(null);




import org.openide.filesystems.FileStatusListener;
import org.openide.filesystems.FileSystem;
import org.openide.filesystems.FileUtil;
import org.openide.filesystems.Repository;
import org.openide.loaders.DataObject;
import org.openide.loaders.DataObjectNotFoundException;
import org.openide.loaders.FolderLookup;

/**
 * Support for creating logical views.

            actions.add(SystemAction.get( org.openide.actions.FindAction.class ));
            
            // honor 57874 contract

            Lookup lookup = Lookups.forPath("Projects/Actions"); // NOI18N
            Lookup.Template query = new Lookup.Template(Object.class);
            Iterator it = lookup.lookup(query).allInstances().iterator();
            if (it.hasNext()) {
                actions.add(null);
            }
            while (it.hasNext()) {
                Object next = it.next();
                if (next instanceof Action) {
                    actions.add(next);
                } else if (next instanceof JSeparator) {
                    actions.add(null);
                    }
                    while (it.hasNext()) {
                        Object next = it.next();
                        if (next instanceof Action) {
                            actions.add(next);
                        } else if (next instanceof JSeparator) {
                            actions.add(null);
                        }
                    }
                }
            } catch (DataObjectNotFoundException ex) {
                // data folder for existing fileobject expected
                ErrorManager.getDefault().notify(ex);
            }
            
            actions.add(null);

Lines 44-49 Link Here

(-)j2eeserver/src/org/netbeans/modules/j2ee/deployment/impl/Server.java (-2 / +3 lines)
44	import org.netbeans.modules.j2ee.deployment.plugins.spi.OptionalDeploymentManagerFactory;	44	import org.netbeans.modules.j2ee.deployment.plugins.spi.OptionalDeploymentManagerFactory;
45	import org.netbeans.modules.j2ee.deployment.plugins.spi.RegistryNodeFactory;	45	import org.netbeans.modules.j2ee.deployment.plugins.spi.RegistryNodeFactory;
46	import org.netbeans.modules.j2ee.deployment.plugins.spi.VerifierSupport;	46	import org.netbeans.modules.j2ee.deployment.plugins.spi.VerifierSupport;
		47	import org.openide.util.lookup.Lookups;
47		48
48		49
49	public class Server implements Node.Cookie {	50	public class Server implements Node.Cookie {
Lines 74-81 Link Here
74		75
75	dep = NetbeansDeployment.createGraph(descriptor.getInputStream());	76	dep = NetbeansDeployment.createGraph(descriptor.getInputStream());
76		77
77	lkp = new FolderLookup (DataFolder.findContainer (fo)).getLookup ();	78	lkp = Lookups.forPath(fo.getPath());
78	factory = (DeploymentFactory) lkp.lookup (DeploymentFactory.class);	79	factory = lkp.lookup (DeploymentFactory.class);
79	if (factory != null) {	80	if (factory != null) {
80	factoryCls = factory.getClass ();	81	factoryCls = factory.getClass ();
81	} else {	82	} else {




 */
package org.netbeans.modules.j2ee.deployment.impl.ui;

import java.awt.Image;
import org.netbeans.modules.j2ee.deployment.plugins.spi.StartServer;
import org.openide.nodes.*;
import org.openide.filesystems.*;

import org.openide.util.NbBundle;
import org.openide.util.actions.SystemAction;
import org.openide.util.HelpCtx;
import org.openide.ErrorManager;
import org.netbeans.modules.j2ee.deployment.impl.ui.actions.*;
import org.netbeans.modules.j2ee.deployment.impl.*;
import java.util.*;
import org.netbeans.modules.j2ee.deployment.devmodules.spi.InstanceListener;
import org.openide.util.lookup.Lookups;

/**
 * The server registry node is a node representing the registry in global options.

    }
    
    public static ServerRegistryNode getServerRegistryNode() {
        return Lookups.forPath("UI/Runtime").lookup(ServerRegistryNode.class);
            FileSystem defaultFileSystem = Repository.getDefault().getDefaultFileSystem();
            FileObject fo = defaultFileSystem.findResource("UI/Runtime");    //NOI18N
            DataFolder df = (DataFolder) DataObject.find(fo);
            org.openide.util.Lookup l = new FolderLookup(df).getLookup();
            return (ServerRegistryNode) l.lookup(ServerRegistryNode.class);
        } catch (DataObjectNotFoundException e) {
            ErrorManager.getDefault().notify(ErrorManager.INFORMATIONAL, e);
            return null;
        }
    }
}




import org.netbeans.spi.project.LookupMerger;
import org.netbeans.spi.project.LookupProvider;
import org.openide.ErrorManager;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.Repository;
import org.openide.loaders.DataFolder;
import org.openide.loaders.FolderLookup;
import org.openide.util.ChangeSupport;
import org.openide.util.Lookup;
import org.openide.util.LookupEvent;

    
    //TODO maybe have just one single instance for a given path?
    private static Lookup createLookup(String folderPath) {
        return Lookups.forPath(folderPath);
        if (root != null) {
            DataFolder folder = DataFolder.findFolder(root);
            return new FolderLookup(folder).getLookup();
        } else { // #87544
            return Lookup.EMPTY;
        }
    }
    
    static class DelegatingLookupImpl extends ProxyLookup implements LookupListener {




import org.netbeans.spi.project.ui.LogicalViewProvider;
import org.openide.ErrorManager;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.Repository;
import org.openide.loaders.DataFolder;
import org.openide.loaders.FolderLookup;
import org.openide.nodes.AbstractNode;
import org.openide.nodes.Children;
import org.openide.nodes.FilterNode;

            return new Action[0];
        } else {
            List<Action> actions = new ArrayList<Action>();
            for (Object o: Lookups.forPath(ACTIONS_FOLDER).lookupAll(Object.class)) {
            for (Object o: new FolderLookup(actionsFolder).getLookup().lookupAll(Object.class)) {
                if (o instanceof Action) {
                    actions.add((Action) o);
                } else if (o instanceof JSeparator) {




import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import org.netbeans.api.project.Project;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.Repository;
import org.openide.loaders.DataFolder;
import org.openide.loaders.FolderLookup;
import org.openide.nodes.Children;
import org.openide.nodes.Node;
import org.openide.util.Lookup;
import org.openide.util.LookupEvent;
import org.openide.util.LookupListener;
import org.openide.util.lookup.Lookups;

/**
 * Support class for creating Project node's children nodes from NodeFactory instances

        
        // protected for tests..
        protected Lookup createLookup() {
            return Lookups.forPath(folderPath);
            assert root != null : "Cannot find path " + folderPath + " in layers";
            DataFolder folder = DataFolder.findFolder(root);
            return new FolderLookup(folder).getLookup();
        }
        
       protected Node[] createNodes(NodeListKeyWrapper key) {




import org.openide.filesystems.FileStatusEvent;
import org.openide.filesystems.FileStatusListener;
import org.openide.filesystems.FileUtil;
import org.openide.filesystems.Repository;
import org.openide.loaders.DataFolder;
import org.openide.loaders.DataObject;
import org.openide.loaders.DataObjectNotFoundException;
import org.openide.loaders.FolderLookup;
import org.openide.nodes.*;
import org.openide.util.ContextAwareAction;
import org.openide.util.HelpCtx;

            actions.add(SystemAction.get( org.openide.actions.FindAction.class ));            
            
            // honor 57874 contact

            
            for (Object next : Lookups.forPath("Projects/Actions").lookupAll(Object.class)) {
                if (next instanceof Action) {
                    actions.add((Action) next);
                } else if (next instanceof JSeparator) {
                    actions.add(null);
                    } else if (next instanceof JSeparator) {
                        actions.add(null);
                    }
                }
            }
            




package org.netbeans.modules.web.api.webmodule;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.Repository;
import org.netbeans.modules.web.spi.webmodule.WebFrameworkProvider;
import org.openide.loaders.DataFolder;
import org.openide.loaders.FolderLookup;
import org.openide.util.Lookup;
import org.openide.util.lookup.Lookups;

/**
 *

     * @return List of all {@link org.netbeans.modules.web.spi.webmodule.WebFrameworkProvider}s, which are registered in the layer - j2ee/webtier/framework folder.
     */
    public static List/*<WebFrameworkProvider>*/ getFrameworkProviders(){
        Lookup l = Lookups.forPath("j2ee/webtier/framework"); //NOI18N
        Lookup.Result result = l.lookupResult(WebFrameworkProvider.class);
        if (f == null)
            return Collections.EMPTY_LIST;
        DataFolder folder = DataFolder.findFolder(f);
        FolderLookup l = new FolderLookup(folder);
        Lookup.Result result = l.getLookup().lookup(new Lookup.Template(WebFrameworkProvider.class));
        return new ArrayList(result.allInstances()); // since allInstances() returns a Collection
    }
}




import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;

import org.openide.ErrorManager;
import org.openide.nodes.Node;
import org.openide.filesystems.FileSystem;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileStateInvalidException;
import org.openide.filesystems.Repository;
import org.openide.loaders.DataObject;
import org.openide.loaders.DataFolder;
import org.openide.loaders.FolderLookup;
import org.openide.loaders.DataObjectNotFoundException;
import org.openide.util.Lookup;

import org.netbeans.modules.websvc.registry.model.WebServiceGroup;

import org.netbeans.modules.websvc.registry.wsdl.WSDLInfo;

import org.netbeans.modules.websvc.api.registry.WebServicesRegistryView;
import org.openide.util.lookup.Lookups;

/**
 *

    public Node getRegistryRootNode() {
        Node rootNode = null;

        Lookup l = Lookups.forPath("UI/Runtime"); // NOI18N
        rootNode = (WebServicesRootNode) l.lookup(WebServicesRootNode.class);
            FileObject fo = defaultFileSystem.findResource("UI/Runtime");    //NOI18N
            DataFolder df = (DataFolder) DataObject.find(fo);
            Lookup l = new FolderLookup(df).getLookup();
            rootNode = (WebServicesRootNode) l.lookup(WebServicesRootNode.class);
        } catch (DataObjectNotFoundException ex) {
            ErrorManager.getDefault().notify(ErrorManager.INFORMATIONAL, ex);
            rootNode = null;
        }

        return rootNode;
    }




import org.netbeans.modules.xml.catalog.lib.IteratorIterator;

import org.openide.*;
import org.openide.util.HelpCtx;
import org.openide.util.io.NbMarshalledObject;

import org.netbeans.modules.xml.catalog.spi.*;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileSystem;
import org.openide.filesystems.Repository;
import org.openide.loaders.DataFolder;
import org.openide.loaders.DataObject;
import org.openide.loaders.DataObjectNotFoundException;
import org.openide.loaders.FolderLookup;
import org.openide.util.Lookup;
import org.openide.util.LookupListener;
import org.openide.util.LookupEvent;

     */
    private static Lookup getUserCatalogsLookup() {
        if (userCatalogLookup == null) {
            userCatalogLookup = Lookups.forPath(REGISTRATIONS);
            FileObject folder = sfs.findResource(REGISTRATIONS);
            // do not cache any module providing it can be enabled at any time
            if (folder == null) return Lookups.fixed(new Object[0]);
            try {
                DataFolder dataFolder = (DataFolder) DataObject.find(folder);
                userCatalogLookup = new FolderLookup(dataFolder).getLookup();
            } catch (DataObjectNotFoundException ex) {
                throw new IllegalStateException("There must be DataFolder for " + folder + "!");
            }
        }
        return userCatalogLookup;
    }




import java.util.Iterator;
import org.netbeans.modules.xml.api.model.GrammarQuery;
import org.openide.ErrorManager;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileSystem;
import org.openide.filesystems.Repository;
import org.openide.loaders.DataObject;
import org.openide.loaders.DataObjectNotFoundException;
import org.openide.loaders.FolderLookup;
import org.openide.util.Lookup;
import org.openide.util.lookup.Lookups;

/**
 * GrammarQuery service provider definition. Manager methods

                return registrations.allInstances().iterator();
            }

            registrations = Lookups.forPath(FOLDER).lookupResult(GrammarQueryManager.class);
            return registrations.allInstances().iterator();
            try {
                FileSystem fs = Repository.getDefault().getDefaultFileSystem();
                FileObject fo = fs.findResource(FOLDER);      
                DataObject df = DataObject.find(fo);
                if (df instanceof DataObject.Container) {
                    FolderLookup lookup =
                        new FolderLookup((DataObject.Container) df);
                    Lookup.Template template =
                        new Lookup.Template(GrammarQueryManager.class);
                    registrations = lookup.getLookup().lookup(template);
                    return registrations.allInstances().iterator();
                } else {
                    return new ArrayList(0).iterator();
                }
            } catch (DataObjectNotFoundException ex) {
                return new ArrayList(0).iterator();
            }
        }
    }
}





import java.awt.Dialog;
import java.util.Iterator;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileSystem;
import org.openide.filesystems.Repository;
import org.openide.loaders.FolderLookup;
import org.openide.util.Lookup;
import org.openide.loaders.DataObject;
import org.openide.loaders.DataObjectNotFoundException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Vector;
import javax.swing.DefaultComboBoxModel;


import org.openide.util.HelpCtx;
import org.netbeans.modules.xml.api.scenario.*;
import org.openide.util.lookup.Lookups;

/**
 * A UI panel which allows the user to select a name and scenario type from

        nameField.setText(defaultName);
        nameField.setSelectionStart(0);
        nameField.setSelectionEnd(defaultName.length());

       
        Lookup.Result registrations = Lookups.forPath(FOLDER).lookupResult(ScenarioFactory.class);

        // Only display enabled factories for this DataObject
        Collection allFactories = registrations.allInstances();
        Vector allowedFactories = new Vector();
        Iterator iter = allFactories.iterator();
        while(iter.hasNext()) {
            ScenarioFactory factory = (ScenarioFactory)iter.next();
            if (factory.isEnabled(dataObject)) {
                allowedFactories.add(factory);
                    new Lookup.Template(ScenarioFactory.class);
                Lookup.Result registrations = lookup.getLookup().lookup(template);
                
                // Only display enabled factories for this DataObject
                Collection allFactories = registrations.allInstances();
                Vector allowedFactories = new Vector();
                Iterator iter = allFactories.iterator();
                while(iter.hasNext()) {
                    ScenarioFactory factory = (ScenarioFactory)iter.next();
                    if (factory.isEnabled(dataObject)) {
                        allowedFactories.add(factory);
                    }
                }
                
                if (allowedFactories.size() == 0) {
                    throw new NoFactoriesException();
                }
                
                typeCombo.setModel(new javax.swing.DefaultComboBoxModel(allowedFactories.toArray()));
            } else {
                throw new NoFactoriesException();
            }
        }

        if (allowedFactories.size() == 0) {
            throw new NoFactoriesException();
        }

        typeCombo.setModel(new javax.swing.DefaultComboBoxModel(allowedFactories.toArray()));
    }
    
    /**




import org.netbeans.modules.xml.spi.dom.*;
import org.netbeans.modules.xml.api.cookies.ScenarioCookie;
import org.netbeans.modules.xsl.api.XSLCustomizer;
import org.netbeans.modules.xsl.api.XSLScenario;
import org.openide.filesystems.Repository;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileSystem;
import org.openide.loaders.FolderLookup;
import org.openide.loaders.DataFolder;
import org.openide.loaders.DataObject;
import org.openide.loaders.DataObjectNotFoundException;
import org.openide.loaders.InstanceDataObject;
import org.openide.nodes.PropertySupport;
import org.openide.util.Lookup;
import org.openide.util.NbBundle;
import org.openide.util.lookup.Lookups;

import org.w3c.dom.*;
import org.w3c.dom.NodeList;
import org.xml.sax.EntityResolver;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;

     * Looks up registered XSLCustomizer objects which will be used by this object
     */
    private static XSLCustomizer lookupCustomizerInstance() {
        Lookup.Template template =
            new Lookup.Template(XSLCustomizer.class);
            FileSystem fs = Repository.getDefault().getDefaultFileSystem();
            FileObject fo = fs.findResource(CUSTOMIZER_FOLDER);
            if (fo == null) return null;
            DataObject df = DataObject.find(fo);
            if (!(df instanceof DataObject.Container)) {
                return null;
            }

            // ??? What is it? Should not we use naming instead?

            FolderLookup lookup =
                new FolderLookup((DataObject.Container) df);
            Lookup.Template template =
                new Lookup.Template(XSLCustomizer.class);

        Lookup.Item lookupItem = Lookups.forPath(CUSTOMIZER_FOLDER).lookupItem(template);
        if (lookupItem == null) {
                return null;
            }

            return (XSLCustomizer)lookupItem.getInstance();
        } catch (DataObjectNotFoundException e) {
            return null;
        }

        return (XSLCustomizer)lookupItem.getInstance();
    }

    /**

Return to bug 98426

Lines 28-34 Link Here

(-)ant/freeform/src/org/netbeans/modules/ant/freeform/ui/ProjectNodeWrapper.java (-28 / +8 lines)
28	import java.util.Collection;	28	import java.util.Collection;
29	import java.util.HashMap;	29	import java.util.HashMap;
30	import java.util.HashSet;	30	import java.util.HashSet;
31	import java.util.Iterator;
32	import java.util.List;	31	import java.util.List;
33	import java.util.Map;	32	import java.util.Map;
34	import java.util.Set;	33	import java.util.Set;
Lines 48-63 Link Here
48	import org.openide.filesystems.FileStatusListener;	47	import org.openide.filesystems.FileStatusListener;
49	import org.openide.filesystems.FileSystem;	48	import org.openide.filesystems.FileSystem;
50	import org.openide.filesystems.FileUtil;	49	import org.openide.filesystems.FileUtil;
51	import org.openide.filesystems.Repository;
52	import org.openide.loaders.DataFolder;
53	import org.openide.loaders.DataObject;
54	import org.openide.loaders.DataObjectNotFoundException;
55	import org.openide.loaders.FolderLookup;
56	import org.openide.nodes.FilterNode;	50	import org.openide.nodes.FilterNode;
57	import org.openide.nodes.Node;	51	import org.openide.nodes.Node;
58	import org.openide.util.Lookup;
59	import org.openide.util.RequestProcessor;	52	import org.openide.util.RequestProcessor;
60	import org.openide.util.WeakListeners;	53	import org.openide.util.WeakListeners;
		54	import org.openide.util.lookup.Lookups;
61		55
62		56
63	/**A wrapper node for project's root node that adds CVS badges+Project/Actions.	57	/**A wrapper node for project's root node that adds CVS badges+Project/Actions.
Lines 101-130 Link Here
101	result.add(actions[cntr]);	95	result.add(actions[cntr]);
102	} else {	96	} else {
103	// honor 57874 contact:	97	// honor 57874 contact:
104	try {	98	Collection<? extends Object> res = Lookups.forPath("Projects/Actions").lookupAll(Object.class); // NOI18N
105	Repository repository = Repository.getDefault();	99	if (!res.isEmpty()) {
106	FileSystem sfs = repository.getDefaultFileSystem();	100	result.add(null);
107	FileObject fo = sfs.findResource("Projects/Actions"); // NOI18N	101	for (Object next : res) {
108	if (fo != null) {	102	if (next instanceof Action) {
109	DataObject dobj = DataObject.find(fo);	103	result.add((Action) next);
110	FolderLookup actionRegistry = new FolderLookup((DataFolder)dobj);	104	} else if (next instanceof JSeparator) {
111	Lookup lookup = actionRegistry.getLookup();
112	Iterator<? extends Object> it = lookup.lookupAll(Object.class).iterator();
113	if (it.hasNext()) {
114	result.add(null);	105	result.add(null);
115	}	106	}
116	while (it.hasNext()) {
117	Object next = it.next();
118	if (next instanceof Action) {
119	result.add((Action) next);
120	} else if (next instanceof JSeparator) {
121	result.add(null);
122	}
123	}
124	}	107	}
125	} catch (DataObjectNotFoundException ex) {
126	// data folder for exitinf fileobject expected
127	ErrorManager.getDefault().notify(ex);
128	}	108	}
129	}	109	}
130	}	110	}

Lines 22-27 Link Here

(-)apisupport/project/src/org/netbeans/modules/apisupport/project/ui/ModuleActions.java (-4 / +5 lines)
22	import java.awt.event.ActionEvent;	22	import java.awt.event.ActionEvent;
23	import java.io.IOException;	23	import java.io.IOException;
24	import java.util.ArrayList;	24	import java.util.ArrayList;
		25	import java.util.Collection;
25	import java.util.HashMap;	26	import java.util.HashMap;
26	import java.util.HashSet;	27	import java.util.HashSet;
27	import java.util.List;	28	import java.util.List;
Lines 59-69 Link Here
59	import org.openide.filesystems.FileUtil;	60	import org.openide.filesystems.FileUtil;
60	import org.openide.filesystems.Repository;	61	import org.openide.filesystems.Repository;
61	import org.openide.loaders.DataFolder;	62	import org.openide.loaders.DataFolder;
62	import org.openide.loaders.FolderLookup;
63	import org.openide.util.Lookup;	63	import org.openide.util.Lookup;
64	import org.openide.util.Mutex;	64	import org.openide.util.Mutex;
65	import org.openide.util.NbBundle;	65	import org.openide.util.NbBundle;
66	import org.openide.util.actions.SystemAction;	66	import org.openide.util.actions.SystemAction;
		67	import org.openide.util.lookup.Lookups;
67		68
68	public final class ModuleActions implements ActionProvider {	69	public final class ModuleActions implements ActionProvider {
69		70
Lines 112-121 Link Here
112	actions.add(CommonProjectActions.deleteProjectAction());	113	actions.add(CommonProjectActions.deleteProjectAction());
113		114
114	// Honor #57874 contract:	115	// Honor #57874 contract:
115	FileObject fo = Repository.getDefault().getDefaultFileSystem().findResource("Projects/Actions"); // NOI18N	116	Collection<? extends Object> res = Lookups.forPath("Projects/Actions").lookupAll(Object.class); // NOI18N
116	if (fo != null && fo.isFolder()) {	117	if (!res.isEmpty()) {
117	actions.add(null);	118	actions.add(null);
118	for (Object next : new FolderLookup(DataFolder.findFolder(fo)).getLookup().lookupAll(Object.class)) {	119	for (Object next : res) {
119	if (next instanceof Action) {	120	if (next instanceof Action) {
120	actions.add((Action) next);	121	actions.add((Action) next);
121	} else if (next instanceof JSeparator) {	122	} else if (next instanceof JSeparator) {

Lines 23-33 Link Here

(-)db/dbapi/src/org/netbeans/modules/dbapi/DbMetaDataListenerImpl.java (-7 / +2 lines)
23	import org.netbeans.api.db.explorer.DatabaseConnection;	23	import org.netbeans.api.db.explorer.DatabaseConnection;
24	import org.netbeans.modules.db.api.explorer.MetaDataListener;	24	import org.netbeans.modules.db.api.explorer.MetaDataListener;
25	import org.netbeans.modules.db.explorer.DbMetaDataListener;	25	import org.netbeans.modules.db.explorer.DbMetaDataListener;
26	import org.openide.filesystems.FileObject;
27	import org.openide.filesystems.Repository;
28	import org.openide.loaders.DataFolder;
29	import org.openide.loaders.FolderLookup;
30	import org.openide.util.Lookup;	26	import org.openide.util.Lookup;
		27	import org.openide.util.lookup.Lookups;
31		28
32	/**	29	/**
33	*	30	*
Lines 55-62 Link Here
55	}	52	}
56		53
57	private static Lookup.Result getListeners() {	54	private static Lookup.Result getListeners() {
58	FileObject fo = Repository.getDefault().getDefaultFileSystem().findResource(REFRESH_LISTENERS_PATH);	55	return Lookups.forPath(REFRESH_LISTENERS_PATH).lookupResult(MetaDataListener.class);
59	DataFolder folder = DataFolder.findFolder(fo);
60	return new FolderLookup(folder).getLookup().lookup(new Lookup.Template(MetaDataListener.class));
61	}	56	}
62	}	57	}

Lines 28-40 Link Here

(-)db/src/org/netbeans/api/db/explorer/JDBCDriverManager.java (-10 / +2 lines)
28	import javax.swing.SwingUtilities;	28	import javax.swing.SwingUtilities;
29	import org.netbeans.modules.db.explorer.actions.AddDriverAction;	29	import org.netbeans.modules.db.explorer.actions.AddDriverAction;
30	import org.netbeans.modules.db.explorer.driver.JDBCDriverConvertor;	30	import org.netbeans.modules.db.explorer.driver.JDBCDriverConvertor;
31	import org.openide.filesystems.FileObject;
32	import org.openide.filesystems.Repository;
33	import org.openide.loaders.DataFolder;
34	import org.openide.loaders.FolderLookup;
35	import org.openide.util.Lookup;	31	import org.openide.util.Lookup;
36	import org.openide.util.LookupEvent;	32	import org.openide.util.LookupEvent;
37	import org.openide.util.LookupListener;	33	import org.openide.util.LookupListener;
		34	import org.openide.util.lookup.Lookups;
38		35
39	/**	36	/**
40	* This class manages the list of JDBC drivers registered in the Database Explorer.	37	* This class manages the list of JDBC drivers registered in the Database Explorer.
Lines 198-208 Link Here
198	}	195	}
199		196
200	private synchronized Lookup.Result getLookupResult() {	197	private synchronized Lookup.Result getLookupResult() {
201	if (result == null) {	198	return Lookups.forPath(JDBCDriverConvertor.DRIVERS_PATH).lookupResult(JDBCDriver.class);
202	FileObject fo = Repository.getDefault().getDefaultFileSystem().findResource(JDBCDriverConvertor.DRIVERS_PATH);
203	DataFolder folder = DataFolder.findFolder(fo);
204	result = new FolderLookup(folder).getLookup().lookup(new Lookup.Template(JDBCDriver.class));
205	}
206	return result;
207	}	199	}
208	}	200	}

Lines 27-39 Link Here

(-)db/src/org/netbeans/modules/db/explorer/ConnectionList.java (-10 / +2 lines)
27	import org.netbeans.api.db.explorer.ConnectionListener;	27	import org.netbeans.api.db.explorer.ConnectionListener;
28	import org.netbeans.api.db.explorer.DatabaseException;	28	import org.netbeans.api.db.explorer.DatabaseException;
29	import org.netbeans.modules.db.explorer.nodes.RootNode;	29	import org.netbeans.modules.db.explorer.nodes.RootNode;
30	import org.openide.filesystems.FileObject;
31	import org.openide.filesystems.Repository;
32	import org.openide.loaders.DataFolder;
33	import org.openide.loaders.FolderLookup;
34	import org.openide.util.Lookup;	30	import org.openide.util.Lookup;
35	import org.openide.util.LookupEvent;	31	import org.openide.util.LookupEvent;
36	import org.openide.util.LookupListener;	32	import org.openide.util.LookupListener;
		33	import org.openide.util.lookup.Lookups;
37		34
38		35
39	/**	36	/**
Lines 142-152 Link Here
142	}	139	}
143		140
144	private synchronized Lookup.Result getLookupResult() {	141	private synchronized Lookup.Result getLookupResult() {
145	if (result == null) {	142	return Lookups.forPath(DatabaseConnectionConvertor.CONNECTIONS_PATH).lookupResult(DatabaseConnection.class);
146	FileObject fo = Repository.getDefault().getDefaultFileSystem().findResource(DatabaseConnectionConvertor.CONNECTIONS_PATH);
147	DataFolder folder = DataFolder.findFolder(fo);
148	result = new FolderLookup(folder).getLookup().lookup(new Lookup.Template(DatabaseConnection.class));
149	}
150	return result;
151	}	143	}
152	}	144	}

Lines 23-36 Link Here

(-)db/src/org/netbeans/modules/db/runtime/DatabaseRuntimeManager.java (-11 / +2 lines)
23	import java.util.Iterator;	23	import java.util.Iterator;
24	import java.util.LinkedList;	24	import java.util.LinkedList;
25	import java.util.List;	25	import java.util.List;
26	import javax.swing.SwingUtilities;
27	import org.netbeans.spi.db.explorer.DatabaseRuntime;	26	import org.netbeans.spi.db.explorer.DatabaseRuntime;
28	import org.openide.ErrorManager;	27	import org.openide.ErrorManager;
29	import org.openide.filesystems.FileObject;
30	import org.openide.filesystems.Repository;
31	import org.openide.loaders.DataFolder;
32	import org.openide.loaders.FolderLookup;
33	import org.openide.util.Lookup;	28	import org.openide.util.Lookup;
		29	import org.openide.util.lookup.Lookups;
34		30
35		31
36	/**	32	/**
Lines 105-115 Link Here
105	}	101	}
106		102
107	private synchronized Lookup.Result getLookupResult() {	103	private synchronized Lookup.Result getLookupResult() {
108	if (result == null) {	104	return Lookups.forPath(RUNTIMES_PATH).lookupResult(DatabaseRuntime.class);
109	FileObject fo = Repository.getDefault().getDefaultFileSystem().findResource(RUNTIMES_PATH);
110	DataFolder folder = DataFolder.findFolder(fo);
111	result = new FolderLookup(folder).getLookup().lookup(new Lookup.Template(DatabaseRuntime.class));
112	}
113	return result;
114	}	105	}
115	}	106	}

Lines 21-27 Link Here

(-)editor/errorstripe/src/org/netbeans/modules/editor/errorstripe/AnnotationViewDataImpl.java (-72 / +57 lines)
21		21
22	import java.beans.PropertyChangeEvent;	22	import java.beans.PropertyChangeEvent;
23	import java.beans.PropertyChangeListener;	23	import java.beans.PropertyChangeListener;
24	import java.io.IOException;
25	import java.util.ArrayList;	24	import java.util.ArrayList;
26	import java.util.Collection;	25	import java.util.Collection;
27	import java.util.Collections;	26	import java.util.Collections;
Lines 45-60 Link Here
45	import org.netbeans.spi.editor.errorstripe.UpToDateStatusProvider;	44	import org.netbeans.spi.editor.errorstripe.UpToDateStatusProvider;
46	import org.netbeans.spi.editor.errorstripe.UpToDateStatusProviderFactory;	45	import org.netbeans.spi.editor.errorstripe.UpToDateStatusProviderFactory;
47	import org.openide.ErrorManager;	46	import org.openide.ErrorManager;
48	import org.openide.filesystems.FileObject;
49	import org.openide.filesystems.Repository;
50	import org.openide.loaders.DataFolder;
51	import org.openide.loaders.DataObject;
52	import org.openide.loaders.FolderLookup;
53	import org.openide.util.Lookup;	47	import org.openide.util.Lookup;
54	import org.openide.util.Lookup.Result;	48	import org.openide.util.Lookup.Result;
55	import org.openide.util.Lookup.Template;	49	import org.openide.util.Lookup.Template;
56	import org.openide.util.lookup.ProxyLookup;	50	import org.openide.util.lookup.ProxyLookup;
57	import org.netbeans.modules.editor.errorstripe.apimodule.SPIAccessor;	51	import org.netbeans.modules.editor.errorstripe.apimodule.SPIAccessor;
		52	import org.openide.util.lookup.Lookups;
58		53
59	/**	54	/**
60	*	55	*
Lines 107-183 Link Here
107		102
108	private void gatherProviders(JTextComponent pane) {	103	private void gatherProviders(JTextComponent pane) {
109	long start = System.currentTimeMillis();	104	long start = System.currentTimeMillis();
110	try {	105	BaseKit kit = Utilities.getKit(pane);
111	BaseKit kit = Utilities.getKit(pane);	106
112		107	if (kit == null)
113	if (kit == null)	108	return ;
114	return ;	109
115		110	String content = kit.getContentType();
116	String content = kit.getContentType();	111	BaseDocument document = (BaseDocument) pane.getDocument();
117	BaseDocument document = (BaseDocument) pane.getDocument();	112	String baseFolder = "Editors/text/base/UpToDateStatusProvider"; // NOI18N
118	FileObject baseFolder = Repository.getDefault().getDefaultFileSystem().findResource("Editors/text/base/UpToDateStatusProvider"); // NOI18N	113	String contentFolder = "Editors/" + content + "/UpToDateStatusProvider"; // NOI18N
119	FileObject contentFolder = Repository.getDefault().getDefaultFileSystem().findResource("Editors/" + content + "/UpToDateStatusProvider"); // NOI18N	114
120		115	if (ERR.isLoggable(ErrorManager.INFORMATIONAL)) {
121	if (ERR.isLoggable(ErrorManager.INFORMATIONAL)) {	116	ERR.log(ErrorManager.INFORMATIONAL, "baseFolder = " + baseFolder );
122	ERR.log(ErrorManager.INFORMATIONAL, "baseFolder = " + baseFolder );	117	}
123	}	118
124		119
125	DataObject baseDO = baseFolder != null ? DataObject.find(baseFolder) : null;	120	Lookup baseLookup = Lookups.forPath(baseFolder);
126		121
		122	if (ERR.isLoggable(ErrorManager.INFORMATIONAL)) {
		123	ERR.log(ErrorManager.INFORMATIONAL, "contentFolder = " + contentFolder );
		124	}
		125
		126	Lookup contentLookup = Lookups.forPath(contentFolder);
		127
		128	Lookup lookup = new ProxyLookup(new Lookup[] {baseLookup, contentLookup});
		129
		130	Result creators = lookup.lookup(new Template(MarkProviderCreator.class));
		131
		132	List markProviders = new ArrayList();
		133
		134	for (Iterator i = creators.allInstances().iterator(); i.hasNext(); ) {
		135	MarkProviderCreator creator = (MarkProviderCreator) i.next();
		136
127	if (ERR.isLoggable(ErrorManager.INFORMATIONAL)) {	137	if (ERR.isLoggable(ErrorManager.INFORMATIONAL)) {
128	ERR.log(ErrorManager.INFORMATIONAL, "baseDO = " + baseDO );	138	ERR.log(ErrorManager.INFORMATIONAL, "creator = " + creator );
129	}	139	}
130		140
131	Lookup baseLookup = baseFolder != null ? new FolderLookup((DataFolder) baseDO).getLookup() : Lookup.EMPTY;	141	MarkProvider provider = creator.createMarkProvider(pane);
132		142
		143	if (provider != null)
		144	markProviders.add(provider);
		145	}
		146
		147	this.providers = markProviders;
		148
		149	Result updsCreators = lookup.lookup(new Template(UpToDateStatusProviderFactory.class));
		150	List updsProviders = new ArrayList();
		151
		152	for (Iterator i = updsCreators.allInstances().iterator(); i.hasNext(); ) {
		153	UpToDateStatusProviderFactory creator = (UpToDateStatusProviderFactory) i.next();
		154
133	if (ERR.isLoggable(ErrorManager.INFORMATIONAL)) {	155	if (ERR.isLoggable(ErrorManager.INFORMATIONAL)) {
134	ERR.log(ErrorManager.INFORMATIONAL, "contentFolder = " + contentFolder );	156	ERR.log(ErrorManager.INFORMATIONAL, "creator = " + creator );
135	}
136
137	DataObject contentDO = contentFolder != null ? DataObject.find(contentFolder) : null;
138	Lookup contentLookup = contentFolder != null ? new FolderLookup((DataFolder) contentDO).getLookup() : Lookup.EMPTY;
139
140	Lookup lookup = new ProxyLookup(new Lookup[] {baseLookup, contentLookup});
141
142	Result creators = lookup.lookup(new Template(MarkProviderCreator.class));
143
144	List markProviders = new ArrayList();
145
146	for (Iterator i = creators.allInstances().iterator(); i.hasNext(); ) {
147	MarkProviderCreator creator = (MarkProviderCreator) i.next();
148
149	if (ERR.isLoggable(ErrorManager.INFORMATIONAL)) {
150	ERR.log(ErrorManager.INFORMATIONAL, "creator = " + creator );
151	}
152
153	MarkProvider provider = creator.createMarkProvider(pane);
154
155	if (provider != null)
156	markProviders.add(provider);
157	}
158
159	this.providers = markProviders;
160
161	Result updsCreators = lookup.lookup(new Template(UpToDateStatusProviderFactory.class));
162	List updsProviders = new ArrayList();
163
164	for (Iterator i = updsCreators.allInstances().iterator(); i.hasNext(); ) {
165	UpToDateStatusProviderFactory creator = (UpToDateStatusProviderFactory) i.next();
166
167	if (ERR.isLoggable(ErrorManager.INFORMATIONAL)) {
168	ERR.log(ErrorManager.INFORMATIONAL, "creator = " + creator );
169	}
170
171	UpToDateStatusProvider provider = creator.createUpToDateStatusProvider(pane.getDocument());
172
173	if (provider != null)
174	updsProviders.add(provider);
175	}	157	}
176		158
177	this.upToDateStatusProviders = updsProviders;	159	UpToDateStatusProvider provider = creator.createUpToDateStatusProvider(pane.getDocument());
178	} catch (IOException e) {	160
179	ErrorManager.getDefault().notify(e);	161	if (provider != null)
		162	updsProviders.add(provider);
180	}	163	}
		164
		165	this.upToDateStatusProviders = updsProviders;
181		166
182	long end = System.currentTimeMillis();	167	long end = System.currentTimeMillis();
183		168

Lines 26-32 Link Here

(-)editor/hints/src/org/netbeans/spi/editor/hints/ProvidersList.java (-7 / +3 lines)
26	import java.util.ArrayList;	26	import java.util.ArrayList;
27	import java.util.Collection;	27	import java.util.Collection;
28	import java.util.HashMap;	28	import java.util.HashMap;
29	import java.util.Iterator;
30	import java.util.List;	29	import java.util.List;
31	import java.util.Map;	30	import java.util.Map;
32	import org.netbeans.modules.editor.hints.options.ProvidersListAccessor;	31	import org.netbeans.modules.editor.hints.options.ProvidersListAccessor;
Lines 35-43 Link Here
35	import org.openide.filesystems.FileObject;	34	import org.openide.filesystems.FileObject;
36	import org.openide.filesystems.FileUtil;	35	import org.openide.filesystems.FileUtil;
37	import org.openide.filesystems.Repository;	36	import org.openide.filesystems.Repository;
38	import org.openide.loaders.DataFolder;	37	import org.openide.util.lookup.Lookups;
39	import org.openide.loaders.FolderLookup;
40	import org.openide.util.Lookup.Template;
41		38
42	/**	39	/**
43	*	40	*
Lines 91-99 Link Here
91	private static void init() {	88	private static void init() {
92	key2Description = new HashMap<String, ProviderDescription>();	89	key2Description = new HashMap<String, ProviderDescription>();
93	descriptions = new ArrayList<ProviderDescription>();	90	descriptions = new ArrayList<ProviderDescription>();
94	FileObject listFolder = Repository.getDefault().getDefaultFileSystem().findResource(PROVIDERS_LIST_FOLDER);	91
95	FolderLookup flookup = new FolderLookup(DataFolder.findContainer(listFolder));	92	Collection<? extends ProviderDescription> looked = Lookups.forPath(PROVIDERS_LIST_FOLDER).lookupAll(ProviderDescription.class);
96	Collection<? extends ProviderDescription> looked = flookup.getLookup().lookupAll(ProviderDescription.class);
97		93
98	for (ProviderDescription desc : looked) {	94	for (ProviderDescription desc : looked) {
99	key2Description.put(desc.getKey(), desc);	95	key2Description.put(desc.getKey(), desc);

Lines 72-80 Link Here

(-)java/j2seproject/src/org/netbeans/modules/java/j2seproject/ui/J2SELogicalViewProvider.java (-11 / +6 lines)
72	import org.openide.filesystems.FileStatusListener;	72	import org.openide.filesystems.FileStatusListener;
73	import org.openide.filesystems.FileSystem;	73	import org.openide.filesystems.FileSystem;
74	import org.openide.filesystems.FileUtil;	74	import org.openide.filesystems.FileUtil;
75	import org.openide.filesystems.Repository;
76	import org.openide.loaders.DataFolder;	75	import org.openide.loaders.DataFolder;
77	import org.openide.loaders.FolderLookup;
78	import org.openide.modules.SpecificationVersion;	76	import org.openide.modules.SpecificationVersion;
79	import org.openide.nodes.AbstractNode;	77	import org.openide.nodes.AbstractNode;
80	import org.openide.nodes.Node;	78	import org.openide.nodes.Node;
Lines 493-507 Link Here
493	actions.add(null);	491	actions.add(null);
494		492
495	// honor 57874 contact	493	// honor 57874 contact
496		494
497	FileObject fo = Repository.getDefault().getDefaultFileSystem().findResource("Projects/Actions"); // NOI18N	495	for (Object next : Lookups.forPath("Projects/Actions").lookupAll(Object.class)) {
498	if (fo != null) {	496	if (next instanceof Action) {
499	for (Object next : new FolderLookup(DataFolder.findFolder(fo)).getLookup().lookupAll(Object.class)) {	497	actions.add((Action) next);
500	if (next instanceof Action) {	498	} else if (next instanceof JSeparator) {
501	actions.add((Action) next);	499	actions.add(null);
502	} else if (next instanceof JSeparator) {
503	actions.add(null);
504	}
505	}	500	}
506	}	501	}
507		502

Lines 35-49 Link Here

(-)j2ee/archiveproject/src/org/netbeans/modules/j2ee/archive/ui/RootNode.java (-31 / +13 lines)
35	import org.netbeans.spi.project.ActionProvider;	35	import org.netbeans.spi.project.ActionProvider;
36	import org.netbeans.spi.project.ui.support.CommonProjectActions;	36	import org.netbeans.spi.project.ui.support.CommonProjectActions;
37	import org.netbeans.spi.project.ui.support.ProjectSensitiveActions;	37	import org.netbeans.spi.project.ui.support.ProjectSensitiveActions;
38	import org.openide.ErrorManager;
39	import org.openide.filesystems.FileChangeListener;	38	import org.openide.filesystems.FileChangeListener;
40	import org.openide.filesystems.FileObject;	39	import org.openide.filesystems.FileObject;
41	import org.openide.filesystems.FileSystem;
42	import org.openide.filesystems.Repository;
43	import org.openide.loaders.DataFolder;	40	import org.openide.loaders.DataFolder;
44	import org.openide.loaders.DataObject;
45	import org.openide.loaders.DataObjectNotFoundException;
46	import org.openide.loaders.FolderLookup;
47	import org.openide.nodes.Children;	41	import org.openide.nodes.Children;
48	import org.openide.nodes.Node;	42	import org.openide.nodes.Node;
49	//import org.openide.util.HelpCtx;	43	//import org.openide.util.HelpCtx;
Lines 112-143 Link Here
112	actions.add(SystemAction.get( org.openide.actions.FindAction.class ));	106	actions.add(SystemAction.get( org.openide.actions.FindAction.class ));
113		107
114	// honor 57874 contact	108	// honor 57874 contact
115		109
116	try {	110	Lookup lookup = Lookups.forPath("Projects/Actions"); // NOI18N
117	Repository repository = Repository.getDefault();	111	Lookup.Template query = new Lookup.Template(Object.class);
118	FileSystem sfs = repository.getDefaultFileSystem();	112	Iterator it = lookup.lookup(query).allInstances().iterator();
119	FileObject fo = sfs.findResource("Projects/Actions"); // NOI18N	113	if (it.hasNext()) {
120	if (fo != null) {	114	actions.add(null);
121	DataObject dobj = DataObject.find(fo);	115	}
122	FolderLookup actionRegistry = new FolderLookup((DataFolder)dobj);	116	while (it.hasNext()) {
123	Lookup.Template query = new Lookup.Template(Object.class);	117	Object next = it.next();
124	Lookup lookup = actionRegistry.getLookup();	118	if (next instanceof Action) {
125	Iterator it = lookup.lookup(query).allInstances().iterator();	119	actions.add(next);
126	if (it.hasNext()) {	120	} else if (next instanceof JSeparator) {
127	actions.add(null);	121	actions.add(null);
128	}
129	while (it.hasNext()) {
130	Object next = it.next();
131	if (next instanceof Action) {
132	actions.add(next);
133	} else if (next instanceof JSeparator) {
134	actions.add(null);
135	}
136	}
137	}	122	}
138	} catch (DataObjectNotFoundException ex) {
139	// data folder for exitinf fileobject expected
140	ErrorManager.getDefault().notify(ex);
141	}	123	}
142		124
143	// actions.add(null);	125	// actions.add(null);

Lines 97-107 Link Here

(-)j2ee/clientproject/src/org/netbeans/modules/j2ee/clientproject/ui/AppClientLogicalViewProvider.java (-28 / +13 lines)
97	import org.openide.filesystems.FileStatusListener;	97	import org.openide.filesystems.FileStatusListener;
98	import org.openide.filesystems.FileSystem;	98	import org.openide.filesystems.FileSystem;
99	import org.openide.filesystems.FileUtil;	99	import org.openide.filesystems.FileUtil;
100	import org.openide.filesystems.Repository;
101	import org.openide.loaders.DataFolder;
102	import org.openide.loaders.DataObject;
103	import org.openide.loaders.DataObjectNotFoundException;
104	import org.openide.loaders.FolderLookup;
105	import org.openide.modules.SpecificationVersion;	100	import org.openide.modules.SpecificationVersion;
106	import org.openide.nodes.AbstractNode;	101	import org.openide.nodes.AbstractNode;
107	import org.openide.nodes.Children;	102	import org.openide.nodes.Children;
Lines 533-562 Link Here
533	actions.add(SystemAction.get(FindAction.class));	528	actions.add(SystemAction.get(FindAction.class));
534		529
535	// honor 57874 contact	530	// honor 57874 contact
536		531
537	try {	532	Lookup lookup = Lookups.forPath("Projects/Actions"); // NOI18N
538	FileObject fo = Repository.getDefault().getDefaultFileSystem().findResource("Projects/Actions"); // NOI18N	533	Lookup.Template query = new Lookup.Template(Object.class);
539	if (fo != null) {	534	Iterator it = lookup.lookup(query).allInstances().iterator();
540	DataObject dobj = DataObject.find(fo);	535	if (it.hasNext()) {
541	FolderLookup actionRegistry = new FolderLookup((DataFolder)dobj);	536	actions.add(null);
542	Lookup.Template query = new Lookup.Template(Object.class);	537	}
543	Lookup lookup = actionRegistry.getLookup();	538	while (it.hasNext()) {
544	Iterator it = lookup.lookup(query).allInstances().iterator();	539	Object next = it.next();
545	if (it.hasNext()) {	540	if (next instanceof Action) {
546	actions.add(null);	541	actions.add((Action) next);
547	}	542	} else if (next instanceof JSeparator) {
548	while (it.hasNext()) {	543	actions.add(null);
549	Object next = it.next();
550	if (next instanceof Action) {
551	actions.add((Action) next);
552	} else if (next instanceof JSeparator) {
553	actions.add(null);
554	}
555	}
556	}	544	}
557	} catch (DataObjectNotFoundException ex) {
558	// data folder for existing fileobject expected
559	ErrorManager.getDefault().notify(ex);
560	}	545	}
561		546
562	actions.add(null);	547	actions.add(null);

Lines 76-86 Link Here

(-)j2ee/earproject/src/org/netbeans/modules/j2ee/earproject/ui/J2eeArchiveLogicalViewProvider.java (-28 / +12 lines)
76	import org.openide.filesystems.FileStatusListener;	76	import org.openide.filesystems.FileStatusListener;
77	import org.openide.filesystems.FileSystem;	77	import org.openide.filesystems.FileSystem;
78	import org.openide.filesystems.FileUtil;	78	import org.openide.filesystems.FileUtil;
79	import org.openide.filesystems.Repository;
80	import org.openide.loaders.DataFolder;	79	import org.openide.loaders.DataFolder;
81	import org.openide.loaders.DataObject;
82	import org.openide.loaders.DataObjectNotFoundException;
83	import org.openide.loaders.FolderLookup;
84	import org.openide.nodes.AbstractNode;	80	import org.openide.nodes.AbstractNode;
85	import org.openide.nodes.Node;	81	import org.openide.nodes.Node;
86	import org.openide.nodes.NodeOp;	82	import org.openide.nodes.NodeOp;
Lines 505-535 Link Here
505	null,	501	null,
506	}));	502	}));
507		503
508	try {	504	Lookup lookup = Lookups.forPath("Projects/Actions"); // NOI18N
509	Repository repository = Repository.getDefault();	505	Lookup.Template query = new Lookup.Template(Object.class);
510	FileSystem sfs = repository.getDefaultFileSystem();	506	Iterator it = lookup.lookup(query).allInstances().iterator();
511	FileObject fo = sfs.findResource("Projects/Actions"); // NOI18N	507	if (it.hasNext()) {
512	if (fo != null) {	508	actions.add(null);
513	DataObject dobj = DataObject.find(fo);	509	}
514	FolderLookup actionRegistry = new FolderLookup((DataFolder)dobj);	510	while (it.hasNext()) {
515	Lookup.Template query = new Lookup.Template(Object.class);	511	Object next = it.next();
516	Lookup lookup = actionRegistry.getLookup();	512	if (next instanceof Action) {
517	Iterator it = lookup.lookup(query).allInstances().iterator();	513	actions.add((Action) next);
518	if (it.hasNext()) {	514	} else if (next instanceof JSeparator) {
519	actions.add(null);	515	actions.add(null);
520	}
521	while (it.hasNext()) {
522	Object next = it.next();
523	if (next instanceof Action) {
524	actions.add((Action) next);
525	} else if (next instanceof JSeparator) {
526	actions.add(null);
527	}
528	}
529	}	516	}
530	} catch (DataObjectNotFoundException ex) {
531	// data folder for existing fileobject expected
532	ErrorManager.getDefault().notify(ex);
533	}	517	}
534		518
535	actions.add(null);	519	actions.add(null);

Lines 88-97 Link Here

(-)j2ee/ejbjarproject/src/org/netbeans/modules/j2ee/ejbjarproject/ui/EjbJarLogicalViewProvider.java (-27 / +13 lines)
88	import org.openide.filesystems.FileStatusListener;	88	import org.openide.filesystems.FileStatusListener;
89	import org.openide.filesystems.FileSystem;	89	import org.openide.filesystems.FileSystem;
90	import org.openide.filesystems.FileUtil;	90	import org.openide.filesystems.FileUtil;
91	import org.openide.filesystems.Repository;
92	import org.openide.loaders.DataObject;	91	import org.openide.loaders.DataObject;
93	import org.openide.loaders.DataObjectNotFoundException;	92	import org.openide.loaders.DataObjectNotFoundException;
94	import org.openide.loaders.FolderLookup;
95		93
96	/**	94	/**
97	* Support for creating logical views.	95	* Support for creating logical views.
Lines 489-520 Link Here
489	actions.add(SystemAction.get( org.openide.actions.FindAction.class ));	487	actions.add(SystemAction.get( org.openide.actions.FindAction.class ));
490		488
491	// honor 57874 contract	489	// honor 57874 contract
492		490
493	try {	491	Lookup lookup = Lookups.forPath("Projects/Actions"); // NOI18N
494	Repository repository = Repository.getDefault();	492	Lookup.Template query = new Lookup.Template(Object.class);
495	FileSystem sfs = repository.getDefaultFileSystem();	493	Iterator it = lookup.lookup(query).allInstances().iterator();
496	FileObject fo = sfs.findResource("Projects/Actions"); // NOI18N	494	if (it.hasNext()) {
497	if (fo != null) {	495	actions.add(null);
498	DataObject dobj = DataObject.find(fo);	496	}
499	FolderLookup actionRegistry = new FolderLookup((DataFolder)dobj);	497	while (it.hasNext()) {
500	Lookup.Template query = new Lookup.Template(Object.class);	498	Object next = it.next();
501	Lookup lookup = actionRegistry.getLookup();	499	if (next instanceof Action) {
502	Iterator it = lookup.lookup(query).allInstances().iterator();	500	actions.add(next);
503	if (it.hasNext()) {	501	} else if (next instanceof JSeparator) {
504	actions.add(null);	502	actions.add(null);
505	}
506	while (it.hasNext()) {
507	Object next = it.next();
508	if (next instanceof Action) {
509	actions.add(next);
510	} else if (next instanceof JSeparator) {
511	actions.add(null);
512	}
513	}
514	}	503	}
515	} catch (DataObjectNotFoundException ex) {
516	// data folder for existing fileobject expected
517	ErrorManager.getDefault().notify(ex);
518	}	504	}
519		505
520	actions.add(null);	506	actions.add(null);

Lines 24-30 Link Here

(-)j2eeserver/src/org/netbeans/modules/j2ee/deployment/impl/ui/ServerRegistryNode.java (-13 / +2 lines)
24	*/	24	*/
25	package org.netbeans.modules.j2ee.deployment.impl.ui;	25	package org.netbeans.modules.j2ee.deployment.impl.ui;
26		26
27	import java.awt.Image;
28	import org.netbeans.modules.j2ee.deployment.plugins.spi.StartServer;	27	import org.netbeans.modules.j2ee.deployment.plugins.spi.StartServer;
29	import org.openide.nodes.*;	28	import org.openide.nodes.*;
30	import org.openide.filesystems.*;	29	import org.openide.filesystems.*;
Lines 32-43 Link Here
32	import org.openide.util.NbBundle;	31	import org.openide.util.NbBundle;
33	import org.openide.util.actions.SystemAction;	32	import org.openide.util.actions.SystemAction;
34	import org.openide.util.HelpCtx;	33	import org.openide.util.HelpCtx;
35	import org.openide.ErrorManager;
36	import org.netbeans.modules.j2ee.deployment.impl.ui.actions.*;	34	import org.netbeans.modules.j2ee.deployment.impl.ui.actions.*;
37	import org.netbeans.modules.j2ee.deployment.impl.*;	35	import org.netbeans.modules.j2ee.deployment.impl.*;
38	import java.util.*;	36	import java.util.*;
39	import org.netbeans.modules.j2ee.deployment.devmodules.spi.InstanceListener;	37	import org.netbeans.modules.j2ee.deployment.devmodules.spi.InstanceListener;
40	import org.openide.util.Utilities;	38	import org.openide.util.lookup.Lookups;
41		39
42	/**	40	/**
43	* The server registry node is a node representing the registry in global options.	41	* The server registry node is a node representing the registry in global options.
Lines 156-170 Link Here
156	}	154	}
157		155
158	public static ServerRegistryNode getServerRegistryNode() {	156	public static ServerRegistryNode getServerRegistryNode() {
159	try {	157	return Lookups.forPath("UI/Runtime").lookup(ServerRegistryNode.class);
160	FileSystem defaultFileSystem = Repository.getDefault().getDefaultFileSystem();
161	FileObject fo = defaultFileSystem.findResource("UI/Runtime"); //NOI18N
162	DataFolder df = (DataFolder) DataObject.find(fo);
163	org.openide.util.Lookup l = new FolderLookup(df).getLookup();
164	return (ServerRegistryNode) l.lookup(ServerRegistryNode.class);
165	} catch (DataObjectNotFoundException e) {
166	ErrorManager.getDefault().notify(ErrorManager.INFORMATIONAL, e);
167	return null;
168	}
169	}	158	}
170	}	159	}

Lines 32-41 Link Here

(-)projects/projectapi/src/org/netbeans/spi/project/support/LookupProviderSupport.java (-11 / +1 lines)
32	import org.netbeans.spi.project.LookupMerger;	32	import org.netbeans.spi.project.LookupMerger;
33	import org.netbeans.spi.project.LookupProvider;	33	import org.netbeans.spi.project.LookupProvider;
34	import org.openide.ErrorManager;	34	import org.openide.ErrorManager;
35	import org.openide.filesystems.FileObject;
36	import org.openide.filesystems.Repository;
37	import org.openide.loaders.DataFolder;
38	import org.openide.loaders.FolderLookup;
39	import org.openide.util.ChangeSupport;	35	import org.openide.util.ChangeSupport;
40	import org.openide.util.Lookup;	36	import org.openide.util.Lookup;
41	import org.openide.util.LookupEvent;	37	import org.openide.util.LookupEvent;
Lines 82-94 Link Here
82		78
83	//TODO maybe have just one single instance for a given path?	79	//TODO maybe have just one single instance for a given path?
84	private static Lookup createLookup(String folderPath) {	80	private static Lookup createLookup(String folderPath) {
85	FileObject root = Repository.getDefault().getDefaultFileSystem().findResource(folderPath);	81	return Lookups.forPath(folderPath);
86	if (root != null) {
87	DataFolder folder = DataFolder.findFolder(root);
88	return new FolderLookup(folder).getLookup();
89	} else { // #87544
90	return Lookup.EMPTY;
91	}
92	}	82	}
93		83
94	static class DelegatingLookupImpl extends ProxyLookup implements LookupListener {	84	static class DelegatingLookupImpl extends ProxyLookup implements LookupListener {

Lines 45-53 Link Here

(-)projects/projectui/src/org/netbeans/modules/project/ui/ProjectsRootNode.java (-5 / +1 lines)
45	import org.netbeans.spi.project.ui.LogicalViewProvider;	45	import org.netbeans.spi.project.ui.LogicalViewProvider;
46	import org.openide.ErrorManager;	46	import org.openide.ErrorManager;
47	import org.openide.filesystems.FileObject;	47	import org.openide.filesystems.FileObject;
48	import org.openide.filesystems.Repository;
49	import org.openide.loaders.DataFolder;
50	import org.openide.loaders.FolderLookup;
51	import org.openide.nodes.AbstractNode;	48	import org.openide.nodes.AbstractNode;
52	import org.openide.nodes.Children;	49	import org.openide.nodes.Children;
53	import org.openide.nodes.FilterNode;	50	import org.openide.nodes.FilterNode;
Lines 104-111 Link Here
104	return new Action[0];	101	return new Action[0];
105	} else {	102	} else {
106	List<Action> actions = new ArrayList<Action>();	103	List<Action> actions = new ArrayList<Action>();
107	DataFolder actionsFolder = DataFolder.findFolder(Repository.getDefault().getDefaultFileSystem().findResource(ACTIONS_FOLDER));	104	for (Object o: Lookups.forPath(ACTIONS_FOLDER).lookupAll(Object.class)) {
108	for (Object o: new FolderLookup(actionsFolder).getLookup().lookupAll(Object.class)) {
109	if (o instanceof Action) {	105	if (o instanceof Action) {
110	actions.add((Action) o);	106	actions.add((Action) o);
111	} else if (o instanceof JSeparator) {	107	} else if (o instanceof JSeparator) {

Lines 28-42 Link Here

(-)projects/projectuiapi/src/org/netbeans/spi/project/ui/support/NodeFactorySupport.java (-8 / +2 lines)
28	import javax.swing.event.ChangeEvent;	28	import javax.swing.event.ChangeEvent;
29	import javax.swing.event.ChangeListener;	29	import javax.swing.event.ChangeListener;
30	import org.netbeans.api.project.Project;	30	import org.netbeans.api.project.Project;
31	import org.openide.filesystems.FileObject;
32	import org.openide.filesystems.Repository;
33	import org.openide.loaders.DataFolder;
34	import org.openide.loaders.FolderLookup;
35	import org.openide.nodes.Children;	31	import org.openide.nodes.Children;
36	import org.openide.nodes.Node;	32	import org.openide.nodes.Node;
37	import org.openide.util.Lookup;	33	import org.openide.util.Lookup;
38	import org.openide.util.LookupEvent;	34	import org.openide.util.LookupEvent;
39	import org.openide.util.LookupListener;	35	import org.openide.util.LookupListener;
		36	import org.openide.util.lookup.Lookups;
40		37
41	/**	38	/**
42	* Support class for creating Project node's children nodes from NodeFactory instances	39	* Support class for creating Project node's children nodes from NodeFactory instances
Lines 112-121 Link Here
112		109
113	// protected for tests..	110	// protected for tests..
114	protected Lookup createLookup() {	111	protected Lookup createLookup() {
115	FileObject root = Repository.getDefault().getDefaultFileSystem().findResource(folderPath);	112	return Lookups.forPath(folderPath);
116	assert root != null : "Cannot find path " + folderPath + " in layers";
117	DataFolder folder = DataFolder.findFolder(root);
118	return new FolderLookup(folder).getLookup();
119	}	113	}
120		114
121	protected Node[] createNodes(NodeListKeyWrapper key) {	115	protected Node[] createNodes(NodeListKeyWrapper key) {

Lines 49-59 Link Here

(-)web/project/src/org/netbeans/modules/web/project/ui/WebLogicalViewProvider.java (-11 / +6 lines)
49	import org.openide.filesystems.FileStatusEvent;	49	import org.openide.filesystems.FileStatusEvent;
50	import org.openide.filesystems.FileStatusListener;	50	import org.openide.filesystems.FileStatusListener;
51	import org.openide.filesystems.FileUtil;	51	import org.openide.filesystems.FileUtil;
52	import org.openide.filesystems.Repository;
53	import org.openide.loaders.DataFolder;
54	import org.openide.loaders.DataObject;	52	import org.openide.loaders.DataObject;
55	import org.openide.loaders.DataObjectNotFoundException;	53	import org.openide.loaders.DataObjectNotFoundException;
56	import org.openide.loaders.FolderLookup;
57	import org.openide.nodes.*;	54	import org.openide.nodes.*;
58	import org.openide.util.ContextAwareAction;	55	import org.openide.util.ContextAwareAction;
59	import org.openide.util.HelpCtx;	56	import org.openide.util.HelpCtx;
Lines 506-520 Link Here
506	actions.add(SystemAction.get( org.openide.actions.FindAction.class ));	503	actions.add(SystemAction.get( org.openide.actions.FindAction.class ));
507		504
508	// honor 57874 contact	505	// honor 57874 contact
		506
509		507
510	FileObject fo = Repository.getDefault().getDefaultFileSystem().findResource("Projects/Actions"); // NOI18N	508	for (Object next : Lookups.forPath("Projects/Actions").lookupAll(Object.class)) {
511	if (fo != null) {	509	if (next instanceof Action) {
512	for (Object next : new FolderLookup(DataFolder.findFolder(fo)).getLookup().lookupAll(Object.class)) {	510	actions.add((Action) next);
513	if (next instanceof Action) {	511	} else if (next instanceof JSeparator) {
514	actions.add((Action) next);	512	actions.add(null);
515	} else if (next instanceof JSeparator) {
516	actions.add(null);
517	}
518	}	513	}
519	}	514	}
520		515

Lines 20-33 Link Here

(-)web/webapi/src/org/netbeans/modules/web/api/webmodule/WebFrameworkSupport.java (-12 / +3 lines)
20	package org.netbeans.modules.web.api.webmodule;	20	package org.netbeans.modules.web.api.webmodule;
21		21
22	import java.util.ArrayList;	22	import java.util.ArrayList;
23	import java.util.Collections;
24	import java.util.List;	23	import java.util.List;
25	import org.openide.filesystems.FileObject;
26	import org.openide.filesystems.Repository;
27	import org.netbeans.modules.web.spi.webmodule.WebFrameworkProvider;	24	import org.netbeans.modules.web.spi.webmodule.WebFrameworkProvider;
28	import org.openide.loaders.DataFolder;
29	import org.openide.loaders.FolderLookup;
30	import org.openide.util.Lookup;	25	import org.openide.util.Lookup;
		26	import org.openide.util.lookup.Lookups;
31		27
32	/**	28	/**
33	*	29	*
Lines 46-58 Link Here
46	* @return List of all {@link org.netbeans.modules.web.spi.webmodule.WebFrameworkProvider}s, which are registered in the layer - j2ee/webtier/framework folder.	42	* @return List of all {@link org.netbeans.modules.web.spi.webmodule.WebFrameworkProvider}s, which are registered in the layer - j2ee/webtier/framework folder.
47	*/	43	*/
48	public static List/<WebFrameworkProvider>/ getFrameworkProviders(){	44	public static List/<WebFrameworkProvider>/ getFrameworkProviders(){
49	FileObject f = Repository.getDefault().getDefaultFileSystem().	45	Lookup l = Lookups.forPath("j2ee/webtier/framework"); //NOI18N
50	findResource("j2ee/webtier/framework"); //NOI18N	46	Lookup.Result result = l.lookupResult(WebFrameworkProvider.class);
51	if (f == null)
52	return Collections.EMPTY_LIST;
53	DataFolder folder = DataFolder.findFolder(f);
54	FolderLookup l = new FolderLookup(folder);
55	Lookup.Result result = l.getLookup().lookup(new Lookup.Template(WebFrameworkProvider.class));
56	return new ArrayList(result.allInstances()); // since allInstances() returns a Collection	47	return new ArrayList(result.allInstances()); // since allInstances() returns a Collection
57	}	48	}
58	}	49	}

Lines 37-52 Link Here

(-)websvc/registry/extsrc/org/netbeans/modules/websvc/registry/RegistryViewImpl.java (-17 / +3 lines)
37	import org.xml.sax.SAXException;	37	import org.xml.sax.SAXException;
38	import org.xml.sax.helpers.DefaultHandler;	38	import org.xml.sax.helpers.DefaultHandler;
39		39
40	import org.openide.ErrorManager;
41	import org.openide.nodes.Node;	40	import org.openide.nodes.Node;
42	import org.openide.filesystems.FileSystem;
43	import org.openide.filesystems.FileObject;	41	import org.openide.filesystems.FileObject;
44	import org.openide.filesystems.FileStateInvalidException;	42	import org.openide.filesystems.FileStateInvalidException;
45	import org.openide.filesystems.Repository;
46	import org.openide.loaders.DataObject;
47	import org.openide.loaders.DataFolder;
48	import org.openide.loaders.FolderLookup;
49	import org.openide.loaders.DataObjectNotFoundException;
50	import org.openide.util.Lookup;	43	import org.openide.util.Lookup;
51		44
52	import org.netbeans.modules.websvc.registry.model.WebServiceGroup;	45	import org.netbeans.modules.websvc.registry.model.WebServiceGroup;
Lines 58-63 Link Here
58	import org.netbeans.modules.websvc.registry.wsdl.WSDLInfo;	51	import org.netbeans.modules.websvc.registry.wsdl.WSDLInfo;
59		52
60	import org.netbeans.modules.websvc.api.registry.WebServicesRegistryView;	53	import org.netbeans.modules.websvc.api.registry.WebServicesRegistryView;
		54	import org.openide.util.lookup.Lookups;
61		55
62	/**	56	/**
63	*	57	*
Lines 73-88 Link Here
73	public Node getRegistryRootNode() {	67	public Node getRegistryRootNode() {
74	Node rootNode = null;	68	Node rootNode = null;
75		69
76	try {	70	Lookup l = Lookups.forPath("UI/Runtime"); // NOI18N
77	FileSystem defaultFileSystem = Repository.getDefault().getDefaultFileSystem();	71	rootNode = (WebServicesRootNode) l.lookup(WebServicesRootNode.class);
78	FileObject fo = defaultFileSystem.findResource("UI/Runtime"); //NOI18N
79	DataFolder df = (DataFolder) DataObject.find(fo);
80	Lookup l = new FolderLookup(df).getLookup();
81	rootNode = (WebServicesRootNode) l.lookup(WebServicesRootNode.class);
82	} catch (DataObjectNotFoundException ex) {
83	ErrorManager.getDefault().notify(ErrorManager.INFORMATIONAL, ex);
84	rootNode = null;
85	}
86		72
87	return rootNode;	73	return rootNode;
88	}	74	}

Lines 24-40 Link Here

(-)xml/catalog/src/org/netbeans/modules/xml/catalog/settings/CatalogSettings.java (-18 / +1 lines)
24	import org.netbeans.modules.xml.catalog.lib.IteratorIterator;	24	import org.netbeans.modules.xml.catalog.lib.IteratorIterator;
25		25
26	import org.openide.*;	26	import org.openide.*;
27	import org.openide.util.HelpCtx;
28	import org.openide.util.io.NbMarshalledObject;	27	import org.openide.util.io.NbMarshalledObject;
29		28
30	import org.netbeans.modules.xml.catalog.spi.*;	29	import org.netbeans.modules.xml.catalog.spi.*;
31	import org.openide.filesystems.FileObject;
32	import org.openide.filesystems.FileSystem;
33	import org.openide.filesystems.Repository;
34	import org.openide.loaders.DataFolder;
35	import org.openide.loaders.DataObject;
36	import org.openide.loaders.DataObjectNotFoundException;
37	import org.openide.loaders.FolderLookup;
38	import org.openide.util.Lookup;	30	import org.openide.util.Lookup;
39	import org.openide.util.LookupListener;	31	import org.openide.util.LookupListener;
40	import org.openide.util.LookupEvent;	32	import org.openide.util.LookupEvent;
Lines 252-267 Link Here
252	*/	244	*/
253	private static Lookup getUserCatalogsLookup() {	245	private static Lookup getUserCatalogsLookup() {
254	if (userCatalogLookup == null) {	246	if (userCatalogLookup == null) {
255	FileSystem sfs = Repository.getDefault().getDefaultFileSystem();	247	userCatalogLookup = Lookups.forPath(REGISTRATIONS);
256	FileObject folder = sfs.findResource(REGISTRATIONS);
257	// do not cache any module providing it can be enabled at any time
258	if (folder == null) return Lookups.fixed(new Object[0]);
259	try {
260	DataFolder dataFolder = (DataFolder) DataObject.find(folder);
261	userCatalogLookup = new FolderLookup(dataFolder).getLookup();
262	} catch (DataObjectNotFoundException ex) {
263	throw new IllegalStateException("There must be DataFolder for " + folder + "!");
264	}
265	}	248	}
266	return userCatalogLookup;	249	return userCatalogLookup;
267	}	250	}

Lines 29-42 Link Here

(-)xml/core/src/org/netbeans/modules/xml/api/model/GrammarQueryManager.java (-26 / +3 lines)
29	import java.util.Iterator;	29	import java.util.Iterator;
30	import org.netbeans.modules.xml.api.model.GrammarQuery;	30	import org.netbeans.modules.xml.api.model.GrammarQuery;
31	import org.openide.ErrorManager;	31	import org.openide.ErrorManager;
32	import org.openide.filesystems.FileObject;
33	import org.openide.filesystems.FileSystem;
34	import org.openide.filesystems.Repository;
35	import org.openide.loaders.DataObject;
36	import org.openide.loaders.DataObjectNotFoundException;
37	import org.openide.loaders.FolderLookup;
38	import org.openide.util.Lookup;	32	import org.openide.util.Lookup;
39	import org.xml.sax.InputSource;	33	import org.openide.util.lookup.Lookups;
40		34
41	/**	35	/**
42	* GrammarQuery service provider definition. Manager methods	36	* GrammarQuery service provider definition. Manager methods
Lines 182-206 Link Here
182	return registrations.allInstances().iterator();	176	return registrations.allInstances().iterator();
183	}	177	}
184		178
185	// try to initialize it	179	registrations = Lookups.forPath(FOLDER).lookupResult(GrammarQueryManager.class);
186		180	return registrations.allInstances().iterator();
187	try {
188	FileSystem fs = Repository.getDefault().getDefaultFileSystem();
189	FileObject fo = fs.findResource(FOLDER);
190	DataObject df = DataObject.find(fo);
191	if (df instanceof DataObject.Container) {
192	FolderLookup lookup =
193	new FolderLookup((DataObject.Container) df);
194	Lookup.Template template =
195	new Lookup.Template(GrammarQueryManager.class);
196	registrations = lookup.getLookup().lookup(template);
197	return registrations.allInstances().iterator();
198	} else {
199	return new ArrayList(0).iterator();
200	}
201	} catch (DataObjectNotFoundException ex) {
202	return new ArrayList(0).iterator();
203	}
204	}	181	}
205	}	182	}
206	}	183	}

Lines 20-33 Link Here

(-)xml/core/src/org/netbeans/modules/xml/core/scenario/NewScenarioPanel.java (-38 / +17 lines)
20		20
21	import java.awt.Dialog;	21	import java.awt.Dialog;
22	import java.util.Iterator;	22	import java.util.Iterator;
23	import org.openide.filesystems.FileObject;
24	import org.openide.filesystems.FileSystem;
25	import org.openide.filesystems.Repository;
26	import org.openide.loaders.FolderLookup;
27	import org.openide.util.Lookup;	23	import org.openide.util.Lookup;
28	import org.openide.loaders.DataObject;	24	import org.openide.loaders.DataObject;
29	import org.openide.loaders.DataObjectNotFoundException;
30	import java.util.ArrayList;
31	import java.util.Collection;	25	import java.util.Collection;
32	import java.util.Vector;	26	import java.util.Vector;
33	import javax.swing.DefaultComboBoxModel;	27	import javax.swing.DefaultComboBoxModel;
Lines 37-42 Link Here
37		31
38	import org.openide.util.HelpCtx;	32	import org.openide.util.HelpCtx;
39	import org.netbeans.modules.xml.api.scenario.*;	33	import org.netbeans.modules.xml.api.scenario.*;
		34	import org.openide.util.lookup.Lookups;
40		35
41	/**	36	/**
42	* A UI panel which allows the user to select a name and scenario type from	37	* A UI panel which allows the user to select a name and scenario type from
Lines 59-100 Link Here
59	nameField.setText(defaultName);	54	nameField.setText(defaultName);
60	nameField.setSelectionStart(0);	55	nameField.setSelectionStart(0);
61	nameField.setSelectionEnd(defaultName.length());	56	nameField.setSelectionEnd(defaultName.length());
		57
62		58
63	try {	59	Lookup.Result registrations = Lookups.forPath(FOLDER).lookupResult(ScenarioFactory.class);
64	// Load the ScenarioFactories from the XML layer	60
65	FileSystem fs = Repository.getDefault().getDefaultFileSystem();	61	// Only display enabled factories for this DataObject
66	FileObject fo = fs.findResource(FOLDER);	62	Collection allFactories = registrations.allInstances();
67	if (fo == null) throw new NoFactoriesException();	63	Vector allowedFactories = new Vector();
68	DataObject df = DataObject.find(fo);	64	Iterator iter = allFactories.iterator();
69	if (df instanceof DataObject.Container) {	65	while(iter.hasNext()) {
70	FolderLookup lookup =	66	ScenarioFactory factory = (ScenarioFactory)iter.next();
71	new FolderLookup((DataObject.Container) df);	67	if (factory.isEnabled(dataObject)) {
72	Lookup.Template template =	68	allowedFactories.add(factory);
73	new Lookup.Template(ScenarioFactory.class);
74	Lookup.Result registrations = lookup.getLookup().lookup(template);
75
76	// Only display enabled factories for this DataObject
77	Collection allFactories = registrations.allInstances();
78	Vector allowedFactories = new Vector();
79	Iterator iter = allFactories.iterator();
80	while(iter.hasNext()) {
81	ScenarioFactory factory = (ScenarioFactory)iter.next();
82	if (factory.isEnabled(dataObject)) {
83	allowedFactories.add(factory);
84	}
85	}
86
87	if (allowedFactories.size() == 0) {
88	throw new NoFactoriesException();
89	}
90
91	typeCombo.setModel(new javax.swing.DefaultComboBoxModel(allowedFactories.toArray()));
92	} else {
93	throw new NoFactoriesException();
94	}	69	}
95	} catch (DataObjectNotFoundException ex) {	70	}
		71
		72	if (allowedFactories.size() == 0) {
96	throw new NoFactoriesException();	73	throw new NoFactoriesException();
97	}	74	}
		75
		76	typeCombo.setModel(new javax.swing.DefaultComboBoxModel(allowedFactories.toArray()));
98	}	77	}
99		78
100	/**	79	/**

Lines 29-49 Link Here

(-)xml/xsl/src/org/netbeans/modules/xsl/grammar/XSLGrammarQuery.java (-32 / +7 lines)
29	import org.netbeans.modules.xml.spi.dom.*;	29	import org.netbeans.modules.xml.spi.dom.*;
30	import org.netbeans.modules.xml.api.cookies.ScenarioCookie;	30	import org.netbeans.modules.xml.api.cookies.ScenarioCookie;
31	import org.netbeans.modules.xsl.api.XSLCustomizer;	31	import org.netbeans.modules.xsl.api.XSLCustomizer;
32	import org.netbeans.modules.xsl.api.XSLScenario;
33	import org.openide.filesystems.Repository;
34	import org.openide.filesystems.FileObject;
35	import org.openide.filesystems.FileSystem;
36	import org.openide.loaders.FolderLookup;
37	import org.openide.loaders.DataFolder;
38	import org.openide.loaders.DataObject;	32	import org.openide.loaders.DataObject;
39	import org.openide.loaders.DataObjectNotFoundException;
40	import org.openide.loaders.InstanceDataObject;
41	import org.openide.nodes.PropertySupport;	33	import org.openide.nodes.PropertySupport;
42	import org.openide.util.Lookup;	34	import org.openide.util.Lookup;
43	import org.openide.util.NbBundle;	35	import org.openide.util.NbBundle;
		36	import org.openide.util.lookup.Lookups;
44		37
45	import org.w3c.dom.*;	38	import org.w3c.dom.*;
46	import org.w3c.dom.NodeList;
47	import org.xml.sax.EntityResolver;	39	import org.xml.sax.EntityResolver;
48	import org.xml.sax.InputSource;	40	import org.xml.sax.InputSource;
49	import org.xml.sax.SAXException;	41	import org.xml.sax.SAXException;
Lines 809-840 Link Here
809	* Looks up registered XSLCustomizer objects which will be used by this object	801	* Looks up registered XSLCustomizer objects which will be used by this object
810	*/	802	*/
811	private static XSLCustomizer lookupCustomizerInstance() {	803	private static XSLCustomizer lookupCustomizerInstance() {
812	try {	804	Lookup.Template template =
813	// Load the XSLCustomizer from the XML layer	805	new Lookup.Template(XSLCustomizer.class);
814	FileSystem fs = Repository.getDefault().getDefaultFileSystem();
815	FileObject fo = fs.findResource(CUSTOMIZER_FOLDER);
816	if (fo == null) return null;
817	DataObject df = DataObject.find(fo);
818	if (!(df instanceof DataObject.Container)) {
819	return null;
820	}
821
822	// ??? What is it? Should not we use naming instead?
823
824	FolderLookup lookup =
825	new FolderLookup((DataObject.Container) df);
826	Lookup.Template template =
827	new Lookup.Template(XSLCustomizer.class);
828		806
829	Lookup.Item lookupItem = lookup.getLookup().lookupItem(template);	807	Lookup.Item lookupItem = Lookups.forPath(CUSTOMIZER_FOLDER).lookupItem(template);
830	if (lookupItem == null) {	808	if (lookupItem == null) {
831	return null;
832	}
833
834	return (XSLCustomizer)lookupItem.getInstance();
835	} catch (DataObjectNotFoundException e) {
836	return null;	809	return null;
837	}	810	}
		811
		812	return (XSLCustomizer)lookupItem.getInstance();
838	}	813	}
839		814
840	/**	815	/**