Java LookupListener.resultChanged方法代码示例

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包/类
@Override
public void resultChanged(LookupEvent ev) {
    synchronized (PathLookupResult.this) {
        items = null;
    }
    List<LookupListener> lls;
    synchronized (listeners) {
        if (listeners.isEmpty()) {
            return;
        } else {
            lls = new ArrayList<LookupListener>(listeners);
        }
    }
    LookupEvent lev = new LookupEvent(PathLookupResult.this);
    for (LookupListener ll : lls) {
        ll.resultChanged(lev);
    }
}
 

import org.openide.util.LookupListener; //导入方法依赖的package包/类
public @Override synchronized URLStreamHandler createURLStreamHandler(final String protocol) {
    if (STANDARD_PROTOCOLS.contains(protocol)) {
        // Well-known handlers in JRE. Do not try to initialize lookup.
        return null;
    }
    if (!results.containsKey(protocol)) {
        final Lookup.Result<URLStreamHandler> result = Lookups.forPath("URLStreamHandler/" + protocol).lookupResult(URLStreamHandler.class);
        LookupListener listener = new LookupListener() {
            public @Override void resultChanged(LookupEvent ev) {
                synchronized (ProxyURLStreamHandlerFactory.this) {
                    Collection<? extends URLStreamHandler> instances = result.allInstances();
                    handlers.put(protocol, instances.isEmpty() ? null : instances.iterator().next());
                }
            }
        };
        result.addLookupListener(listener);
        listener.resultChanged(null);
        results.put(protocol, result);
    }
    return handlers.get(protocol);
}
 

import org.openide.util.LookupListener; //导入方法依赖的package包/类
public void run() {
    Iterator it = evAndListeners.iterator();
    while (it.hasNext()) {
        LookupEvent ev = (LookupEvent)it.next();
        LookupListener l = (LookupListener)it.next();
        try {
            l.resultChanged(ev);
        } catch (RuntimeException x) {
            LOG.log(Level.WARNING, null, x);
        }
    }
}
 

import org.openide.util.LookupListener; //导入方法依赖的package包/类
@Override
public void resultChanged(LookupEvent ev) {
    if (ev.getSource() == nodes) {
        Collection<? extends Item<Provider>> arr = nodes.allItems();
        if (arr.size() == 1 && arr.iterator().next().getInstance() == null) {
            return;
        }
        initValues();
        return;
    }
    final LookupEvent mev = new LookupEvent(this);
    for (LookupListener ll : listeners) {
        ll.resultChanged(mev);
    }
}
 

import org.openide.util.LookupListener; //导入方法依赖的package包/类
/** Checks whether we still delegate to the same lookup */
private Lookup checkLookup() {
    Lookup l = provider.getLookup();

    // iterator over Reference (ProxyResult)
    Iterator<Reference<ProxyResult<?>>> toCheck = null;

    synchronized (this) {
        if (l != delegate) {
            this.delegate = l;

            if (results != null) {
                toCheck = new ArrayList<Reference<ProxyResult<?>>>(results.values()).iterator();
            }
        }
    }

    if (toCheck != null) {
        // update
        ArrayList<Object> evAndListeners = new ArrayList<Object>();
        for (Iterator<Reference<ProxyResult<?>>> it = toCheck; it.hasNext(); ) {
            java.lang.ref.Reference<ProxyResult<?>> ref = it.next();
            if (ref == null) {
                continue;
            }

            ProxyResult<?> p = ref.get();

            if (p != null && p.updateLookup(null, null)) {
                p.collectFires(evAndListeners);
            }
        }

        for (Iterator it = evAndListeners.iterator(); it.hasNext(); ) {
            LookupEvent ev = (LookupEvent)it.next();
            LookupListener ll = (LookupListener)it.next();
            ll.resultChanged(ev);
        }
    }
    return l;
}