Java LookupListener类代码示例

import org.openide.util.LookupListener; //导入依赖的package包/类
public void testDontCallMeUnderLock() throws Exception {
    final Lookup l = getTestedLookup(c2);
    ProxyLookup pl = new ProxyLookup(l) {
        @Override
        void beforeLookup(boolean call, Template<?> template) {
            super.beforeLookup(call, template);
            assertFalse("Don't hold MetaInfServicesLookup lock", Thread.holdsLock(l));
        }
    };
    Class<?> xface = c1.loadClass("org.foo.Interface");
    Result<?> res = pl.lookupResult(Object.class);
    res.addLookupListener(new LookupListener() {
        @Override
        public void resultChanged(LookupEvent ev) {
        }
    });
    assertTrue("Empty now", res.allItems().isEmpty());
    
    Object first = l.lookup(xface);
    assertEquals(first, l.lookupAll(xface).iterator().next());
    Object second = pl.lookup(xface);
    assertEquals(first, second);
}
 

import org.openide.util.LookupListener; //导入依赖的package包/类
private Coloring getColoring() {
    if (attribs == null) {
        if (fcsLookupResult == null) {
            fcsLookupResult = MimeLookup.getLookup(org.netbeans.lib.editor.util.swing.DocumentUtilities.getMimeType(component))
                    .lookupResult(FontColorSettings.class);
            fcsLookupResult.addLookupListener(WeakListeners.create(LookupListener.class, fcsTracker, fcsLookupResult));
        }
        
        FontColorSettings fcs = fcsLookupResult.allInstances().iterator().next();
        AttributeSet attr = fcs.getFontColors(FontColorNames.CODE_FOLDING_BAR_COLORING);
        specificAttrs = attr;
        if (attr == null) {
            attr = fcs.getFontColors(FontColorNames.DEFAULT_COLORING);
        } else {
            attr = AttributesUtilities.createComposite(
                    attr, 
                    fcs.getFontColors(FontColorNames.DEFAULT_COLORING));
        }
        attribs = attr;
    }        
    return Coloring.fromAttributeSet(attribs);
}
 

import org.openide.util.LookupListener; //导入依赖的package包/类
private ColoringMap(
    List<String> legacyNonTokenColoringNames,
    Language<?> lexerLanguage, 
    List<? extends TokenContext> syntaxLanguages, 
    Lookup.Result<FontColorSettings> lookupResult
) {
    this.legacyNonTokenColoringNames = legacyNonTokenColoringNames;
    this.lexerLanguage = lexerLanguage;
    this.syntaxLanguages = syntaxLanguages;
    this.lookupResult = lookupResult;
    
    this.map = loadTheMap(
        legacyNonTokenColoringNames, 
        lexerLanguage, 
        syntaxLanguages, 
        lookupResult.allInstances()
    );
    
    this.lookupResult.addLookupListener(WeakListeners.create(LookupListener.class, lookupListener, this.lookupResult));
}
 

import org.openide.util.LookupListener; //导入依赖的package包/类
private Coloring getColoring() {
    if (attribs == null) {
        if (fcsLookupResult == null) {
            fcsLookupResult = MimeLookup.getLookup(org.netbeans.lib.editor.util.swing.DocumentUtilities.getMimeType(getComponent()))
                    .lookupResult(FontColorSettings.class);
            fcsLookupResult.addLookupListener(WeakListeners.create(LookupListener.class, fcsTracker, fcsLookupResult));
        }
        
        FontColorSettings fcs = fcsLookupResult.allInstances().iterator().next();
        AttributeSet attr = fcs.getFontColors(FontColorNames.CODE_FOLDING_COLORING);
        if (attr == null) {
            attr = fcs.getFontColors(FontColorNames.DEFAULT_COLORING);
        } else {
            attr = AttributesUtilities.createComposite(attr, fcs.getFontColors(FontColorNames.DEFAULT_COLORING));
        }
        
        attribs = attr;
    }        
    return Coloring.fromAttributeSet(attribs);
}
 

import org.openide.util.LookupListener; //导入依赖的package包/类
private Coloring getColoring() {
    if (attribs == null) {
        if (fcsLookupResult == null) {
            fcsLookupResult = MimeLookup.getLookup(org.netbeans.lib.editor.util.swing.DocumentUtilities.getMimeType(component))
                    .lookupResult(FontColorSettings.class);
            fcsLookupResult.addLookupListener(WeakListeners.create(LookupListener.class, fcsTracker, fcsLookupResult));
        }
        
        FontColorSettings fcs = fcsLookupResult.allInstances().iterator().next();
        AttributeSet attr = fcs.getFontColors(FontColorNames.CODE_FOLDING_BAR_COLORING);
        if (attr == null) {
            attr = fcs.getFontColors(FontColorNames.DEFAULT_COLORING);
        } else {
            attr = AttributesUtilities.createComposite(attr, fcs.getFontColors(FontColorNames.DEFAULT_COLORING));
        }
        attribs = attr;
    }        
    return Coloring.fromAttributeSet(attribs);
}
 

import org.openide.util.LookupListener; //导入依赖的package包/类
public ComponentBreakpointActionProvider() {
    final Result<Node> nodeLookupResult = Utilities.actionsGlobalContext().lookupResult(Node.class);
    LookupListener ll = new LookupListener() {
        @Override
        public void resultChanged(LookupEvent ev) {
            Collection<? extends Node> nodeInstances = nodeLookupResult.allInstances();
            for (Node n : nodeInstances) {
                JavaComponentInfo ci = n.getLookup().lookup(JavaComponentInfo.class);
                if (ci != null) {
                    setEnabled(ActionsManager.ACTION_TOGGLE_BREAKPOINT, true);
                    return ;
                }
            }
            setEnabled(ActionsManager.ACTION_TOGGLE_BREAKPOINT, false);
        }
    };
    nodeLookupResult.addLookupListener(ll);
    ll.resultChanged(null); // To initialize
}
 

import org.openide.util.LookupListener; //导入依赖的package包/类
/** Creates a new instance of JavaSourceTaskFactoryManager */
private JavaSourceTaskFactoryManager() {
    final RequestProcessor.Task updateTask = new RequestProcessor("JavaSourceTaskFactoryManager Worker", 1).create(new Runnable() {
        public void run() {
            update();
        }
    });
    
    factories = Lookup.getDefault().lookupResult(JavaSourceTaskFactory.class);
    factories.addLookupListener(new LookupListener() {
        public void resultChanged(LookupEvent ev) {
            updateTask.schedule(0);
        }
    });
    
    update();
}
 

import org.openide.util.LookupListener; //导入依赖的package包/类
/** Called when there may be a need for initialization.
 *
 * @return true if subclasses shall initialize themselves
 */
protected boolean init () { 
    synchronized (RESULTS_LOCK) {//synchronized == issue 215335
    if (initialized) {
        return false;
    }
    this.results = new Lookup.Result[watch.length];
    // Needs to listen on changes in results
    for ( int i = 0; i < watch.length; i++ ) {
        results[i] = lookup.lookupResult(watch[i]);
        results[i].allItems();
        LookupListener resultListener = WeakListeners.create(LookupListener.class, this, results[i]);
        results[i].addLookupListener( resultListener );
    }
    initialized = true;
    return true;
    }
}
 

import org.openide.util.LookupListener; //导入依赖的package包/类
/** Get all available help sets.
 * Pay attention to {@link #helpSetsChanged} to see
 * when this set will change.
 * @return a collection of HelpSet
 */    
protected final Collection<? extends HelpSet> getHelpSets() {
    if (helpsets == null) {
        Installer.log.fine("searching for instances of HelpSet...");
        helpsets = Lookup.getDefault().lookupResult(HelpSet.class);
        helpsets.addLookupListener(new LookupListener() {
            public void resultChanged(LookupEvent ev) {
                helpSetsChanged();
            }
        });
        fireChangeEvent(); // since someone may be listening to whether they are ready
    }
    Collection<? extends HelpSet> c = helpsets.allInstances();
    if (Installer.log.isLoggable(Level.FINE)) {
        List<String> l = new ArrayList<String>(Math.min(1, c.size()));
        for (HelpSet hs: c) {
            l.add(hs.getTitle());
        }
        Installer.log.fine("listing helpsets: " + l);
    }
    return c;
}
 

import org.openide.util.LookupListener; //导入依赖的package包/类
private static synchronized List<Selenium2SupportImpl> getImplementations() {
    if (implementations == null) {
        implementations = Lookup.getDefault().lookupResult(Selenium2SupportImpl.class);
        implementations.addLookupListener(new LookupListener() {
            @Override
            public void resultChanged(LookupEvent ev) {
                synchronized (Selenium2Support.class) {
                    cache = null;
                }
            }
        });
    }
    if (cache == null) {
        cache = new ArrayList<Selenium2SupportImpl>(implementations.allInstances());
    }
    return Collections.unmodifiableList(cache);
}
 

import org.openide.util.LookupListener; //导入依赖的package包/类
private synchronized void ensureTaskListLoaded () throws CoreException {
    if (!taskListInitialized) {
        if (result == null) {
            LookupListener lookupListener = new LookupListener() {
                @Override
                public void resultChanged (LookupEvent ev) {
                    registerConnectors();
                }
            };
            result = Lookup.getDefault().lookupResult(RepositoryConnectorProvider.class);
            result.addLookupListener(lookupListener);
        }
        registerConnectors();
        try {
            if (taskListStorageFile.length() > 0) {
                taskListWriter.readTaskList(taskList, taskListStorageFile);
            }
        } catch (CoreException ex) {
            LOG.log(Level.INFO, null, ex);
            throw new CoreException(new Status(ex.getStatus().getSeverity(), ex.getStatus().getPlugin(), "Cannot deserialize tasklist"));
        } finally {
            taskListInitialized = true;
        }
    }
}
 

import org.openide.util.LookupListener; //导入依赖的package包/类
/** Prepares settings. */
private void prepareSettings() {
    if (prepared) return;
    prepared = true;

    // Set listening on changes of settings.
    fontsColors = MimeLookup.getLookup(PropertiesKit.PROPERTIES_MIME_TYPE).lookupResult(FontColorSettings.class);
    fontsColors.addLookupListener(WeakListeners.create(LookupListener.class, fontsColorsTracker, fontsColors));
    
    keybindings = MimeLookup.getLookup(PropertiesKit.PROPERTIES_MIME_TYPE).lookupResult(KeyBindingSettings.class);
    keybindings.addLookupListener(WeakListeners.create(LookupListener.class, keybindingsTracker, keybindings));
    
    // Init settings.                            
    updateColors();
    updateKeyStrokes();
}
 

import org.openide.util.LookupListener; //导入依赖的package包/类
private void initCategories() {
    synchronized (this) {
        if (null == name2category) {
            if (null == lookupRes) {
                lookupRes = initLookup();
                lookupRes.addLookupListener(new LookupListener() {
                    @Override
                    public void resultChanged(LookupEvent ev) {
                        synchronized (NotificationCategoryFactory.this) {
                            name2category = null;
                            categories = null;
                        }
                    }
                });
            }
            int index = 0;
            categories = new ArrayList<Category>(Category.getDefaultCategories());
            categories.addAll(lookupRes.allInstances());
            name2category = new HashMap<String, Category>(categories.size());
            for (Category c : categories) {
                name2category.put(c.getName(), c);
                c.setIndex(index++);
            }
        }
    }
}
 

import org.openide.util.LookupListener; //导入依赖的package包/类
private Lookup.Result<ModuleInfo> getModulesResult() {
    synchronized (this) {
        if (modulesResult == null) {
            Lookup lookup = getModuleLookup();
            modulesResult = lookup.
                lookup(new Lookup.Template<ModuleInfo>(ModuleInfo.class));
            modulesResult.addLookupListener(new LookupListener() {
                public void resultChanged(LookupEvent ev) {
                    Collection<? extends ModuleInfo> l = getModulesResult().allInstances();
                    XMLSettingsSupport.err.fine("Modules changed: " + l); // NOI18N
                    List reloaded;
                    synchronized (this) {
                        fillModules(l);
                        reloaded = replaceReloadedModules();
                        XMLSettingsSupport.err.fine("Reloaded modules: " + reloaded); // NOI18N
                    }
                    notifyReloads(reloaded);
                }
            });
        }
        return modulesResult;
    }
}
 

import org.openide.util.LookupListener; //导入依赖的package包/类
private void initGroups() {
    synchronized( this ) {
        if( null == name2group ) {
            if( null == lookupRes ) {
                lookupRes = initLookup();
                lookupRes.addLookupListener( new LookupListener() {
                    public void resultChanged(LookupEvent ev) {
                        synchronized( TaskGroupFactory.this ) {
                            name2group = null;
                            groups = null;
                        }
                    }
                });
            }
            int index = 0;
            groups = new ArrayList<TaskGroup>( lookupRes.allInstances() );
            name2group = new HashMap<String,TaskGroup>(groups.size());
            for( TaskGroup tg : groups) {
                name2group.put( tg.getName(), tg );
                tg.setIndex( index++ );
            }
        }
    }
}